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