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 "RewriterTestContext.h" 11 #include "clang/AST/ASTConsumer.h" 12 #include "clang/AST/ASTContext.h" 13 #include "clang/AST/DeclCXX.h" 14 #include "clang/AST/DeclGroup.h" 15 #include "clang/AST/RecursiveASTVisitor.h" 16 #include "clang/Basic/Diagnostic.h" 17 #include "clang/Basic/DiagnosticOptions.h" 18 #include "clang/Basic/FileManager.h" 19 #include "clang/Basic/LangOptions.h" 20 #include "clang/Basic/SourceManager.h" 21 #include "clang/Frontend/CompilerInstance.h" 22 #include "clang/Frontend/FrontendAction.h" 23 #include "clang/Frontend/TextDiagnosticPrinter.h" 24 #include "clang/Rewrite/Core/Rewriter.h" 25 #include "clang/Tooling/Refactoring.h" 26 #include "clang/Tooling/Tooling.h" 27 #include "llvm/ADT/SmallString.h" 28 #include "llvm/Support/Path.h" 29 #include "gtest/gtest.h" 30 31 namespace clang { 32 namespace tooling { 33 34 class ReplacementTest : public ::testing::Test { 35 protected: 36 Replacement createReplacement(SourceLocation Start, unsigned Length, 37 llvm::StringRef ReplacementText) { 38 return Replacement(Context.Sources, Start, Length, ReplacementText); 39 } 40 41 RewriterTestContext Context; 42 }; 43 44 TEST_F(ReplacementTest, CanDeleteAllText) { 45 FileID ID = Context.createInMemoryFile("input.cpp", "text"); 46 SourceLocation Location = Context.getLocation(ID, 1, 1); 47 Replacement Replace(createReplacement(Location, 4, "")); 48 EXPECT_TRUE(Replace.apply(Context.Rewrite)); 49 EXPECT_EQ("", Context.getRewrittenText(ID)); 50 } 51 52 TEST_F(ReplacementTest, CanDeleteAllTextInTextWithNewlines) { 53 FileID ID = Context.createInMemoryFile("input.cpp", "line1\nline2\nline3"); 54 SourceLocation Location = Context.getLocation(ID, 1, 1); 55 Replacement Replace(createReplacement(Location, 17, "")); 56 EXPECT_TRUE(Replace.apply(Context.Rewrite)); 57 EXPECT_EQ("", Context.getRewrittenText(ID)); 58 } 59 60 TEST_F(ReplacementTest, CanAddText) { 61 FileID ID = Context.createInMemoryFile("input.cpp", ""); 62 SourceLocation Location = Context.getLocation(ID, 1, 1); 63 Replacement Replace(createReplacement(Location, 0, "result")); 64 EXPECT_TRUE(Replace.apply(Context.Rewrite)); 65 EXPECT_EQ("result", Context.getRewrittenText(ID)); 66 } 67 68 TEST_F(ReplacementTest, CanReplaceTextAtPosition) { 69 FileID ID = Context.createInMemoryFile("input.cpp", 70 "line1\nline2\nline3\nline4"); 71 SourceLocation Location = Context.getLocation(ID, 2, 3); 72 Replacement Replace(createReplacement(Location, 12, "x")); 73 EXPECT_TRUE(Replace.apply(Context.Rewrite)); 74 EXPECT_EQ("line1\nlixne4", Context.getRewrittenText(ID)); 75 } 76 77 TEST_F(ReplacementTest, CanReplaceTextAtPositionMultipleTimes) { 78 FileID ID = Context.createInMemoryFile("input.cpp", 79 "line1\nline2\nline3\nline4"); 80 SourceLocation Location1 = Context.getLocation(ID, 2, 3); 81 Replacement Replace1(createReplacement(Location1, 12, "x\ny\n")); 82 EXPECT_TRUE(Replace1.apply(Context.Rewrite)); 83 EXPECT_EQ("line1\nlix\ny\nne4", Context.getRewrittenText(ID)); 84 85 // Since the original source has not been modified, the (4, 4) points to the 86 // 'e' in the original content. 87 SourceLocation Location2 = Context.getLocation(ID, 4, 4); 88 Replacement Replace2(createReplacement(Location2, 1, "f")); 89 EXPECT_TRUE(Replace2.apply(Context.Rewrite)); 90 EXPECT_EQ("line1\nlix\ny\nnf4", Context.getRewrittenText(ID)); 91 } 92 93 TEST_F(ReplacementTest, ApplyFailsForNonExistentLocation) { 94 Replacement Replace("nonexistent-file.cpp", 0, 1, ""); 95 EXPECT_FALSE(Replace.apply(Context.Rewrite)); 96 } 97 98 TEST_F(ReplacementTest, CanRetrivePath) { 99 Replacement Replace("/path/to/file.cpp", 0, 1, ""); 100 EXPECT_EQ("/path/to/file.cpp", Replace.getFilePath()); 101 } 102 103 TEST_F(ReplacementTest, ReturnsInvalidPath) { 104 Replacement Replace1(Context.Sources, SourceLocation(), 0, ""); 105 EXPECT_TRUE(Replace1.getFilePath().empty()); 106 107 Replacement Replace2; 108 EXPECT_TRUE(Replace2.getFilePath().empty()); 109 } 110 111 TEST_F(ReplacementTest, CanApplyReplacements) { 112 FileID ID = Context.createInMemoryFile("input.cpp", 113 "line1\nline2\nline3\nline4"); 114 Replacements Replaces; 115 Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 116 5, "replaced")); 117 Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 3, 1), 118 5, "other")); 119 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite)); 120 EXPECT_EQ("line1\nreplaced\nother\nline4", Context.getRewrittenText(ID)); 121 } 122 123 // FIXME: Remove this test case when Replacements is implemented as std::vector 124 // instead of std::set. The other ReplacementTest tests will need to be updated 125 // at that point as well. 126 TEST_F(ReplacementTest, VectorCanApplyReplacements) { 127 FileID ID = Context.createInMemoryFile("input.cpp", 128 "line1\nline2\nline3\nline4"); 129 std::vector<Replacement> Replaces; 130 Replaces.push_back(Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 131 5, "replaced")); 132 Replaces.push_back( 133 Replacement(Context.Sources, Context.getLocation(ID, 3, 1), 5, "other")); 134 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite)); 135 EXPECT_EQ("line1\nreplaced\nother\nline4", Context.getRewrittenText(ID)); 136 } 137 138 TEST_F(ReplacementTest, SkipsDuplicateReplacements) { 139 FileID ID = Context.createInMemoryFile("input.cpp", 140 "line1\nline2\nline3\nline4"); 141 Replacements Replaces; 142 Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 143 5, "replaced")); 144 Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 145 5, "replaced")); 146 Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 147 5, "replaced")); 148 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite)); 149 EXPECT_EQ("line1\nreplaced\nline3\nline4", Context.getRewrittenText(ID)); 150 } 151 152 TEST_F(ReplacementTest, ApplyAllFailsIfOneApplyFails) { 153 // This test depends on the value of the file name of an invalid source 154 // location being in the range ]a, z[. 155 FileID IDa = Context.createInMemoryFile("a.cpp", "text"); 156 FileID IDz = Context.createInMemoryFile("z.cpp", "text"); 157 Replacements Replaces; 158 Replaces.insert(Replacement(Context.Sources, Context.getLocation(IDa, 1, 1), 159 4, "a")); 160 Replaces.insert(Replacement(Context.Sources, SourceLocation(), 161 5, "2")); 162 Replaces.insert(Replacement(Context.Sources, Context.getLocation(IDz, 1, 1), 163 4, "z")); 164 EXPECT_FALSE(applyAllReplacements(Replaces, Context.Rewrite)); 165 EXPECT_EQ("a", Context.getRewrittenText(IDa)); 166 EXPECT_EQ("z", Context.getRewrittenText(IDz)); 167 } 168 169 TEST(ShiftedCodePositionTest, FindsNewCodePosition) { 170 Replacements Replaces; 171 Replaces.insert(Replacement("", 0, 1, "")); 172 Replaces.insert(Replacement("", 4, 3, " ")); 173 // Assume ' int i;' is turned into 'int i;' and cursor is located at '|'. 174 EXPECT_EQ(0u, shiftedCodePosition(Replaces, 0)); // |int i; 175 EXPECT_EQ(0u, shiftedCodePosition(Replaces, 1)); // |nt i; 176 EXPECT_EQ(1u, shiftedCodePosition(Replaces, 2)); // i|t i; 177 EXPECT_EQ(2u, shiftedCodePosition(Replaces, 3)); // in| i; 178 EXPECT_EQ(3u, shiftedCodePosition(Replaces, 4)); // int| i; 179 EXPECT_EQ(4u, shiftedCodePosition(Replaces, 5)); // int | i; 180 EXPECT_EQ(4u, shiftedCodePosition(Replaces, 6)); // int |i; 181 EXPECT_EQ(4u, shiftedCodePosition(Replaces, 7)); // int |; 182 EXPECT_EQ(5u, shiftedCodePosition(Replaces, 8)); // int i| 183 } 184 185 // FIXME: Remove this test case when Replacements is implemented as std::vector 186 // instead of std::set. The other ReplacementTest tests will need to be updated 187 // at that point as well. 188 TEST(ShiftedCodePositionTest, VectorFindsNewCodePositionWithInserts) { 189 std::vector<Replacement> Replaces; 190 Replaces.push_back(Replacement("", 0, 1, "")); 191 Replaces.push_back(Replacement("", 4, 3, " ")); 192 // Assume ' int i;' is turned into 'int i;' and cursor is located at '|'. 193 EXPECT_EQ(0u, shiftedCodePosition(Replaces, 0)); // |int i; 194 EXPECT_EQ(0u, shiftedCodePosition(Replaces, 1)); // |nt i; 195 EXPECT_EQ(1u, shiftedCodePosition(Replaces, 2)); // i|t i; 196 EXPECT_EQ(2u, shiftedCodePosition(Replaces, 3)); // in| i; 197 EXPECT_EQ(3u, shiftedCodePosition(Replaces, 4)); // int| i; 198 EXPECT_EQ(4u, shiftedCodePosition(Replaces, 5)); // int | i; 199 EXPECT_EQ(4u, shiftedCodePosition(Replaces, 6)); // int |i; 200 EXPECT_EQ(4u, shiftedCodePosition(Replaces, 7)); // int |; 201 EXPECT_EQ(5u, shiftedCodePosition(Replaces, 8)); // int i| 202 } 203 204 TEST(ShiftedCodePositionTest, FindsNewCodePositionWithInserts) { 205 Replacements Replaces; 206 Replaces.insert(Replacement("", 4, 0, "\"\n\"")); 207 // Assume '"12345678"' is turned into '"1234"\n"5678"'. 208 EXPECT_EQ(4u, shiftedCodePosition(Replaces, 4)); // "123|5678" 209 EXPECT_EQ(8u, shiftedCodePosition(Replaces, 5)); // "1234|678" 210 } 211 212 class FlushRewrittenFilesTest : public ::testing::Test { 213 public: 214 FlushRewrittenFilesTest() {} 215 216 ~FlushRewrittenFilesTest() { 217 for (llvm::StringMap<std::string>::iterator I = TemporaryFiles.begin(), 218 E = TemporaryFiles.end(); 219 I != E; ++I) { 220 llvm::StringRef Name = I->second; 221 std::error_code EC = llvm::sys::fs::remove(Name); 222 (void)EC; 223 assert(!EC); 224 } 225 } 226 227 FileID createFile(llvm::StringRef Name, llvm::StringRef Content) { 228 SmallString<1024> Path; 229 int FD; 230 std::error_code EC = llvm::sys::fs::createTemporaryFile(Name, "", FD, Path); 231 assert(!EC); 232 (void)EC; 233 234 llvm::raw_fd_ostream OutStream(FD, true); 235 OutStream << Content; 236 OutStream.close(); 237 const FileEntry *File = Context.Files.getFile(Path); 238 assert(File != nullptr); 239 240 StringRef Found = TemporaryFiles.GetOrCreateValue(Name, Path.str()).second; 241 assert(Found == Path); 242 (void)Found; 243 return Context.Sources.createFileID(File, SourceLocation(), SrcMgr::C_User); 244 } 245 246 std::string getFileContentFromDisk(llvm::StringRef Name) { 247 std::string Path = TemporaryFiles.lookup(Name); 248 assert(!Path.empty()); 249 // We need to read directly from the FileManager without relaying through 250 // a FileEntry, as otherwise we'd read through an already opened file 251 // descriptor, which might not see the changes made. 252 // FIXME: Figure out whether there is a way to get the SourceManger to 253 // reopen the file. 254 std::unique_ptr<const llvm::MemoryBuffer> FileBuffer( 255 Context.Files.getBufferForFile(Path, nullptr)); 256 return FileBuffer->getBuffer(); 257 } 258 259 llvm::StringMap<std::string> TemporaryFiles; 260 RewriterTestContext Context; 261 }; 262 263 TEST_F(FlushRewrittenFilesTest, StoresChangesOnDisk) { 264 FileID ID = createFile("input.cpp", "line1\nline2\nline3\nline4"); 265 Replacements Replaces; 266 Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 267 5, "replaced")); 268 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite)); 269 EXPECT_FALSE(Context.Rewrite.overwriteChangedFiles()); 270 EXPECT_EQ("line1\nreplaced\nline3\nline4", 271 getFileContentFromDisk("input.cpp")); 272 } 273 274 namespace { 275 template <typename T> 276 class TestVisitor : public clang::RecursiveASTVisitor<T> { 277 public: 278 bool runOver(StringRef Code) { 279 return runToolOnCode(new TestAction(this), Code); 280 } 281 282 protected: 283 clang::SourceManager *SM; 284 285 private: 286 class FindConsumer : public clang::ASTConsumer { 287 public: 288 FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {} 289 290 virtual void HandleTranslationUnit(clang::ASTContext &Context) { 291 Visitor->TraverseDecl(Context.getTranslationUnitDecl()); 292 } 293 294 private: 295 TestVisitor *Visitor; 296 }; 297 298 class TestAction : public clang::ASTFrontendAction { 299 public: 300 TestAction(TestVisitor *Visitor) : Visitor(Visitor) {} 301 302 virtual clang::ASTConsumer* CreateASTConsumer( 303 clang::CompilerInstance& compiler, llvm::StringRef dummy) { 304 Visitor->SM = &compiler.getSourceManager(); 305 /// TestConsumer will be deleted by the framework calling us. 306 return new FindConsumer(Visitor); 307 } 308 309 private: 310 TestVisitor *Visitor; 311 }; 312 }; 313 } // end namespace 314 315 void expectReplacementAt(const Replacement &Replace, 316 StringRef File, unsigned Offset, unsigned Length) { 317 ASSERT_TRUE(Replace.isApplicable()); 318 EXPECT_EQ(File, Replace.getFilePath()); 319 EXPECT_EQ(Offset, Replace.getOffset()); 320 EXPECT_EQ(Length, Replace.getLength()); 321 } 322 323 class ClassDeclXVisitor : public TestVisitor<ClassDeclXVisitor> { 324 public: 325 bool VisitCXXRecordDecl(CXXRecordDecl *Record) { 326 if (Record->getName() == "X") { 327 Replace = Replacement(*SM, Record, ""); 328 } 329 return true; 330 } 331 Replacement Replace; 332 }; 333 334 TEST(Replacement, CanBeConstructedFromNode) { 335 ClassDeclXVisitor ClassDeclX; 336 EXPECT_TRUE(ClassDeclX.runOver(" class X;")); 337 expectReplacementAt(ClassDeclX.Replace, "input.cc", 5, 7); 338 } 339 340 TEST(Replacement, ReplacesAtSpellingLocation) { 341 ClassDeclXVisitor ClassDeclX; 342 EXPECT_TRUE(ClassDeclX.runOver("#define A(Y) Y\nA(class X);")); 343 expectReplacementAt(ClassDeclX.Replace, "input.cc", 17, 7); 344 } 345 346 class CallToFVisitor : public TestVisitor<CallToFVisitor> { 347 public: 348 bool VisitCallExpr(CallExpr *Call) { 349 if (Call->getDirectCallee()->getName() == "F") { 350 Replace = Replacement(*SM, Call, ""); 351 } 352 return true; 353 } 354 Replacement Replace; 355 }; 356 357 TEST(Replacement, FunctionCall) { 358 CallToFVisitor CallToF; 359 EXPECT_TRUE(CallToF.runOver("void F(); void G() { F(); }")); 360 expectReplacementAt(CallToF.Replace, "input.cc", 21, 3); 361 } 362 363 TEST(Replacement, TemplatedFunctionCall) { 364 CallToFVisitor CallToF; 365 EXPECT_TRUE(CallToF.runOver( 366 "template <typename T> void F(); void G() { F<int>(); }")); 367 expectReplacementAt(CallToF.Replace, "input.cc", 43, 8); 368 } 369 370 TEST(Range, overlaps) { 371 EXPECT_TRUE(Range(10, 10).overlapsWith(Range(0, 11))); 372 EXPECT_TRUE(Range(0, 11).overlapsWith(Range(10, 10))); 373 EXPECT_FALSE(Range(10, 10).overlapsWith(Range(0, 10))); 374 EXPECT_FALSE(Range(0, 10).overlapsWith(Range(10, 10))); 375 EXPECT_TRUE(Range(0, 10).overlapsWith(Range(2, 6))); 376 EXPECT_TRUE(Range(2, 6).overlapsWith(Range(0, 10))); 377 } 378 379 TEST(Range, contains) { 380 EXPECT_TRUE(Range(0, 10).contains(Range(0, 10))); 381 EXPECT_TRUE(Range(0, 10).contains(Range(2, 6))); 382 EXPECT_FALSE(Range(2, 6).contains(Range(0, 10))); 383 EXPECT_FALSE(Range(0, 10).contains(Range(0, 11))); 384 } 385 386 TEST(DeduplicateTest, removesDuplicates) { 387 std::vector<Replacement> Input; 388 Input.push_back(Replacement("fileA", 50, 0, " foo ")); 389 Input.push_back(Replacement("fileA", 10, 3, " bar ")); 390 Input.push_back(Replacement("fileA", 10, 2, " bar ")); // Length differs 391 Input.push_back(Replacement("fileA", 9, 3, " bar ")); // Offset differs 392 Input.push_back(Replacement("fileA", 50, 0, " foo ")); // Duplicate 393 Input.push_back(Replacement("fileA", 51, 3, " bar ")); 394 Input.push_back(Replacement("fileB", 51, 3, " bar ")); // Filename differs! 395 Input.push_back(Replacement("fileA", 51, 3, " moo ")); // Replacement text 396 // differs! 397 398 std::vector<Replacement> Expected; 399 Expected.push_back(Replacement("fileA", 9, 3, " bar ")); 400 Expected.push_back(Replacement("fileA", 10, 2, " bar ")); 401 Expected.push_back(Replacement("fileA", 10, 3, " bar ")); 402 Expected.push_back(Replacement("fileA", 50, 0, " foo ")); 403 Expected.push_back(Replacement("fileA", 51, 3, " bar ")); 404 Expected.push_back(Replacement("fileA", 51, 3, " moo ")); 405 Expected.push_back(Replacement("fileB", 51, 3, " bar ")); 406 407 std::vector<Range> Conflicts; // Ignored for this test 408 deduplicate(Input, Conflicts); 409 410 ASSERT_TRUE(Expected == Input); 411 } 412 413 TEST(DeduplicateTest, detectsConflicts) { 414 { 415 std::vector<Replacement> Input; 416 Input.push_back(Replacement("fileA", 0, 5, " foo ")); 417 Input.push_back(Replacement("fileA", 0, 5, " foo ")); // Duplicate not a 418 // conflict. 419 Input.push_back(Replacement("fileA", 2, 6, " bar ")); 420 Input.push_back(Replacement("fileA", 7, 3, " moo ")); 421 422 std::vector<Range> Conflicts; 423 deduplicate(Input, Conflicts); 424 425 // One duplicate is removed and the remaining three items form one 426 // conflicted range. 427 ASSERT_EQ(3u, Input.size()); 428 ASSERT_EQ(1u, Conflicts.size()); 429 ASSERT_EQ(0u, Conflicts.front().getOffset()); 430 ASSERT_EQ(3u, Conflicts.front().getLength()); 431 } 432 { 433 std::vector<Replacement> Input; 434 435 // Expected sorted order is shown. It is the sorted order to which the 436 // returned conflict info refers to. 437 Input.push_back(Replacement("fileA", 0, 5, " foo ")); // 0 438 Input.push_back(Replacement("fileA", 5, 5, " bar ")); // 1 439 Input.push_back(Replacement("fileA", 6, 0, " bar ")); // 3 440 Input.push_back(Replacement("fileA", 5, 5, " moo ")); // 2 441 Input.push_back(Replacement("fileA", 7, 2, " bar ")); // 4 442 Input.push_back(Replacement("fileA", 15, 5, " golf ")); // 5 443 Input.push_back(Replacement("fileA", 16, 5, " bag ")); // 6 444 Input.push_back(Replacement("fileA", 10, 3, " club ")); // 7 445 446 // #3 is special in that it is completely contained by another conflicting 447 // Replacement. #4 ensures #3 hasn't messed up the conflicting range size. 448 449 std::vector<Range> Conflicts; 450 deduplicate(Input, Conflicts); 451 452 // No duplicates 453 ASSERT_EQ(8u, Input.size()); 454 ASSERT_EQ(2u, Conflicts.size()); 455 ASSERT_EQ(1u, Conflicts[0].getOffset()); 456 ASSERT_EQ(4u, Conflicts[0].getLength()); 457 ASSERT_EQ(6u, Conflicts[1].getOffset()); 458 ASSERT_EQ(2u, Conflicts[1].getLength()); 459 } 460 } 461 462 } // end namespace tooling 463 } // end namespace clang 464
