unittests/Tooling/RefactoringTest.cpp

   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(_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(_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(_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: \n" // Extra whitespace here!
1127                "  - a.h\n"
1128                "RemovedHeaders:  \n" // Extra whitespace here!
1129                "  - b.h\n"
1130                "Replacements:    \n" // Extra whitespace here!
1131                "  - FilePath:        input.cpp\n"
1132                "    Offset:          20\n"
1133                "    Length:          0\n"
1134                "    ReplacementText: aa\n"
1135                "  - FilePath:        input.cpp\n"
1136                "    Offset:          30\n"
1137                "    Length:          0\n"
1138                "    ReplacementText: bb\n"
1139                "...\n",
1140                YAMLString.c_str());
1141 }
1142
1143 TEST_F(AtomicChangeTest, YAMLToAtomicChange) {
1144   std::string YamlContent = "---\n"
1145                             "Key:             'input.cpp:20'\n"
1146                             "FilePath:        input.cpp\n"
1147                             "Error:           'ok'\n"
1148                             "InsertedHeaders: \n" // Extra whitespace here!
1149                             "  - a.h\n"
1150                             "RemovedHeaders:  \n" // Extra whitespace here!
1151                             "  - b.h\n"
1152                             "Replacements:    \n" // Extra whitespace here!
1153                             "  - FilePath:        input.cpp\n"
1154                             "    Offset:          20\n"
1155                             "    Length:          0\n"
1156                             "    ReplacementText: aa\n"
1157                             "  - FilePath:        input.cpp\n"
1158                             "    Offset:          30\n"
1159                             "    Length:          0\n"
1160                             "    ReplacementText: bb\n"
1161                             "...\n";
1162   AtomicChange ExpectedChange(Context.Sources, DefaultLoc);
1163   llvm::Error Err = ExpectedChange.insert(Context.Sources, DefaultLoc, "aa",
1164                                         /*InsertAfter=*/false);
1165   ASSERT_TRUE(!Err);
1166   Err = ExpectedChange.insert(Context.Sources, DefaultLoc.getLocWithOffset(10),
1167                             "bb", /*InsertAfter=*/false);
1168   ASSERT_TRUE(!Err);
1169
1170   ExpectedChange.addHeader("a.h");
1171   ExpectedChange.removeHeader("b.h");
1172   ExpectedChange.setError("ok");
1173
1174   AtomicChange ActualChange = AtomicChange::convertFromYAML(YamlContent);
1175   EXPECT_EQ(ExpectedChange.getKey(), ActualChange.getKey());
1176   EXPECT_EQ(ExpectedChange.getFilePath(), ActualChange.getFilePath());
1177   EXPECT_EQ(ExpectedChange.getError(), ActualChange.getError());
1178   EXPECT_EQ(ExpectedChange.getInsertedHeaders(),
1179             ActualChange.getInsertedHeaders());
1180   EXPECT_EQ(ExpectedChange.getRemovedHeaders(),
1181             ActualChange.getRemovedHeaders());
1182   EXPECT_EQ(ExpectedChange.getReplacements().size(),
1183             ActualChange.getReplacements().size());
1184   EXPECT_EQ(2u, ActualChange.getReplacements().size());
1185   EXPECT_EQ(*ExpectedChange.getReplacements().begin(),
1186             *ActualChange.getReplacements().begin());
1187   EXPECT_EQ(*(++ExpectedChange.getReplacements().begin()),
1188             *(++ActualChange.getReplacements().begin()));
1189 }
1190
1191 TEST_F(AtomicChangeTest, CheckKeyAndKeyFile) {
1192   AtomicChange Change(Context.Sources, DefaultLoc);
1193   EXPECT_EQ("input.cpp:20", Change.getKey());
1194   EXPECT_EQ("input.cpp", Change.getFilePath());
1195 }
1196
1197 TEST_F(AtomicChangeTest, Replace) {
1198   AtomicChange Change(Context.Sources, DefaultLoc);
1199   llvm::Error Err = Change.replace(Context.Sources, DefaultLoc, 2, "aa");
1200   ASSERT_TRUE(!Err);
1201   EXPECT_EQ(Change.getReplacements().size(), 1u);
1202   EXPECT_EQ(*Change.getReplacements().begin(),
1203             Replacement(Context.Sources, DefaultLoc, 2, "aa"));
1204
1205   // Add a new replacement that conflicts with the existing one.
1206   Err = Change.replace(Context.Sources, DefaultLoc, 3, "ab");
1207   EXPECT_TRUE((bool)Err);
1208   llvm::consumeError(std::move(Err));
1209   EXPECT_EQ(Change.getReplacements().size(), 1u);
1210 }
1211
1212 TEST_F(AtomicChangeTest, ReplaceWithRange) {
1213   AtomicChange Change(Context.Sources, DefaultLoc);
1214   SourceLocation End = DefaultLoc.getLocWithOffset(20);
1215   llvm::Error Err = Change.replace(
1216       Context.Sources, CharSourceRange::getCharRange(DefaultLoc, End), "aa");
1217   ASSERT_TRUE(!Err);
1218   EXPECT_EQ(Change.getReplacements().size(), 1u);
1219   EXPECT_EQ(*Change.getReplacements().begin(),
1220             Replacement(Context.Sources, DefaultLoc, 20, "aa"));
1221 }
1222
1223 TEST_F(AtomicChangeTest, InsertBefore) {
1224   AtomicChange Change(Context.Sources, DefaultLoc);
1225   llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa");
1226   ASSERT_TRUE(!Err);
1227   EXPECT_EQ(Change.getReplacements().size(), 1u);
1228   EXPECT_EQ(*Change.getReplacements().begin(),
1229             Replacement(Context.Sources, DefaultLoc, 0, "aa"));
1230   Err = Change.insert(Context.Sources, DefaultLoc, "b", /*InsertAfter=*/false);
1231   ASSERT_TRUE(!Err);
1232   EXPECT_EQ(Change.getReplacements().size(), 1u);
1233   EXPECT_EQ(*Change.getReplacements().begin(),
1234             Replacement(Context.Sources, DefaultLoc, 0, "baa"));
1235 }
1236
1237 TEST_F(AtomicChangeTest, InsertAfter) {
1238   AtomicChange Change(Context.Sources, DefaultLoc);
1239   llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa");
1240   ASSERT_TRUE(!Err);
1241   EXPECT_EQ(Change.getReplacements().size(), 1u);
1242   EXPECT_EQ(*Change.getReplacements().begin(),
1243             Replacement(Context.Sources, DefaultLoc, 0, "aa"));
1244   Err = Change.insert(Context.Sources, DefaultLoc, "b");
1245   ASSERT_TRUE(!Err);
1246   EXPECT_EQ(Change.getReplacements().size(), 1u);
1247   EXPECT_EQ(*Change.getReplacements().begin(),
1248             Replacement(Context.Sources, DefaultLoc, 0, "aab"));
1249 }
1250
1251 TEST_F(AtomicChangeTest, InsertBeforeWithInvalidLocation) {
1252   AtomicChange Change(Context.Sources, DefaultLoc);
1253   llvm::Error Err =
1254       Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false);
1255   ASSERT_TRUE(!Err);
1256
1257   // Invalid location.
1258   Err = Change.insert(Context.Sources, SourceLocation(), "a",
1259                     /*InsertAfter=*/false);
1260   ASSERT_TRUE((bool)Err);
1261   EXPECT_TRUE(checkReplacementError(
1262       std::move(Err), replacement_error::wrong_file_path,
1263       Replacement(Context.Sources, DefaultLoc, 0, "a"),
1264       Replacement(Context.Sources, SourceLocation(), 0, "a")));
1265 }
1266
1267 TEST_F(AtomicChangeTest, InsertBeforeToWrongFile) {
1268   AtomicChange Change(Context.Sources, DefaultLoc);
1269   llvm::Error Err =
1270       Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false);
1271   ASSERT_TRUE(!Err);
1272
1273   // Inserting at a different file.
1274   FileID NewID = Context.createInMemoryFile("extra.cpp", DefaultCode);
1275   SourceLocation NewLoc = Context.Sources.getLocForStartOfFile(NewID);
1276   Err = Change.insert(Context.Sources, NewLoc, "b", /*InsertAfter=*/false);
1277   ASSERT_TRUE((bool)Err);
1278   EXPECT_TRUE(
1279       checkReplacementError(std::move(Err), replacement_error::wrong_file_path,
1280                             Replacement(Context.Sources, DefaultLoc, 0, "a"),
1281                             Replacement(Context.Sources, NewLoc, 0, "b")));
1282 }
1283
1284 TEST_F(AtomicChangeTest, InsertAfterWithInvalidLocation) {
1285   AtomicChange Change(Context.Sources, DefaultLoc);
1286   llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "a");
1287   ASSERT_TRUE(!Err);
1288
1289   // Invalid location.
1290   Err = Change.insert(Context.Sources, SourceLocation(), "b");
1291   ASSERT_TRUE((bool)Err);
1292   EXPECT_TRUE(checkReplacementError(
1293       std::move(Err), replacement_error::wrong_file_path,
1294       Replacement(Context.Sources, DefaultLoc, 0, "a"),
1295       Replacement(Context.Sources, SourceLocation(), 0, "b")));
1296 }
1297
1298 class ApplyAtomicChangesTest : public ::testing::Test {
1299 protected:
1300   ApplyAtomicChangesTest() : FilePath("file.cc") {
1301     Spec.Cleanup = true;
1302     Spec.Format = ApplyChangesSpec::kAll;
1303     Spec.Style = format::getLLVMStyle();
1304   }
1305
1306   ~ApplyAtomicChangesTest() override {}
1307
1308   void setInput(llvm::StringRef Input) {
1309     Code = Input;
1310     FID = Context.createInMemoryFile(FilePath, Code);
1311   }
1312
1313   SourceLocation getLoc(unsigned Offset) const {
1314     return Context.Sources.getLocForStartOfFile(FID).getLocWithOffset(Offset);
1315   }
1316
1317   AtomicChange replacementToAtomicChange(llvm::StringRef Key, unsigned Offset,
1318                                          unsigned Length,
1319                                          llvm::StringRef Text) {
1320     AtomicChange Change(FilePath, Key);
1321     llvm::Error Err =
1322         Change.replace(Context.Sources, getLoc(Offset), Length, Text);
1323     EXPECT_FALSE(Err);
1324     return Change;
1325   }
1326
1327   std::string rewrite(bool FailureExpected = false) {
1328     llvm::Expected<std::string> ChangedCode =
1329         applyAtomicChanges(FilePath, Code, Changes, Spec);
1330     EXPECT_EQ(FailureExpected, !ChangedCode);
1331     if (!ChangedCode) {
1332       llvm::errs() << "Failed to apply changes: "
1333                    << llvm::toString(ChangedCode.takeError()) << "\n";
1334       return "";
1335     }
1336     return *ChangedCode;
1337   }
1338
1339   RewriterTestContext Context;
1340   FileID FID;
1341   ApplyChangesSpec Spec;
1342   std::string Code;
1343   std::string FilePath;
1344   llvm::SmallVector<AtomicChange, 8> Changes;
1345 };
1346
1347 TEST_F(ApplyAtomicChangesTest, BasicRefactoring) {
1348   setInput("int a;");
1349   AtomicChange Change(FilePath, "key1");
1350   Changes.push_back(replacementToAtomicChange("key1", 4, 1, "b"));
1351   EXPECT_EQ("int b;", rewrite());
1352 }
1353
1354 TEST_F(ApplyAtomicChangesTest, SeveralRefactorings) {
1355   setInput("int a;\n"
1356            "int b;");
1357   Changes.push_back(replacementToAtomicChange("key1", 0, 3, "float"));
1358   Changes.push_back(replacementToAtomicChange("key2", 4, 1, "f"));
1359   Changes.push_back(replacementToAtomicChange("key3", 11, 1, "g"));
1360   Changes.push_back(replacementToAtomicChange("key4", 7, 3, "float"));
1361   EXPECT_EQ("float f;\n"
1362             "float g;",
1363             rewrite());
1364 }
1365
1366 TEST_F(ApplyAtomicChangesTest, IgnorePathsInRefactorings) {
1367   setInput("int a;\n"
1368            "int b;");
1369   Changes.push_back(replacementToAtomicChange("key1", 4, 1, "aa"));
1370
1371   FileID ID = Context.createInMemoryFile("AnotherFile", "12345678912345");
1372   Changes.emplace_back("AnotherFile", "key2");
1373   auto Err = Changes.back().replace(
1374       Context.Sources,
1375       Context.Sources.getLocForStartOfFile(ID).getLocWithOffset(11), 1, "bb");
1376   ASSERT_TRUE(!Err);
1377   EXPECT_EQ("int aa;\n"
1378             "int bb;",
1379             rewrite());
1380 }
1381
1382 TEST_F(ApplyAtomicChangesTest, AppliesDuplicateInsertions) {
1383   setInput("int a;");
1384   Changes.push_back(replacementToAtomicChange("key1", 5, 0, "b"));
1385   Changes.push_back(replacementToAtomicChange("key2", 5, 0, "b"));
1386   EXPECT_EQ("int abb;", rewrite());
1387 }
1388
1389 TEST_F(ApplyAtomicChangesTest, BailsOnOverlappingRefactorings) {
1390   setInput("int a;");
1391   Changes.push_back(replacementToAtomicChange("key1", 0, 5, "float f"));
1392   Changes.push_back(replacementToAtomicChange("key2", 4, 1, "b"));
1393   EXPECT_EQ("", rewrite(/*FailureExpected=*/true));
1394 }
1395
1396 TEST_F(ApplyAtomicChangesTest, BasicReformatting) {
1397   setInput("int  a;");
1398   Changes.push_back(replacementToAtomicChange("key1", 5, 1, "b"));
1399   EXPECT_EQ("int b;", rewrite());
1400 }
1401
1402 TEST_F(ApplyAtomicChangesTest, OnlyFormatWhenViolateColumnLimits) {
1403   Spec.Format = ApplyChangesSpec::kViolations;
1404   Spec.Style.ColumnLimit = 8;
1405   setInput("int  a;\n"
1406            "int    a;\n"
1407            "int  aaaaaaaa;\n");
1408   Changes.push_back(replacementToAtomicChange("key1", 5, 1, "x"));
1409   Changes.push_back(replacementToAtomicChange("key2", 15, 1, "x"));
1410   Changes.push_back(replacementToAtomicChange("key3", 23, 8, "xx"));
1411   EXPECT_EQ("int  x;\n"
1412             "int x;\n"
1413             "int  xx;\n",
1414             rewrite());
1415 }
1416
1417 TEST_F(ApplyAtomicChangesTest, LastLineViolateColumnLimits) {
1418   Spec.Format = ApplyChangesSpec::kViolations;
1419   Spec.Style.ColumnLimit = 8;
1420   setInput("int  a;\n"
1421            "int    a;");
1422   Changes.push_back(replacementToAtomicChange("key1", 0, 1, "i"));
1423   Changes.push_back(replacementToAtomicChange("key2", 15, 2, "y;"));
1424   EXPECT_EQ("int  a;\n"
1425             "int y;",
1426             rewrite());
1427 }
1428
1429 TEST_F(ApplyAtomicChangesTest, LastLineWithNewlineViolateColumnLimits) {
1430   Spec.Format = ApplyChangesSpec::kViolations;
1431   Spec.Style.ColumnLimit = 8;
1432   setInput("int  a;\n"
1433            "int   a;\n");
1434   Changes.push_back(replacementToAtomicChange("key1", 0, 1, "i"));
1435   Changes.push_back(replacementToAtomicChange("key2", 14, 3, "y;\n"));
1436   EXPECT_EQ("int  a;\n"
1437             "int   y;\n",
1438             rewrite());
1439 }
1440
1441 TEST_F(ApplyAtomicChangesTest, Longer) {
1442   setInput("int  a;");
1443   Changes.push_back(replacementToAtomicChange("key1", 5, 1, "bbb"));
1444   EXPECT_EQ("int bbb;", rewrite());
1445 }
1446
1447 TEST_F(ApplyAtomicChangesTest, Shorter) {
1448   setInput("int  aaa;");
1449   Changes.push_back(replacementToAtomicChange("key1", 5, 3, "b"));
1450   EXPECT_EQ("int b;", rewrite());
1451 }
1452
1453 TEST_F(ApplyAtomicChangesTest, OnlyFormatChangedLines) {
1454   setInput("int  aaa;\n"
1455            "int a = b;\n"
1456            "int  bbb;");
1457   Changes.push_back(replacementToAtomicChange("key1", 14, 1, "b"));
1458   EXPECT_EQ("int  aaa;\n"
1459             "int b = b;\n"
1460             "int  bbb;",
1461             rewrite());
1462 }
1463
1464 TEST_F(ApplyAtomicChangesTest, DisableFormatting) {
1465   Spec.Format = ApplyChangesSpec::kNone;
1466   setInput("int  aaa;\n"
1467            "int a   = b;\n"
1468            "int  bbb;");
1469   Changes.push_back(replacementToAtomicChange("key1", 14, 1, "b"));
1470   EXPECT_EQ("int  aaa;\n"
1471             "int b   = b;\n"
1472             "int  bbb;",
1473             rewrite());
1474 }
1475
1476 TEST_F(ApplyAtomicChangesTest, AdaptsToLocalPointerStyle) {
1477   setInput("int *aaa;\n"
1478            "int *bbb;");
1479   Changes.push_back(replacementToAtomicChange("key1", 0, 0, "int* ccc;\n"));
1480   EXPECT_EQ("int *ccc;\n"
1481             "int *aaa;\n"
1482             "int *bbb;",
1483             rewrite());
1484 }
1485
1486 TEST_F(ApplyAtomicChangesTest, AcceptsSurroundingFormatting) {
1487   setInput("   int  aaa;\n"
1488            "   int a = b;\n"
1489            "   int  bbb;");
1490   Changes.push_back(replacementToAtomicChange("key1", 20, 1, "b"));
1491   EXPECT_EQ("   int  aaa;\n"
1492             "   int b = b;\n"
1493             "   int  bbb;",
1494             rewrite());
1495 }
1496
1497 TEST_F(ApplyAtomicChangesTest, BailsOutOnConflictingChanges) {
1498   setInput("int c;\n"
1499            "int f;");
1500   // Insertions at the same offset are only allowed in the same AtomicChange.
1501   Changes.push_back(replacementToAtomicChange("key1", 0, 0, "int a;\n"));
1502   Changes.push_back(replacementToAtomicChange("key2", 0, 0, "int b;\n"));
1503   EXPECT_EQ("", rewrite(/*FailureExpected=*/true));
1504 }
1505
1506 TEST_F(ApplyAtomicChangesTest, InsertsNewIncludesInRightOrder) {
1507   setInput("int a;");
1508   Changes.emplace_back(FilePath, "key1");
1509   Changes.back().addHeader("b");
1510   Changes.back().addHeader("c");
1511   Changes.emplace_back(FilePath, "key2");
1512   Changes.back().addHeader("a");
1513   EXPECT_EQ("#include \"a\"\n"
1514             "#include \"b\"\n"
1515             "#include \"c\"\n"
1516             "int a;",
1517             rewrite());
1518 }
1519
1520 TEST_F(ApplyAtomicChangesTest, RemoveAndSortIncludes) {
1521   setInput("#include \"a\"\n"
1522            "#include \"b\"\n"
1523            "#include \"c\"\n"
1524            "\n"
1525            "int a;");
1526   Changes.emplace_back(FilePath, "key1");
1527   Changes.back().removeHeader("b");
1528   EXPECT_EQ("#include \"a\"\n"
1529             "#include \"c\"\n"
1530             "\n"
1531             "int a;",
1532             rewrite());
1533 }
1534 TEST_F(ApplyAtomicChangesTest, InsertsSystemIncludes) {
1535   setInput("#include <asys>\n"
1536            "#include <csys>\n"
1537            "\n"
1538            "#include \"a\"\n"
1539            "#include \"c\"\n");
1540   Changes.emplace_back(FilePath, "key1");
1541   Changes.back().addHeader("<asys>"); // Already exists.
1542   Changes.back().addHeader("<b>");
1543   Changes.back().addHeader("<d>");
1544   Changes.back().addHeader("\"b-already-escaped\"");
1545   EXPECT_EQ("#include <asys>\n"
1546             "#include <b>\n"
1547             "#include <csys>\n"
1548             "#include <d>\n"
1549             "\n"
1550             "#include \"a\"\n"
1551             "#include \"b-already-escaped\"\n"
1552             "#include \"c\"\n",
1553             rewrite());
1554 }
1555
1556 TEST_F(ApplyAtomicChangesTest, RemoveSystemIncludes) {
1557   setInput("#include <a>\n"
1558            "#include <b>\n"
1559            "\n"
1560            "#include \"c\""
1561            "\n"
1562            "int a;");
1563   Changes.emplace_back(FilePath, "key1");
1564   Changes.back().removeHeader("<a>");
1565   EXPECT_EQ("#include <b>\n"
1566             "\n"
1567             "#include \"c\""
1568             "\n"
1569             "int a;",
1570             rewrite());
1571 }
1572
1573 TEST_F(ApplyAtomicChangesTest,
1574        DoNotFormatFollowingLinesIfSeparatedWithNewline) {
1575   setInput("#ifndef __H__\n"
1576            "#define __H__\n"
1577            "#include \"b\"\n"
1578            "\n"
1579            "int  a;\n"
1580            "int  a;\n"
1581            "int  a;\n"
1582            "#endif // __H__\n");
1583   Changes.push_back(replacementToAtomicChange("key1",
1584                                               llvm::StringRef("#ifndef __H__\n"
1585                                                               "#define __H__\n"
1586                                                               "\n"
1587                                                               "#include \"b\"\n"
1588                                                               "int  a;\n"
1589                                                               "int  ")
1590                                                   .size(),
1591                                               1, "b"));
1592   Changes.back().addHeader("a");
1593   EXPECT_EQ("#ifndef __H__\n"
1594             "#define __H__\n"
1595             "#include \"a\"\n"
1596             "#include \"b\"\n"
1597             "\n"
1598             "int  a;\n"
1599             "int b;\n"
1600             "int  a;\n"
1601             "#endif // __H__\n",
1602             rewrite());
1603 }
1604
1605 TEST_F(ApplyAtomicChangesTest, FormatsCorrectLineWhenHeaderIsRemoved) {
1606   setInput("#include \"a\"\n"
1607            "\n"
1608            "int  a;\n"
1609            "int  a;\n"
1610            "int  a;");
1611   Changes.push_back(replacementToAtomicChange("key1", 27, 1, "b"));
1612   Changes.back().removeHeader("a");
1613   EXPECT_EQ("\n"
1614             "int  a;\n"
1615             "int b;\n"
1616             "int  a;",
1617             rewrite());
1618 }
1619
1620 TEST_F(ApplyAtomicChangesTest, CleansUpCtorInitializers) {
1621   setInput("A::A() : a(), b() {}\n"
1622            "A::A() : a(), b() {}\n"
1623            "A::A() : a(), b() {}\n"
1624            "A::A() : a()/**/, b() {}\n"
1625            "A::A() : a()  ,// \n"
1626            "   /**/    b()    {}");
1627   Changes.emplace_back(FilePath, "key1");
1628   auto Err = Changes.back().replace(Context.Sources, getLoc(9), 3, "");
1629   ASSERT_TRUE(!Err);
1630   Err = Changes.back().replace(Context.Sources, getLoc(35), 3, "");
1631   ASSERT_TRUE(!Err);
1632   Err = Changes.back().replace(Context.Sources, getLoc(51), 3, "");
1633   ASSERT_TRUE(!Err);
1634   Err = Changes.back().replace(Context.Sources, getLoc(56), 3, "");
1635   ASSERT_TRUE(!Err);
1636   Err = Changes.back().replace(Context.Sources, getLoc(72), 3, "");
1637   ASSERT_TRUE(!Err);
1638   Err = Changes.back().replace(Context.Sources, getLoc(97), 3, "");
1639   ASSERT_TRUE(!Err);
1640   Err = Changes.back().replace(Context.Sources, getLoc(118), 3, "");
1641   ASSERT_TRUE(!Err);
1642   EXPECT_EQ("A::A() : b() {}\n"
1643             "A::A() : a() {}\n"
1644             "A::A() {}\n"
1645             "A::A() : b() {}\n"
1646             "A::A() {}",
1647             rewrite());
1648 }
1649
1650 TEST_F(ApplyAtomicChangesTest, CleansUpParameterLists) {
1651   setInput("void f(int i, float f, string s);\n"
1652            "f(1, 2.0f, \"a\");\n"
1653            "g(1, 1);");
1654   Changes.emplace_back(FilePath, "key1");
1655   auto Err = Changes.back().replace(Context.Sources, getLoc(7), 5, "");
1656   ASSERT_TRUE(!Err);
1657   Err = Changes.back().replace(Context.Sources, getLoc(23), 8, "");
1658   ASSERT_TRUE(!Err);
1659   Err = Changes.back().replace(Context.Sources, getLoc(36), 1, "");
1660   ASSERT_TRUE(!Err);
1661   Err = Changes.back().replace(Context.Sources, getLoc(45), 3, "");
1662   ASSERT_TRUE(!Err);
1663   Err = Changes.back().replace(Context.Sources, getLoc(53), 1, "");
1664   ASSERT_TRUE(!Err);
1665   Err = Changes.back().replace(Context.Sources, getLoc(56), 1, "");
1666   ASSERT_TRUE(!Err);
1667   EXPECT_EQ("void f(float f);\n"
1668             "f(2.0f);\n"
1669             "g();",
1670             rewrite());
1671 }
1672
1673 TEST_F(ApplyAtomicChangesTest, DisableCleanup) {
1674   Spec.Cleanup = false;
1675   setInput("void f(int i, float f, string s);\n"
1676            "f(1, 2.0f, \"a\");\n"
1677            "g(1, 1);");
1678   Changes.emplace_back(FilePath, "key1");
1679   auto Err = Changes.back().replace(Context.Sources, getLoc(7), 5, "");
1680   ASSERT_TRUE(!Err);
1681   Err = Changes.back().replace(Context.Sources, getLoc(23), 8, "");
1682   ASSERT_TRUE(!Err);
1683   Err = Changes.back().replace(Context.Sources, getLoc(36), 1, "");
1684   ASSERT_TRUE(!Err);
1685   Err = Changes.back().replace(Context.Sources, getLoc(45), 3, "");
1686   ASSERT_TRUE(!Err);
1687   Err = Changes.back().replace(Context.Sources, getLoc(53), 1, "");
1688   ASSERT_TRUE(!Err);
1689   Err = Changes.back().replace(Context.Sources, getLoc(56), 1, "");
1690   ASSERT_TRUE(!Err);
1691   EXPECT_EQ("void f(, float f, );\n"
1692             "f(, 2.0f, );\n"
1693             "g(, );",
1694             rewrite());
1695 }
1696
1697 TEST_F(ApplyAtomicChangesTest, EverythingDeleted) {
1698   setInput("int a;");
1699   Changes.push_back(replacementToAtomicChange("key1", 0, 6, ""));
1700   EXPECT_EQ("", rewrite());
1701 }
1702
1703 TEST_F(ApplyAtomicChangesTest, DoesNotDeleteInserts) {
1704   setInput("int a;\n"
1705            "int b;");
1706   Changes.emplace_back(FilePath, "key1");
1707   auto Err = Changes.back().replace(Context.Sources, getLoc(4), 1, "");
1708   ASSERT_TRUE(!Err);
1709   Err = Changes.back().replace(Context.Sources, getLoc(4), 0, "b");
1710   ASSERT_TRUE(!Err);
1711   Err = Changes.back().replace(Context.Sources, getLoc(11), 0, "a");
1712   ASSERT_TRUE(!Err);
1713   Err = Changes.back().replace(Context.Sources, getLoc(11), 1, "");
1714   ASSERT_TRUE(!Err);
1715   EXPECT_EQ("int b;\n"
1716             "int a;",
1717             rewrite());
1718 }
1719
1720 } // end namespace tooling
1721 } // end namespace clang