1 //===- unittest/Tooling/CleanupTest.cpp - Include insertion/deletion tests ===//
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/Tooling/Inclusions/HeaderIncludes.h"
10 #include "../Tooling/ReplacementTest.h"
11 #include "../Tooling/RewriterTestContext.h"
12 #include "clang/Format/Format.h"
13 #include "clang/Tooling/Core/Replacement.h"
14 
15 #include "gtest/gtest.h"
16 
17 namespace clang {
18 namespace tooling {
19 namespace {
20 
21 class HeaderIncludesTest : public ::testing::Test {
22 protected:
23   std::string insert(llvm::StringRef Code, llvm::StringRef Header) {
24     HeaderIncludes Includes(FileName, Code, Style);
25     assert(Header.startswith("\"") || Header.startswith("<"));
26     auto R = Includes.insert(Header.trim("\"<>"), Header.startswith("<"));
27     if (!R)
28       return std::string(Code);
29     auto Result = applyAllReplacements(Code, Replacements(*R));
30     EXPECT_TRUE(static_cast<bool>(Result));
31     return *Result;
32   }
33 
34   std::string remove(llvm::StringRef Code, llvm::StringRef Header) {
35     HeaderIncludes Includes(FileName, Code, Style);
36     assert(Header.startswith("\"") || Header.startswith("<"));
37     auto Replaces = Includes.remove(Header.trim("\"<>"), Header.startswith("<"));
38     auto Result = applyAllReplacements(Code, Replaces);
39     EXPECT_TRUE(static_cast<bool>(Result));
40     return *Result;
41   }
42 
43   std::string FileName = "fix.cpp";
44   IncludeStyle Style = format::getLLVMStyle().IncludeStyle;
45 };
46 
47 TEST_F(HeaderIncludesTest, NoExistingIncludeWithoutDefine) {
48   std::string Code = "int main() {}";
49   std::string Expected = "#include \"a.h\"\n"
50                          "int main() {}";
51   EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
52 }
53 
54 TEST_F(HeaderIncludesTest, NoExistingIncludeWithDefine) {
55   std::string Code = "#ifndef A_H\n"
56                      "#define A_H\n"
57                      "class A {};\n"
58                      "#define MMM 123\n"
59                      "#endif";
60   std::string Expected = "#ifndef A_H\n"
61                          "#define A_H\n"
62                          "#include \"b.h\"\n"
63                          "class A {};\n"
64                          "#define MMM 123\n"
65                          "#endif";
66 
67   EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
68 }
69 
70 TEST_F(HeaderIncludesTest, InsertBeforeCategoryWithLowerPriority) {
71   std::string Code = "#ifndef A_H\n"
72                      "#define A_H\n"
73                      "\n"
74                      "\n"
75                      "\n"
76                      "#include <vector>\n"
77                      "class A {};\n"
78                      "#define MMM 123\n"
79                      "#endif";
80   std::string Expected = "#ifndef A_H\n"
81                          "#define A_H\n"
82                          "\n"
83                          "\n"
84                          "\n"
85                          "#include \"a.h\"\n"
86                          "#include <vector>\n"
87                          "class A {};\n"
88                          "#define MMM 123\n"
89                          "#endif";
90 
91   EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
92 }
93 
94 TEST_F(HeaderIncludesTest, InsertAfterMainHeader) {
95   std::string Code = "#include \"fix.h\"\n"
96                      "\n"
97                      "int main() {}";
98   std::string Expected = "#include \"fix.h\"\n"
99                          "#include <a>\n"
100                          "\n"
101                          "int main() {}";
102   Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
103               .IncludeStyle;
104   EXPECT_EQ(Expected, insert(Code, "<a>"));
105 
106   FileName = "fix.cu.cpp";
107   EXPECT_EQ(Expected, insert(Code, "<a>"));
108 
109   FileName = "fix_test.cu.cpp";
110   EXPECT_EQ(Expected, insert(Code, "<a>"));
111 
112   FileName = "bar.cpp";
113   EXPECT_NE(Expected, insert(Code, "<a>")) << "Not main header";
114 }
115 
116 TEST_F(HeaderIncludesTest, InsertBeforeSystemHeaderLLVM) {
117   std::string Code = "#include <memory>\n"
118                      "\n"
119                      "int main() {}";
120   std::string Expected = "#include \"z.h\"\n"
121                          "#include <memory>\n"
122                          "\n"
123                          "int main() {}";
124   EXPECT_EQ(Expected, insert(Code, "\"z.h\""));
125 }
126 
127 TEST_F(HeaderIncludesTest, InsertAfterSystemHeaderGoogle) {
128   std::string Code = "#include <memory>\n"
129                      "\n"
130                      "int main() {}";
131   std::string Expected = "#include <memory>\n"
132                          "#include \"z.h\"\n"
133                          "\n"
134                          "int main() {}";
135   Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
136               .IncludeStyle;
137   EXPECT_EQ(Expected, insert(Code, "\"z.h\""));
138 }
139 
140 TEST_F(HeaderIncludesTest, InsertOneIncludeLLVMStyle) {
141   std::string Code = "#include \"x/fix.h\"\n"
142                      "#include \"a.h\"\n"
143                      "#include \"b.h\"\n"
144                      "#include \"clang/Format/Format.h\"\n"
145                      "#include <memory>\n";
146   std::string Expected = "#include \"x/fix.h\"\n"
147                          "#include \"a.h\"\n"
148                          "#include \"b.h\"\n"
149                          "#include \"clang/Format/Format.h\"\n"
150                          "#include \"llvm/x/y.h\"\n"
151                          "#include <memory>\n";
152   EXPECT_EQ(Expected, insert(Code, "\"llvm/x/y.h\""));
153 }
154 
155 TEST_F(HeaderIncludesTest, InsertIntoBlockSorted) {
156   std::string Code = "#include \"x/fix.h\"\n"
157                      "#include \"a.h\"\n"
158                      "#include \"c.h\"\n"
159                      "#include <memory>\n";
160   std::string Expected = "#include \"x/fix.h\"\n"
161                          "#include \"a.h\"\n"
162                          "#include \"b.h\"\n"
163                          "#include \"c.h\"\n"
164                          "#include <memory>\n";
165   EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
166 }
167 
168 TEST_F(HeaderIncludesTest, InsertIntoFirstBlockOfSameKind) {
169   std::string Code = "#include \"x/fix.h\"\n"
170                      "#include \"c.h\"\n"
171                      "#include \"e.h\"\n"
172                      "#include \"f.h\"\n"
173                      "#include <memory>\n"
174                      "#include <vector>\n"
175                      "#include \"m.h\"\n"
176                      "#include \"n.h\"\n";
177   std::string Expected = "#include \"x/fix.h\"\n"
178                          "#include \"c.h\"\n"
179                          "#include \"d.h\"\n"
180                          "#include \"e.h\"\n"
181                          "#include \"f.h\"\n"
182                          "#include <memory>\n"
183                          "#include <vector>\n"
184                          "#include \"m.h\"\n"
185                          "#include \"n.h\"\n";
186   EXPECT_EQ(Expected, insert(Code, "\"d.h\""));
187 }
188 
189 TEST_F(HeaderIncludesTest, InsertIntoSystemBlockSorted) {
190   std::string Code = "#include \"x/fix.h\"\n"
191                      "#include \"a.h\"\n"
192                      "#include \"c.h\"\n"
193                      "#include <a>\n"
194                      "#include <z>\n";
195   std::string Expected = "#include \"x/fix.h\"\n"
196                          "#include \"a.h\"\n"
197                          "#include \"c.h\"\n"
198                          "#include <a>\n"
199                          "#include <vector>\n"
200                          "#include <z>\n";
201   EXPECT_EQ(Expected, insert(Code, "<vector>"));
202 }
203 
204 TEST_F(HeaderIncludesTest, InsertNewSystemIncludeGoogleStyle) {
205   std::string Code = "#include \"x/fix.h\"\n"
206                      "\n"
207                      "#include \"y/a.h\"\n"
208                      "#include \"z/b.h\"\n";
209   // FIXME: inserting after the empty line following the main header might be
210   // preferred.
211   std::string Expected = "#include \"x/fix.h\"\n"
212                          "#include <vector>\n"
213                          "\n"
214                          "#include \"y/a.h\"\n"
215                          "#include \"z/b.h\"\n";
216   Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
217               .IncludeStyle;
218   EXPECT_EQ(Expected, insert(Code, "<vector>"));
219 }
220 
221 TEST_F(HeaderIncludesTest, NotConfusedByDefine) {
222   std::string Code = "void f() {}\n"
223                      "#define A \\\n"
224                      "  int i;";
225   std::string Expected = "#include <vector>\n"
226                          "void f() {}\n"
227                          "#define A \\\n"
228                          "  int i;";
229   EXPECT_EQ(Expected, insert(Code, "<vector>"));
230 }
231 
232 TEST_F(HeaderIncludesTest, SkippedTopComment) {
233   std::string Code = "// comment\n"
234                      "\n"
235                      "   // comment\n";
236   std::string Expected = "// comment\n"
237                          "\n"
238                          "   // comment\n"
239                          "#include <vector>\n";
240   EXPECT_EQ(Expected, insert(Code, "<vector>"));
241 }
242 
243 TEST_F(HeaderIncludesTest, SkippedMixedComments) {
244   std::string Code = "// comment\n"
245                      "// comment \\\n"
246                      " comment continued\n"
247                      "/*\n"
248                      "* comment\n"
249                      "*/\n";
250   std::string Expected = "// comment\n"
251                          "// comment \\\n"
252                          " comment continued\n"
253                          "/*\n"
254                          "* comment\n"
255                          "*/\n"
256                          "#include <vector>\n";
257   EXPECT_EQ(Expected, insert(Code, "<vector>"));
258 }
259 
260 TEST_F(HeaderIncludesTest, MultipleBlockCommentsInOneLine) {
261   std::string Code = "/*\n"
262                      "* comment\n"
263                      "*/ /* comment\n"
264                      "*/\n"
265                      "\n\n"
266                      "/* c1 */ /*c2 */\n";
267   std::string Expected = "/*\n"
268                          "* comment\n"
269                          "*/ /* comment\n"
270                          "*/\n"
271                          "\n\n"
272                          "/* c1 */ /*c2 */\n"
273                          "#include <vector>\n";
274   EXPECT_EQ(Expected, insert(Code, "<vector>"));
275 }
276 
277 TEST_F(HeaderIncludesTest, CodeAfterComments) {
278   std::string Code = "/*\n"
279                      "* comment\n"
280                      "*/ /* comment\n"
281                      "*/\n"
282                      "\n\n"
283                      "/* c1 */ /*c2 */\n"
284                      "\n"
285                      "int x;\n";
286   std::string Expected = "/*\n"
287                          "* comment\n"
288                          "*/ /* comment\n"
289                          "*/\n"
290                          "\n\n"
291                          "/* c1 */ /*c2 */\n"
292                          "\n"
293                          "#include <vector>\n"
294                          "int x;\n";
295   EXPECT_EQ(Expected, insert(Code, "<vector>"));
296 }
297 
298 TEST_F(HeaderIncludesTest, FakeHeaderGuardIfDef) {
299   std::string Code = "// comment \n"
300                      "#ifdef X\n"
301                      "#define X\n";
302   std::string Expected = "// comment \n"
303                          "#include <vector>\n"
304                          "#ifdef X\n"
305                          "#define X\n";
306   EXPECT_EQ(Expected, insert(Code, "<vector>"));
307 }
308 
309 TEST_F(HeaderIncludesTest, RealHeaderGuardAfterComments) {
310   std::string Code = "// comment \n"
311                      "#ifndef X\n"
312                      "#define X\n"
313                      "int x;\n"
314                      "#define Y 1\n";
315   std::string Expected = "// comment \n"
316                          "#ifndef X\n"
317                          "#define X\n"
318                          "#include <vector>\n"
319                          "int x;\n"
320                          "#define Y 1\n";
321   EXPECT_EQ(Expected, insert(Code, "<vector>"));
322 }
323 
324 TEST_F(HeaderIncludesTest, PragmaOnce) {
325   std::string Code = "// comment \n"
326                      "#pragma once\n"
327                      "int x;\n";
328   std::string Expected = "// comment \n"
329                          "#pragma once\n"
330                          "#include <vector>\n"
331                          "int x;\n";
332   EXPECT_EQ(Expected, insert(Code, "<vector>"));
333 }
334 
335 TEST_F(HeaderIncludesTest, IfNDefWithNoDefine) {
336   std::string Code = "// comment \n"
337                      "#ifndef X\n"
338                      "int x;\n"
339                      "#define Y 1\n";
340   std::string Expected = "// comment \n"
341                          "#include <vector>\n"
342                          "#ifndef X\n"
343                          "int x;\n"
344                          "#define Y 1\n";
345   EXPECT_EQ(Expected, insert(Code, "<vector>"));
346 }
347 
348 TEST_F(HeaderIncludesTest, FakeHeaderGuard) {
349   std::string Code = "// comment \n"
350                      "#ifndef X\n"
351                      "#define 1\n";
352   std::string Expected = "// comment \n"
353                          "#include <vector>\n"
354                          "#ifndef X\n"
355                          "#define 1\n";
356   EXPECT_EQ(Expected, insert(Code, "<vector>"));
357 }
358 
359 TEST_F(HeaderIncludesTest, FakeHeaderGuardIfnDef) {
360   std::string Code = "#ifndef A_H\n"
361                      "#define A_H 1\n"
362                      "#endif";
363   std::string Expected = "#include \"b.h\"\n"
364                          "#ifndef A_H\n"
365                          "#define A_H 1\n"
366                          "#endif";
367 
368   EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
369 }
370 
371 TEST_F(HeaderIncludesTest, HeaderGuardWithComment) {
372   std::string Code = "// comment \n"
373                      "#ifndef X // comment\n"
374                      "// comment\n"
375                      "/* comment\n"
376                      "*/\n"
377                      "/* comment */ #define X\n"
378                      "int x;\n"
379                      "#define Y 1\n";
380   std::string Expected = "// comment \n"
381                          "#ifndef X // comment\n"
382                          "// comment\n"
383                          "/* comment\n"
384                          "*/\n"
385                          "/* comment */ #define X\n"
386                          "#include <vector>\n"
387                          "int x;\n"
388                          "#define Y 1\n";
389   EXPECT_EQ(Expected, insert(Code, "<vector>"));
390 }
391 
392 TEST_F(HeaderIncludesTest, EmptyCode) {
393   std::string Code = "";
394   std::string Expected = "#include <vector>\n";
395   EXPECT_EQ(Expected, insert(Code, "<vector>"));
396 }
397 
398 TEST_F(HeaderIncludesTest, NoNewLineAtTheEndOfCode) {
399   std::string Code = "#include <map>";
400   std::string Expected = "#include <map>\n#include <vector>\n";
401   EXPECT_EQ(Expected, insert(Code, "<vector>"));
402 }
403 
404 TEST_F(HeaderIncludesTest, SkipExistingHeaders) {
405   std::string Code = "#include \"a.h\"\n"
406                      "#include <vector>\n";
407   std::string Expected = "#include \"a.h\"\n"
408                          "#include <vector>\n";
409   EXPECT_EQ(Expected, insert(Code, "<vector>"));
410   EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
411 }
412 
413 TEST_F(HeaderIncludesTest, AddIncludesWithDifferentForms) {
414   std::string Code = "#include <vector>\n";
415   // FIXME: this might not be the best behavior.
416   std::string Expected = "#include \"vector\"\n"
417                          "#include <vector>\n";
418   EXPECT_EQ(Expected, insert(Code, "\"vector\""));
419 }
420 
421 TEST_F(HeaderIncludesTest, NoInsertionAfterCode) {
422   std::string Code = "#include \"a.h\"\n"
423                      "void f() {}\n"
424                      "#include \"b.h\"\n";
425   std::string Expected = "#include \"a.h\"\n"
426                          "#include \"c.h\"\n"
427                          "void f() {}\n"
428                          "#include \"b.h\"\n";
429   EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
430 }
431 
432 TEST_F(HeaderIncludesTest, NoInsertionInStringLiteral) {
433   std::string Code = "#include \"a.h\"\n"
434                      "const char[] = R\"(\n"
435                      "#include \"b.h\"\n"
436                      ")\";\n";
437   std::string Expected = "#include \"a.h\"\n"
438                          "#include \"c.h\"\n"
439                          "const char[] = R\"(\n"
440                          "#include \"b.h\"\n"
441                          ")\";\n";
442   EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
443 }
444 
445 TEST_F(HeaderIncludesTest, NoInsertionAfterOtherDirective) {
446   std::string Code = "#include \"a.h\"\n"
447                      "#ifdef X\n"
448                      "#include \"b.h\"\n"
449                      "#endif\n";
450   std::string Expected = "#include \"a.h\"\n"
451                          "#include \"c.h\"\n"
452                          "#ifdef X\n"
453                          "#include \"b.h\"\n"
454                          "#endif\n";
455   EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
456 }
457 
458 TEST_F(HeaderIncludesTest, CanInsertAfterLongSystemInclude) {
459   std::string Code = "#include \"a.h\"\n"
460                      "// comment\n\n"
461                      "#include <a/b/c/d/e.h>\n";
462   std::string Expected = "#include \"a.h\"\n"
463                          "// comment\n\n"
464                          "#include <a/b/c/d/e.h>\n"
465                          "#include <x.h>\n";
466   EXPECT_EQ(Expected, insert(Code, "<x.h>"));
467 }
468 
469 TEST_F(HeaderIncludesTest, CanInsertAfterComment) {
470   std::string Code = "#include \"a.h\"\n"
471                      "// Comment\n"
472                      "\n"
473                      "/* Comment */\n"
474                      "// Comment\n"
475                      "\n"
476                      "#include \"b.h\"\n";
477   std::string Expected = "#include \"a.h\"\n"
478                          "// Comment\n"
479                          "\n"
480                          "/* Comment */\n"
481                          "// Comment\n"
482                          "\n"
483                          "#include \"b.h\"\n"
484                          "#include \"c.h\"\n";
485   EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
486 }
487 
488 TEST_F(HeaderIncludesTest, LongCommentsInTheBeginningOfFile) {
489   std::string Code = "// Loooooooooooooooooooooooooong comment\n"
490                      "// Loooooooooooooooooooooooooong comment\n"
491                      "// Loooooooooooooooooooooooooong comment\n"
492                      "#include <string>\n"
493                      "#include <vector>\n"
494                      "\n"
495                      "#include \"a.h\"\n"
496                      "#include \"b.h\"\n";
497   std::string Expected = "// Loooooooooooooooooooooooooong comment\n"
498                          "// Loooooooooooooooooooooooooong comment\n"
499                          "// Loooooooooooooooooooooooooong comment\n"
500                          "#include <string>\n"
501                          "#include <vector>\n"
502                          "\n"
503                          "#include \"a.h\"\n"
504                          "#include \"b.h\"\n"
505                          "#include \"third.h\"\n";
506   Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
507               .IncludeStyle;
508   EXPECT_EQ(Expected, insert(Code, "\"third.h\""));
509 }
510 
511 TEST_F(HeaderIncludesTest, SimpleDeleteInclude) {
512   std::string Code = "#include \"abc.h\"\n"
513                      "#include \"xyz.h\" // comment\n"
514                      "int x;\n";
515   std::string Expected = "#include \"abc.h\"\n"
516                          "int x;\n";
517   EXPECT_EQ(Expected, remove(Code, "\"xyz.h\""));
518 }
519 
520 TEST_F(HeaderIncludesTest, DeleteQuotedOnly) {
521   std::string Code = "#include \"abc.h\"\n"
522                      "#include <abc.h>\n"
523                      "int x;\n";
524   std::string Expected = "#include <abc.h>\n"
525                          "int x;\n";
526   EXPECT_EQ(Expected, remove(Code, "\"abc.h\""));
527 }
528 
529 TEST_F(HeaderIncludesTest, DeleteAllCode) {
530   std::string Code = "#include \"xyz.h\"\n";
531   std::string Expected = "";
532   EXPECT_EQ(Expected, remove(Code, "\"xyz.h\""));
533 }
534 
535 TEST_F(HeaderIncludesTest, DeleteOnlyIncludesWithSameQuote) {
536   std::string Code = "#include \"xyz.h\"\n"
537                      "#include \"xyz\"\n"
538                      "#include <xyz.h>\n";
539   std::string Expected = "#include \"xyz.h\"\n"
540                          "#include \"xyz\"\n";
541   EXPECT_EQ(Expected, remove(Code, "<xyz.h>"));
542 }
543 
544 TEST_F(HeaderIncludesTest, CanDeleteAfterCode) {
545   std::string Code = "#include \"a.h\"\n"
546                      "void f() {}\n"
547                      "#include \"b.h\"\n";
548   std::string Expected = "#include \"a.h\"\n"
549                          "void f() {}\n";
550   EXPECT_EQ(Expected, remove(Code, "\"b.h\""));
551 }
552 
553 } // namespace
554 } // namespace tooling
555 } // namespace clang
556