1 //===- unittest/Tooling/RefactoringTest.cpp - Refactoring unit tests ------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Tooling/Refactoring.h" 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/Format/Format.h" 23 #include "clang/Frontend/CompilerInstance.h" 24 #include "clang/Frontend/FrontendAction.h" 25 #include "clang/Frontend/TextDiagnosticPrinter.h" 26 #include "clang/Rewrite/Core/Rewriter.h" 27 #include "clang/Tooling/Refactoring/AtomicChange.h" 28 #include "clang/Tooling/Tooling.h" 29 #include "llvm/ADT/SmallString.h" 30 #include "llvm/Support/VirtualFileSystem.h" 31 #include "gtest/gtest.h" 32 33 namespace clang { 34 namespace tooling { 35 36 TEST_F(ReplacementTest, CanDeleteAllText) { 37 FileID ID = Context.createInMemoryFile("input.cpp", "text"); 38 SourceLocation Location = Context.getLocation(ID, 1, 1); 39 Replacement Replace(createReplacement(Location, 4, "")); 40 EXPECT_TRUE(Replace.apply(Context.Rewrite)); 41 EXPECT_EQ("", Context.getRewrittenText(ID)); 42 } 43 44 TEST_F(ReplacementTest, CanDeleteAllTextInTextWithNewlines) { 45 FileID ID = Context.createInMemoryFile("input.cpp", "line1\nline2\nline3"); 46 SourceLocation Location = Context.getLocation(ID, 1, 1); 47 Replacement Replace(createReplacement(Location, 17, "")); 48 EXPECT_TRUE(Replace.apply(Context.Rewrite)); 49 EXPECT_EQ("", Context.getRewrittenText(ID)); 50 } 51 52 TEST_F(ReplacementTest, CanAddText) { 53 FileID ID = Context.createInMemoryFile("input.cpp", ""); 54 SourceLocation Location = Context.getLocation(ID, 1, 1); 55 Replacement Replace(createReplacement(Location, 0, "result")); 56 EXPECT_TRUE(Replace.apply(Context.Rewrite)); 57 EXPECT_EQ("result", Context.getRewrittenText(ID)); 58 } 59 60 TEST_F(ReplacementTest, CanReplaceTextAtPosition) { 61 FileID ID = Context.createInMemoryFile("input.cpp", 62 "line1\nline2\nline3\nline4"); 63 SourceLocation Location = Context.getLocation(ID, 2, 3); 64 Replacement Replace(createReplacement(Location, 12, "x")); 65 EXPECT_TRUE(Replace.apply(Context.Rewrite)); 66 EXPECT_EQ("line1\nlixne4", Context.getRewrittenText(ID)); 67 } 68 69 TEST_F(ReplacementTest, CanReplaceTextAtPositionMultipleTimes) { 70 FileID ID = Context.createInMemoryFile("input.cpp", 71 "line1\nline2\nline3\nline4"); 72 SourceLocation Location1 = Context.getLocation(ID, 2, 3); 73 Replacement Replace1(createReplacement(Location1, 12, "x\ny\n")); 74 EXPECT_TRUE(Replace1.apply(Context.Rewrite)); 75 EXPECT_EQ("line1\nlix\ny\nne4", Context.getRewrittenText(ID)); 76 77 // Since the original source has not been modified, the (4, 4) points to the 78 // 'e' in the original content. 79 SourceLocation Location2 = Context.getLocation(ID, 4, 4); 80 Replacement Replace2(createReplacement(Location2, 1, "f")); 81 EXPECT_TRUE(Replace2.apply(Context.Rewrite)); 82 EXPECT_EQ("line1\nlix\ny\nnf4", Context.getRewrittenText(ID)); 83 } 84 85 TEST_F(ReplacementTest, ApplyFailsForNonExistentLocation) { 86 Replacement Replace("nonexistent-file.cpp", 0, 1, ""); 87 EXPECT_FALSE(Replace.apply(Context.Rewrite)); 88 } 89 90 TEST_F(ReplacementTest, CanRetrivePath) { 91 Replacement Replace("/path/to/file.cpp", 0, 1, ""); 92 EXPECT_EQ("/path/to/file.cpp", Replace.getFilePath()); 93 } 94 95 TEST_F(ReplacementTest, ReturnsInvalidPath) { 96 Replacement Replace1(Context.Sources, SourceLocation(), 0, ""); 97 EXPECT_TRUE(Replace1.getFilePath().empty()); 98 99 Replacement Replace2; 100 EXPECT_TRUE(Replace2.getFilePath().empty()); 101 } 102 103 // Checks that an llvm::Error instance contains a ReplacementError with expected 104 // error code, expected new replacement, and expected existing replacement. 105 static bool checkReplacementError(llvm::Error &&Error, 106 replacement_error ExpectedErr, 107 llvm::Optional<Replacement> ExpectedExisting, 108 llvm::Optional<Replacement> ExpectedNew) { 109 if (!Error) { 110 llvm::errs() << "Error is a success."; 111 return false; 112 } 113 std::string ErrorMessage; 114 llvm::raw_string_ostream OS(ErrorMessage); 115 llvm::handleAllErrors(std::move(Error), [&](const ReplacementError &RE) { 116 llvm::errs() << "Handling error...\n"; 117 if (ExpectedErr != RE.get()) 118 OS << "Unexpected error code: " << int(RE.get()) << "\n"; 119 if (ExpectedExisting != RE.getExistingReplacement()) { 120 OS << "Expected Existing != Actual Existing.\n"; 121 if (ExpectedExisting) 122 OS << "Expected existing replacement: " << ExpectedExisting->toString() 123 << "\n"; 124 if (RE.getExistingReplacement()) 125 OS << "Actual existing replacement: " 126 << RE.getExistingReplacement()->toString() << "\n"; 127 } 128 if (ExpectedNew != RE.getNewReplacement()) { 129 OS << "Expected New != Actual New.\n"; 130 if (ExpectedNew) 131 OS << "Expected new replacement: " << ExpectedNew->toString() << "\n"; 132 if (RE.getNewReplacement()) 133 OS << "Actual new replacement: " << RE.getNewReplacement()->toString() 134 << "\n"; 135 } 136 }); 137 OS.flush(); 138 if (ErrorMessage.empty()) return true; 139 llvm::errs() << ErrorMessage; 140 return false; 141 } 142 143 TEST_F(ReplacementTest, FailAddReplacements) { 144 Replacements Replaces; 145 Replacement Deletion("x.cc", 0, 10, "3"); 146 auto Err = Replaces.add(Deletion); 147 EXPECT_TRUE(!Err); 148 llvm::consumeError(std::move(Err)); 149 150 Replacement OverlappingReplacement("x.cc", 0, 2, "a"); 151 Err = Replaces.add(OverlappingReplacement); 152 EXPECT_TRUE(checkReplacementError(std::move(Err), 153 replacement_error::overlap_conflict, 154 Deletion, OverlappingReplacement)); 155 156 Replacement ContainedReplacement("x.cc", 2, 2, "a"); 157 Err = Replaces.add(Replacement(ContainedReplacement)); 158 EXPECT_TRUE(checkReplacementError(std::move(Err), 159 replacement_error::overlap_conflict, 160 Deletion, ContainedReplacement)); 161 162 Replacement WrongPathReplacement("y.cc", 20, 2, ""); 163 Err = Replaces.add(WrongPathReplacement); 164 EXPECT_TRUE(checkReplacementError(std::move(Err), 165 replacement_error::wrong_file_path, 166 Deletion, WrongPathReplacement)); 167 168 EXPECT_EQ(1u, Replaces.size()); 169 EXPECT_EQ(Deletion, *Replaces.begin()); 170 } 171 172 TEST_F(ReplacementTest, DeletionInReplacements) { 173 Replacements Replaces; 174 Replacement R("x.cc", 0, 10, "3"); 175 auto Err = Replaces.add(R); 176 EXPECT_TRUE(!Err); 177 llvm::consumeError(std::move(Err)); 178 Err = Replaces.add(Replacement("x.cc", 0, 2, "")); 179 EXPECT_TRUE(!Err); 180 llvm::consumeError(std::move(Err)); 181 Err = Replaces.add(Replacement("x.cc", 2, 2, "")); 182 EXPECT_TRUE(!Err); 183 llvm::consumeError(std::move(Err)); 184 EXPECT_EQ(1u, Replaces.size()); 185 EXPECT_EQ(R, *Replaces.begin()); 186 } 187 188 TEST_F(ReplacementTest, OverlappingReplacements) { 189 Replacements Replaces; 190 auto Err = Replaces.add(Replacement("x.cc", 0, 3, "345")); 191 EXPECT_TRUE(!Err); 192 llvm::consumeError(std::move(Err)); 193 Err = Replaces.add(Replacement("x.cc", 2, 3, "543")); 194 EXPECT_TRUE(!Err); 195 llvm::consumeError(std::move(Err)); 196 197 EXPECT_EQ(1u, Replaces.size()); 198 EXPECT_EQ(Replacement("x.cc", 0, 5, "34543"), *Replaces.begin()); 199 200 Err = Replaces.add(Replacement("x.cc", 2, 1, "5")); 201 EXPECT_TRUE(!Err); 202 llvm::consumeError(std::move(Err)); 203 EXPECT_EQ(1u, Replaces.size()); 204 EXPECT_EQ(Replacement("x.cc", 0, 5, "34543"), *Replaces.begin()); 205 } 206 207 TEST_F(ReplacementTest, AddAdjacentInsertionAndReplacement) { 208 Replacements Replaces; 209 // Test adding an insertion at the offset of an existing replacement. 210 auto Err = Replaces.add(Replacement("x.cc", 10, 3, "replace")); 211 EXPECT_TRUE(!Err); 212 llvm::consumeError(std::move(Err)); 213 Err = Replaces.add(Replacement("x.cc", 10, 0, "insert")); 214 EXPECT_TRUE(!Err); 215 llvm::consumeError(std::move(Err)); 216 EXPECT_EQ(Replaces.size(), 2u); 217 218 Replaces.clear(); 219 // Test overlap with an existing insertion. 220 Err = Replaces.add(Replacement("x.cc", 10, 0, "insert")); 221 EXPECT_TRUE(!Err); 222 llvm::consumeError(std::move(Err)); 223 Err = Replaces.add(Replacement("x.cc", 10, 3, "replace")); 224 EXPECT_TRUE(!Err); 225 llvm::consumeError(std::move(Err)); 226 EXPECT_EQ(Replaces.size(), 2u); 227 } 228 229 TEST_F(ReplacementTest, MergeNewDeletions) { 230 Replacements Replaces; 231 Replacement ContainingReplacement("x.cc", 0, 10, ""); 232 auto Err = Replaces.add(ContainingReplacement); 233 EXPECT_TRUE(!Err); 234 llvm::consumeError(std::move(Err)); 235 236 Err = Replaces.add(Replacement("x.cc", 5, 3, "")); 237 EXPECT_TRUE(!Err); 238 llvm::consumeError(std::move(Err)); 239 240 Err = Replaces.add(Replacement("x.cc", 0, 10, "")); 241 EXPECT_TRUE(!Err); 242 llvm::consumeError(std::move(Err)); 243 244 Err = Replaces.add(Replacement("x.cc", 5, 5, "")); 245 EXPECT_TRUE(!Err); 246 llvm::consumeError(std::move(Err)); 247 248 EXPECT_EQ(1u, Replaces.size()); 249 EXPECT_EQ(*Replaces.begin(), ContainingReplacement); 250 } 251 252 TEST_F(ReplacementTest, MergeOverlappingButNotAdjacentReplacement) { 253 Replacements Replaces; 254 auto Err = Replaces.add(Replacement("x.cc", 0, 2, "")); 255 EXPECT_TRUE(!Err); 256 llvm::consumeError(std::move(Err)); 257 258 Err = Replaces.add(Replacement("x.cc", 5, 5, "")); 259 EXPECT_TRUE(!Err); 260 llvm::consumeError(std::move(Err)); 261 262 Replacement After = Replacement("x.cc", 10, 5, ""); 263 Err = Replaces.add(After); 264 EXPECT_TRUE(!Err); 265 llvm::consumeError(std::move(Err)); 266 267 Replacement ContainingReplacement("x.cc", 0, 10, ""); 268 Err = Replaces.add(ContainingReplacement); 269 EXPECT_TRUE(!Err); 270 llvm::consumeError(std::move(Err)); 271 272 EXPECT_EQ(2u, Replaces.size()); 273 EXPECT_EQ(*Replaces.begin(), ContainingReplacement); 274 EXPECT_EQ(*(++Replaces.begin()), After); 275 } 276 277 TEST_F(ReplacementTest, InsertionBeforeMergedDeletions) { 278 Replacements Replaces; 279 280 Replacement Insertion("x.cc", 0, 0, "123"); 281 auto Err = Replaces.add(Insertion); 282 EXPECT_TRUE(!Err); 283 llvm::consumeError(std::move(Err)); 284 285 Err = Replaces.add(Replacement("x.cc", 5, 5, "")); 286 EXPECT_TRUE(!Err); 287 llvm::consumeError(std::move(Err)); 288 289 Replacement Deletion("x.cc", 0, 10, ""); 290 Err = Replaces.add(Deletion); 291 EXPECT_TRUE(!Err); 292 llvm::consumeError(std::move(Err)); 293 294 EXPECT_EQ(2u, Replaces.size()); 295 EXPECT_EQ(*Replaces.begin(), Insertion); 296 EXPECT_EQ(*(++Replaces.begin()), Deletion); 297 } 298 299 TEST_F(ReplacementTest, MergeOverlappingDeletions) { 300 Replacements Replaces; 301 auto Err = Replaces.add(Replacement("x.cc", 0, 2, "")); 302 EXPECT_TRUE(!Err); 303 llvm::consumeError(std::move(Err)); 304 305 Err = Replaces.add(Replacement("x.cc", 0, 5, "")); 306 EXPECT_TRUE(!Err); 307 llvm::consumeError(std::move(Err)); 308 309 EXPECT_EQ(1u, Replaces.size()); 310 EXPECT_EQ(Replacement("x.cc", 0, 5, ""), *Replaces.begin()); 311 312 Err = Replaces.add(Replacement("x.cc", 1, 5, "")); 313 EXPECT_TRUE(!Err); 314 llvm::consumeError(std::move(Err)); 315 EXPECT_EQ(1u, Replaces.size()); 316 EXPECT_EQ(Replacement("x.cc", 0, 6, ""), *Replaces.begin()); 317 } 318 319 TEST_F(ReplacementTest, FailedMergeExistingDeletions) { 320 Replacements Replaces; 321 Replacement First("x.cc", 0, 2, ""); 322 auto Err = Replaces.add(First); 323 EXPECT_TRUE(!Err); 324 llvm::consumeError(std::move(Err)); 325 326 Replacement Second("x.cc", 5, 5, ""); 327 Err = Replaces.add(Second); 328 EXPECT_TRUE(!Err); 329 llvm::consumeError(std::move(Err)); 330 331 Err = Replaces.add(Replacement("x.cc", 1, 10, "")); 332 EXPECT_TRUE(!Err); 333 llvm::consumeError(std::move(Err)); 334 335 EXPECT_EQ(1u, Replaces.size()); 336 EXPECT_EQ(Replacement("x.cc", 0, 11, ""), *Replaces.begin()); 337 } 338 339 TEST_F(ReplacementTest, FailAddRegression) { 340 Replacements Replaces; 341 // Create two replacements, where the second one is an insertion of the empty 342 // string exactly at the end of the first one. 343 auto Err = Replaces.add(Replacement("x.cc", 0, 10, "1")); 344 EXPECT_TRUE(!Err); 345 llvm::consumeError(std::move(Err)); 346 Err = Replaces.add(Replacement("x.cc", 10, 0, "")); 347 EXPECT_TRUE(!Err); 348 llvm::consumeError(std::move(Err)); 349 350 // Make sure we find the overlap with the first entry when inserting a 351 // replacement that ends exactly at the seam of the existing replacements. 352 Replacement OverlappingReplacement("x.cc", 5, 5, "fail"); 353 Err = Replaces.add(OverlappingReplacement); 354 EXPECT_TRUE(checkReplacementError(std::move(Err), 355 replacement_error::overlap_conflict, 356 *Replaces.begin(), OverlappingReplacement)); 357 358 Err = Replaces.add(Replacement("x.cc", 10, 0, "")); 359 EXPECT_TRUE(!Err); 360 llvm::consumeError(std::move(Err)); 361 } 362 363 TEST_F(ReplacementTest, InsertAtOffsetOfReplacement) { 364 Replacements Replaces; 365 auto Err = Replaces.add(Replacement("x.cc", 10, 2, "")); 366 EXPECT_TRUE(!Err); 367 llvm::consumeError(std::move(Err)); 368 Err = Replaces.add(Replacement("x.cc", 10, 0, "")); 369 EXPECT_TRUE(!Err); 370 llvm::consumeError(std::move(Err)); 371 EXPECT_EQ(Replaces.size(), 2u); 372 373 Replaces.clear(); 374 Err = Replaces.add(Replacement("x.cc", 10, 0, "")); 375 EXPECT_TRUE(!Err); 376 llvm::consumeError(std::move(Err)); 377 Err = Replaces.add(Replacement("x.cc", 10, 2, "")); 378 EXPECT_TRUE(!Err); 379 llvm::consumeError(std::move(Err)); 380 EXPECT_EQ(Replaces.size(), 2u); 381 } 382 383 TEST_F(ReplacementTest, AddInsertAtOtherInsertWhenOderIndependent) { 384 Replacements Replaces; 385 auto Err = Replaces.add(Replacement("x.cc", 10, 0, "a")); 386 EXPECT_TRUE(!Err); 387 llvm::consumeError(std::move(Err)); 388 Replacement ConflictInsertion("x.cc", 10, 0, "b"); 389 Err = Replaces.add(ConflictInsertion); 390 EXPECT_TRUE(checkReplacementError(std::move(Err), 391 replacement_error::insert_conflict, 392 *Replaces.begin(), ConflictInsertion)); 393 394 Replaces.clear(); 395 Err = Replaces.add(Replacement("x.cc", 10, 0, "a")); 396 EXPECT_TRUE(!Err); 397 llvm::consumeError(std::move(Err)); 398 Err = Replaces.add(Replacement("x.cc", 10, 0, "aa")); 399 EXPECT_TRUE(!Err); 400 llvm::consumeError(std::move(Err)); 401 EXPECT_EQ(1u, Replaces.size()); 402 EXPECT_EQ(Replacement("x.cc", 10, 0, "aaa"), *Replaces.begin()); 403 404 Replaces.clear(); 405 Err = Replaces.add(Replacement("x.cc", 10, 0, "")); 406 EXPECT_TRUE(!Err); 407 llvm::consumeError(std::move(Err)); 408 Err = Replaces.add(Replacement("x.cc", 10, 3, "")); 409 EXPECT_TRUE(!Err); 410 llvm::consumeError(std::move(Err)); 411 Err = Replaces.add(Replacement("x.cc", 10, 0, "")); 412 EXPECT_TRUE(!Err); 413 llvm::consumeError(std::move(Err)); 414 EXPECT_EQ(2u, Replaces.size()); 415 EXPECT_EQ(Replacement("x.cc", 10, 0, ""), *Replaces.begin()); 416 EXPECT_EQ(Replacement("x.cc", 10, 3, ""), *std::next(Replaces.begin())); 417 } 418 419 TEST_F(ReplacementTest, InsertBetweenAdjacentReplacements) { 420 Replacements Replaces; 421 auto Err = Replaces.add(Replacement("x.cc", 10, 5, "a")); 422 EXPECT_TRUE(!Err); 423 llvm::consumeError(std::move(Err)); 424 Err = Replaces.add(Replacement("x.cc", 8, 2, "a")); 425 EXPECT_TRUE(!Err); 426 llvm::consumeError(std::move(Err)); 427 Err = Replaces.add(Replacement("x.cc", 10, 0, "b")); 428 EXPECT_TRUE(!Err); 429 llvm::consumeError(std::move(Err)); 430 } 431 432 TEST_F(ReplacementTest, CanApplyReplacements) { 433 FileID ID = Context.createInMemoryFile("input.cpp", 434 "line1\nline2\nline3\nline4"); 435 Replacements Replaces = 436 toReplacements({Replacement(Context.Sources, 437 Context.getLocation(ID, 2, 1), 5, "replaced"), 438 Replacement(Context.Sources, 439 Context.getLocation(ID, 3, 1), 5, "other")}); 440 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite)); 441 EXPECT_EQ("line1\nreplaced\nother\nline4", Context.getRewrittenText(ID)); 442 } 443 444 // Verifies that replacement/deletion is applied before insertion at the same 445 // offset. 446 TEST_F(ReplacementTest, InsertAndDelete) { 447 FileID ID = Context.createInMemoryFile("input.cpp", 448 "line1\nline2\nline3\nline4"); 449 Replacements Replaces = toReplacements( 450 {Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 6, ""), 451 Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 0, 452 "other\n")}); 453 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite)); 454 EXPECT_EQ("line1\nother\nline3\nline4", Context.getRewrittenText(ID)); 455 } 456 457 TEST_F(ReplacementTest, AdjacentReplacements) { 458 FileID ID = Context.createInMemoryFile("input.cpp", 459 "ab"); 460 Replacements Replaces = toReplacements( 461 {Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 1, "x"), 462 Replacement(Context.Sources, Context.getLocation(ID, 1, 2), 1, "y")}); 463 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite)); 464 EXPECT_EQ("xy", Context.getRewrittenText(ID)); 465 } 466 467 TEST_F(ReplacementTest, AddDuplicateReplacements) { 468 FileID ID = Context.createInMemoryFile("input.cpp", 469 "line1\nline2\nline3\nline4"); 470 auto Replaces = toReplacements({Replacement( 471 Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")}); 472 473 auto Err = Replaces.add(Replacement( 474 Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")); 475 EXPECT_TRUE(!Err); 476 llvm::consumeError(std::move(Err)); 477 478 Err = Replaces.add(Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 479 5, "replaced")); 480 EXPECT_TRUE(!Err); 481 llvm::consumeError(std::move(Err)); 482 483 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite)); 484 EXPECT_EQ("line1\nreplaced\nline3\nline4", Context.getRewrittenText(ID)); 485 } 486 487 TEST_F(ReplacementTest, FailOrderDependentReplacements) { 488 FileID ID = Context.createInMemoryFile("input.cpp", 489 "line1\nline2\nline3\nline4"); 490 auto Replaces = toReplacements({Replacement( 491 Context.Sources, Context.getLocation(ID, 2, 1), 5, "other")}); 492 493 Replacement ConflictReplacement(Context.Sources, 494 Context.getLocation(ID, 2, 1), 5, "rehto"); 495 auto Err = Replaces.add(ConflictReplacement); 496 EXPECT_TRUE(checkReplacementError(std::move(Err), 497 replacement_error::overlap_conflict, 498 *Replaces.begin(), ConflictReplacement)); 499 500 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite)); 501 EXPECT_EQ("line1\nother\nline3\nline4", Context.getRewrittenText(ID)); 502 } 503 504 TEST_F(ReplacementTest, InvalidSourceLocationFailsApplyAll) { 505 Replacements Replaces = 506 toReplacements({Replacement(Context.Sources, SourceLocation(), 5, "2")}); 507 508 EXPECT_FALSE(applyAllReplacements(Replaces, Context.Rewrite)); 509 } 510 511 TEST_F(ReplacementTest, MultipleFilesReplaceAndFormat) { 512 // Column limit is 20. 513 std::string Code1 = "Long *a =\n" 514 " new Long();\n" 515 "long x = 1;"; 516 std::string Expected1 = "auto a = new Long();\n" 517 "long x =\n" 518 " 12345678901;"; 519 std::string Code2 = "int x = 123;\n" 520 "int y = 0;"; 521 std::string Expected2 = "int x =\n" 522 " 1234567890123;\n" 523 "int y = 10;"; 524 StringRef File1 = "format_1.cpp"; 525 StringRef File2 = "format_2.cpp"; 526 FileID ID1 = Context.createInMemoryFile(File1, Code1); 527 FileID ID2 = Context.createInMemoryFile(File2, Code2); 528 529 // Scrambled the order of replacements. 530 std::map<std::string, Replacements> FileToReplaces; 531 FileToReplaces[std::string(File1)] = toReplacements( 532 {tooling::Replacement(Context.Sources, Context.getLocation(ID1, 1, 1), 6, 533 "auto "), 534 tooling::Replacement(Context.Sources, Context.getLocation(ID1, 3, 10), 1, 535 "12345678901")}); 536 FileToReplaces[std::string(File2)] = toReplacements( 537 {tooling::Replacement(Context.Sources, Context.getLocation(ID2, 1, 12), 0, 538 "4567890123"), 539 tooling::Replacement(Context.Sources, Context.getLocation(ID2, 2, 9), 1, 540 "10")}); 541 EXPECT_TRUE( 542 formatAndApplyAllReplacements(FileToReplaces, Context.Rewrite, 543 "{BasedOnStyle: LLVM, ColumnLimit: 20}")); 544 EXPECT_EQ(Expected1, Context.getRewrittenText(ID1)); 545 EXPECT_EQ(Expected2, Context.getRewrittenText(ID2)); 546 } 547 548 TEST(ShiftedCodePositionTest, FindsNewCodePosition) { 549 Replacements Replaces = 550 toReplacements({Replacement("", 0, 1, ""), Replacement("", 4, 3, " ")}); 551 // Assume ' int i;' is turned into 'int i;' and cursor is located at '|'. 552 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(0)); // |int i; 553 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(1)); // |nt i; 554 EXPECT_EQ(1u, Replaces.getShiftedCodePosition(2)); // i|t i; 555 EXPECT_EQ(2u, Replaces.getShiftedCodePosition(3)); // in| i; 556 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(4)); // int| i; 557 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(5)); // int | i; 558 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(6)); // int |i; 559 EXPECT_EQ(4u, Replaces.getShiftedCodePosition(7)); // int |; 560 EXPECT_EQ(5u, Replaces.getShiftedCodePosition(8)); // int i| 561 } 562 563 TEST(ShiftedCodePositionTest, FindsNewCodePositionWithInserts) { 564 Replacements Replaces = toReplacements({Replacement("", 4, 0, "\"\n\"")}); 565 // Assume '"12345678"' is turned into '"1234"\n"5678"'. 566 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(3)); // "123|5678" 567 EXPECT_EQ(7u, Replaces.getShiftedCodePosition(4)); // "1234|678" 568 EXPECT_EQ(8u, Replaces.getShiftedCodePosition(5)); // "12345|78" 569 } 570 571 TEST(ShiftedCodePositionTest, FindsNewCodePositionInReplacedText) { 572 // Replace the first four characters with "abcd". 573 auto Replaces = toReplacements({Replacement("", 0, 4, "abcd")}); 574 for (unsigned i = 0; i < 3; ++i) 575 EXPECT_EQ(i, Replaces.getShiftedCodePosition(i)); 576 } 577 578 TEST(ShiftedCodePositionTest, NoReplacementText) { 579 Replacements Replaces = toReplacements({Replacement("", 0, 42, "")}); 580 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(0)); 581 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(39)); 582 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(45)); 583 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(42)); 584 } 585 586 class FlushRewrittenFilesTest : public ::testing::Test { 587 public: 588 FlushRewrittenFilesTest() {} 589 590 ~FlushRewrittenFilesTest() override { 591 for (llvm::StringMap<std::string>::iterator I = TemporaryFiles.begin(), 592 E = TemporaryFiles.end(); 593 I != E; ++I) { 594 llvm::StringRef Name = I->second; 595 std::error_code EC = llvm::sys::fs::remove(Name); 596 (void)EC; 597 assert(!EC); 598 } 599 } 600 601 FileID createFile(llvm::StringRef Name, llvm::StringRef Content) { 602 SmallString<1024> Path; 603 int FD; 604 std::error_code EC = llvm::sys::fs::createTemporaryFile(Name, "", FD, Path); 605 assert(!EC); 606 (void)EC; 607 608 llvm::raw_fd_ostream OutStream(FD, true); 609 OutStream << Content; 610 OutStream.close(); 611 auto File = Context.Files.getOptionalFileRef(Path); 612 assert(File); 613 614 StringRef Found = 615 TemporaryFiles.insert(std::make_pair(Name, std::string(Path.str()))) 616 .first->second; 617 assert(Found == Path); 618 (void)Found; 619 return Context.Sources.createFileID(*File, SourceLocation(), 620 SrcMgr::C_User); 621 } 622 623 std::string getFileContentFromDisk(llvm::StringRef Name) { 624 std::string Path = TemporaryFiles.lookup(Name); 625 assert(!Path.empty()); 626 // We need to read directly from the FileManager without relaying through 627 // a FileEntry, as otherwise we'd read through an already opened file 628 // descriptor, which might not see the changes made. 629 // FIXME: Figure out whether there is a way to get the SourceManger to 630 // reopen the file. 631 auto FileBuffer = Context.Files.getBufferForFile(Path); 632 return std::string((*FileBuffer)->getBuffer()); 633 } 634 635 llvm::StringMap<std::string> TemporaryFiles; 636 RewriterTestContext Context; 637 }; 638 639 TEST_F(FlushRewrittenFilesTest, StoresChangesOnDisk) { 640 FileID ID = createFile("input.cpp", "line1\nline2\nline3\nline4"); 641 Replacements Replaces = toReplacements({Replacement( 642 Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")}); 643 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite)); 644 EXPECT_FALSE(Context.Rewrite.overwriteChangedFiles()); 645 EXPECT_EQ("line1\nreplaced\nline3\nline4", 646 getFileContentFromDisk("input.cpp")); 647 } 648 649 namespace { 650 template <typename T> 651 class TestVisitor : public clang::RecursiveASTVisitor<T> { 652 public: 653 bool runOver(StringRef Code) { 654 return runToolOnCode(std::make_unique<TestAction>(this), Code); 655 } 656 657 protected: 658 clang::SourceManager *SM; 659 clang::ASTContext *Context; 660 661 private: 662 class FindConsumer : public clang::ASTConsumer { 663 public: 664 FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {} 665 666 void HandleTranslationUnit(clang::ASTContext &Context) override { 667 Visitor->TraverseDecl(Context.getTranslationUnitDecl()); 668 } 669 670 private: 671 TestVisitor *Visitor; 672 }; 673 674 class TestAction : public clang::ASTFrontendAction { 675 public: 676 TestAction(TestVisitor *Visitor) : Visitor(Visitor) {} 677 678 std::unique_ptr<clang::ASTConsumer> 679 CreateASTConsumer(clang::CompilerInstance &compiler, 680 llvm::StringRef dummy) override { 681 Visitor->SM = &compiler.getSourceManager(); 682 Visitor->Context = &compiler.getASTContext(); 683 /// TestConsumer will be deleted by the framework calling us. 684 return std::make_unique<FindConsumer>(Visitor); 685 } 686 687 private: 688 TestVisitor *Visitor; 689 }; 690 }; 691 } // end namespace 692 693 void expectReplacementAt(const Replacement &Replace, 694 StringRef File, unsigned Offset, unsigned Length) { 695 ASSERT_TRUE(Replace.isApplicable()); 696 EXPECT_EQ(File, Replace.getFilePath()); 697 EXPECT_EQ(Offset, Replace.getOffset()); 698 EXPECT_EQ(Length, Replace.getLength()); 699 } 700 701 class ClassDeclXVisitor : public TestVisitor<ClassDeclXVisitor> { 702 public: 703 bool VisitCXXRecordDecl(CXXRecordDecl *Record) { 704 if (Record->getName() == "X") { 705 Replace = Replacement(*SM, Record, ""); 706 } 707 return true; 708 } 709 Replacement Replace; 710 }; 711 712 TEST(Replacement, CanBeConstructedFromNode) { 713 ClassDeclXVisitor ClassDeclX; 714 EXPECT_TRUE(ClassDeclX.runOver(" class X;")); 715 expectReplacementAt(ClassDeclX.Replace, "input.cc", 5, 7); 716 } 717 718 TEST(Replacement, ReplacesAtSpellingLocation) { 719 ClassDeclXVisitor ClassDeclX; 720 EXPECT_TRUE(ClassDeclX.runOver("#define A(Y) Y\nA(class X);")); 721 expectReplacementAt(ClassDeclX.Replace, "input.cc", 17, 7); 722 } 723 724 class CallToFVisitor : public TestVisitor<CallToFVisitor> { 725 public: 726 bool VisitCallExpr(CallExpr *Call) { 727 if (Call->getDirectCallee()->getName() == "F") { 728 Replace = Replacement(*SM, Call, ""); 729 } 730 return true; 731 } 732 Replacement Replace; 733 }; 734 735 TEST(Replacement, FunctionCall) { 736 CallToFVisitor CallToF; 737 EXPECT_TRUE(CallToF.runOver("void F(); void G() { F(); }")); 738 expectReplacementAt(CallToF.Replace, "input.cc", 21, 3); 739 } 740 741 TEST(Replacement, TemplatedFunctionCall) { 742 CallToFVisitor CallToF; 743 EXPECT_TRUE(CallToF.runOver( 744 "template <typename T> void F(); void G() { F<int>(); }")); 745 expectReplacementAt(CallToF.Replace, "input.cc", 43, 8); 746 } 747 748 class NestedNameSpecifierAVisitor 749 : public TestVisitor<NestedNameSpecifierAVisitor> { 750 public: 751 bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc) { 752 if (NNSLoc.getNestedNameSpecifier()) { 753 if (const NamespaceDecl* NS = NNSLoc.getNestedNameSpecifier()->getAsNamespace()) { 754 if (NS->getName() == "a") { 755 Replace = Replacement(*SM, &NNSLoc, "", Context->getLangOpts()); 756 } 757 } 758 } 759 return TestVisitor<NestedNameSpecifierAVisitor>::TraverseNestedNameSpecifierLoc( 760 NNSLoc); 761 } 762 Replacement Replace; 763 }; 764 765 TEST(Replacement, ColonColon) { 766 NestedNameSpecifierAVisitor VisitNNSA; 767 EXPECT_TRUE(VisitNNSA.runOver("namespace a { void f() { ::a::f(); } }")); 768 expectReplacementAt(VisitNNSA.Replace, "input.cc", 25, 5); 769 } 770 771 TEST(Range, overlaps) { 772 EXPECT_TRUE(Range(10, 10).overlapsWith(Range(0, 11))); 773 EXPECT_TRUE(Range(0, 11).overlapsWith(Range(10, 10))); 774 EXPECT_FALSE(Range(10, 10).overlapsWith(Range(0, 10))); 775 EXPECT_FALSE(Range(0, 10).overlapsWith(Range(10, 10))); 776 EXPECT_TRUE(Range(0, 10).overlapsWith(Range(2, 6))); 777 EXPECT_TRUE(Range(2, 6).overlapsWith(Range(0, 10))); 778 } 779 780 TEST(Range, contains) { 781 EXPECT_TRUE(Range(0, 10).contains(Range(0, 10))); 782 EXPECT_TRUE(Range(0, 10).contains(Range(2, 6))); 783 EXPECT_FALSE(Range(2, 6).contains(Range(0, 10))); 784 EXPECT_FALSE(Range(0, 10).contains(Range(0, 11))); 785 } 786 787 TEST(Range, CalculateRangesOfReplacements) { 788 // Before: aaaabbbbbbz 789 // After : bbbbbbzzzzzzoooooooooooooooo 790 Replacements Replaces = toReplacements( 791 {Replacement("foo", 0, 4, ""), Replacement("foo", 10, 1, "zzzzzz"), 792 Replacement("foo", 11, 0, "oooooooooooooooo")}); 793 794 std::vector<Range> Ranges = Replaces.getAffectedRanges(); 795 796 EXPECT_EQ(2ul, Ranges.size()); 797 EXPECT_TRUE(Ranges[0].getOffset() == 0); 798 EXPECT_TRUE(Ranges[0].getLength() == 0); 799 EXPECT_TRUE(Ranges[1].getOffset() == 6); 800 EXPECT_TRUE(Ranges[1].getLength() == 22); 801 } 802 803 TEST(Range, CalculateRangesOfInsertionAroundReplacement) { 804 Replacements Replaces = toReplacements( 805 {Replacement("foo", 0, 2, ""), Replacement("foo", 0, 0, "ba")}); 806 807 std::vector<Range> Ranges = Replaces.getAffectedRanges(); 808 809 EXPECT_EQ(1ul, Ranges.size()); 810 EXPECT_EQ(0u, Ranges[0].getOffset()); 811 EXPECT_EQ(2u, Ranges[0].getLength()); 812 } 813 814 TEST(Range, RangesAfterEmptyReplacements) { 815 std::vector<Range> Ranges = {Range(5, 6), Range(10, 5)}; 816 Replacements Replaces; 817 std::vector<Range> Expected = {Range(5, 10)}; 818 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 819 } 820 821 TEST(Range, RangesAfterReplacements) { 822 std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)}; 823 Replacements Replaces = toReplacements({Replacement("foo", 0, 2, "1234")}); 824 std::vector<Range> Expected = {Range(0, 4), Range(7, 2), Range(12, 5)}; 825 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 826 } 827 828 TEST(Range, RangesBeforeReplacements) { 829 std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)}; 830 Replacements Replaces = toReplacements({Replacement("foo", 20, 2, "1234")}); 831 std::vector<Range> Expected = {Range(5, 2), Range(10, 5), Range(20, 4)}; 832 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 833 } 834 835 TEST(Range, NotAffectedByReplacements) { 836 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)}; 837 Replacements Replaces = toReplacements({Replacement("foo", 3, 2, "12"), 838 Replacement("foo", 12, 2, "12"), 839 Replacement("foo", 20, 5, "")}); 840 std::vector<Range> Expected = {Range(0, 2), Range(3, 4), Range(10, 5), 841 Range(20, 0)}; 842 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 843 } 844 845 TEST(Range, RangesWithNonOverlappingReplacements) { 846 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)}; 847 Replacements Replaces = toReplacements({Replacement("foo", 3, 1, ""), 848 Replacement("foo", 6, 1, "123"), 849 Replacement("foo", 20, 2, "12345")}); 850 std::vector<Range> Expected = {Range(0, 2), Range(3, 0), Range(4, 4), 851 Range(11, 5), Range(21, 5)}; 852 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 853 } 854 855 TEST(Range, RangesWithOverlappingReplacements) { 856 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5), 857 Range(30, 5)}; 858 Replacements Replaces = toReplacements( 859 {Replacement("foo", 1, 3, ""), Replacement("foo", 6, 1, "123"), 860 Replacement("foo", 13, 3, "1"), Replacement("foo", 25, 15, "")}); 861 std::vector<Range> Expected = {Range(0, 1), Range(2, 4), Range(12, 5), 862 Range(22, 0)}; 863 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 864 } 865 866 TEST(Range, MergeIntoOneRange) { 867 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)}; 868 Replacements Replaces = 869 toReplacements({Replacement("foo", 1, 15, "1234567890")}); 870 std::vector<Range> Expected = {Range(0, 15)}; 871 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 872 } 873 874 TEST(Range, ReplacementsStartingAtRangeOffsets) { 875 std::vector<Range> Ranges = {Range(0, 2), Range(5, 5), Range(15, 5)}; 876 Replacements Replaces = toReplacements( 877 {Replacement("foo", 0, 2, "12"), Replacement("foo", 5, 1, "123"), 878 Replacement("foo", 7, 4, "12345"), Replacement("foo", 15, 10, "12")}); 879 std::vector<Range> Expected = {Range(0, 2), Range(5, 9), Range(18, 2)}; 880 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 881 } 882 883 TEST(Range, ReplacementsEndingAtRangeEnds) { 884 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)}; 885 Replacements Replaces = toReplacements( 886 {Replacement("foo", 6, 1, "123"), Replacement("foo", 17, 3, "12")}); 887 std::vector<Range> Expected = {Range(0, 2), Range(5, 4), Range(17, 4)}; 888 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 889 } 890 891 TEST(Range, AjacentReplacements) { 892 std::vector<Range> Ranges = {Range(0, 0), Range(15, 5)}; 893 Replacements Replaces = toReplacements( 894 {Replacement("foo", 1, 2, "123"), Replacement("foo", 12, 3, "1234")}); 895 std::vector<Range> Expected = {Range(0, 0), Range(1, 3), Range(13, 9)}; 896 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 897 } 898 899 TEST(Range, MergeRangesAfterReplacements) { 900 std::vector<Range> Ranges = {Range(8, 0), Range(5, 2), Range(9, 0), Range(0, 1)}; 901 Replacements Replaces = toReplacements({Replacement("foo", 1, 3, ""), 902 Replacement("foo", 7, 0, "12"), 903 Replacement("foo", 9, 2, "")}); 904 std::vector<Range> Expected = {Range(0, 1), Range(2, 4), Range(7, 0), 905 Range(8, 0)}; 906 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 907 } 908 909 TEST(Range, ConflictingRangesBeforeReplacements) { 910 std::vector<Range> Ranges = {Range(8, 3), Range(5, 4), Range(9, 1)}; 911 Replacements Replaces = toReplacements({Replacement("foo", 1, 3, "")}); 912 std::vector<Range> Expected = {Range(1, 0), Range(2, 6)}; 913 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); 914 } 915 916 class MergeReplacementsTest : public ::testing::Test { 917 protected: 918 void mergeAndTestRewrite(StringRef Code, StringRef Intermediate, 919 StringRef Result, const Replacements &First, 920 const Replacements &Second) { 921 // These are mainly to verify the test itself and make it easier to read. 922 auto AfterFirst = applyAllReplacements(Code, First); 923 EXPECT_TRUE(static_cast<bool>(AfterFirst)); 924 auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second); 925 EXPECT_TRUE(static_cast<bool>(InSequenceRewrite)); 926 EXPECT_EQ(Intermediate, *AfterFirst); 927 EXPECT_EQ(Result, *InSequenceRewrite); 928 929 tooling::Replacements Merged = First.merge(Second); 930 auto MergedRewrite = applyAllReplacements(Code, Merged); 931 EXPECT_TRUE(static_cast<bool>(MergedRewrite)); 932 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite); 933 if (*InSequenceRewrite != *MergedRewrite) 934 for (tooling::Replacement M : Merged) 935 llvm::errs() << M.getOffset() << " " << M.getLength() << " " 936 << M.getReplacementText() << "\n"; 937 } 938 void mergeAndTestRewrite(StringRef Code, const Replacements &First, 939 const Replacements &Second) { 940 auto AfterFirst = applyAllReplacements(Code, First); 941 EXPECT_TRUE(static_cast<bool>(AfterFirst)); 942 auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second); 943 tooling::Replacements Merged = First.merge(Second); 944 auto MergedRewrite = applyAllReplacements(Code, Merged); 945 EXPECT_TRUE(static_cast<bool>(MergedRewrite)); 946 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite); 947 if (*InSequenceRewrite != *MergedRewrite) 948 for (tooling::Replacement M : Merged) 949 llvm::errs() << M.getOffset() << " " << M.getLength() << " " 950 << M.getReplacementText() << "\n"; 951 } 952 }; 953 954 TEST_F(MergeReplacementsTest, Offsets) { 955 mergeAndTestRewrite("aaa", "aabab", "cacabab", 956 toReplacements({{"", 2, 0, "b"}, {"", 3, 0, "b"}}), 957 toReplacements({{"", 0, 0, "c"}, {"", 1, 0, "c"}})); 958 mergeAndTestRewrite("aaa", "babaa", "babacac", 959 toReplacements({{"", 0, 0, "b"}, {"", 1, 0, "b"}}), 960 toReplacements({{"", 4, 0, "c"}, {"", 5, 0, "c"}})); 961 mergeAndTestRewrite("aaaa", "aaa", "aac", toReplacements({{"", 1, 1, ""}}), 962 toReplacements({{"", 2, 1, "c"}})); 963 964 mergeAndTestRewrite("aa", "bbabba", "bbabcba", 965 toReplacements({{"", 0, 0, "bb"}, {"", 1, 0, "bb"}}), 966 toReplacements({{"", 4, 0, "c"}})); 967 } 968 969 TEST_F(MergeReplacementsTest, Concatenations) { 970 // Basic concatenations. It is important to merge these into a single 971 // replacement to ensure the correct order. 972 { 973 auto First = toReplacements({{"", 0, 0, "a"}}); 974 auto Second = toReplacements({{"", 1, 0, "b"}}); 975 EXPECT_EQ(toReplacements({{"", 0, 0, "ab"}}), First.merge(Second)); 976 } 977 { 978 auto First = toReplacements({{"", 0, 0, "a"}}); 979 auto Second = toReplacements({{"", 0, 0, "b"}}); 980 EXPECT_EQ(toReplacements({{"", 0, 0, "ba"}}), First.merge(Second)); 981 } 982 mergeAndTestRewrite("", "a", "ab", toReplacements({{"", 0, 0, "a"}}), 983 toReplacements({{"", 1, 0, "b"}})); 984 mergeAndTestRewrite("", "a", "ba", toReplacements({{"", 0, 0, "a"}}), 985 toReplacements({{"", 0, 0, "b"}})); 986 } 987 988 TEST_F(MergeReplacementsTest, NotChangingLengths) { 989 mergeAndTestRewrite("aaaa", "abba", "acca", 990 toReplacements({{"", 1, 2, "bb"}}), 991 toReplacements({{"", 1, 2, "cc"}})); 992 mergeAndTestRewrite("aaaa", "abba", "abcc", 993 toReplacements({{"", 1, 2, "bb"}}), 994 toReplacements({{"", 2, 2, "cc"}})); 995 mergeAndTestRewrite("aaaa", "abba", "ccba", 996 toReplacements({{"", 1, 2, "bb"}}), 997 toReplacements({{"", 0, 2, "cc"}})); 998 mergeAndTestRewrite("aaaaaa", "abbdda", "abccda", 999 toReplacements({{"", 1, 2, "bb"}, {"", 3, 2, "dd"}}), 1000 toReplacements({{"", 2, 2, "cc"}})); 1001 } 1002 1003 TEST_F(MergeReplacementsTest, OverlappingRanges) { 1004 mergeAndTestRewrite("aaa", "bbd", "bcbcd", 1005 toReplacements({{"", 0, 1, "bb"}, {"", 1, 2, "d"}}), 1006 toReplacements({{"", 1, 0, "c"}, {"", 2, 0, "c"}})); 1007 1008 mergeAndTestRewrite("aaaa", "aabbaa", "acccca", 1009 toReplacements({{"", 2, 0, "bb"}}), 1010 toReplacements({{"", 1, 4, "cccc"}})); 1011 mergeAndTestRewrite("aaaa", "aababa", "acccca", 1012 toReplacements({{"", 2, 0, "b"}, {"", 3, 0, "b"}}), 1013 toReplacements({{"", 1, 4, "cccc"}})); 1014 mergeAndTestRewrite("aaaaaa", "abbbba", "abba", 1015 toReplacements({{"", 1, 4, "bbbb"}}), 1016 toReplacements({{"", 2, 2, ""}})); 1017 mergeAndTestRewrite("aaaa", "aa", "cc", 1018 toReplacements({{"", 1, 1, ""}, {"", 2, 1, ""}}), 1019 toReplacements({{"", 0, 2, "cc"}})); 1020 mergeAndTestRewrite("aa", "abbba", "abcbcba", 1021 toReplacements({{"", 1, 0, "bbb"}}), 1022 toReplacements({{"", 2, 0, "c"}, {"", 3, 0, "c"}})); 1023 1024 mergeAndTestRewrite( 1025 "aaa", "abbab", "ccdd", 1026 toReplacements({{"", 0, 1, ""}, {"", 2, 0, "bb"}, {"", 3, 0, "b"}}), 1027 toReplacements({{"", 0, 2, "cc"}, {"", 2, 3, "dd"}})); 1028 mergeAndTestRewrite( 1029 "aa", "babbab", "ccdd", 1030 toReplacements({{"", 0, 0, "b"}, {"", 1, 0, "bb"}, {"", 2, 0, "b"}}), 1031 toReplacements({{"", 0, 3, "cc"}, {"", 3, 3, "dd"}})); 1032 } 1033 1034 static constexpr bool usesWindowsPaths() { 1035 return is_style_windows(llvm::sys::path::Style::native); 1036 } 1037 1038 TEST(DeduplicateByFileTest, PathsWithDots) { 1039 std::map<std::string, Replacements> FileToReplaces; 1040 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS( 1041 new llvm::vfs::InMemoryFileSystem()); 1042 FileManager FileMgr(FileSystemOptions(), VFS); 1043 StringRef Path1 = usesWindowsPaths() ? "a\\b\\..\\.\\c.h" : "a/b/.././c.h"; 1044 StringRef Path2 = usesWindowsPaths() ? "a\\c.h" : "a/c.h"; 1045 EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer(""))); 1046 EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer(""))); 1047 FileToReplaces[std::string(Path1)] = Replacements(); 1048 FileToReplaces[std::string(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<llvm::vfs::InMemoryFileSystem> VFS( 1057 new llvm::vfs::InMemoryFileSystem()); 1058 FileManager FileMgr(FileSystemOptions(), VFS); 1059 StringRef Path1 = usesWindowsPaths() ? ".\\a\\b\\c.h" : "./a/b/c.h"; 1060 StringRef Path2 = usesWindowsPaths() ? "a\\b\\c.h" : "a/b/c.h"; 1061 EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer(""))); 1062 EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer(""))); 1063 FileToReplaces[std::string(Path1)] = Replacements(); 1064 FileToReplaces[std::string(Path2)] = Replacements(); 1065 FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces); 1066 EXPECT_EQ(1u, FileToReplaces.size()); 1067 EXPECT_EQ(Path1, FileToReplaces.begin()->first); 1068 } 1069 1070 TEST(DeduplicateByFileTest, NonExistingFilePath) { 1071 std::map<std::string, Replacements> FileToReplaces; 1072 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS( 1073 new llvm::vfs::InMemoryFileSystem()); 1074 FileManager FileMgr(FileSystemOptions(), VFS); 1075 StringRef Path1 = usesWindowsPaths() ? ".\\a\\b\\c.h" : "./a/b/c.h"; 1076 StringRef Path2 = usesWindowsPaths() ? "a\\b\\c.h" : "a/b/c.h"; 1077 FileToReplaces[std::string(Path1)] = Replacements(); 1078 FileToReplaces[std::string(Path2)] = Replacements(); 1079 FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces); 1080 EXPECT_TRUE(FileToReplaces.empty()); 1081 } 1082 1083 class AtomicChangeTest : public ::testing::Test { 1084 protected: 1085 void SetUp() override { 1086 DefaultFileID = Context.createInMemoryFile("input.cpp", DefaultCode); 1087 DefaultLoc = Context.Sources.getLocForStartOfFile(DefaultFileID) 1088 .getLocWithOffset(20); 1089 assert(DefaultLoc.isValid() && "Default location must be valid."); 1090 } 1091 1092 RewriterTestContext Context; 1093 std::string DefaultCode = std::string(100, 'a'); 1094 unsigned DefaultOffset = 20; 1095 SourceLocation DefaultLoc; 1096 FileID DefaultFileID; 1097 }; 1098 1099 TEST_F(AtomicChangeTest, AtomicChangeToYAML) { 1100 AtomicChange Change(Context.Sources, DefaultLoc); 1101 llvm::Error Err = 1102 Change.insert(Context.Sources, DefaultLoc, "aa", /*InsertAfter=*/false); 1103 ASSERT_TRUE(!Err); 1104 Err = Change.insert(Context.Sources, DefaultLoc.getLocWithOffset(10), "bb", 1105 /*InsertAfter=*/false); 1106 ASSERT_TRUE(!Err); 1107 Change.addHeader("a.h"); 1108 Change.removeHeader("b.h"); 1109 std::string YAMLString = Change.toYAMLString(); 1110 1111 // NOTE: If this test starts to fail for no obvious reason, check whitespace. 1112 ASSERT_STREQ("---\n" 1113 "Key: 'input.cpp:20'\n" 1114 "FilePath: input.cpp\n" 1115 "Error: ''\n" 1116 "InsertedHeaders:\n" 1117 " - a.h\n" 1118 "RemovedHeaders:\n" 1119 " - b.h\n" 1120 "Replacements:\n" 1121 " - FilePath: input.cpp\n" 1122 " Offset: 20\n" 1123 " Length: 0\n" 1124 " ReplacementText: aa\n" 1125 " - FilePath: input.cpp\n" 1126 " Offset: 30\n" 1127 " Length: 0\n" 1128 " ReplacementText: bb\n" 1129 "...\n", 1130 YAMLString.c_str()); 1131 } 1132 1133 TEST_F(AtomicChangeTest, YAMLToAtomicChange) { 1134 std::string YamlContent = "---\n" 1135 "Key: 'input.cpp:20'\n" 1136 "FilePath: input.cpp\n" 1137 "Error: 'ok'\n" 1138 "InsertedHeaders:\n" 1139 " - a.h\n" 1140 "RemovedHeaders:\n" 1141 " - b.h\n" 1142 "Replacements:\n" 1143 " - FilePath: input.cpp\n" 1144 " Offset: 20\n" 1145 " Length: 0\n" 1146 " ReplacementText: aa\n" 1147 " - FilePath: input.cpp\n" 1148 " Offset: 30\n" 1149 " Length: 0\n" 1150 " ReplacementText: bb\n" 1151 "...\n"; 1152 AtomicChange ExpectedChange(Context.Sources, DefaultLoc); 1153 llvm::Error Err = ExpectedChange.insert(Context.Sources, DefaultLoc, "aa", 1154 /*InsertAfter=*/false); 1155 ASSERT_TRUE(!Err); 1156 Err = ExpectedChange.insert(Context.Sources, DefaultLoc.getLocWithOffset(10), 1157 "bb", /*InsertAfter=*/false); 1158 ASSERT_TRUE(!Err); 1159 1160 ExpectedChange.addHeader("a.h"); 1161 ExpectedChange.removeHeader("b.h"); 1162 ExpectedChange.setError("ok"); 1163 1164 AtomicChange ActualChange = AtomicChange::convertFromYAML(YamlContent); 1165 EXPECT_EQ(ExpectedChange.getKey(), ActualChange.getKey()); 1166 EXPECT_EQ(ExpectedChange.getFilePath(), ActualChange.getFilePath()); 1167 EXPECT_EQ(ExpectedChange.getError(), ActualChange.getError()); 1168 EXPECT_EQ(ExpectedChange.getInsertedHeaders(), 1169 ActualChange.getInsertedHeaders()); 1170 EXPECT_EQ(ExpectedChange.getRemovedHeaders(), 1171 ActualChange.getRemovedHeaders()); 1172 EXPECT_EQ(ExpectedChange.getReplacements().size(), 1173 ActualChange.getReplacements().size()); 1174 EXPECT_EQ(2u, ActualChange.getReplacements().size()); 1175 EXPECT_EQ(*ExpectedChange.getReplacements().begin(), 1176 *ActualChange.getReplacements().begin()); 1177 EXPECT_EQ(*(++ExpectedChange.getReplacements().begin()), 1178 *(++ActualChange.getReplacements().begin())); 1179 } 1180 1181 TEST_F(AtomicChangeTest, CheckKeyAndKeyFile) { 1182 AtomicChange Change(Context.Sources, DefaultLoc); 1183 EXPECT_EQ("input.cpp:20", Change.getKey()); 1184 EXPECT_EQ("input.cpp", Change.getFilePath()); 1185 } 1186 1187 TEST_F(AtomicChangeTest, Replace) { 1188 AtomicChange Change(Context.Sources, DefaultLoc); 1189 llvm::Error Err = Change.replace(Context.Sources, DefaultLoc, 2, "aa"); 1190 ASSERT_TRUE(!Err); 1191 EXPECT_EQ(Change.getReplacements().size(), 1u); 1192 EXPECT_EQ(*Change.getReplacements().begin(), 1193 Replacement(Context.Sources, DefaultLoc, 2, "aa")); 1194 1195 // Add a new replacement that conflicts with the existing one. 1196 Err = Change.replace(Context.Sources, DefaultLoc, 3, "ab"); 1197 EXPECT_TRUE((bool)Err); 1198 llvm::consumeError(std::move(Err)); 1199 EXPECT_EQ(Change.getReplacements().size(), 1u); 1200 } 1201 1202 TEST_F(AtomicChangeTest, ReplaceWithRange) { 1203 AtomicChange Change(Context.Sources, DefaultLoc); 1204 SourceLocation End = DefaultLoc.getLocWithOffset(20); 1205 llvm::Error Err = Change.replace( 1206 Context.Sources, CharSourceRange::getCharRange(DefaultLoc, End), "aa"); 1207 ASSERT_TRUE(!Err); 1208 EXPECT_EQ(Change.getReplacements().size(), 1u); 1209 EXPECT_EQ(*Change.getReplacements().begin(), 1210 Replacement(Context.Sources, DefaultLoc, 20, "aa")); 1211 } 1212 1213 TEST_F(AtomicChangeTest, InsertBefore) { 1214 AtomicChange Change(Context.Sources, DefaultLoc); 1215 llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa"); 1216 ASSERT_TRUE(!Err); 1217 EXPECT_EQ(Change.getReplacements().size(), 1u); 1218 EXPECT_EQ(*Change.getReplacements().begin(), 1219 Replacement(Context.Sources, DefaultLoc, 0, "aa")); 1220 Err = Change.insert(Context.Sources, DefaultLoc, "b", /*InsertAfter=*/false); 1221 ASSERT_TRUE(!Err); 1222 EXPECT_EQ(Change.getReplacements().size(), 1u); 1223 EXPECT_EQ(*Change.getReplacements().begin(), 1224 Replacement(Context.Sources, DefaultLoc, 0, "baa")); 1225 } 1226 1227 TEST_F(AtomicChangeTest, InsertAfter) { 1228 AtomicChange Change(Context.Sources, DefaultLoc); 1229 llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa"); 1230 ASSERT_TRUE(!Err); 1231 EXPECT_EQ(Change.getReplacements().size(), 1u); 1232 EXPECT_EQ(*Change.getReplacements().begin(), 1233 Replacement(Context.Sources, DefaultLoc, 0, "aa")); 1234 Err = Change.insert(Context.Sources, DefaultLoc, "b"); 1235 ASSERT_TRUE(!Err); 1236 EXPECT_EQ(Change.getReplacements().size(), 1u); 1237 EXPECT_EQ(*Change.getReplacements().begin(), 1238 Replacement(Context.Sources, DefaultLoc, 0, "aab")); 1239 } 1240 1241 TEST_F(AtomicChangeTest, InsertBeforeWithInvalidLocation) { 1242 AtomicChange Change(Context.Sources, DefaultLoc); 1243 llvm::Error Err = 1244 Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false); 1245 ASSERT_TRUE(!Err); 1246 1247 // Invalid location. 1248 Err = Change.insert(Context.Sources, SourceLocation(), "a", 1249 /*InsertAfter=*/false); 1250 ASSERT_TRUE((bool)Err); 1251 EXPECT_TRUE(checkReplacementError( 1252 std::move(Err), replacement_error::wrong_file_path, 1253 Replacement(Context.Sources, DefaultLoc, 0, "a"), 1254 Replacement(Context.Sources, SourceLocation(), 0, "a"))); 1255 } 1256 1257 TEST_F(AtomicChangeTest, InsertBeforeToWrongFile) { 1258 AtomicChange Change(Context.Sources, DefaultLoc); 1259 llvm::Error Err = 1260 Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false); 1261 ASSERT_TRUE(!Err); 1262 1263 // Inserting at a different file. 1264 FileID NewID = Context.createInMemoryFile("extra.cpp", DefaultCode); 1265 SourceLocation NewLoc = Context.Sources.getLocForStartOfFile(NewID); 1266 Err = Change.insert(Context.Sources, NewLoc, "b", /*InsertAfter=*/false); 1267 ASSERT_TRUE((bool)Err); 1268 EXPECT_TRUE( 1269 checkReplacementError(std::move(Err), replacement_error::wrong_file_path, 1270 Replacement(Context.Sources, DefaultLoc, 0, "a"), 1271 Replacement(Context.Sources, NewLoc, 0, "b"))); 1272 } 1273 1274 TEST_F(AtomicChangeTest, InsertAfterWithInvalidLocation) { 1275 AtomicChange Change(Context.Sources, DefaultLoc); 1276 llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "a"); 1277 ASSERT_TRUE(!Err); 1278 1279 // Invalid location. 1280 Err = Change.insert(Context.Sources, SourceLocation(), "b"); 1281 ASSERT_TRUE((bool)Err); 1282 EXPECT_TRUE(checkReplacementError( 1283 std::move(Err), replacement_error::wrong_file_path, 1284 Replacement(Context.Sources, DefaultLoc, 0, "a"), 1285 Replacement(Context.Sources, SourceLocation(), 0, "b"))); 1286 } 1287 1288 TEST_F(AtomicChangeTest, Metadata) { 1289 AtomicChange Change(Context.Sources, DefaultLoc, 17); 1290 const llvm::Any &Metadata = Change.getMetadata(); 1291 ASSERT_TRUE(llvm::any_isa<int>(Metadata)); 1292 EXPECT_EQ(llvm::any_cast<int>(Metadata), 17); 1293 } 1294 1295 TEST_F(AtomicChangeTest, NoMetadata) { 1296 AtomicChange Change(Context.Sources, DefaultLoc); 1297 EXPECT_FALSE(Change.getMetadata().hasValue()); 1298 } 1299 1300 class ApplyAtomicChangesTest : public ::testing::Test { 1301 protected: 1302 ApplyAtomicChangesTest() : FilePath("file.cc") { 1303 Spec.Cleanup = true; 1304 Spec.Format = ApplyChangesSpec::kAll; 1305 Spec.Style = format::getLLVMStyle(); 1306 } 1307 1308 ~ApplyAtomicChangesTest() override {} 1309 1310 void setInput(llvm::StringRef Input) { 1311 Code = std::string(Input); 1312 FID = Context.createInMemoryFile(FilePath, Code); 1313 } 1314 1315 SourceLocation getLoc(unsigned Offset) const { 1316 return Context.Sources.getLocForStartOfFile(FID).getLocWithOffset(Offset); 1317 } 1318 1319 AtomicChange replacementToAtomicChange(llvm::StringRef Key, unsigned Offset, 1320 unsigned Length, 1321 llvm::StringRef Text) { 1322 AtomicChange Change(FilePath, Key); 1323 llvm::Error Err = 1324 Change.replace(Context.Sources, getLoc(Offset), Length, Text); 1325 EXPECT_FALSE(Err); 1326 return Change; 1327 } 1328 1329 std::string rewrite(bool FailureExpected = false) { 1330 llvm::Expected<std::string> ChangedCode = 1331 applyAtomicChanges(FilePath, Code, Changes, Spec); 1332 EXPECT_EQ(FailureExpected, !ChangedCode); 1333 if (!ChangedCode) { 1334 llvm::errs() << "Failed to apply changes: " 1335 << llvm::toString(ChangedCode.takeError()) << "\n"; 1336 return ""; 1337 } 1338 return *ChangedCode; 1339 } 1340 1341 RewriterTestContext Context; 1342 FileID FID; 1343 ApplyChangesSpec Spec; 1344 std::string Code; 1345 std::string FilePath; 1346 llvm::SmallVector<AtomicChange, 8> Changes; 1347 }; 1348 1349 TEST_F(ApplyAtomicChangesTest, BasicRefactoring) { 1350 setInput("int a;"); 1351 AtomicChange Change(FilePath, "key1"); 1352 Changes.push_back(replacementToAtomicChange("key1", 4, 1, "b")); 1353 EXPECT_EQ("int b;", rewrite()); 1354 } 1355 1356 TEST_F(ApplyAtomicChangesTest, SeveralRefactorings) { 1357 setInput("int a;\n" 1358 "int b;"); 1359 Changes.push_back(replacementToAtomicChange("key1", 0, 3, "float")); 1360 Changes.push_back(replacementToAtomicChange("key2", 4, 1, "f")); 1361 Changes.push_back(replacementToAtomicChange("key3", 11, 1, "g")); 1362 Changes.push_back(replacementToAtomicChange("key4", 7, 3, "float")); 1363 EXPECT_EQ("float f;\n" 1364 "float g;", 1365 rewrite()); 1366 } 1367 1368 TEST_F(ApplyAtomicChangesTest, IgnorePathsInRefactorings) { 1369 setInput("int a;\n" 1370 "int b;"); 1371 Changes.push_back(replacementToAtomicChange("key1", 4, 1, "aa")); 1372 1373 FileID ID = Context.createInMemoryFile("AnotherFile", "12345678912345"); 1374 Changes.emplace_back("AnotherFile", "key2"); 1375 auto Err = Changes.back().replace( 1376 Context.Sources, 1377 Context.Sources.getLocForStartOfFile(ID).getLocWithOffset(11), 1, "bb"); 1378 ASSERT_TRUE(!Err); 1379 EXPECT_EQ("int aa;\n" 1380 "int bb;", 1381 rewrite()); 1382 } 1383 1384 TEST_F(ApplyAtomicChangesTest, AppliesDuplicateInsertions) { 1385 setInput("int a;"); 1386 Changes.push_back(replacementToAtomicChange("key1", 5, 0, "b")); 1387 Changes.push_back(replacementToAtomicChange("key2", 5, 0, "b")); 1388 EXPECT_EQ("int abb;", rewrite()); 1389 } 1390 1391 TEST_F(ApplyAtomicChangesTest, BailsOnOverlappingRefactorings) { 1392 setInput("int a;"); 1393 Changes.push_back(replacementToAtomicChange("key1", 0, 5, "float f")); 1394 Changes.push_back(replacementToAtomicChange("key2", 4, 1, "b")); 1395 EXPECT_EQ("", rewrite(/*FailureExpected=*/true)); 1396 } 1397 1398 TEST_F(ApplyAtomicChangesTest, BasicReformatting) { 1399 setInput("int a;"); 1400 Changes.push_back(replacementToAtomicChange("key1", 5, 1, "b")); 1401 EXPECT_EQ("int b;", rewrite()); 1402 } 1403 1404 TEST_F(ApplyAtomicChangesTest, OnlyFormatWhenViolateColumnLimits) { 1405 Spec.Format = ApplyChangesSpec::kViolations; 1406 Spec.Style.ColumnLimit = 8; 1407 setInput("int a;\n" 1408 "int a;\n" 1409 "int aaaaaaaa;\n"); 1410 Changes.push_back(replacementToAtomicChange("key1", 5, 1, "x")); 1411 Changes.push_back(replacementToAtomicChange("key2", 15, 1, "x")); 1412 Changes.push_back(replacementToAtomicChange("key3", 23, 8, "xx")); 1413 EXPECT_EQ("int x;\n" 1414 "int x;\n" 1415 "int xx;\n", 1416 rewrite()); 1417 } 1418 1419 TEST_F(ApplyAtomicChangesTest, LastLineViolateColumnLimits) { 1420 Spec.Format = ApplyChangesSpec::kViolations; 1421 Spec.Style.ColumnLimit = 8; 1422 setInput("int a;\n" 1423 "int a;"); 1424 Changes.push_back(replacementToAtomicChange("key1", 0, 1, "i")); 1425 Changes.push_back(replacementToAtomicChange("key2", 15, 2, "y;")); 1426 EXPECT_EQ("int a;\n" 1427 "int y;", 1428 rewrite()); 1429 } 1430 1431 TEST_F(ApplyAtomicChangesTest, LastLineWithNewlineViolateColumnLimits) { 1432 Spec.Format = ApplyChangesSpec::kViolations; 1433 Spec.Style.ColumnLimit = 8; 1434 setInput("int a;\n" 1435 "int a;\n"); 1436 Changes.push_back(replacementToAtomicChange("key1", 0, 1, "i")); 1437 Changes.push_back(replacementToAtomicChange("key2", 14, 3, "y;\n")); 1438 EXPECT_EQ("int a;\n" 1439 "int y;\n", 1440 rewrite()); 1441 } 1442 1443 TEST_F(ApplyAtomicChangesTest, Longer) { 1444 setInput("int a;"); 1445 Changes.push_back(replacementToAtomicChange("key1", 5, 1, "bbb")); 1446 EXPECT_EQ("int bbb;", rewrite()); 1447 } 1448 1449 TEST_F(ApplyAtomicChangesTest, Shorter) { 1450 setInput("int aaa;"); 1451 Changes.push_back(replacementToAtomicChange("key1", 5, 3, "b")); 1452 EXPECT_EQ("int b;", rewrite()); 1453 } 1454 1455 TEST_F(ApplyAtomicChangesTest, OnlyFormatChangedLines) { 1456 setInput("int aaa;\n" 1457 "int a = b;\n" 1458 "int bbb;"); 1459 Changes.push_back(replacementToAtomicChange("key1", 14, 1, "b")); 1460 EXPECT_EQ("int aaa;\n" 1461 "int b = b;\n" 1462 "int bbb;", 1463 rewrite()); 1464 } 1465 1466 TEST_F(ApplyAtomicChangesTest, DisableFormatting) { 1467 Spec.Format = ApplyChangesSpec::kNone; 1468 setInput("int aaa;\n" 1469 "int a = b;\n" 1470 "int bbb;"); 1471 Changes.push_back(replacementToAtomicChange("key1", 14, 1, "b")); 1472 EXPECT_EQ("int aaa;\n" 1473 "int b = b;\n" 1474 "int bbb;", 1475 rewrite()); 1476 } 1477 1478 TEST_F(ApplyAtomicChangesTest, AdaptsToLocalPointerStyle) { 1479 setInput("int *aaa;\n" 1480 "int *bbb;"); 1481 Changes.push_back(replacementToAtomicChange("key1", 0, 0, "int* ccc;\n")); 1482 EXPECT_EQ("int *ccc;\n" 1483 "int *aaa;\n" 1484 "int *bbb;", 1485 rewrite()); 1486 } 1487 1488 TEST_F(ApplyAtomicChangesTest, AcceptsSurroundingFormatting) { 1489 setInput(" int aaa;\n" 1490 " int a = b;\n" 1491 " int bbb;"); 1492 Changes.push_back(replacementToAtomicChange("key1", 20, 1, "b")); 1493 EXPECT_EQ(" int aaa;\n" 1494 " int b = b;\n" 1495 " int bbb;", 1496 rewrite()); 1497 } 1498 1499 TEST_F(ApplyAtomicChangesTest, BailsOutOnConflictingChanges) { 1500 setInput("int c;\n" 1501 "int f;"); 1502 // Insertions at the same offset are only allowed in the same AtomicChange. 1503 Changes.push_back(replacementToAtomicChange("key1", 0, 0, "int a;\n")); 1504 Changes.push_back(replacementToAtomicChange("key2", 0, 0, "int b;\n")); 1505 EXPECT_EQ("", rewrite(/*FailureExpected=*/true)); 1506 } 1507 1508 TEST_F(ApplyAtomicChangesTest, InsertsNewIncludesInRightOrder) { 1509 setInput("int a;"); 1510 Changes.emplace_back(FilePath, "key1"); 1511 Changes.back().addHeader("b"); 1512 Changes.back().addHeader("c"); 1513 Changes.emplace_back(FilePath, "key2"); 1514 Changes.back().addHeader("a"); 1515 EXPECT_EQ("#include \"a\"\n" 1516 "#include \"b\"\n" 1517 "#include \"c\"\n" 1518 "int a;", 1519 rewrite()); 1520 } 1521 1522 TEST_F(ApplyAtomicChangesTest, RemoveAndSortIncludes) { 1523 setInput("#include \"a\"\n" 1524 "#include \"b\"\n" 1525 "#include \"c\"\n" 1526 "\n" 1527 "int a;"); 1528 Changes.emplace_back(FilePath, "key1"); 1529 Changes.back().removeHeader("b"); 1530 EXPECT_EQ("#include \"a\"\n" 1531 "#include \"c\"\n" 1532 "\n" 1533 "int a;", 1534 rewrite()); 1535 } 1536 TEST_F(ApplyAtomicChangesTest, InsertsSystemIncludes) { 1537 setInput("#include <asys>\n" 1538 "#include <csys>\n" 1539 "\n" 1540 "#include \"a\"\n" 1541 "#include \"c\"\n"); 1542 Changes.emplace_back(FilePath, "key1"); 1543 Changes.back().addHeader("<asys>"); // Already exists. 1544 Changes.back().addHeader("<b>"); 1545 Changes.back().addHeader("<d>"); 1546 Changes.back().addHeader("\"b-already-escaped\""); 1547 EXPECT_EQ("#include <asys>\n" 1548 "#include <b>\n" 1549 "#include <csys>\n" 1550 "#include <d>\n" 1551 "\n" 1552 "#include \"a\"\n" 1553 "#include \"b-already-escaped\"\n" 1554 "#include \"c\"\n", 1555 rewrite()); 1556 } 1557 1558 TEST_F(ApplyAtomicChangesTest, RemoveSystemIncludes) { 1559 setInput("#include <a>\n" 1560 "#include <b>\n" 1561 "\n" 1562 "#include \"c\"" 1563 "\n" 1564 "int a;"); 1565 Changes.emplace_back(FilePath, "key1"); 1566 Changes.back().removeHeader("<a>"); 1567 EXPECT_EQ("#include <b>\n" 1568 "\n" 1569 "#include \"c\"" 1570 "\n" 1571 "int a;", 1572 rewrite()); 1573 } 1574 1575 TEST_F(ApplyAtomicChangesTest, 1576 DoNotFormatFollowingLinesIfSeparatedWithNewline) { 1577 setInput("#ifndef __H__\n" 1578 "#define __H__\n" 1579 "#include \"b\"\n" 1580 "\n" 1581 "int a;\n" 1582 "int a;\n" 1583 "int a;\n" 1584 "#endif // __H__\n"); 1585 Changes.push_back(replacementToAtomicChange("key1", 1586 llvm::StringRef("#ifndef __H__\n" 1587 "#define __H__\n" 1588 "\n" 1589 "#include \"b\"\n" 1590 "int a;\n" 1591 "int ") 1592 .size(), 1593 1, "b")); 1594 Changes.back().addHeader("a"); 1595 EXPECT_EQ("#ifndef __H__\n" 1596 "#define __H__\n" 1597 "#include \"a\"\n" 1598 "#include \"b\"\n" 1599 "\n" 1600 "int a;\n" 1601 "int b;\n" 1602 "int a;\n" 1603 "#endif // __H__\n", 1604 rewrite()); 1605 } 1606 1607 TEST_F(ApplyAtomicChangesTest, FormatsCorrectLineWhenHeaderIsRemoved) { 1608 setInput("#include \"a\"\n" 1609 "\n" 1610 "int a;\n" 1611 "int a;\n" 1612 "int a;"); 1613 Changes.push_back(replacementToAtomicChange("key1", 27, 1, "b")); 1614 Changes.back().removeHeader("a"); 1615 EXPECT_EQ("\n" 1616 "int a;\n" 1617 "int b;\n" 1618 "int a;", 1619 rewrite()); 1620 } 1621 1622 TEST_F(ApplyAtomicChangesTest, CleansUpCtorInitializers) { 1623 setInput("A::A() : a(), b() {}\n" 1624 "A::A() : a(), b() {}\n" 1625 "A::A() : a(), b() {}\n" 1626 "A::A() : a()/**/, b() {}\n" 1627 "A::A() : a() ,// \n" 1628 " /**/ b() {}"); 1629 Changes.emplace_back(FilePath, "key1"); 1630 auto Err = Changes.back().replace(Context.Sources, getLoc(9), 3, ""); 1631 ASSERT_TRUE(!Err); 1632 Err = Changes.back().replace(Context.Sources, getLoc(35), 3, ""); 1633 ASSERT_TRUE(!Err); 1634 Err = Changes.back().replace(Context.Sources, getLoc(51), 3, ""); 1635 ASSERT_TRUE(!Err); 1636 Err = Changes.back().replace(Context.Sources, getLoc(56), 3, ""); 1637 ASSERT_TRUE(!Err); 1638 Err = Changes.back().replace(Context.Sources, getLoc(72), 3, ""); 1639 ASSERT_TRUE(!Err); 1640 Err = Changes.back().replace(Context.Sources, getLoc(97), 3, ""); 1641 ASSERT_TRUE(!Err); 1642 Err = Changes.back().replace(Context.Sources, getLoc(118), 3, ""); 1643 ASSERT_TRUE(!Err); 1644 EXPECT_EQ("A::A() : b() {}\n" 1645 "A::A() : a() {}\n" 1646 "A::A() {}\n" 1647 "A::A() : b() {}\n" 1648 "A::A() {}", 1649 rewrite()); 1650 } 1651 1652 TEST_F(ApplyAtomicChangesTest, CleansUpParameterLists) { 1653 setInput("void f(int i, float f, string s);\n" 1654 "f(1, 2.0f, \"a\");\n" 1655 "g(1, 1);"); 1656 Changes.emplace_back(FilePath, "key1"); 1657 auto Err = Changes.back().replace(Context.Sources, getLoc(7), 5, ""); 1658 ASSERT_TRUE(!Err); 1659 Err = Changes.back().replace(Context.Sources, getLoc(23), 8, ""); 1660 ASSERT_TRUE(!Err); 1661 Err = Changes.back().replace(Context.Sources, getLoc(36), 1, ""); 1662 ASSERT_TRUE(!Err); 1663 Err = Changes.back().replace(Context.Sources, getLoc(45), 3, ""); 1664 ASSERT_TRUE(!Err); 1665 Err = Changes.back().replace(Context.Sources, getLoc(53), 1, ""); 1666 ASSERT_TRUE(!Err); 1667 Err = Changes.back().replace(Context.Sources, getLoc(56), 1, ""); 1668 ASSERT_TRUE(!Err); 1669 EXPECT_EQ("void f(float f);\n" 1670 "f(2.0f);\n" 1671 "g();", 1672 rewrite()); 1673 } 1674 1675 TEST_F(ApplyAtomicChangesTest, DisableCleanup) { 1676 Spec.Cleanup = false; 1677 setInput("void f(int i, float f, string s);\n" 1678 "f(1, 2.0f, \"a\");\n" 1679 "g(1, 1);"); 1680 Changes.emplace_back(FilePath, "key1"); 1681 auto Err = Changes.back().replace(Context.Sources, getLoc(7), 5, ""); 1682 ASSERT_TRUE(!Err); 1683 Err = Changes.back().replace(Context.Sources, getLoc(23), 8, ""); 1684 ASSERT_TRUE(!Err); 1685 Err = Changes.back().replace(Context.Sources, getLoc(36), 1, ""); 1686 ASSERT_TRUE(!Err); 1687 Err = Changes.back().replace(Context.Sources, getLoc(45), 3, ""); 1688 ASSERT_TRUE(!Err); 1689 Err = Changes.back().replace(Context.Sources, getLoc(53), 1, ""); 1690 ASSERT_TRUE(!Err); 1691 Err = Changes.back().replace(Context.Sources, getLoc(56), 1, ""); 1692 ASSERT_TRUE(!Err); 1693 EXPECT_EQ("void f(, float f, );\n" 1694 "f(, 2.0f, );\n" 1695 "g(, );", 1696 rewrite()); 1697 } 1698 1699 TEST_F(ApplyAtomicChangesTest, EverythingDeleted) { 1700 setInput("int a;"); 1701 Changes.push_back(replacementToAtomicChange("key1", 0, 6, "")); 1702 EXPECT_EQ("", rewrite()); 1703 } 1704 1705 TEST_F(ApplyAtomicChangesTest, DoesNotDeleteInserts) { 1706 setInput("int a;\n" 1707 "int b;"); 1708 Changes.emplace_back(FilePath, "key1"); 1709 auto Err = Changes.back().replace(Context.Sources, getLoc(4), 1, ""); 1710 ASSERT_TRUE(!Err); 1711 Err = Changes.back().replace(Context.Sources, getLoc(4), 0, "b"); 1712 ASSERT_TRUE(!Err); 1713 Err = Changes.back().replace(Context.Sources, getLoc(11), 0, "a"); 1714 ASSERT_TRUE(!Err); 1715 Err = Changes.back().replace(Context.Sources, getLoc(11), 1, ""); 1716 ASSERT_TRUE(!Err); 1717 EXPECT_EQ("int b;\n" 1718 "int a;", 1719 rewrite()); 1720 } 1721 1722 } // end namespace tooling 1723 } // end namespace clang 1724