1 //===- unittests/Lex/DependencyDirectivesSourceMinimizer.cpp - -----------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "clang/Lex/DependencyDirectivesSourceMinimizer.h"
10 #include "llvm/ADT/SmallString.h"
11 #include "gtest/gtest.h"
12
13 using namespace llvm;
14 using namespace clang;
15 using namespace clang::minimize_source_to_dependency_directives;
16
17 namespace clang {
18
minimizeSourceToDependencyDirectives(StringRef Input,SmallVectorImpl<char> & Out)19 bool minimizeSourceToDependencyDirectives(StringRef Input,
20 SmallVectorImpl<char> &Out) {
21 SmallVector<minimize_source_to_dependency_directives::Token, 32> Tokens;
22 return minimizeSourceToDependencyDirectives(Input, Out, Tokens);
23 }
24
25 } // end namespace clang
26
27 namespace {
28
TEST(MinimizeSourceToDependencyDirectivesTest,Empty)29 TEST(MinimizeSourceToDependencyDirectivesTest, Empty) {
30 SmallVector<char, 128> Out;
31 SmallVector<Token, 4> Tokens;
32
33 ASSERT_FALSE(minimizeSourceToDependencyDirectives("", Out, Tokens));
34 EXPECT_TRUE(Out.empty());
35 ASSERT_EQ(1u, Tokens.size());
36 ASSERT_EQ(pp_eof, Tokens.back().K);
37
38 ASSERT_FALSE(
39 minimizeSourceToDependencyDirectives("abc def\nxyz", Out, Tokens));
40 EXPECT_TRUE(Out.empty());
41 ASSERT_EQ(1u, Tokens.size());
42 ASSERT_EQ(pp_eof, Tokens.back().K);
43 }
44
TEST(MinimizeSourceToDependencyDirectivesTest,AllTokens)45 TEST(MinimizeSourceToDependencyDirectivesTest, AllTokens) {
46 SmallVector<char, 128> Out;
47 SmallVector<Token, 4> Tokens;
48
49 ASSERT_FALSE(
50 minimizeSourceToDependencyDirectives("#define A\n"
51 "#undef A\n"
52 "#endif\n"
53 "#if A\n"
54 "#ifdef A\n"
55 "#ifndef A\n"
56 "#elif A\n"
57 "#else\n"
58 "#include <A>\n"
59 "#include_next <A>\n"
60 "#__include_macros <A>\n"
61 "#import <A>\n"
62 "@import A;\n"
63 "#pragma clang module import A\n",
64 Out, Tokens));
65 EXPECT_EQ(pp_define, Tokens[0].K);
66 EXPECT_EQ(pp_undef, Tokens[1].K);
67 EXPECT_EQ(pp_endif, Tokens[2].K);
68 EXPECT_EQ(pp_if, Tokens[3].K);
69 EXPECT_EQ(pp_ifdef, Tokens[4].K);
70 EXPECT_EQ(pp_ifndef, Tokens[5].K);
71 EXPECT_EQ(pp_elif, Tokens[6].K);
72 EXPECT_EQ(pp_else, Tokens[7].K);
73 EXPECT_EQ(pp_include, Tokens[8].K);
74 EXPECT_EQ(pp_include_next, Tokens[9].K);
75 EXPECT_EQ(pp___include_macros, Tokens[10].K);
76 EXPECT_EQ(pp_import, Tokens[11].K);
77 EXPECT_EQ(decl_at_import, Tokens[12].K);
78 EXPECT_EQ(pp_pragma_import, Tokens[13].K);
79 EXPECT_EQ(pp_eof, Tokens[14].K);
80 }
81
TEST(MinimizeSourceToDependencyDirectivesTest,Define)82 TEST(MinimizeSourceToDependencyDirectivesTest, Define) {
83 SmallVector<char, 128> Out;
84 SmallVector<Token, 4> Tokens;
85
86 ASSERT_FALSE(
87 minimizeSourceToDependencyDirectives("#define MACRO", Out, Tokens));
88 EXPECT_STREQ("#define MACRO\n", Out.data());
89 ASSERT_EQ(2u, Tokens.size());
90 ASSERT_EQ(pp_define, Tokens.front().K);
91 }
92
TEST(MinimizeSourceToDependencyDirectivesTest,DefineSpacing)93 TEST(MinimizeSourceToDependencyDirectivesTest, DefineSpacing) {
94 SmallVector<char, 128> Out;
95
96 ASSERT_FALSE(
97 minimizeSourceToDependencyDirectives("#define MACRO\n\n\n", Out));
98 EXPECT_STREQ("#define MACRO\n", Out.data());
99
100 ASSERT_FALSE(
101 minimizeSourceToDependencyDirectives("#define MACRO \n\n\n", Out));
102 EXPECT_STREQ("#define MACRO\n", Out.data());
103
104 ASSERT_FALSE(
105 minimizeSourceToDependencyDirectives("#define MACRO a \n\n\n", Out));
106 EXPECT_STREQ("#define MACRO a\n", Out.data());
107
108 ASSERT_FALSE(
109 minimizeSourceToDependencyDirectives("#define MACRO\n\n\n", Out));
110 EXPECT_STREQ("#define MACRO\n", Out.data());
111 }
112
TEST(MinimizeSourceToDependencyDirectivesTest,DefineMacroArguments)113 TEST(MinimizeSourceToDependencyDirectivesTest, DefineMacroArguments) {
114 SmallVector<char, 128> Out;
115
116 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO()", Out));
117 EXPECT_STREQ("#define MACRO()\n", Out.data());
118
119 ASSERT_FALSE(
120 minimizeSourceToDependencyDirectives("#define MACRO(a, b...)", Out));
121 EXPECT_STREQ("#define MACRO(a,b...)\n", Out.data());
122
123 ASSERT_FALSE(
124 minimizeSourceToDependencyDirectives("#define MACRO content", Out));
125 EXPECT_STREQ("#define MACRO content\n", Out.data());
126
127 ASSERT_FALSE(minimizeSourceToDependencyDirectives(
128 "#define MACRO con tent ", Out));
129 EXPECT_STREQ("#define MACRO con tent\n", Out.data());
130
131 ASSERT_FALSE(minimizeSourceToDependencyDirectives(
132 "#define MACRO() con tent ", Out));
133 EXPECT_STREQ("#define MACRO() con tent\n", Out.data());
134 }
135
TEST(MinimizeSourceToDependencyDirectivesTest,DefineInvalidMacroArguments)136 TEST(MinimizeSourceToDependencyDirectivesTest, DefineInvalidMacroArguments) {
137 SmallVector<char, 128> Out;
138
139 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO((a))", Out));
140 EXPECT_STREQ("#define MACRO(/* invalid */\n", Out.data());
141
142 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO(", Out));
143 EXPECT_STREQ("#define MACRO(/* invalid */\n", Out.data());
144
145 ASSERT_FALSE(
146 minimizeSourceToDependencyDirectives("#define MACRO(a * b)", Out));
147 EXPECT_STREQ("#define MACRO(/* invalid */\n", Out.data());
148 }
149
TEST(MinimizeSourceToDependencyDirectivesTest,DefineHorizontalWhitespace)150 TEST(MinimizeSourceToDependencyDirectivesTest, DefineHorizontalWhitespace) {
151 SmallVector<char, 128> Out;
152
153 ASSERT_FALSE(minimizeSourceToDependencyDirectives(
154 "#define MACRO(\t)\tcon \t tent\t", Out));
155 EXPECT_STREQ("#define MACRO() con \t tent\n", Out.data());
156
157 ASSERT_FALSE(minimizeSourceToDependencyDirectives(
158 "#define MACRO(\f)\fcon \f tent\f", Out));
159 EXPECT_STREQ("#define MACRO() con \f tent\n", Out.data());
160
161 ASSERT_FALSE(minimizeSourceToDependencyDirectives(
162 "#define MACRO(\v)\vcon \v tent\v", Out));
163 EXPECT_STREQ("#define MACRO() con \v tent\n", Out.data());
164
165 ASSERT_FALSE(minimizeSourceToDependencyDirectives(
166 "#define MACRO \t\v\f\v\t con\f\t\vtent\v\f \v", Out));
167 EXPECT_STREQ("#define MACRO con\f\t\vtent\n", Out.data());
168 }
169
TEST(MinimizeSourceToDependencyDirectivesTest,DefineMultilineArgs)170 TEST(MinimizeSourceToDependencyDirectivesTest, DefineMultilineArgs) {
171 SmallVector<char, 128> Out;
172
173 ASSERT_FALSE(
174 minimizeSourceToDependencyDirectives("#define MACRO(a \\\n"
175 " )",
176 Out));
177 EXPECT_STREQ("#define MACRO(a)\n", Out.data());
178
179 ASSERT_FALSE(
180 minimizeSourceToDependencyDirectives("#define MACRO(a, \\\n"
181 " b) \\\n"
182 " call((a), \\\n"
183 " (b))",
184 Out));
185 EXPECT_STREQ("#define MACRO(a,b) call((a),(b))\n", Out.data());
186 }
187
TEST(MinimizeSourceToDependencyDirectivesTest,DefineMultilineArgsCarriageReturn)188 TEST(MinimizeSourceToDependencyDirectivesTest,
189 DefineMultilineArgsCarriageReturn) {
190 SmallVector<char, 128> Out;
191
192 ASSERT_FALSE(
193 minimizeSourceToDependencyDirectives("#define MACRO(a, \\\r"
194 " b) \\\r"
195 " call((a), \\\r"
196 " (b))",
197 Out));
198 EXPECT_STREQ("#define MACRO(a,b) call((a),(b))\n", Out.data());
199 }
200
TEST(MinimizeSourceToDependencyDirectivesTest,DefineMultilineArgsCarriageReturnNewline)201 TEST(MinimizeSourceToDependencyDirectivesTest,
202 DefineMultilineArgsCarriageReturnNewline) {
203 SmallVector<char, 128> Out;
204
205 ASSERT_FALSE(
206 minimizeSourceToDependencyDirectives("#define MACRO(a, \\\r\n"
207 " b) \\\r\n"
208 " call((a), \\\r\n"
209 " (b))",
210 Out));
211 EXPECT_STREQ("#define MACRO(a,b) call((a),(b))\n", Out.data());
212 }
213
TEST(MinimizeSourceToDependencyDirectivesTest,DefineMultilineArgsNewlineCarriageReturn)214 TEST(MinimizeSourceToDependencyDirectivesTest,
215 DefineMultilineArgsNewlineCarriageReturn) {
216 SmallVector<char, 128> Out;
217
218 ASSERT_FALSE(
219 minimizeSourceToDependencyDirectives("#define MACRO(a, \\\n\r"
220 " b) \\\n\r"
221 " call((a), \\\n\r"
222 " (b))",
223 Out));
224 EXPECT_STREQ("#define MACRO(a,b) call((a),(b))\n", Out.data());
225 }
226
TEST(MinimizeSourceToDependencyDirectivesTest,DefineNumber)227 TEST(MinimizeSourceToDependencyDirectivesTest, DefineNumber) {
228 SmallVector<char, 128> Out;
229
230 ASSERT_TRUE(minimizeSourceToDependencyDirectives("#define 0\n", Out));
231 }
232
TEST(MinimizeSourceToDependencyDirectivesTest,DefineNoName)233 TEST(MinimizeSourceToDependencyDirectivesTest, DefineNoName) {
234 SmallVector<char, 128> Out;
235
236 ASSERT_TRUE(minimizeSourceToDependencyDirectives("#define &\n", Out));
237 }
238
TEST(MinimizeSourceToDependencyDirectivesTest,DefineNoWhitespace)239 TEST(MinimizeSourceToDependencyDirectivesTest, DefineNoWhitespace) {
240 SmallVector<char, 128> Out;
241
242 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define AND&\n", Out));
243 EXPECT_STREQ("#define AND &\n", Out.data());
244
245 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define AND\\\n"
246 "&\n",
247 Out));
248 EXPECT_STREQ("#define AND &\n", Out.data());
249 }
250
TEST(MinimizeSourceToDependencyDirectivesTest,MultilineComment)251 TEST(MinimizeSourceToDependencyDirectivesTest, MultilineComment) {
252 SmallVector<char, 128> Out;
253
254 ASSERT_FALSE(
255 minimizeSourceToDependencyDirectives("#define MACRO a/*\n"
256 " /*\n"
257 "#define MISSING abc\n"
258 " /*\n"
259 " /* something */ \n"
260 "#include /* \"def\" */ <abc> \n",
261 Out));
262 EXPECT_STREQ("#define MACRO a\n"
263 "#include <abc>\n",
264 Out.data());
265 }
266
TEST(MinimizeSourceToDependencyDirectivesTest,MultilineCommentInStrings)267 TEST(MinimizeSourceToDependencyDirectivesTest, MultilineCommentInStrings) {
268 SmallVector<char, 128> Out;
269
270 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO1 \"/*\"\n"
271 "#define MACRO2 \"*/\"\n",
272 Out));
273 EXPECT_STREQ("#define MACRO1 \"/*\"\n"
274 "#define MACRO2 \"*/\"\n",
275 Out.data());
276 }
277
TEST(MinimizeSourceToDependencyDirectivesTest,Ifdef)278 TEST(MinimizeSourceToDependencyDirectivesTest, Ifdef) {
279 SmallVector<char, 128> Out;
280
281 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
282 "#define B\n"
283 "#endif\n",
284 Out));
285 EXPECT_STREQ("#ifdef A\n"
286 "#define B\n"
287 "#endif\n",
288 Out.data());
289
290 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
291 "#define B\n"
292 "#elif B\n"
293 "#define C\n"
294 "#elif C\n"
295 "#define D\n"
296 "#else\n"
297 "#define E\n"
298 "#endif\n",
299 Out));
300 EXPECT_STREQ("#ifdef A\n"
301 "#define B\n"
302 "#elif B\n"
303 "#define C\n"
304 "#elif C\n"
305 "#define D\n"
306 "#else\n"
307 "#define E\n"
308 "#endif\n",
309 Out.data());
310 }
311
TEST(MinimizeSourceToDependencyDirectivesTest,EmptyIfdef)312 TEST(MinimizeSourceToDependencyDirectivesTest, EmptyIfdef) {
313 SmallVector<char, 128> Out;
314
315 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
316 "#elif B\n"
317 "#elif C\n"
318 "#else D\n"
319 "#endif\n",
320 Out));
321 EXPECT_STREQ("", Out.data());
322 }
323
TEST(MinimizeSourceToDependencyDirectivesTest,Pragma)324 TEST(MinimizeSourceToDependencyDirectivesTest, Pragma) {
325 SmallVector<char, 128> Out;
326
327 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#pragma A\n", Out));
328 EXPECT_STREQ("", Out.data());
329
330 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#pragma clang\n", Out));
331 EXPECT_STREQ("", Out.data());
332
333 ASSERT_FALSE(
334 minimizeSourceToDependencyDirectives("#pragma clang module\n", Out));
335 EXPECT_STREQ("", Out.data());
336
337 ASSERT_FALSE(minimizeSourceToDependencyDirectives(
338 "#pragma clang module impor\n", Out));
339 EXPECT_STREQ("", Out.data());
340
341 ASSERT_FALSE(minimizeSourceToDependencyDirectives(
342 "#pragma clang module import\n", Out));
343 EXPECT_STREQ("#pragma clang module import\n", Out.data());
344 }
345
TEST(MinimizeSourceToDependencyDirectivesTest,Include)346 TEST(MinimizeSourceToDependencyDirectivesTest, Include) {
347 SmallVector<char, 128> Out;
348
349 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#include \"A\"\n", Out));
350 EXPECT_STREQ("#include \"A\"\n", Out.data());
351
352 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#include <A>\n", Out));
353 EXPECT_STREQ("#include <A>\n", Out.data());
354
355 ASSERT_FALSE(
356 minimizeSourceToDependencyDirectives("#include_next <A>\n", Out));
357 EXPECT_STREQ("#include_next <A>\n", Out.data());
358
359 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#import <A>\n", Out));
360 EXPECT_STREQ("#import <A>\n", Out.data());
361
362 ASSERT_FALSE(
363 minimizeSourceToDependencyDirectives("#__include_macros <A>\n", Out));
364 EXPECT_STREQ("#__include_macros <A>\n", Out.data());
365 }
366
TEST(MinimizeSourceToDependencyDirectivesTest,AtImport)367 TEST(MinimizeSourceToDependencyDirectivesTest, AtImport) {
368 SmallVector<char, 128> Out;
369
370 ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A;\n", Out));
371 EXPECT_STREQ("@import A;\n", Out.data());
372
373 ASSERT_FALSE(minimizeSourceToDependencyDirectives(" @ import A;\n", Out));
374 EXPECT_STREQ("@import A;\n", Out.data());
375
376 ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A\n;", Out));
377 EXPECT_STREQ("@import A;\n", Out.data());
378
379 ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A.B;\n", Out));
380 EXPECT_STREQ("@import A.B;\n", Out.data());
381
382 ASSERT_FALSE(minimizeSourceToDependencyDirectives(
383 "@import /*x*/ A /*x*/ . /*x*/ B /*x*/ \n /*x*/ ; /*x*/", Out));
384 EXPECT_STREQ("@import A.B;\n", Out.data());
385 }
386
TEST(MinimizeSourceToDependencyDirectivesTest,AtImportFailures)387 TEST(MinimizeSourceToDependencyDirectivesTest, AtImportFailures) {
388 SmallVector<char, 128> Out;
389
390 ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import A\n", Out));
391 ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import MACRO(A);\n", Out));
392 ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import \" \";\n", Out));
393 }
394
TEST(MinimizeSourceToDependencyDirectivesTest,RawStringLiteral)395 TEST(MinimizeSourceToDependencyDirectivesTest, RawStringLiteral) {
396 SmallVector<char, 128> Out;
397
398 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifndef GUARD\n"
399 "#define GUARD\n"
400 "R\"()\"\n"
401 "#endif\n",
402 Out));
403 EXPECT_STREQ("#ifndef GUARD\n"
404 "#define GUARD\n"
405 "#endif\n",
406 Out.data());
407
408 bool RawStringLiteralResult = minimizeSourceToDependencyDirectives(
409 "#ifndef GUARD\n"
410 "#define GUARD\n"
411 R"raw(static constexpr char bytes[] = R"(-?:\,[]{}#&*!|>'"%@`)";)raw"
412 "\n"
413 "#endif\n",
414 Out);
415 ASSERT_FALSE(RawStringLiteralResult);
416 EXPECT_STREQ("#ifndef GUARD\n"
417 "#define GUARD\n"
418 "#endif\n",
419 Out.data());
420
421 bool RawStringLiteralResult2 = minimizeSourceToDependencyDirectives(
422 "#ifndef GUARD\n"
423 "#define GUARD\n"
424 R"raw(static constexpr char bytes[] = R"abc(-?:\,[]{}#&*!|>'"%@`)abc";)raw"
425 "\n"
426 "#endif\n",
427 Out);
428 ASSERT_FALSE(RawStringLiteralResult2);
429 EXPECT_STREQ("#ifndef GUARD\n"
430 "#define GUARD\n"
431 "#endif\n",
432 Out.data());
433 }
434
435 TEST(MinimizeSourceToDependencyDirectivesTest, SplitIdentifier) {
436 SmallVector<char, 128> Out;
437
438 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#if\\\n"
439 "ndef GUARD\n"
440 "#define GUARD\n"
441 "#endif\n",
442 Out));
443 EXPECT_STREQ("#ifndef GUARD\n"
444 "#define GUARD\n"
445 "#endif\n",
446 Out.data());
447
448 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\n"
449 "RD\n",
450 Out));
451 EXPECT_STREQ("#define GUARD\n", Out.data());
452
453 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\r"
454 "RD\n",
455 Out));
456 EXPECT_STREQ("#define GUARD\n", Out.data());
457
458 ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\n"
459 " RD\n",
460 Out));
461 EXPECT_STREQ("#define GUA RD\n", Out.data());
462 }
463
464 TEST(MinimizeSourceToDependencyDirectivesTest, PoundWarningAndError) {
465 SmallVector<char, 128> Out;
466
467 for (auto Source : {
468 "#warning '\n#include <t.h>\n",
469 "#warning \"\n#include <t.h>\n",
470 "#warning /*\n#include <t.h>\n",
471 "#warning \\\n#include <t.h>\n#include <t.h>\n",
472 "#error '\n#include <t.h>\n",
473 "#error \"\n#include <t.h>\n",
474 "#error /*\n#include <t.h>\n",
475 "#error \\\n#include <t.h>\n#include <t.h>\n",
476 }) {
477 ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
478 EXPECT_STREQ("#include <t.h>\n", Out.data());
479 }
480
481 for (auto Source : {
482 "#warning \\\n#include <t.h>\n",
483 "#error \\\n#include <t.h>\n",
484 "#if MACRO\n#warning '\n#endif\n",
485 "#if MACRO\n#warning \"\n#endif\n",
486 "#if MACRO\n#warning /*\n#endif\n",
487 "#if MACRO\n#error '\n#endif\n",
488 "#if MACRO\n#error \"\n#endif\n",
489 "#if MACRO\n#error /*\n#endif\n",
490 }) {
491 ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
492 EXPECT_STREQ("", Out.data());
493 }
494 }
495
TEST(MinimizeSourceToDependencyDirectivesTest,CharacterLiteral)496 TEST(MinimizeSourceToDependencyDirectivesTest, CharacterLiteral) {
497 SmallVector<char, 128> Out;
498
499 StringRef Source = R"(
500 #include <bob>
501 int a = 0'1;
502 int b = 0xfa'af'fa;
503 int c = 12 ' ';
504 #include <foo>
505 )";
506 ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
507 EXPECT_STREQ("#include <bob>\n#include <foo>\n", Out.data());
508 }
509
TEST(MinimizeSourceToDependencyDirectivesTest,CharacterLiteralPrefixL)510 TEST(MinimizeSourceToDependencyDirectivesTest, CharacterLiteralPrefixL) {
511 SmallVector<char, 128> Out;
512
513 StringRef Source = R"(L'P'
514 #if DEBUG
515 // '
516 #endif
517 #include <test.h>
518 )";
519 ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
520 EXPECT_STREQ("#include <test.h>\n", Out.data());
521 }
522
TEST(MinimizeSourceToDependencyDirectivesTest,CharacterLiteralPrefixU)523 TEST(MinimizeSourceToDependencyDirectivesTest, CharacterLiteralPrefixU) {
524 SmallVector<char, 128> Out;
525
526 StringRef Source = R"(int x = U'P';
527 #include <test.h>
528 // '
529 )";
530 ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
531 EXPECT_STREQ("#include <test.h>\n", Out.data());
532 }
533
TEST(MinimizeSourceToDependencyDirectivesTest,CharacterLiteralPrefixu)534 TEST(MinimizeSourceToDependencyDirectivesTest, CharacterLiteralPrefixu) {
535 SmallVector<char, 128> Out;
536
537 StringRef Source = R"(int x = u'b';
538 int y = u8'a';
539 int z = 128'78;
540 #include <test.h>
541 // '
542 )";
543 ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
544 EXPECT_STREQ("#include <test.h>\n", Out.data());
545 }
546
547 } // end anonymous namespace
548