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 llvm::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 llvm::error_code EC = 231 llvm::sys::fs::createTemporaryFile(Name, "", FD, Path); 232 assert(!EC); 233 (void)EC; 234 235 llvm::raw_fd_ostream OutStream(FD, true); 236 OutStream << Content; 237 OutStream.close(); 238 const FileEntry *File = Context.Files.getFile(Path); 239 assert(File != NULL); 240 241 StringRef Found = TemporaryFiles.GetOrCreateValue(Name, Path.str()).second; 242 assert(Found == Path); 243 (void)Found; 244 return Context.Sources.createFileID(File, SourceLocation(), SrcMgr::C_User); 245 } 246 247 std::string getFileContentFromDisk(llvm::StringRef Name) { 248 std::string Path = TemporaryFiles.lookup(Name); 249 assert(!Path.empty()); 250 // We need to read directly from the FileManager without relaying through 251 // a FileEntry, as otherwise we'd read through an already opened file 252 // descriptor, which might not see the changes made. 253 // FIXME: Figure out whether there is a way to get the SourceManger to 254 // reopen the file. 255 return Context.Files.getBufferForFile(Path, NULL)->getBuffer(); 256 } 257 258 llvm::StringMap<std::string> TemporaryFiles; 259 RewriterTestContext Context; 260 }; 261 262 TEST_F(FlushRewrittenFilesTest, StoresChangesOnDisk) { 263 FileID ID = createFile("input.cpp", "line1\nline2\nline3\nline4"); 264 Replacements Replaces; 265 Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 266 5, "replaced")); 267 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite)); 268 EXPECT_FALSE(Context.Rewrite.overwriteChangedFiles()); 269 EXPECT_EQ("line1\nreplaced\nline3\nline4", 270 getFileContentFromDisk("input.cpp")); 271 } 272 273 namespace { 274 template <typename T> 275 class TestVisitor : public clang::RecursiveASTVisitor<T> { 276 public: 277 bool runOver(StringRef Code) { 278 return runToolOnCode(new TestAction(this), Code); 279 } 280 281 protected: 282 clang::SourceManager *SM; 283 284 private: 285 class FindConsumer : public clang::ASTConsumer { 286 public: 287 FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {} 288 289 virtual void HandleTranslationUnit(clang::ASTContext &Context) { 290 Visitor->TraverseDecl(Context.getTranslationUnitDecl()); 291 } 292 293 private: 294 TestVisitor *Visitor; 295 }; 296 297 class TestAction : public clang::ASTFrontendAction { 298 public: 299 TestAction(TestVisitor *Visitor) : Visitor(Visitor) {} 300 301 virtual clang::ASTConsumer* CreateASTConsumer( 302 clang::CompilerInstance& compiler, llvm::StringRef dummy) { 303 Visitor->SM = &compiler.getSourceManager(); 304 /// TestConsumer will be deleted by the framework calling us. 305 return new FindConsumer(Visitor); 306 } 307 308 private: 309 TestVisitor *Visitor; 310 }; 311 }; 312 } // end namespace 313 314 void expectReplacementAt(const Replacement &Replace, 315 StringRef File, unsigned Offset, unsigned Length) { 316 ASSERT_TRUE(Replace.isApplicable()); 317 EXPECT_EQ(File, Replace.getFilePath()); 318 EXPECT_EQ(Offset, Replace.getOffset()); 319 EXPECT_EQ(Length, Replace.getLength()); 320 } 321 322 class ClassDeclXVisitor : public TestVisitor<ClassDeclXVisitor> { 323 public: 324 bool VisitCXXRecordDecl(CXXRecordDecl *Record) { 325 if (Record->getName() == "X") { 326 Replace = Replacement(*SM, Record, ""); 327 } 328 return true; 329 } 330 Replacement Replace; 331 }; 332 333 TEST(Replacement, CanBeConstructedFromNode) { 334 ClassDeclXVisitor ClassDeclX; 335 EXPECT_TRUE(ClassDeclX.runOver(" class X;")); 336 expectReplacementAt(ClassDeclX.Replace, "input.cc", 5, 7); 337 } 338 339 TEST(Replacement, ReplacesAtSpellingLocation) { 340 ClassDeclXVisitor ClassDeclX; 341 EXPECT_TRUE(ClassDeclX.runOver("#define A(Y) Y\nA(class X);")); 342 expectReplacementAt(ClassDeclX.Replace, "input.cc", 17, 7); 343 } 344 345 class CallToFVisitor : public TestVisitor<CallToFVisitor> { 346 public: 347 bool VisitCallExpr(CallExpr *Call) { 348 if (Call->getDirectCallee()->getName() == "F") { 349 Replace = Replacement(*SM, Call, ""); 350 } 351 return true; 352 } 353 Replacement Replace; 354 }; 355 356 TEST(Replacement, FunctionCall) { 357 CallToFVisitor CallToF; 358 EXPECT_TRUE(CallToF.runOver("void F(); void G() { F(); }")); 359 expectReplacementAt(CallToF.Replace, "input.cc", 21, 3); 360 } 361 362 TEST(Replacement, TemplatedFunctionCall) { 363 CallToFVisitor CallToF; 364 EXPECT_TRUE(CallToF.runOver( 365 "template <typename T> void F(); void G() { F<int>(); }")); 366 expectReplacementAt(CallToF.Replace, "input.cc", 43, 8); 367 } 368 369 TEST(Range, overlaps) { 370 EXPECT_TRUE(Range(10, 10).overlapsWith(Range(0, 11))); 371 EXPECT_TRUE(Range(0, 11).overlapsWith(Range(10, 10))); 372 EXPECT_FALSE(Range(10, 10).overlapsWith(Range(0, 10))); 373 EXPECT_FALSE(Range(0, 10).overlapsWith(Range(10, 10))); 374 EXPECT_TRUE(Range(0, 10).overlapsWith(Range(2, 6))); 375 EXPECT_TRUE(Range(2, 6).overlapsWith(Range(0, 10))); 376 } 377 378 TEST(Range, contains) { 379 EXPECT_TRUE(Range(0, 10).contains(Range(0, 10))); 380 EXPECT_TRUE(Range(0, 10).contains(Range(2, 6))); 381 EXPECT_FALSE(Range(2, 6).contains(Range(0, 10))); 382 EXPECT_FALSE(Range(0, 10).contains(Range(0, 11))); 383 } 384 385 TEST(DeduplicateTest, removesDuplicates) { 386 std::vector<Replacement> Input; 387 Input.push_back(Replacement("fileA", 50, 0, " foo ")); 388 Input.push_back(Replacement("fileA", 10, 3, " bar ")); 389 Input.push_back(Replacement("fileA", 10, 2, " bar ")); // Length differs 390 Input.push_back(Replacement("fileA", 9, 3, " bar ")); // Offset differs 391 Input.push_back(Replacement("fileA", 50, 0, " foo ")); // Duplicate 392 Input.push_back(Replacement("fileA", 51, 3, " bar ")); 393 Input.push_back(Replacement("fileB", 51, 3, " bar ")); // Filename differs! 394 Input.push_back(Replacement("fileA", 51, 3, " moo ")); // Replacement text 395 // differs! 396 397 std::vector<Replacement> Expected; 398 Expected.push_back(Replacement("fileA", 9, 3, " bar ")); 399 Expected.push_back(Replacement("fileA", 10, 2, " bar ")); 400 Expected.push_back(Replacement("fileA", 10, 3, " bar ")); 401 Expected.push_back(Replacement("fileA", 50, 0, " foo ")); 402 Expected.push_back(Replacement("fileA", 51, 3, " bar ")); 403 Expected.push_back(Replacement("fileA", 51, 3, " moo ")); 404 Expected.push_back(Replacement("fileB", 51, 3, " bar ")); 405 406 std::vector<Range> Conflicts; // Ignored for this test 407 deduplicate(Input, Conflicts); 408 409 ASSERT_TRUE(Expected == Input); 410 } 411 412 TEST(DeduplicateTest, detectsConflicts) { 413 { 414 std::vector<Replacement> Input; 415 Input.push_back(Replacement("fileA", 0, 5, " foo ")); 416 Input.push_back(Replacement("fileA", 0, 5, " foo ")); // Duplicate not a 417 // conflict. 418 Input.push_back(Replacement("fileA", 2, 6, " bar ")); 419 Input.push_back(Replacement("fileA", 7, 3, " moo ")); 420 421 std::vector<Range> Conflicts; 422 deduplicate(Input, Conflicts); 423 424 // One duplicate is removed and the remaining three items form one 425 // conflicted range. 426 ASSERT_EQ(3u, Input.size()); 427 ASSERT_EQ(1u, Conflicts.size()); 428 ASSERT_EQ(0u, Conflicts.front().getOffset()); 429 ASSERT_EQ(3u, Conflicts.front().getLength()); 430 } 431 { 432 std::vector<Replacement> Input; 433 434 // Expected sorted order is shown. It is the sorted order to which the 435 // returned conflict info refers to. 436 Input.push_back(Replacement("fileA", 0, 5, " foo ")); // 0 437 Input.push_back(Replacement("fileA", 5, 5, " bar ")); // 1 438 Input.push_back(Replacement("fileA", 6, 0, " bar ")); // 3 439 Input.push_back(Replacement("fileA", 5, 5, " moo ")); // 2 440 Input.push_back(Replacement("fileA", 7, 2, " bar ")); // 4 441 Input.push_back(Replacement("fileA", 15, 5, " golf ")); // 5 442 Input.push_back(Replacement("fileA", 16, 5, " bag ")); // 6 443 Input.push_back(Replacement("fileA", 10, 3, " club ")); // 7 444 445 // #3 is special in that it is completely contained by another conflicting 446 // Replacement. #4 ensures #3 hasn't messed up the conflicting range size. 447 448 std::vector<Range> Conflicts; 449 deduplicate(Input, Conflicts); 450 451 // No duplicates 452 ASSERT_EQ(8u, Input.size()); 453 ASSERT_EQ(2u, Conflicts.size()); 454 ASSERT_EQ(1u, Conflicts[0].getOffset()); 455 ASSERT_EQ(4u, Conflicts[0].getLength()); 456 ASSERT_EQ(6u, Conflicts[1].getOffset()); 457 ASSERT_EQ(2u, Conflicts[1].getLength()); 458 } 459 } 460 461 } // end namespace tooling 462 } // end namespace clang 463