xref: /llvm-project/clang/unittests/Tooling/RefactoringTest.cpp (revision ce27e59b3e33c11cb385c361ad9cb79c93a7d012) 
1 //===- unittest/Tooling/RefactoringTest.cpp - Refactoring unit tests ------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "ReplacementTest.h"
11 #include "RewriterTestContext.h"
12 #include "clang/AST/ASTConsumer.h"
13 #include "clang/AST/ASTContext.h"
14 #include "clang/AST/DeclCXX.h"
15 #include "clang/AST/DeclGroup.h"
16 #include "clang/AST/RecursiveASTVisitor.h"
17 #include "clang/Basic/Diagnostic.h"
18 #include "clang/Basic/DiagnosticOptions.h"
19 #include "clang/Basic/FileManager.h"
20 #include "clang/Basic/LangOptions.h"
21 #include "clang/Basic/SourceManager.h"
22 #include "clang/Basic/VirtualFileSystem.h"
23 #include "clang/Format/Format.h"
24 #include "clang/Frontend/CompilerInstance.h"
25 #include "clang/Frontend/FrontendAction.h"
26 #include "clang/Frontend/TextDiagnosticPrinter.h"
27 #include "clang/Rewrite/Core/Rewriter.h"
28 #include "clang/Tooling/Refactoring.h"
29 #include "clang/Tooling/Refactoring/AtomicChange.h"
30 #include "clang/Tooling/Tooling.h"
31 #include "llvm/ADT/SmallString.h"
32 #include "gtest/gtest.h"
33 
34 namespace clang {
35 namespace tooling {
36 
37 TEST_F(ReplacementTest, CanDeleteAllText) {
38   FileID ID = Context.createInMemoryFile("input.cpp", "text");
39   SourceLocation Location = Context.getLocation(ID, 1, 1);
40   Replacement Replace(createReplacement(Location, 4, ""));
41   EXPECT_TRUE(Replace.apply(Context.Rewrite));
42   EXPECT_EQ("", Context.getRewrittenText(ID));
43 }
44 
45 TEST_F(ReplacementTest, CanDeleteAllTextInTextWithNewlines) {
46   FileID ID = Context.createInMemoryFile("input.cpp", "line1\nline2\nline3");
47   SourceLocation Location = Context.getLocation(ID, 1, 1);
48   Replacement Replace(createReplacement(Location, 17, ""));
49   EXPECT_TRUE(Replace.apply(Context.Rewrite));
50   EXPECT_EQ("", Context.getRewrittenText(ID));
51 }
52 
53 TEST_F(ReplacementTest, CanAddText) {
54   FileID ID = Context.createInMemoryFile("input.cpp", "");
55   SourceLocation Location = Context.getLocation(ID, 1, 1);
56   Replacement Replace(createReplacement(Location, 0, "result"));
57   EXPECT_TRUE(Replace.apply(Context.Rewrite));
58   EXPECT_EQ("result", Context.getRewrittenText(ID));
59 }
60 
61 TEST_F(ReplacementTest, CanReplaceTextAtPosition) {
62   FileID ID = Context.createInMemoryFile("input.cpp",
63                                          "line1\nline2\nline3\nline4");
64   SourceLocation Location = Context.getLocation(ID, 2, 3);
65   Replacement Replace(createReplacement(Location, 12, "x"));
66   EXPECT_TRUE(Replace.apply(Context.Rewrite));
67   EXPECT_EQ("line1\nlixne4", Context.getRewrittenText(ID));
68 }
69 
70 TEST_F(ReplacementTest, CanReplaceTextAtPositionMultipleTimes) {
71   FileID ID = Context.createInMemoryFile("input.cpp",
72                                          "line1\nline2\nline3\nline4");
73   SourceLocation Location1 = Context.getLocation(ID, 2, 3);
74   Replacement Replace1(createReplacement(Location1, 12, "x\ny\n"));
75   EXPECT_TRUE(Replace1.apply(Context.Rewrite));
76   EXPECT_EQ("line1\nlix\ny\nne4", Context.getRewrittenText(ID));
77 
78   // Since the original source has not been modified, the (4, 4) points to the
79   // 'e' in the original content.
80   SourceLocation Location2 = Context.getLocation(ID, 4, 4);
81   Replacement Replace2(createReplacement(Location2, 1, "f"));
82   EXPECT_TRUE(Replace2.apply(Context.Rewrite));
83   EXPECT_EQ("line1\nlix\ny\nnf4", Context.getRewrittenText(ID));
84 }
85 
86 TEST_F(ReplacementTest, ApplyFailsForNonExistentLocation) {
87   Replacement Replace("nonexistent-file.cpp", 0, 1, "");
88   EXPECT_FALSE(Replace.apply(Context.Rewrite));
89 }
90 
91 TEST_F(ReplacementTest, CanRetrivePath) {
92   Replacement Replace("/path/to/file.cpp", 0, 1, "");
93   EXPECT_EQ("/path/to/file.cpp", Replace.getFilePath());
94 }
95 
96 TEST_F(ReplacementTest, ReturnsInvalidPath) {
97   Replacement Replace1(Context.Sources, SourceLocation(), 0, "");
98   EXPECT_TRUE(Replace1.getFilePath().empty());
99 
100   Replacement Replace2;
101   EXPECT_TRUE(Replace2.getFilePath().empty());
102 }
103 
104 // Checks that an llvm::Error instance contains a ReplacementError with expected
105 // error code, expected new replacement, and expected existing replacement.
106 static bool checkReplacementError(llvm::Error &&Error,
107                                   replacement_error ExpectedErr,
108                                   llvm::Optional<Replacement> ExpectedExisting,
109                                   llvm::Optional<Replacement> ExpectedNew) {
110   if (!Error) {
111     llvm::errs() << "Error is a success.";
112     return false;
113   }
114   std::string ErrorMessage;
115   llvm::raw_string_ostream OS(ErrorMessage);
116   llvm::handleAllErrors(std::move(Error), [&](const ReplacementError &RE) {
117     llvm::errs() << "Handling error...\n";
118     if (ExpectedErr != RE.get())
119       OS << "Unexpected error code: " << int(RE.get()) << "\n";
120     if (ExpectedExisting != RE.getExistingReplacement()) {
121       OS << "Expected Existing != Actual Existing.\n";
122       if (ExpectedExisting.hasValue())
123         OS << "Expected existing replacement: " << ExpectedExisting->toString()
124            << "\n";
125       if (RE.getExistingReplacement().hasValue())
126         OS << "Actual existing replacement: "
127            << RE.getExistingReplacement()->toString() << "\n";
128     }
129     if (ExpectedNew != RE.getNewReplacement()) {
130       OS << "Expected New != Actual New.\n";
131       if (ExpectedNew.hasValue())
132         OS << "Expected new replacement: " << ExpectedNew->toString() << "\n";
133       if (RE.getNewReplacement().hasValue())
134         OS << "Actual new replacement: " << RE.getNewReplacement()->toString()
135            << "\n";
136     }
137   });
138   OS.flush();
139   if (ErrorMessage.empty()) return true;
140   llvm::errs() << ErrorMessage;
141   return false;
142 }
143 
144 TEST_F(ReplacementTest, FailAddReplacements) {
145   Replacements Replaces;
146   Replacement Deletion("x.cc", 0, 10, "3");
147   auto Err = Replaces.add(Deletion);
148   EXPECT_TRUE(!Err);
149   llvm::consumeError(std::move(Err));
150 
151   Replacement OverlappingReplacement("x.cc", 0, 2, "a");
152   Err = Replaces.add(OverlappingReplacement);
153   EXPECT_TRUE(checkReplacementError(std::move(Err),
154                                     replacement_error::overlap_conflict,
155                                     Deletion, OverlappingReplacement));
156 
157   Replacement ContainedReplacement("x.cc", 2, 2, "a");
158   Err = Replaces.add(Replacement(ContainedReplacement));
159   EXPECT_TRUE(checkReplacementError(std::move(Err),
160                                     replacement_error::overlap_conflict,
161                                     Deletion, ContainedReplacement));
162 
163   Replacement WrongPathReplacement("y.cc", 20, 2, "");
164   Err = Replaces.add(WrongPathReplacement);
165   EXPECT_TRUE(checkReplacementError(std::move(Err),
166                                     replacement_error::wrong_file_path,
167                                     Deletion, WrongPathReplacement));
168 
169   EXPECT_EQ(1u, Replaces.size());
170   EXPECT_EQ(Deletion, *Replaces.begin());
171 }
172 
173 TEST_F(ReplacementTest, DeletionInReplacements) {
174   Replacements Replaces;
175   Replacement R("x.cc", 0, 10, "3");
176   auto Err = Replaces.add(R);
177   EXPECT_TRUE(!Err);
178   llvm::consumeError(std::move(Err));
179   Err = Replaces.add(Replacement("x.cc", 0, 2, ""));
180   EXPECT_TRUE(!Err);
181   llvm::consumeError(std::move(Err));
182   Err = Replaces.add(Replacement("x.cc", 2, 2, ""));
183   EXPECT_TRUE(!Err);
184   llvm::consumeError(std::move(Err));
185   EXPECT_EQ(1u, Replaces.size());
186   EXPECT_EQ(R, *Replaces.begin());
187 }
188 
189 TEST_F(ReplacementTest, OverlappingReplacements) {
190   Replacements Replaces;
191   auto Err = Replaces.add(Replacement("x.cc", 0, 3, "345"));
192   EXPECT_TRUE(!Err);
193   llvm::consumeError(std::move(Err));
194   Err = Replaces.add(Replacement("x.cc", 2, 3, "543"));
195   EXPECT_TRUE(!Err);
196   llvm::consumeError(std::move(Err));
197 
198   EXPECT_EQ(1u, Replaces.size());
199   EXPECT_EQ(Replacement("x.cc", 0, 5, "34543"), *Replaces.begin());
200 
201   Err = Replaces.add(Replacement("x.cc", 2, 1, "5"));
202   EXPECT_TRUE(!Err);
203   llvm::consumeError(std::move(Err));
204   EXPECT_EQ(1u, Replaces.size());
205   EXPECT_EQ(Replacement("x.cc", 0, 5, "34543"), *Replaces.begin());
206 }
207 
208 TEST_F(ReplacementTest, AddAdjacentInsertionAndReplacement) {
209   Replacements Replaces;
210   // Test adding an insertion at the offset of an existing replacement.
211   auto Err = Replaces.add(Replacement("x.cc", 10, 3, "replace"));
212   EXPECT_TRUE(!Err);
213   llvm::consumeError(std::move(Err));
214   Err = Replaces.add(Replacement("x.cc", 10, 0, "insert"));
215   EXPECT_TRUE(!Err);
216   llvm::consumeError(std::move(Err));
217   EXPECT_EQ(Replaces.size(), 2u);
218 
219   Replaces.clear();
220   // Test overlap with an existing insertion.
221   Err = Replaces.add(Replacement("x.cc", 10, 0, "insert"));
222   EXPECT_TRUE(!Err);
223   llvm::consumeError(std::move(Err));
224   Err = Replaces.add(Replacement("x.cc", 10, 3, "replace"));
225   EXPECT_TRUE(!Err);
226   llvm::consumeError(std::move(Err));
227   EXPECT_EQ(Replaces.size(), 2u);
228 }
229 
230 TEST_F(ReplacementTest, MergeNewDeletions) {
231   Replacements Replaces;
232   Replacement ContainingReplacement("x.cc", 0, 10, "");
233   auto Err = Replaces.add(ContainingReplacement);
234   EXPECT_TRUE(!Err);
235   llvm::consumeError(std::move(Err));
236 
237   Err = Replaces.add(Replacement("x.cc", 5, 3, ""));
238   EXPECT_TRUE(!Err);
239   llvm::consumeError(std::move(Err));
240 
241   Err = Replaces.add(Replacement("x.cc", 0, 10, ""));
242   EXPECT_TRUE(!Err);
243   llvm::consumeError(std::move(Err));
244 
245   Err = Replaces.add(Replacement("x.cc", 5, 5, ""));
246   EXPECT_TRUE(!Err);
247   llvm::consumeError(std::move(Err));
248 
249   EXPECT_EQ(1u, Replaces.size());
250   EXPECT_EQ(*Replaces.begin(), ContainingReplacement);
251 }
252 
253 TEST_F(ReplacementTest, MergeOverlappingButNotAdjacentReplacement) {
254   Replacements Replaces;
255   auto Err = Replaces.add(Replacement("x.cc", 0, 2, ""));
256   EXPECT_TRUE(!Err);
257   llvm::consumeError(std::move(Err));
258 
259   Err = Replaces.add(Replacement("x.cc", 5, 5, ""));
260   EXPECT_TRUE(!Err);
261   llvm::consumeError(std::move(Err));
262 
263   Replacement After = Replacement("x.cc", 10, 5, "");
264   Err = Replaces.add(After);
265   EXPECT_TRUE(!Err);
266   llvm::consumeError(std::move(Err));
267 
268   Replacement ContainingReplacement("x.cc", 0, 10, "");
269   Err = Replaces.add(ContainingReplacement);
270   EXPECT_TRUE(!Err);
271   llvm::consumeError(std::move(Err));
272 
273   EXPECT_EQ(2u, Replaces.size());
274   EXPECT_EQ(*Replaces.begin(), ContainingReplacement);
275   EXPECT_EQ(*(++Replaces.begin()), After);
276 }
277 
278 TEST_F(ReplacementTest, InsertionBeforeMergedDeletions) {
279   Replacements Replaces;
280 
281   Replacement Insertion("x.cc", 0, 0, "123");
282   auto Err = Replaces.add(Insertion);
283   EXPECT_TRUE(!Err);
284   llvm::consumeError(std::move(Err));
285 
286   Err = Replaces.add(Replacement("x.cc", 5, 5, ""));
287   EXPECT_TRUE(!Err);
288   llvm::consumeError(std::move(Err));
289 
290   Replacement Deletion("x.cc", 0, 10, "");
291   Err = Replaces.add(Deletion);
292   EXPECT_TRUE(!Err);
293   llvm::consumeError(std::move(Err));
294 
295   EXPECT_EQ(2u, Replaces.size());
296   EXPECT_EQ(*Replaces.begin(), Insertion);
297   EXPECT_EQ(*(++Replaces.begin()), Deletion);
298 }
299 
300 TEST_F(ReplacementTest, MergeOverlappingDeletions) {
301   Replacements Replaces;
302   auto Err = Replaces.add(Replacement("x.cc", 0, 2, ""));
303   EXPECT_TRUE(!Err);
304   llvm::consumeError(std::move(Err));
305 
306   Err = Replaces.add(Replacement("x.cc", 0, 5, ""));
307   EXPECT_TRUE(!Err);
308   llvm::consumeError(std::move(Err));
309 
310   EXPECT_EQ(1u, Replaces.size());
311   EXPECT_EQ(Replacement("x.cc", 0, 5, ""), *Replaces.begin());
312 
313   Err = Replaces.add(Replacement("x.cc", 1, 5, ""));
314   EXPECT_TRUE(!Err);
315   llvm::consumeError(std::move(Err));
316   EXPECT_EQ(1u, Replaces.size());
317   EXPECT_EQ(Replacement("x.cc", 0, 6, ""), *Replaces.begin());
318 }
319 
320 TEST_F(ReplacementTest, FailedMergeExistingDeletions) {
321   Replacements Replaces;
322   Replacement First("x.cc", 0, 2, "");
323   auto Err = Replaces.add(First);
324   EXPECT_TRUE(!Err);
325   llvm::consumeError(std::move(Err));
326 
327   Replacement Second("x.cc", 5, 5, "");
328   Err = Replaces.add(Second);
329   EXPECT_TRUE(!Err);
330   llvm::consumeError(std::move(Err));
331 
332   Err = Replaces.add(Replacement("x.cc", 1, 10, ""));
333   EXPECT_TRUE(!Err);
334   llvm::consumeError(std::move(Err));
335 
336   EXPECT_EQ(1u, Replaces.size());
337   EXPECT_EQ(Replacement("x.cc", 0, 11, ""), *Replaces.begin());
338 }
339 
340 TEST_F(ReplacementTest, FailAddRegression) {
341   Replacements Replaces;
342   // Create two replacements, where the second one is an insertion of the empty
343   // string exactly at the end of the first one.
344   auto Err = Replaces.add(Replacement("x.cc", 0, 10, "1"));
345   EXPECT_TRUE(!Err);
346   llvm::consumeError(std::move(Err));
347   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
348   EXPECT_TRUE(!Err);
349   llvm::consumeError(std::move(Err));
350 
351   // Make sure we find the overlap with the first entry when inserting a
352   // replacement that ends exactly at the seam of the existing replacements.
353   Replacement OverlappingReplacement("x.cc", 5, 5, "fail");
354   Err = Replaces.add(OverlappingReplacement);
355   EXPECT_TRUE(checkReplacementError(std::move(Err),
356                                     replacement_error::overlap_conflict,
357                                     *Replaces.begin(), OverlappingReplacement));
358 
359   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
360   EXPECT_TRUE(!Err);
361   llvm::consumeError(std::move(Err));
362 }
363 
364 TEST_F(ReplacementTest, InsertAtOffsetOfReplacement) {
365   Replacements Replaces;
366   auto Err = Replaces.add(Replacement("x.cc", 10, 2, ""));
367   EXPECT_TRUE(!Err);
368   llvm::consumeError(std::move(Err));
369   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
370   EXPECT_TRUE(!Err);
371   llvm::consumeError(std::move(Err));
372   EXPECT_EQ(Replaces.size(), 2u);
373 
374   Replaces.clear();
375   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
376   EXPECT_TRUE(!Err);
377   llvm::consumeError(std::move(Err));
378   Err = Replaces.add(Replacement("x.cc", 10, 2, ""));
379   EXPECT_TRUE(!Err);
380   llvm::consumeError(std::move(Err));
381   EXPECT_EQ(Replaces.size(), 2u);
382 }
383 
384 TEST_F(ReplacementTest, AddInsertAtOtherInsertWhenOderIndependent) {
385   Replacements Replaces;
386   auto Err = Replaces.add(Replacement("x.cc", 10, 0, "a"));
387   EXPECT_TRUE(!Err);
388   llvm::consumeError(std::move(Err));
389   Replacement ConflictInsertion("x.cc", 10, 0, "b");
390   Err = Replaces.add(ConflictInsertion);
391   EXPECT_TRUE(checkReplacementError(std::move(Err),
392                                     replacement_error::insert_conflict,
393                                     *Replaces.begin(), ConflictInsertion));
394 
395   Replaces.clear();
396   Err = Replaces.add(Replacement("x.cc", 10, 0, "a"));
397   EXPECT_TRUE(!Err);
398   llvm::consumeError(std::move(Err));
399   Err = Replaces.add(Replacement("x.cc", 10, 0, "aa"));
400   EXPECT_TRUE(!Err);
401   llvm::consumeError(std::move(Err));
402   EXPECT_EQ(1u, Replaces.size());
403   EXPECT_EQ(Replacement("x.cc", 10, 0, "aaa"), *Replaces.begin());
404 
405   Replaces.clear();
406   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
407   EXPECT_TRUE(!Err);
408   llvm::consumeError(std::move(Err));
409   Err = Replaces.add(Replacement("x.cc", 10, 3, ""));
410   EXPECT_TRUE(!Err);
411   llvm::consumeError(std::move(Err));
412   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
413   EXPECT_TRUE(!Err);
414   llvm::consumeError(std::move(Err));
415   EXPECT_EQ(2u, Replaces.size());
416   EXPECT_EQ(Replacement("x.cc", 10, 0, ""), *Replaces.begin());
417   EXPECT_EQ(Replacement("x.cc", 10, 3, ""), *std::next(Replaces.begin()));
418 }
419 
420 TEST_F(ReplacementTest, InsertBetweenAdjacentReplacements) {
421   Replacements Replaces;
422   auto Err = Replaces.add(Replacement("x.cc", 10, 5, "a"));
423   EXPECT_TRUE(!Err);
424   llvm::consumeError(std::move(Err));
425   Err = Replaces.add(Replacement("x.cc", 8, 2, "a"));
426   EXPECT_TRUE(!Err);
427   llvm::consumeError(std::move(Err));
428   Err = Replaces.add(Replacement("x.cc", 10, 0, "b"));
429   EXPECT_TRUE(!Err);
430   llvm::consumeError(std::move(Err));
431 }
432 
433 TEST_F(ReplacementTest, CanApplyReplacements) {
434   FileID ID = Context.createInMemoryFile("input.cpp",
435                                          "line1\nline2\nline3\nline4");
436   Replacements Replaces =
437       toReplacements({Replacement(Context.Sources,
438                                   Context.getLocation(ID, 2, 1), 5, "replaced"),
439                       Replacement(Context.Sources,
440                                   Context.getLocation(ID, 3, 1), 5, "other")});
441   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
442   EXPECT_EQ("line1\nreplaced\nother\nline4", Context.getRewrittenText(ID));
443 }
444 
445 // Verifies that replacement/deletion is applied before insertion at the same
446 // offset.
447 TEST_F(ReplacementTest, InsertAndDelete) {
448   FileID ID = Context.createInMemoryFile("input.cpp",
449                                          "line1\nline2\nline3\nline4");
450   Replacements Replaces = toReplacements(
451       {Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 6, ""),
452        Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 0,
453                    "other\n")});
454   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
455   EXPECT_EQ("line1\nother\nline3\nline4", Context.getRewrittenText(ID));
456 }
457 
458 TEST_F(ReplacementTest, AdjacentReplacements) {
459   FileID ID = Context.createInMemoryFile("input.cpp",
460                                          "ab");
461   Replacements Replaces = toReplacements(
462       {Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 1, "x"),
463        Replacement(Context.Sources, Context.getLocation(ID, 1, 2), 1, "y")});
464   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
465   EXPECT_EQ("xy", Context.getRewrittenText(ID));
466 }
467 
468 TEST_F(ReplacementTest, AddDuplicateReplacements) {
469   FileID ID = Context.createInMemoryFile("input.cpp",
470                                          "line1\nline2\nline3\nline4");
471   auto Replaces = toReplacements({Replacement(
472       Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")});
473 
474   auto Err = Replaces.add(Replacement(
475       Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced"));
476   EXPECT_TRUE(!Err);
477   llvm::consumeError(std::move(Err));
478 
479   Err = Replaces.add(Replacement(Context.Sources, Context.getLocation(ID, 2, 1),
480                                  5, "replaced"));
481   EXPECT_TRUE(!Err);
482   llvm::consumeError(std::move(Err));
483 
484   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
485   EXPECT_EQ("line1\nreplaced\nline3\nline4", Context.getRewrittenText(ID));
486 }
487 
488 TEST_F(ReplacementTest, FailOrderDependentReplacements) {
489   FileID ID = Context.createInMemoryFile("input.cpp",
490                                          "line1\nline2\nline3\nline4");
491   auto Replaces = toReplacements({Replacement(
492       Context.Sources, Context.getLocation(ID, 2, 1), 5, "other")});
493 
494   Replacement ConflictReplacement(Context.Sources,
495                                   Context.getLocation(ID, 2, 1), 5, "rehto");
496   auto Err = Replaces.add(ConflictReplacement);
497   EXPECT_TRUE(checkReplacementError(std::move(Err),
498                                     replacement_error::overlap_conflict,
499                                     *Replaces.begin(), ConflictReplacement));
500 
501   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
502   EXPECT_EQ("line1\nother\nline3\nline4", Context.getRewrittenText(ID));
503 }
504 
505 TEST_F(ReplacementTest, InvalidSourceLocationFailsApplyAll) {
506   Replacements Replaces =
507       toReplacements({Replacement(Context.Sources, SourceLocation(), 5, "2")});
508 
509   EXPECT_FALSE(applyAllReplacements(Replaces, Context.Rewrite));
510 }
511 
512 TEST_F(ReplacementTest, MultipleFilesReplaceAndFormat) {
513   // Column limit is 20.
514   std::string Code1 = "Long *a =\n"
515                       "    new Long();\n"
516                       "long x = 1;";
517   std::string Expected1 = "auto a = new Long();\n"
518                           "long x =\n"
519                           "    12345678901;";
520   std::string Code2 = "int x = 123;\n"
521                       "int y = 0;";
522   std::string Expected2 = "int x =\n"
523                           "    1234567890123;\n"
524                           "int y = 10;";
525   StringRef File1 = "format_1.cpp";
526   StringRef File2 = "format_2.cpp";
527   FileID ID1 = Context.createInMemoryFile(File1, Code1);
528   FileID ID2 = Context.createInMemoryFile(File2, Code2);
529 
530   // Scrambled the order of replacements.
531   std::map<std::string, Replacements> FileToReplaces;
532   FileToReplaces[File1] = toReplacements(
533       {tooling::Replacement(Context.Sources, Context.getLocation(ID1, 1, 1), 6,
534                             "auto "),
535        tooling::Replacement(Context.Sources, Context.getLocation(ID1, 3, 10), 1,
536                             "12345678901")});
537   FileToReplaces[File2] = toReplacements(
538       {tooling::Replacement(Context.Sources, Context.getLocation(ID2, 1, 12), 0,
539                             "4567890123"),
540        tooling::Replacement(Context.Sources, Context.getLocation(ID2, 2, 9), 1,
541                             "10")});
542   EXPECT_TRUE(
543       formatAndApplyAllReplacements(FileToReplaces, Context.Rewrite,
544                                     "{BasedOnStyle: LLVM, ColumnLimit: 20}"));
545   EXPECT_EQ(Expected1, Context.getRewrittenText(ID1));
546   EXPECT_EQ(Expected2, Context.getRewrittenText(ID2));
547 }
548 
549 TEST(ShiftedCodePositionTest, FindsNewCodePosition) {
550   Replacements Replaces =
551       toReplacements({Replacement("", 0, 1, ""), Replacement("", 4, 3, " ")});
552   // Assume ' int   i;' is turned into 'int i;' and cursor is located at '|'.
553   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(0)); // |int   i;
554   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(1)); //  |nt   i;
555   EXPECT_EQ(1u, Replaces.getShiftedCodePosition(2)); //  i|t   i;
556   EXPECT_EQ(2u, Replaces.getShiftedCodePosition(3)); //  in|   i;
557   EXPECT_EQ(3u, Replaces.getShiftedCodePosition(4)); //  int|  i;
558   EXPECT_EQ(3u, Replaces.getShiftedCodePosition(5)); //  int | i;
559   EXPECT_EQ(3u, Replaces.getShiftedCodePosition(6)); //  int  |i;
560   EXPECT_EQ(4u, Replaces.getShiftedCodePosition(7)); //  int   |;
561   EXPECT_EQ(5u, Replaces.getShiftedCodePosition(8)); //  int   i|
562 }
563 
564 TEST(ShiftedCodePositionTest, FindsNewCodePositionWithInserts) {
565   Replacements Replaces = toReplacements({Replacement("", 4, 0, "\"\n\"")});
566   // Assume '"12345678"' is turned into '"1234"\n"5678"'.
567   EXPECT_EQ(3u, Replaces.getShiftedCodePosition(3)); // "123|5678"
568   EXPECT_EQ(7u, Replaces.getShiftedCodePosition(4)); // "1234|678"
569   EXPECT_EQ(8u, Replaces.getShiftedCodePosition(5)); // "12345|78"
570 }
571 
572 TEST(ShiftedCodePositionTest, FindsNewCodePositionInReplacedText) {
573   // Replace the first four characters with "abcd".
574   auto Replaces = toReplacements({Replacement("", 0, 4, "abcd")});
575   for (unsigned i = 0; i < 3; ++i)
576     EXPECT_EQ(i, Replaces.getShiftedCodePosition(i));
577 }
578 
579 TEST(ShiftedCodePositionTest, NoReplacementText) {
580   Replacements Replaces = toReplacements({Replacement("", 0, 42, "")});
581   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(0));
582   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(39));
583   EXPECT_EQ(3u, Replaces.getShiftedCodePosition(45));
584   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(42));
585 }
586 
587 class FlushRewrittenFilesTest : public ::testing::Test {
588 public:
589    FlushRewrittenFilesTest() {}
590 
591    ~FlushRewrittenFilesTest() override {
592     for (llvm::StringMap<std::string>::iterator I = TemporaryFiles.begin(),
593                                                 E = TemporaryFiles.end();
594          I != E; ++I) {
595       llvm::StringRef Name = I->second;
596       std::error_code EC = llvm::sys::fs::remove(Name);
597       (void)EC;
598       assert(!EC);
599     }
600   }
601 
602   FileID createFile(llvm::StringRef Name, llvm::StringRef Content) {
603     SmallString<1024> Path;
604     int FD;
605     std::error_code EC = llvm::sys::fs::createTemporaryFile(Name, "", FD, Path);
606     assert(!EC);
607     (void)EC;
608 
609     llvm::raw_fd_ostream OutStream(FD, true);
610     OutStream << Content;
611     OutStream.close();
612     const FileEntry *File = Context.Files.getFile(Path);
613     assert(File != nullptr);
614 
615     StringRef Found =
616         TemporaryFiles.insert(std::make_pair(Name, Path.str())).first->second;
617     assert(Found == Path);
618     (void)Found;
619     return Context.Sources.createFileID(File, SourceLocation(), SrcMgr::C_User);
620   }
621 
622   std::string getFileContentFromDisk(llvm::StringRef Name) {
623     std::string Path = TemporaryFiles.lookup(Name);
624     assert(!Path.empty());
625     // We need to read directly from the FileManager without relaying through
626     // a FileEntry, as otherwise we'd read through an already opened file
627     // descriptor, which might not see the changes made.
628     // FIXME: Figure out whether there is a way to get the SourceManger to
629     // reopen the file.
630     auto FileBuffer = Context.Files.getBufferForFile(Path);
631     return (*FileBuffer)->getBuffer();
632   }
633 
634   llvm::StringMap<std::string> TemporaryFiles;
635   RewriterTestContext Context;
636 };
637 
638 TEST_F(FlushRewrittenFilesTest, StoresChangesOnDisk) {
639   FileID ID = createFile("input.cpp", "line1\nline2\nline3\nline4");
640   Replacements Replaces = toReplacements({Replacement(
641       Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")});
642   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
643   EXPECT_FALSE(Context.Rewrite.overwriteChangedFiles());
644   EXPECT_EQ("line1\nreplaced\nline3\nline4",
645             getFileContentFromDisk("input.cpp"));
646 }
647 
648 namespace {
649 template <typename T>
650 class TestVisitor : public clang::RecursiveASTVisitor<T> {
651 public:
652   bool runOver(StringRef Code) {
653     return runToolOnCode(new TestAction(this), Code);
654   }
655 
656 protected:
657   clang::SourceManager *SM;
658   clang::ASTContext *Context;
659 
660 private:
661   class FindConsumer : public clang::ASTConsumer {
662   public:
663     FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {}
664 
665     void HandleTranslationUnit(clang::ASTContext &Context) override {
666       Visitor->TraverseDecl(Context.getTranslationUnitDecl());
667     }
668 
669   private:
670     TestVisitor *Visitor;
671   };
672 
673   class TestAction : public clang::ASTFrontendAction {
674   public:
675     TestAction(TestVisitor *Visitor) : Visitor(Visitor) {}
676 
677     std::unique_ptr<clang::ASTConsumer>
678     CreateASTConsumer(clang::CompilerInstance &compiler,
679                       llvm::StringRef dummy) override {
680       Visitor->SM = &compiler.getSourceManager();
681       Visitor->Context = &compiler.getASTContext();
682       /// TestConsumer will be deleted by the framework calling us.
683       return llvm::make_unique<FindConsumer>(Visitor);
684     }
685 
686   private:
687     TestVisitor *Visitor;
688   };
689 };
690 } // end namespace
691 
692 void expectReplacementAt(const Replacement &Replace,
693                          StringRef File, unsigned Offset, unsigned Length) {
694   ASSERT_TRUE(Replace.isApplicable());
695   EXPECT_EQ(File, Replace.getFilePath());
696   EXPECT_EQ(Offset, Replace.getOffset());
697   EXPECT_EQ(Length, Replace.getLength());
698 }
699 
700 class ClassDeclXVisitor : public TestVisitor<ClassDeclXVisitor> {
701 public:
702   bool VisitCXXRecordDecl(CXXRecordDecl *Record) {
703     if (Record->getName() == "X") {
704       Replace = Replacement(*SM, Record, "");
705     }
706     return true;
707   }
708   Replacement Replace;
709 };
710 
711 TEST(Replacement, CanBeConstructedFromNode) {
712   ClassDeclXVisitor ClassDeclX;
713   EXPECT_TRUE(ClassDeclX.runOver("     class X;"));
714   expectReplacementAt(ClassDeclX.Replace, "input.cc", 5, 7);
715 }
716 
717 TEST(Replacement, ReplacesAtSpellingLocation) {
718   ClassDeclXVisitor ClassDeclX;
719   EXPECT_TRUE(ClassDeclX.runOver("#define A(Y) Y\nA(class X);"));
720   expectReplacementAt(ClassDeclX.Replace, "input.cc", 17, 7);
721 }
722 
723 class CallToFVisitor : public TestVisitor<CallToFVisitor> {
724 public:
725   bool VisitCallExpr(CallExpr *Call) {
726     if (Call->getDirectCallee()->getName() == "F") {
727       Replace = Replacement(*SM, Call, "");
728     }
729     return true;
730   }
731   Replacement Replace;
732 };
733 
734 TEST(Replacement, FunctionCall) {
735   CallToFVisitor CallToF;
736   EXPECT_TRUE(CallToF.runOver("void F(); void G() { F(); }"));
737   expectReplacementAt(CallToF.Replace, "input.cc", 21, 3);
738 }
739 
740 TEST(Replacement, TemplatedFunctionCall) {
741   CallToFVisitor CallToF;
742   EXPECT_TRUE(CallToF.runOver(
743         "template <typename T> void F(); void G() { F<int>(); }"));
744   expectReplacementAt(CallToF.Replace, "input.cc", 43, 8);
745 }
746 
747 class NestedNameSpecifierAVisitor
748     : public TestVisitor<NestedNameSpecifierAVisitor> {
749 public:
750   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc) {
751     if (NNSLoc.getNestedNameSpecifier()) {
752       if (const NamespaceDecl* NS = NNSLoc.getNestedNameSpecifier()->getAsNamespace()) {
753         if (NS->getName() == "a") {
754           Replace = Replacement(*SM, &NNSLoc, "", Context->getLangOpts());
755         }
756       }
757     }
758     return TestVisitor<NestedNameSpecifierAVisitor>::TraverseNestedNameSpecifierLoc(
759         NNSLoc);
760   }
761   Replacement Replace;
762 };
763 
764 TEST(Replacement, ColonColon) {
765   NestedNameSpecifierAVisitor VisitNNSA;
766   EXPECT_TRUE(VisitNNSA.runOver("namespace a { void f() { ::a::f(); } }"));
767   expectReplacementAt(VisitNNSA.Replace, "input.cc", 25, 5);
768 }
769 
770 TEST(Range, overlaps) {
771   EXPECT_TRUE(Range(10, 10).overlapsWith(Range(0, 11)));
772   EXPECT_TRUE(Range(0, 11).overlapsWith(Range(10, 10)));
773   EXPECT_FALSE(Range(10, 10).overlapsWith(Range(0, 10)));
774   EXPECT_FALSE(Range(0, 10).overlapsWith(Range(10, 10)));
775   EXPECT_TRUE(Range(0, 10).overlapsWith(Range(2, 6)));
776   EXPECT_TRUE(Range(2, 6).overlapsWith(Range(0, 10)));
777 }
778 
779 TEST(Range, contains) {
780   EXPECT_TRUE(Range(0, 10).contains(Range(0, 10)));
781   EXPECT_TRUE(Range(0, 10).contains(Range(2, 6)));
782   EXPECT_FALSE(Range(2, 6).contains(Range(0, 10)));
783   EXPECT_FALSE(Range(0, 10).contains(Range(0, 11)));
784 }
785 
786 TEST(Range, CalculateRangesOfReplacements) {
787   // Before: aaaabbbbbbz
788   // After : bbbbbbzzzzzzoooooooooooooooo
789   Replacements Replaces = toReplacements(
790       {Replacement("foo", 0, 4, ""), Replacement("foo", 10, 1, "zzzzzz"),
791        Replacement("foo", 11, 0, "oooooooooooooooo")});
792 
793   std::vector<Range> Ranges = Replaces.getAffectedRanges();
794 
795   EXPECT_EQ(2ul, Ranges.size());
796   EXPECT_TRUE(Ranges[0].getOffset() == 0);
797   EXPECT_TRUE(Ranges[0].getLength() == 0);
798   EXPECT_TRUE(Ranges[1].getOffset() == 6);
799   EXPECT_TRUE(Ranges[1].getLength() == 22);
800 }
801 
802 TEST(Range, CalculateRangesOfInsertionAroundReplacement) {
803   Replacements Replaces = toReplacements(
804       {Replacement("foo", 0, 2, ""), Replacement("foo", 0, 0, "ba")});
805 
806   std::vector<Range> Ranges = Replaces.getAffectedRanges();
807 
808   EXPECT_EQ(1ul, Ranges.size());
809   EXPECT_EQ(0u, Ranges[0].getOffset());
810   EXPECT_EQ(2u, Ranges[0].getLength());
811 }
812 
813 TEST(Range, RangesAfterEmptyReplacements) {
814   std::vector<Range> Ranges = {Range(5, 6), Range(10, 5)};
815   Replacements Replaces;
816   std::vector<Range> Expected = {Range(5, 10)};
817   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
818 }
819 
820 TEST(Range, RangesAfterReplacements) {
821   std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)};
822   Replacements Replaces = toReplacements({Replacement("foo", 0, 2, "1234")});
823   std::vector<Range> Expected = {Range(0, 4), Range(7, 2), Range(12, 5)};
824   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
825 }
826 
827 TEST(Range, RangesBeforeReplacements) {
828   std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)};
829   Replacements Replaces = toReplacements({Replacement("foo", 20, 2, "1234")});
830   std::vector<Range> Expected = {Range(5, 2), Range(10, 5), Range(20, 4)};
831   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
832 }
833 
834 TEST(Range, NotAffectedByReplacements) {
835   std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)};
836   Replacements Replaces = toReplacements({Replacement("foo", 3, 2, "12"),
837                                           Replacement("foo", 12, 2, "12"),
838                                           Replacement("foo", 20, 5, "")});
839   std::vector<Range> Expected = {Range(0, 2), Range(3, 4), Range(10, 5),
840                                  Range(20, 0)};
841   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
842 }
843 
844 TEST(Range, RangesWithNonOverlappingReplacements) {
845   std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)};
846   Replacements Replaces = toReplacements({Replacement("foo", 3, 1, ""),
847                                           Replacement("foo", 6, 1, "123"),
848                                           Replacement("foo", 20, 2, "12345")});
849   std::vector<Range> Expected = {Range(0, 2), Range(3, 0), Range(4, 4),
850                                  Range(11, 5), Range(21, 5)};
851   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
852 }
853 
854 TEST(Range, RangesWithOverlappingReplacements) {
855   std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5),
856                                Range(30, 5)};
857   Replacements Replaces = toReplacements(
858       {Replacement("foo", 1, 3, ""), Replacement("foo", 6, 1, "123"),
859        Replacement("foo", 13, 3, "1"), Replacement("foo", 25, 15, "")});
860   std::vector<Range> Expected = {Range(0, 1), Range(2, 4), Range(12, 5),
861                                  Range(22, 0)};
862   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
863 }
864 
865 TEST(Range, MergeIntoOneRange) {
866   std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)};
867   Replacements Replaces =
868       toReplacements({Replacement("foo", 1, 15, "1234567890")});
869   std::vector<Range> Expected = {Range(0, 15)};
870   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
871 }
872 
873 TEST(Range, ReplacementsStartingAtRangeOffsets) {
874   std::vector<Range> Ranges = {Range(0, 2), Range(5, 5), Range(15, 5)};
875   Replacements Replaces = toReplacements(
876       {Replacement("foo", 0, 2, "12"), Replacement("foo", 5, 1, "123"),
877        Replacement("foo", 7, 4, "12345"), Replacement("foo", 15, 10, "12")});
878   std::vector<Range> Expected = {Range(0, 2), Range(5, 9), Range(18, 2)};
879   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
880 }
881 
882 TEST(Range, ReplacementsEndingAtRangeEnds) {
883   std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)};
884   Replacements Replaces = toReplacements(
885       {Replacement("foo", 6, 1, "123"), Replacement("foo", 17, 3, "12")});
886   std::vector<Range> Expected = {Range(0, 2), Range(5, 4), Range(17, 4)};
887   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
888 }
889 
890 TEST(Range, AjacentReplacements) {
891   std::vector<Range> Ranges = {Range(0, 0), Range(15, 5)};
892   Replacements Replaces = toReplacements(
893       {Replacement("foo", 1, 2, "123"), Replacement("foo", 12, 3, "1234")});
894   std::vector<Range> Expected = {Range(0, 0), Range(1, 3), Range(13, 9)};
895   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
896 }
897 
898 TEST(Range, MergeRangesAfterReplacements) {
899   std::vector<Range> Ranges = {Range(8, 0), Range(5, 2), Range(9, 0), Range(0, 1)};
900   Replacements Replaces = toReplacements({Replacement("foo", 1, 3, ""),
901                                           Replacement("foo", 7, 0, "12"),
902                                           Replacement("foo", 9, 2, "")});
903   std::vector<Range> Expected = {Range(0, 1), Range(2, 4), Range(7, 0),
904                                  Range(8, 0)};
905   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
906 }
907 
908 TEST(Range, ConflictingRangesBeforeReplacements) {
909   std::vector<Range> Ranges = {Range(8, 3), Range(5, 4), Range(9, 1)};
910   Replacements Replaces = toReplacements({Replacement("foo", 1, 3, "")});
911   std::vector<Range> Expected = {Range(1, 0), Range(2, 6)};
912   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
913 }
914 
915 class MergeReplacementsTest : public ::testing::Test {
916 protected:
917   void mergeAndTestRewrite(StringRef Code, StringRef Intermediate,
918                            StringRef Result, const Replacements &First,
919                            const Replacements &Second) {
920     // These are mainly to verify the test itself and make it easier to read.
921     auto AfterFirst = applyAllReplacements(Code, First);
922     EXPECT_TRUE(static_cast<bool>(AfterFirst));
923     auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
924     EXPECT_TRUE(static_cast<bool>(InSequenceRewrite));
925     EXPECT_EQ(Intermediate, *AfterFirst);
926     EXPECT_EQ(Result, *InSequenceRewrite);
927 
928     tooling::Replacements Merged = First.merge(Second);
929     auto MergedRewrite = applyAllReplacements(Code, Merged);
930     EXPECT_TRUE(static_cast<bool>(MergedRewrite));
931     EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
932     if (*InSequenceRewrite != *MergedRewrite)
933       for (tooling::Replacement M : Merged)
934         llvm::errs() << M.getOffset() << " " << M.getLength() << " "
935                      << M.getReplacementText() << "\n";
936   }
937   void mergeAndTestRewrite(StringRef Code, const Replacements &First,
938                            const Replacements &Second) {
939     auto AfterFirst = applyAllReplacements(Code, First);
940     EXPECT_TRUE(static_cast<bool>(AfterFirst));
941     auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
942     tooling::Replacements Merged = First.merge(Second);
943     auto MergedRewrite = applyAllReplacements(Code, Merged);
944     EXPECT_TRUE(static_cast<bool>(MergedRewrite));
945     EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
946     if (*InSequenceRewrite != *MergedRewrite)
947       for (tooling::Replacement M : Merged)
948         llvm::errs() << M.getOffset() << " " << M.getLength() << " "
949                      << M.getReplacementText() << "\n";
950   }
951 };
952 
953 TEST_F(MergeReplacementsTest, Offsets) {
954   mergeAndTestRewrite("aaa", "aabab", "cacabab",
955                       toReplacements({{"", 2, 0, "b"}, {"", 3, 0, "b"}}),
956                       toReplacements({{"", 0, 0, "c"}, {"", 1, 0, "c"}}));
957   mergeAndTestRewrite("aaa", "babaa", "babacac",
958                       toReplacements({{"", 0, 0, "b"}, {"", 1, 0, "b"}}),
959                       toReplacements({{"", 4, 0, "c"}, {"", 5, 0, "c"}}));
960   mergeAndTestRewrite("aaaa", "aaa", "aac", toReplacements({{"", 1, 1, ""}}),
961                       toReplacements({{"", 2, 1, "c"}}));
962 
963   mergeAndTestRewrite("aa", "bbabba", "bbabcba",
964                       toReplacements({{"", 0, 0, "bb"}, {"", 1, 0, "bb"}}),
965                       toReplacements({{"", 4, 0, "c"}}));
966 }
967 
968 TEST_F(MergeReplacementsTest, Concatenations) {
969   // Basic concatenations. It is important to merge these into a single
970   // replacement to ensure the correct order.
971   {
972     auto First = toReplacements({{"", 0, 0, "a"}});
973     auto Second = toReplacements({{"", 1, 0, "b"}});
974     EXPECT_EQ(toReplacements({{"", 0, 0, "ab"}}), First.merge(Second));
975   }
976   {
977     auto First = toReplacements({{"", 0, 0, "a"}});
978     auto Second = toReplacements({{"", 0, 0, "b"}});
979     EXPECT_EQ(toReplacements({{"", 0, 0, "ba"}}), First.merge(Second));
980   }
981   mergeAndTestRewrite("", "a", "ab", toReplacements({{"", 0, 0, "a"}}),
982                       toReplacements({{"", 1, 0, "b"}}));
983   mergeAndTestRewrite("", "a", "ba", toReplacements({{"", 0, 0, "a"}}),
984                       toReplacements({{"", 0, 0, "b"}}));
985 }
986 
987 TEST_F(MergeReplacementsTest, NotChangingLengths) {
988   mergeAndTestRewrite("aaaa", "abba", "acca",
989                       toReplacements({{"", 1, 2, "bb"}}),
990                       toReplacements({{"", 1, 2, "cc"}}));
991   mergeAndTestRewrite("aaaa", "abba", "abcc",
992                       toReplacements({{"", 1, 2, "bb"}}),
993                       toReplacements({{"", 2, 2, "cc"}}));
994   mergeAndTestRewrite("aaaa", "abba", "ccba",
995                       toReplacements({{"", 1, 2, "bb"}}),
996                       toReplacements({{"", 0, 2, "cc"}}));
997   mergeAndTestRewrite("aaaaaa", "abbdda", "abccda",
998                       toReplacements({{"", 1, 2, "bb"}, {"", 3, 2, "dd"}}),
999                       toReplacements({{"", 2, 2, "cc"}}));
1000 }
1001 
1002 TEST_F(MergeReplacementsTest, OverlappingRanges) {
1003   mergeAndTestRewrite("aaa", "bbd", "bcbcd",
1004                       toReplacements({{"", 0, 1, "bb"}, {"", 1, 2, "d"}}),
1005                       toReplacements({{"", 1, 0, "c"}, {"", 2, 0, "c"}}));
1006 
1007   mergeAndTestRewrite("aaaa", "aabbaa", "acccca",
1008                       toReplacements({{"", 2, 0, "bb"}}),
1009                       toReplacements({{"", 1, 4, "cccc"}}));
1010   mergeAndTestRewrite("aaaa", "aababa", "acccca",
1011                       toReplacements({{"", 2, 0, "b"}, {"", 3, 0, "b"}}),
1012                       toReplacements({{"", 1, 4, "cccc"}}));
1013   mergeAndTestRewrite("aaaaaa", "abbbba", "abba",
1014                       toReplacements({{"", 1, 4, "bbbb"}}),
1015                       toReplacements({{"", 2, 2, ""}}));
1016   mergeAndTestRewrite("aaaa", "aa", "cc",
1017                       toReplacements({{"", 1, 1, ""}, {"", 2, 1, ""}}),
1018                       toReplacements({{"", 0, 2, "cc"}}));
1019   mergeAndTestRewrite("aa", "abbba", "abcbcba",
1020                       toReplacements({{"", 1, 0, "bbb"}}),
1021                       toReplacements({{"", 2, 0, "c"}, {"", 3, 0, "c"}}));
1022 
1023   mergeAndTestRewrite(
1024       "aaa", "abbab", "ccdd",
1025       toReplacements({{"", 0, 1, ""}, {"", 2, 0, "bb"}, {"", 3, 0, "b"}}),
1026       toReplacements({{"", 0, 2, "cc"}, {"", 2, 3, "dd"}}));
1027   mergeAndTestRewrite(
1028       "aa", "babbab", "ccdd",
1029       toReplacements({{"", 0, 0, "b"}, {"", 1, 0, "bb"}, {"", 2, 0, "b"}}),
1030       toReplacements({{"", 0, 3, "cc"}, {"", 3, 3, "dd"}}));
1031 }
1032 
1033 TEST(DeduplicateByFileTest, PathsWithDots) {
1034   std::map<std::string, Replacements> FileToReplaces;
1035   llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> VFS(
1036       new vfs::InMemoryFileSystem());
1037   FileManager FileMgr(FileSystemOptions(), VFS);
1038 #if !defined(LLVM_ON_WIN32)
1039   StringRef Path1 = "a/b/.././c.h";
1040   StringRef Path2 = "a/c.h";
1041 #else
1042   StringRef Path1 = "a\\b\\..\\.\\c.h";
1043   StringRef Path2 = "a\\c.h";
1044 #endif
1045   EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1046   EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
1047   FileToReplaces[Path1] = Replacements();
1048   FileToReplaces[Path2] = Replacements();
1049   FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1050   EXPECT_EQ(1u, FileToReplaces.size());
1051   EXPECT_EQ(Path1, FileToReplaces.begin()->first);
1052 }
1053 
1054 TEST(DeduplicateByFileTest, PathWithDotSlash) {
1055   std::map<std::string, Replacements> FileToReplaces;
1056   llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> VFS(
1057       new vfs::InMemoryFileSystem());
1058   FileManager FileMgr(FileSystemOptions(), VFS);
1059 #if !defined(LLVM_ON_WIN32)
1060   StringRef Path1 = "./a/b/c.h";
1061   StringRef Path2 = "a/b/c.h";
1062 #else
1063   StringRef Path1 = ".\\a\\b\\c.h";
1064   StringRef Path2 = "a\\b\\c.h";
1065 #endif
1066   EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1067   EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
1068   FileToReplaces[Path1] = Replacements();
1069   FileToReplaces[Path2] = Replacements();
1070   FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1071   EXPECT_EQ(1u, FileToReplaces.size());
1072   EXPECT_EQ(Path1, FileToReplaces.begin()->first);
1073 }
1074 
1075 TEST(DeduplicateByFileTest, NonExistingFilePath) {
1076   std::map<std::string, Replacements> FileToReplaces;
1077   llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> VFS(
1078       new vfs::InMemoryFileSystem());
1079   FileManager FileMgr(FileSystemOptions(), VFS);
1080 #if !defined(LLVM_ON_WIN32)
1081   StringRef Path1 = "./a/b/c.h";
1082   StringRef Path2 = "a/b/c.h";
1083 #else
1084   StringRef Path1 = ".\\a\\b\\c.h";
1085   StringRef Path2 = "a\\b\\c.h";
1086 #endif
1087   FileToReplaces[Path1] = Replacements();
1088   FileToReplaces[Path2] = Replacements();
1089   FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1090   EXPECT_TRUE(FileToReplaces.empty());
1091 }
1092 
1093 class AtomicChangeTest : public ::testing::Test {
1094   protected:
1095     void SetUp() override {
1096       DefaultFileID = Context.createInMemoryFile("input.cpp", DefaultCode);
1097       DefaultLoc = Context.Sources.getLocForStartOfFile(DefaultFileID)
1098                        .getLocWithOffset(20);
1099       assert(DefaultLoc.isValid() && "Default location must be valid.");
1100     }
1101 
1102     RewriterTestContext Context;
1103     std::string DefaultCode = std::string(100, 'a');
1104     unsigned DefaultOffset = 20;
1105     SourceLocation DefaultLoc;
1106     FileID DefaultFileID;
1107 };
1108 
1109 TEST_F(AtomicChangeTest, AtomicChangeToYAML) {
1110   AtomicChange Change(Context.Sources, DefaultLoc);
1111   llvm::Error Err =
1112       Change.insert(Context.Sources, DefaultLoc, "aa", /*InsertAfter=*/false);
1113   ASSERT_TRUE(!Err);
1114   Err = Change.insert(Context.Sources, DefaultLoc.getLocWithOffset(10), "bb",
1115                     /*InsertAfter=*/false);
1116   ASSERT_TRUE(!Err);
1117   Change.addHeader("a.h");
1118   Change.removeHeader("b.h");
1119   std::string YAMLString = Change.toYAMLString();
1120 
1121   // NOTE: If this test starts to fail for no obvious reason, check whitespace.
1122   ASSERT_STREQ("---\n"
1123                "Key:             'input.cpp:20'\n"
1124                "FilePath:        input.cpp\n"
1125                "Error:           ''\n"
1126                "InsertedHeaders: [ a.h ]\n"
1127                "RemovedHeaders:  [ b.h ]\n"
1128                "Replacements:    \n" // Extra whitespace here!
1129                "  - FilePath:        input.cpp\n"
1130                "    Offset:          20\n"
1131                "    Length:          0\n"
1132                "    ReplacementText: aa\n"
1133                "  - FilePath:        input.cpp\n"
1134                "    Offset:          30\n"
1135                "    Length:          0\n"
1136                "    ReplacementText: bb\n"
1137                "...\n",
1138                YAMLString.c_str());
1139 }
1140 
1141 TEST_F(AtomicChangeTest, YAMLToAtomicChange) {
1142   std::string YamlContent = "---\n"
1143                             "Key:             'input.cpp:20'\n"
1144                             "FilePath:        input.cpp\n"
1145                             "Error:           'ok'\n"
1146                             "InsertedHeaders: [ a.h ]\n"
1147                             "RemovedHeaders:  [ b.h ]\n"
1148                             "Replacements:    \n" // Extra whitespace here!
1149                             "  - FilePath:        input.cpp\n"
1150                             "    Offset:          20\n"
1151                             "    Length:          0\n"
1152                             "    ReplacementText: aa\n"
1153                             "  - FilePath:        input.cpp\n"
1154                             "    Offset:          30\n"
1155                             "    Length:          0\n"
1156                             "    ReplacementText: bb\n"
1157                             "...\n";
1158   AtomicChange ExpectedChange(Context.Sources, DefaultLoc);
1159   llvm::Error Err = ExpectedChange.insert(Context.Sources, DefaultLoc, "aa",
1160                                         /*InsertAfter=*/false);
1161   ASSERT_TRUE(!Err);
1162   Err = ExpectedChange.insert(Context.Sources, DefaultLoc.getLocWithOffset(10),
1163                             "bb", /*InsertAfter=*/false);
1164   ASSERT_TRUE(!Err);
1165 
1166   ExpectedChange.addHeader("a.h");
1167   ExpectedChange.removeHeader("b.h");
1168   ExpectedChange.setError("ok");
1169 
1170   AtomicChange ActualChange = AtomicChange::convertFromYAML(YamlContent);
1171   EXPECT_EQ(ExpectedChange.getKey(), ActualChange.getKey());
1172   EXPECT_EQ(ExpectedChange.getFilePath(), ActualChange.getFilePath());
1173   EXPECT_EQ(ExpectedChange.getError(), ActualChange.getError());
1174   EXPECT_EQ(ExpectedChange.getInsertedHeaders(),
1175             ActualChange.getInsertedHeaders());
1176   EXPECT_EQ(ExpectedChange.getRemovedHeaders(),
1177             ActualChange.getRemovedHeaders());
1178   EXPECT_EQ(ExpectedChange.getReplacements().size(),
1179             ActualChange.getReplacements().size());
1180   EXPECT_EQ(2u, ActualChange.getReplacements().size());
1181   EXPECT_EQ(*ExpectedChange.getReplacements().begin(),
1182             *ActualChange.getReplacements().begin());
1183   EXPECT_EQ(*(++ExpectedChange.getReplacements().begin()),
1184             *(++ActualChange.getReplacements().begin()));
1185 }
1186 
1187 TEST_F(AtomicChangeTest, CheckKeyAndKeyFile) {
1188   AtomicChange Change(Context.Sources, DefaultLoc);
1189   EXPECT_EQ("input.cpp:20", Change.getKey());
1190   EXPECT_EQ("input.cpp", Change.getFilePath());
1191 }
1192 
1193 TEST_F(AtomicChangeTest, Replace) {
1194   AtomicChange Change(Context.Sources, DefaultLoc);
1195   llvm::Error Err = Change.replace(Context.Sources, DefaultLoc, 2, "aa");
1196   ASSERT_TRUE(!Err);
1197   EXPECT_EQ(Change.getReplacements().size(), 1u);
1198   EXPECT_EQ(*Change.getReplacements().begin(),
1199             Replacement(Context.Sources, DefaultLoc, 2, "aa"));
1200 
1201   // Add a new replacement that conflicts with the existing one.
1202   Err = Change.replace(Context.Sources, DefaultLoc, 3, "ab");
1203   EXPECT_TRUE((bool)Err);
1204   llvm::consumeError(std::move(Err));
1205   EXPECT_EQ(Change.getReplacements().size(), 1u);
1206 }
1207 
1208 TEST_F(AtomicChangeTest, ReplaceWithRange) {
1209   AtomicChange Change(Context.Sources, DefaultLoc);
1210   SourceLocation End = DefaultLoc.getLocWithOffset(20);
1211   llvm::Error Err = Change.replace(
1212       Context.Sources, CharSourceRange::getCharRange(DefaultLoc, End), "aa");
1213   ASSERT_TRUE(!Err);
1214   EXPECT_EQ(Change.getReplacements().size(), 1u);
1215   EXPECT_EQ(*Change.getReplacements().begin(),
1216             Replacement(Context.Sources, DefaultLoc, 20, "aa"));
1217 }
1218 
1219 TEST_F(AtomicChangeTest, InsertBefore) {
1220   AtomicChange Change(Context.Sources, DefaultLoc);
1221   llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa");
1222   ASSERT_TRUE(!Err);
1223   EXPECT_EQ(Change.getReplacements().size(), 1u);
1224   EXPECT_EQ(*Change.getReplacements().begin(),
1225             Replacement(Context.Sources, DefaultLoc, 0, "aa"));
1226   Err = Change.insert(Context.Sources, DefaultLoc, "b", /*InsertAfter=*/false);
1227   ASSERT_TRUE(!Err);
1228   EXPECT_EQ(Change.getReplacements().size(), 1u);
1229   EXPECT_EQ(*Change.getReplacements().begin(),
1230             Replacement(Context.Sources, DefaultLoc, 0, "baa"));
1231 }
1232 
1233 TEST_F(AtomicChangeTest, InsertAfter) {
1234   AtomicChange Change(Context.Sources, DefaultLoc);
1235   llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa");
1236   ASSERT_TRUE(!Err);
1237   EXPECT_EQ(Change.getReplacements().size(), 1u);
1238   EXPECT_EQ(*Change.getReplacements().begin(),
1239             Replacement(Context.Sources, DefaultLoc, 0, "aa"));
1240   Err = Change.insert(Context.Sources, DefaultLoc, "b");
1241   ASSERT_TRUE(!Err);
1242   EXPECT_EQ(Change.getReplacements().size(), 1u);
1243   EXPECT_EQ(*Change.getReplacements().begin(),
1244             Replacement(Context.Sources, DefaultLoc, 0, "aab"));
1245 }
1246 
1247 TEST_F(AtomicChangeTest, InsertBeforeWithInvalidLocation) {
1248   AtomicChange Change(Context.Sources, DefaultLoc);
1249   llvm::Error Err =
1250       Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false);
1251   ASSERT_TRUE(!Err);
1252 
1253   // Invalid location.
1254   Err = Change.insert(Context.Sources, SourceLocation(), "a",
1255                     /*InsertAfter=*/false);
1256   ASSERT_TRUE((bool)Err);
1257   EXPECT_TRUE(checkReplacementError(
1258       std::move(Err), replacement_error::wrong_file_path,
1259       Replacement(Context.Sources, DefaultLoc, 0, "a"),
1260       Replacement(Context.Sources, SourceLocation(), 0, "a")));
1261 }
1262 
1263 TEST_F(AtomicChangeTest, InsertBeforeToWrongFile) {
1264   AtomicChange Change(Context.Sources, DefaultLoc);
1265   llvm::Error Err =
1266       Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false);
1267   ASSERT_TRUE(!Err);
1268 
1269   // Inserting at a different file.
1270   FileID NewID = Context.createInMemoryFile("extra.cpp", DefaultCode);
1271   SourceLocation NewLoc = Context.Sources.getLocForStartOfFile(NewID);
1272   Err = Change.insert(Context.Sources, NewLoc, "b", /*InsertAfter=*/false);
1273   ASSERT_TRUE((bool)Err);
1274   EXPECT_TRUE(
1275       checkReplacementError(std::move(Err), replacement_error::wrong_file_path,
1276                             Replacement(Context.Sources, DefaultLoc, 0, "a"),
1277                             Replacement(Context.Sources, NewLoc, 0, "b")));
1278 }
1279 
1280 TEST_F(AtomicChangeTest, InsertAfterWithInvalidLocation) {
1281   AtomicChange Change(Context.Sources, DefaultLoc);
1282   llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "a");
1283   ASSERT_TRUE(!Err);
1284 
1285   // Invalid location.
1286   Err = Change.insert(Context.Sources, SourceLocation(), "b");
1287   ASSERT_TRUE((bool)Err);
1288   EXPECT_TRUE(checkReplacementError(
1289       std::move(Err), replacement_error::wrong_file_path,
1290       Replacement(Context.Sources, DefaultLoc, 0, "a"),
1291       Replacement(Context.Sources, SourceLocation(), 0, "b")));
1292 }
1293 
1294 } // end namespace tooling
1295 } // end namespace clang
1296