1 //===- unittest/Format/SortIncludesTest.cpp - Include sort unit 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 "FormatTestUtils.h"
10 #include "clang/Format/Format.h"
11 #include "llvm/ADT/None.h"
12 #include "llvm/Support/Debug.h"
13 #include "gtest/gtest.h"
14 
15 #define DEBUG_TYPE "format-test"
16 
17 namespace clang {
18 namespace format {
19 namespace {
20 
21 class SortIncludesTest : public ::testing::Test {
22 protected:
23   std::vector<tooling::Range> GetCodeRange(StringRef Code) {
24     return std::vector<tooling::Range>(1, tooling::Range(0, Code.size()));
25   }
26 
27   std::string sort(StringRef Code, std::vector<tooling::Range> Ranges,
28                    StringRef FileName = "input.cc",
29                    unsigned ExpectedNumRanges = 1) {
30     auto Replaces = sortIncludes(FmtStyle, Code, Ranges, FileName);
31     Ranges = tooling::calculateRangesAfterReplacements(Replaces, Ranges);
32     EXPECT_EQ(ExpectedNumRanges, Replaces.size());
33     auto Sorted = applyAllReplacements(Code, Replaces);
34     EXPECT_TRUE(static_cast<bool>(Sorted));
35     auto Result = applyAllReplacements(
36         *Sorted, reformat(FmtStyle, *Sorted, Ranges, FileName));
37     EXPECT_TRUE(static_cast<bool>(Result));
38     return *Result;
39   }
40 
41   std::string sort(StringRef Code,
42                    StringRef FileName = "input.cpp",
43                    unsigned ExpectedNumRanges = 1) {
44     return sort(Code, GetCodeRange(Code), FileName, ExpectedNumRanges);
45   }
46 
47   unsigned newCursor(llvm::StringRef Code, unsigned Cursor) {
48     sortIncludes(FmtStyle, Code, GetCodeRange(Code), "input.cpp", &Cursor);
49     return Cursor;
50   }
51 
52   FormatStyle FmtStyle = getLLVMStyle();
53   tooling::IncludeStyle &Style = FmtStyle.IncludeStyle;
54 };
55 
56 TEST_F(SortIncludesTest, BasicSorting) {
57   EXPECT_EQ("#include \"a.h\"\n"
58             "#include \"b.h\"\n"
59             "#include \"c.h\"\n",
60             sort("#include \"a.h\"\n"
61                  "#include \"c.h\"\n"
62                  "#include \"b.h\"\n"));
63 
64   EXPECT_EQ("// comment\n"
65             "#include <a>\n"
66             "#include <b>\n",
67             sort("// comment\n"
68                  "#include <b>\n"
69                  "#include <a>\n",
70                  {tooling::Range(25, 1)}));
71 }
72 
73 TEST_F(SortIncludesTest, NoReplacementsForValidIncludes) {
74   // Identical #includes have led to a failure with an unstable sort.
75   std::string Code = "#include <a>\n"
76                      "#include <b>\n"
77                      "#include <c>\n"
78                      "#include <d>\n"
79                      "#include <e>\n"
80                      "#include <f>\n";
81   EXPECT_TRUE(sortIncludes(FmtStyle, Code, GetCodeRange(Code), "a.cc").empty());
82 }
83 
84 TEST_F(SortIncludesTest, SortedIncludesInMultipleBlocksAreMerged) {
85   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
86   EXPECT_EQ("#include \"a.h\"\n"
87             "#include \"b.h\"\n"
88             "#include \"c.h\"\n",
89             sort("#include \"a.h\"\n"
90                  "#include \"c.h\"\n"
91                  "\n"
92                  "\n"
93                  "#include \"b.h\"\n"));
94 
95   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
96   EXPECT_EQ("#include \"a.h\"\n"
97             "#include \"b.h\"\n"
98             "#include \"c.h\"\n",
99             sort("#include \"a.h\"\n"
100                  "#include \"c.h\"\n"
101                  "\n"
102                  "\n"
103                  "#include \"b.h\"\n"));
104 }
105 
106 TEST_F(SortIncludesTest, SupportClangFormatOff) {
107   EXPECT_EQ("#include <a>\n"
108             "#include <b>\n"
109             "#include <c>\n"
110             "// clang-format off\n"
111             "#include <b>\n"
112             "#include <a>\n"
113             "#include <c>\n"
114             "// clang-format on\n",
115             sort("#include <b>\n"
116                  "#include <a>\n"
117                  "#include <c>\n"
118                  "// clang-format off\n"
119                  "#include <b>\n"
120                  "#include <a>\n"
121                  "#include <c>\n"
122                  "// clang-format on\n"));
123 }
124 
125 TEST_F(SortIncludesTest, SupportClangFormatOffCStyle) {
126   EXPECT_EQ("#include <a>\n"
127             "#include <b>\n"
128             "#include <c>\n"
129             "/* clang-format off */\n"
130             "#include <b>\n"
131             "#include <a>\n"
132             "#include <c>\n"
133             "/* clang-format on */\n",
134             sort("#include <b>\n"
135                  "#include <a>\n"
136                  "#include <c>\n"
137                  "/* clang-format off */\n"
138                  "#include <b>\n"
139                  "#include <a>\n"
140                  "#include <c>\n"
141                  "/* clang-format on */\n"));
142 
143   // Not really turning it off
144   EXPECT_EQ("#include <a>\n"
145             "#include <b>\n"
146             "#include <c>\n"
147             "/* clang-format offically */\n"
148             "#include <a>\n"
149             "#include <b>\n"
150             "#include <c>\n"
151             "/* clang-format onwards */\n",
152             sort("#include <b>\n"
153                  "#include <a>\n"
154                  "#include <c>\n"
155                  "/* clang-format offically */\n"
156                  "#include <b>\n"
157                  "#include <a>\n"
158                  "#include <c>\n"
159                  "/* clang-format onwards */\n", "input.h", 2));
160 }
161 
162 TEST_F(SortIncludesTest, IncludeSortingCanBeDisabled) {
163   FmtStyle.SortIncludes = false;
164   EXPECT_EQ("#include \"a.h\"\n"
165             "#include \"c.h\"\n"
166             "#include \"b.h\"\n",
167             sort("#include \"a.h\"\n"
168                  "#include \"c.h\"\n"
169                  "#include \"b.h\"\n",
170                  "input.h", 0));
171 }
172 
173 TEST_F(SortIncludesTest, MixIncludeAndImport) {
174   EXPECT_EQ("#include \"a.h\"\n"
175             "#import \"b.h\"\n"
176             "#include \"c.h\"\n",
177             sort("#include \"a.h\"\n"
178                  "#include \"c.h\"\n"
179                  "#import \"b.h\"\n"));
180 }
181 
182 TEST_F(SortIncludesTest, FixTrailingComments) {
183   EXPECT_EQ("#include \"a.h\"  // comment\n"
184             "#include \"bb.h\" // comment\n"
185             "#include \"ccc.h\"\n",
186             sort("#include \"a.h\" // comment\n"
187                  "#include \"ccc.h\"\n"
188                  "#include \"bb.h\" // comment\n"));
189 }
190 
191 TEST_F(SortIncludesTest, LeadingWhitespace) {
192   EXPECT_EQ("#include \"a.h\"\n"
193             "#include \"b.h\"\n"
194             "#include \"c.h\"\n",
195             sort(" #include \"a.h\"\n"
196                  "  #include \"c.h\"\n"
197                  "   #include \"b.h\"\n"));
198   EXPECT_EQ("#include \"a.h\"\n"
199             "#include \"b.h\"\n"
200             "#include \"c.h\"\n",
201             sort("# include \"a.h\"\n"
202                  "#  include \"c.h\"\n"
203                  "#   include \"b.h\"\n"));
204 }
205 
206 TEST_F(SortIncludesTest, GreaterInComment) {
207   EXPECT_EQ("#include \"a.h\"\n"
208             "#include \"b.h\" // >\n"
209             "#include \"c.h\"\n",
210             sort("#include \"a.h\"\n"
211                  "#include \"c.h\"\n"
212                  "#include \"b.h\" // >\n"));
213 }
214 
215 TEST_F(SortIncludesTest, SortsLocallyInEachBlock) {
216   EXPECT_EQ("#include \"a.h\"\n"
217             "#include \"c.h\"\n"
218             "\n"
219             "#include \"b.h\"\n",
220             sort("#include \"a.h\"\n"
221                  "#include \"c.h\"\n"
222                  "\n"
223                  "#include \"b.h\"\n", "input.h", 0));
224 }
225 
226 TEST_F(SortIncludesTest, SortsAllBlocksWhenMerging) {
227   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
228   EXPECT_EQ("#include \"a.h\"\n"
229             "#include \"b.h\"\n"
230             "#include \"c.h\"\n",
231             sort("#include \"a.h\"\n"
232                  "#include \"c.h\"\n"
233                  "\n"
234                  "#include \"b.h\"\n"));
235 }
236 
237 TEST_F(SortIncludesTest, CommentsAlwaysSeparateGroups) {
238   EXPECT_EQ("#include \"a.h\"\n"
239             "#include \"c.h\"\n"
240             "// comment\n"
241             "#include \"b.h\"\n",
242             sort("#include \"c.h\"\n"
243                  "#include \"a.h\"\n"
244                  "// comment\n"
245                  "#include \"b.h\"\n"));
246 
247   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
248   EXPECT_EQ("#include \"a.h\"\n"
249             "#include \"c.h\"\n"
250             "// comment\n"
251             "#include \"b.h\"\n",
252             sort("#include \"c.h\"\n"
253                  "#include \"a.h\"\n"
254                  "// comment\n"
255                  "#include \"b.h\"\n"));
256 
257   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
258   EXPECT_EQ("#include \"a.h\"\n"
259             "#include \"c.h\"\n"
260             "// comment\n"
261             "#include \"b.h\"\n",
262             sort("#include \"c.h\"\n"
263                  "#include \"a.h\"\n"
264                  "// comment\n"
265                  "#include \"b.h\"\n"));
266 }
267 
268 TEST_F(SortIncludesTest, HandlesAngledIncludesAsSeparateBlocks) {
269   EXPECT_EQ("#include \"a.h\"\n"
270             "#include \"c.h\"\n"
271             "#include <array>\n"
272             "#include <b.h>\n"
273             "#include <d.h>\n"
274             "#include <vector>\n",
275             sort("#include <vector>\n"
276                  "#include <d.h>\n"
277                  "#include <array>\n"
278                  "#include <b.h>\n"
279                  "#include \"c.h\"\n"
280                  "#include \"a.h\"\n"));
281 
282   FmtStyle = getGoogleStyle(FormatStyle::LK_Cpp);
283   EXPECT_EQ("#include <b.h>\n"
284             "#include <d.h>\n"
285             "\n"
286             "#include <array>\n"
287             "#include <vector>\n"
288             "\n"
289             "#include \"a.h\"\n"
290             "#include \"c.h\"\n",
291             sort("#include <vector>\n"
292                  "#include <d.h>\n"
293                  "#include <array>\n"
294                  "#include <b.h>\n"
295                  "#include \"c.h\"\n"
296                  "#include \"a.h\"\n"));
297 }
298 
299 TEST_F(SortIncludesTest, RegroupsAngledIncludesInSeparateBlocks) {
300   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
301   EXPECT_EQ("#include \"a.h\"\n"
302             "#include \"c.h\"\n"
303             "\n"
304             "#include <b.h>\n"
305             "#include <d.h>\n",
306             sort("#include <d.h>\n"
307                  "#include <b.h>\n"
308                  "#include \"c.h\"\n"
309                  "#include \"a.h\"\n"));
310 }
311 
312 TEST_F(SortIncludesTest, HandlesMultilineIncludes) {
313   EXPECT_EQ("#include \"a.h\"\n"
314             "#include \"b.h\"\n"
315             "#include \"c.h\"\n",
316             sort("#include \"a.h\"\n"
317                  "#include \\\n"
318                  "\"c.h\"\n"
319                  "#include \"b.h\"\n"));
320 }
321 
322 TEST_F(SortIncludesTest, LeavesMainHeaderFirst) {
323   Style.IncludeIsMainRegex = "([-_](test|unittest))?$";
324   EXPECT_EQ("#include \"llvm/a.h\"\n"
325             "#include \"b.h\"\n"
326             "#include \"c.h\"\n",
327             sort("#include \"llvm/a.h\"\n"
328                  "#include \"c.h\"\n"
329                  "#include \"b.h\"\n",
330                  "a.cc"));
331   EXPECT_EQ("#include \"llvm/a.h\"\n"
332             "#include \"b.h\"\n"
333             "#include \"c.h\"\n",
334             sort("#include \"llvm/a.h\"\n"
335                  "#include \"c.h\"\n"
336                  "#include \"b.h\"\n",
337                  "a_test.cc"));
338   EXPECT_EQ("#include \"llvm/input.h\"\n"
339             "#include \"b.h\"\n"
340             "#include \"c.h\"\n",
341             sort("#include \"llvm/input.h\"\n"
342                  "#include \"c.h\"\n"
343                  "#include \"b.h\"\n",
344                  "input.mm"));
345 
346   // Don't allow prefixes.
347   EXPECT_EQ("#include \"b.h\"\n"
348             "#include \"c.h\"\n"
349             "#include \"llvm/not_a.h\"\n",
350             sort("#include \"llvm/not_a.h\"\n"
351                  "#include \"c.h\"\n"
352                  "#include \"b.h\"\n",
353                  "a.cc"));
354 
355   // Don't do this for _main and other suffixes.
356   EXPECT_EQ("#include \"b.h\"\n"
357             "#include \"c.h\"\n"
358             "#include \"llvm/a.h\"\n",
359             sort("#include \"llvm/a.h\"\n"
360                  "#include \"c.h\"\n"
361                  "#include \"b.h\"\n",
362                  "a_main.cc"));
363 
364   // Don't do this in headers.
365   EXPECT_EQ("#include \"b.h\"\n"
366             "#include \"c.h\"\n"
367             "#include \"llvm/a.h\"\n",
368             sort("#include \"llvm/a.h\"\n"
369                  "#include \"c.h\"\n"
370                  "#include \"b.h\"\n",
371                  "a.h"));
372 
373   // Only do this in the first #include block.
374   EXPECT_EQ("#include <a>\n"
375             "\n"
376             "#include \"b.h\"\n"
377             "#include \"c.h\"\n"
378             "#include \"llvm/a.h\"\n",
379             sort("#include <a>\n"
380                  "\n"
381                  "#include \"llvm/a.h\"\n"
382                  "#include \"c.h\"\n"
383                  "#include \"b.h\"\n",
384                  "a.cc"));
385 
386   // Only recognize the first #include with a matching basename as main include.
387   EXPECT_EQ("#include \"a.h\"\n"
388             "#include \"b.h\"\n"
389             "#include \"c.h\"\n"
390             "#include \"llvm/a.h\"\n",
391             sort("#include \"b.h\"\n"
392                  "#include \"a.h\"\n"
393                  "#include \"c.h\"\n"
394                  "#include \"llvm/a.h\"\n",
395                  "a.cc"));
396 }
397 
398 TEST_F(SortIncludesTest, RecognizeMainHeaderInAllGroups) {
399   Style.IncludeIsMainRegex = "([-_](test|unittest))?$";
400   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
401 
402   EXPECT_EQ("#include \"c.h\"\n"
403             "#include \"a.h\"\n"
404             "#include \"b.h\"\n",
405             sort("#include \"b.h\"\n"
406                  "\n"
407                  "#include \"a.h\"\n"
408                  "#include \"c.h\"\n",
409                  "c.cc"));
410 }
411 
412 TEST_F(SortIncludesTest, MainHeaderIsSeparatedWhenRegroupping) {
413   Style.IncludeIsMainRegex = "([-_](test|unittest))?$";
414   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
415 
416   EXPECT_EQ("#include \"a.h\"\n"
417             "\n"
418             "#include \"b.h\"\n"
419             "#include \"c.h\"\n",
420             sort("#include \"b.h\"\n"
421                  "\n"
422                  "#include \"a.h\"\n"
423                  "#include \"c.h\"\n",
424                  "a.cc"));
425 }
426 
427 TEST_F(SortIncludesTest, SupportCaseInsensitiveMatching) {
428   // Setup an regex for main includes so we can cover those as well.
429   Style.IncludeIsMainRegex = "([-_](test|unittest))?$";
430 
431   // Ensure both main header detection and grouping work in a case insensitive
432   // manner.
433   EXPECT_EQ("#include \"llvm/A.h\"\n"
434             "#include \"b.h\"\n"
435             "#include \"c.h\"\n"
436             "#include \"LLVM/z.h\"\n"
437             "#include \"llvm/X.h\"\n"
438             "#include \"GTest/GTest.h\"\n"
439             "#include \"gmock/gmock.h\"\n",
440             sort("#include \"c.h\"\n"
441                  "#include \"b.h\"\n"
442                  "#include \"GTest/GTest.h\"\n"
443                  "#include \"llvm/A.h\"\n"
444                  "#include \"gmock/gmock.h\"\n"
445                  "#include \"llvm/X.h\"\n"
446                  "#include \"LLVM/z.h\"\n",
447                  "a_TEST.cc"));
448 }
449 
450 TEST_F(SortIncludesTest, NegativePriorities) {
451   Style.IncludeCategories = {{".*important_os_header.*", -1}, {".*", 1}};
452   EXPECT_EQ("#include \"important_os_header.h\"\n"
453             "#include \"c_main.h\"\n"
454             "#include \"a_other.h\"\n",
455             sort("#include \"c_main.h\"\n"
456                  "#include \"a_other.h\"\n"
457                  "#include \"important_os_header.h\"\n",
458                  "c_main.cc"));
459 
460   // check stable when re-run
461   EXPECT_EQ("#include \"important_os_header.h\"\n"
462             "#include \"c_main.h\"\n"
463             "#include \"a_other.h\"\n",
464             sort("#include \"important_os_header.h\"\n"
465                  "#include \"c_main.h\"\n"
466                  "#include \"a_other.h\"\n",
467                  "c_main.cc", 0));
468 }
469 
470 TEST_F(SortIncludesTest, PriorityGroupsAreSeparatedWhenRegroupping) {
471   Style.IncludeCategories = {{".*important_os_header.*", -1}, {".*", 1}};
472   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
473 
474   EXPECT_EQ("#include \"important_os_header.h\"\n"
475             "\n"
476             "#include \"c_main.h\"\n"
477             "\n"
478             "#include \"a_other.h\"\n",
479             sort("#include \"c_main.h\"\n"
480                  "#include \"a_other.h\"\n"
481                  "#include \"important_os_header.h\"\n",
482                  "c_main.cc"));
483 
484   // check stable when re-run
485   EXPECT_EQ("#include \"important_os_header.h\"\n"
486             "\n"
487             "#include \"c_main.h\"\n"
488             "\n"
489             "#include \"a_other.h\"\n",
490             sort("#include \"important_os_header.h\"\n"
491                  "\n"
492                  "#include \"c_main.h\"\n"
493                  "\n"
494                  "#include \"a_other.h\"\n",
495                  "c_main.cc", 0));
496 }
497 
498 TEST_F(SortIncludesTest, CalculatesCorrectCursorPosition) {
499   std::string Code = "#include <ccc>\n"    // Start of line: 0
500                      "#include <bbbbbb>\n" // Start of line: 15
501                      "#include <a>\n";     // Start of line: 33
502   EXPECT_EQ(31u, newCursor(Code, 0));
503   EXPECT_EQ(13u, newCursor(Code, 15));
504   EXPECT_EQ(0u, newCursor(Code, 33));
505 
506   EXPECT_EQ(41u, newCursor(Code, 10));
507   EXPECT_EQ(23u, newCursor(Code, 25));
508   EXPECT_EQ(10u, newCursor(Code, 43));
509 }
510 
511 TEST_F(SortIncludesTest, DeduplicateIncludes) {
512   EXPECT_EQ("#include <a>\n"
513             "#include <b>\n"
514             "#include <c>\n",
515             sort("#include <a>\n"
516                  "#include <b>\n"
517                  "#include <b>\n"
518                  "#include <b>\n"
519                  "#include <b>\n"
520                  "#include <c>\n"));
521 
522   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
523   EXPECT_EQ("#include <a>\n"
524             "#include <b>\n"
525             "#include <c>\n",
526             sort("#include <a>\n"
527                  "#include <b>\n"
528                  "\n"
529                  "#include <b>\n"
530                  "\n"
531                  "#include <b>\n"
532                  "#include <c>\n"));
533 
534   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
535   EXPECT_EQ("#include <a>\n"
536             "#include <b>\n"
537             "#include <c>\n",
538             sort("#include <a>\n"
539                  "#include <b>\n"
540                  "\n"
541                  "#include <b>\n"
542                  "\n"
543                  "#include <b>\n"
544                  "#include <c>\n"));
545 }
546 
547 TEST_F(SortIncludesTest, SortAndDeduplicateIncludes) {
548   EXPECT_EQ("#include <a>\n"
549             "#include <b>\n"
550             "#include <c>\n",
551             sort("#include <b>\n"
552                  "#include <a>\n"
553                  "#include <b>\n"
554                  "#include <b>\n"
555                  "#include <c>\n"
556                  "#include <b>\n"));
557 
558   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
559   EXPECT_EQ("#include <a>\n"
560             "#include <b>\n"
561             "#include <c>\n",
562             sort("#include <b>\n"
563                  "#include <a>\n"
564                  "\n"
565                  "#include <b>\n"
566                  "\n"
567                  "#include <c>\n"
568                  "#include <b>\n"));
569 
570   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
571   EXPECT_EQ("#include <a>\n"
572             "#include <b>\n"
573             "#include <c>\n",
574             sort("#include <b>\n"
575                  "#include <a>\n"
576                  "\n"
577                  "#include <b>\n"
578                  "\n"
579                  "#include <c>\n"
580                  "#include <b>\n"));
581 }
582 
583 TEST_F(SortIncludesTest, CalculatesCorrectCursorPositionAfterDeduplicate) {
584   std::string Code = "#include <b>\n"      // Start of line: 0
585                      "#include <a>\n"      // Start of line: 13
586                      "#include <b>\n"      // Start of line: 26
587                      "#include <b>\n"      // Start of line: 39
588                      "#include <c>\n"      // Start of line: 52
589                      "#include <b>\n";     // Start of line: 65
590   std::string Expected = "#include <a>\n"  // Start of line: 0
591                          "#include <b>\n"  // Start of line: 13
592                          "#include <c>\n"; // Start of line: 26
593   EXPECT_EQ(Expected, sort(Code));
594   // Cursor on 'i' in "#include <a>".
595   EXPECT_EQ(1u, newCursor(Code, 14));
596   // Cursor on 'b' in "#include <b>".
597   EXPECT_EQ(23u, newCursor(Code, 10));
598   EXPECT_EQ(23u, newCursor(Code, 36));
599   EXPECT_EQ(23u, newCursor(Code, 49));
600   EXPECT_EQ(23u, newCursor(Code, 36));
601   EXPECT_EQ(23u, newCursor(Code, 75));
602   // Cursor on '#' in "#include <c>".
603   EXPECT_EQ(26u, newCursor(Code, 52));
604 }
605 
606 TEST_F(SortIncludesTest, DeduplicateLocallyInEachBlock) {
607   EXPECT_EQ("#include <a>\n"
608             "#include <b>\n"
609             "\n"
610             "#include <b>\n"
611             "#include <c>\n",
612             sort("#include <a>\n"
613                  "#include <b>\n"
614                  "\n"
615                  "#include <c>\n"
616                  "#include <b>\n"
617                  "#include <b>\n"));
618 }
619 
620 TEST_F(SortIncludesTest, ValidAffactedRangesAfterDeduplicatingIncludes) {
621   std::string Code = "#include <a>\n"
622                      "#include <b>\n"
623                      "#include <a>\n"
624                      "#include <a>\n"
625                      "\n"
626                      "   int     x ;";
627   std::vector<tooling::Range> Ranges = {tooling::Range(0, 52)};
628   auto Replaces = sortIncludes(FmtStyle, Code, Ranges, "input.cpp");
629   Ranges = tooling::calculateRangesAfterReplacements(Replaces, Ranges);
630   EXPECT_EQ(1u, Ranges.size());
631   EXPECT_EQ(0u, Ranges[0].getOffset());
632   EXPECT_EQ(26u, Ranges[0].getLength());
633 }
634 
635 TEST_F(SortIncludesTest, DoNotSortLikelyXml) {
636   EXPECT_EQ("<!--;\n"
637             "#include <b>\n"
638             "#include <a>\n"
639             "-->",
640             sort("<!--;\n"
641                  "#include <b>\n"
642                  "#include <a>\n"
643                  "-->", "input.h", 0));
644 }
645 
646 TEST_F(SortIncludesTest, DoNotOutputReplacementsForSortedBlocksWithRegrouping) {
647   Style.IncludeBlocks = Style.IBS_Regroup;
648   std::string Code = R"(
649 #include "b.h"
650 
651 #include <a.h>
652 )";
653   EXPECT_EQ(Code, sort(Code, "input.h", 0));
654 }
655 
656 
657 TEST_F(SortIncludesTest, DoNotRegroupGroupsInGoogleObjCStyle) {
658   FmtStyle = getGoogleStyle(FormatStyle::LK_ObjC);
659 
660   EXPECT_EQ("#include <a.h>\n"
661             "#include <b.h>\n"
662             "#include \"a.h\"",
663             sort("#include <b.h>\n"
664                  "#include <a.h>\n"
665                  "#include \"a.h\""));
666 }
667 
668 } // end namespace
669 } // end namespace format
670 } // end namespace clang
671