1 //===- unittest/Tooling/ToolingTest.cpp - Tooling 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 "clang/AST/ASTConsumer.h" 11 #include "clang/AST/DeclCXX.h" 12 #include "clang/AST/DeclGroup.h" 13 #include "clang/Frontend/CompilerInstance.h" 14 #include "clang/Frontend/FrontendAction.h" 15 #include "clang/Frontend/FrontendActions.h" 16 #include "clang/Tooling/CompilationDatabase.h" 17 #include "clang/Tooling/Tooling.h" 18 #include "gtest/gtest.h" 19 #include <string> 20 21 namespace clang { 22 namespace tooling { 23 24 namespace { 25 /// Takes an ast consumer and returns it from CreateASTConsumer. This only 26 /// works with single translation unit compilations. 27 class TestAction : public clang::ASTFrontendAction { 28 public: 29 /// Takes ownership of TestConsumer. 30 explicit TestAction(clang::ASTConsumer *TestConsumer) 31 : TestConsumer(TestConsumer) {} 32 33 protected: 34 virtual clang::ASTConsumer* CreateASTConsumer( 35 clang::CompilerInstance& compiler, StringRef dummy) { 36 /// TestConsumer will be deleted by the framework calling us. 37 return TestConsumer; 38 } 39 40 private: 41 clang::ASTConsumer * const TestConsumer; 42 }; 43 44 class FindTopLevelDeclConsumer : public clang::ASTConsumer { 45 public: 46 explicit FindTopLevelDeclConsumer(bool *FoundTopLevelDecl) 47 : FoundTopLevelDecl(FoundTopLevelDecl) {} 48 virtual bool HandleTopLevelDecl(clang::DeclGroupRef DeclGroup) { 49 *FoundTopLevelDecl = true; 50 return true; 51 } 52 private: 53 bool * const FoundTopLevelDecl; 54 }; 55 } // end namespace 56 57 TEST(runToolOnCode, FindsNoTopLevelDeclOnEmptyCode) { 58 bool FoundTopLevelDecl = false; 59 EXPECT_TRUE(runToolOnCode( 60 new TestAction(new FindTopLevelDeclConsumer(&FoundTopLevelDecl)), "")); 61 #if !defined(_MSC_VER) 62 EXPECT_FALSE(FoundTopLevelDecl); 63 #else 64 // FIXME: LangOpts.MicrosoftExt appends "class type_info;" 65 EXPECT_TRUE(FoundTopLevelDecl); 66 #endif 67 } 68 69 namespace { 70 class FindClassDeclXConsumer : public clang::ASTConsumer { 71 public: 72 FindClassDeclXConsumer(bool *FoundClassDeclX) 73 : FoundClassDeclX(FoundClassDeclX) {} 74 virtual bool HandleTopLevelDecl(clang::DeclGroupRef GroupRef) { 75 if (CXXRecordDecl* Record = dyn_cast<clang::CXXRecordDecl>( 76 *GroupRef.begin())) { 77 if (Record->getName() == "X") { 78 *FoundClassDeclX = true; 79 } 80 } 81 return true; 82 } 83 private: 84 bool *FoundClassDeclX; 85 }; 86 } // end namespace 87 88 TEST(runToolOnCode, FindsClassDecl) { 89 bool FoundClassDeclX = false; 90 EXPECT_TRUE(runToolOnCode(new TestAction( 91 new FindClassDeclXConsumer(&FoundClassDeclX)), "class X;")); 92 EXPECT_TRUE(FoundClassDeclX); 93 94 FoundClassDeclX = false; 95 EXPECT_TRUE(runToolOnCode(new TestAction( 96 new FindClassDeclXConsumer(&FoundClassDeclX)), "class Y;")); 97 EXPECT_FALSE(FoundClassDeclX); 98 } 99 100 TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromType) { 101 OwningPtr<FrontendActionFactory> Factory( 102 newFrontendActionFactory<SyntaxOnlyAction>()); 103 OwningPtr<FrontendAction> Action(Factory->create()); 104 EXPECT_TRUE(Action.get() != NULL); 105 } 106 107 struct IndependentFrontendActionCreator { 108 ASTConsumer *newASTConsumer() { 109 return new FindTopLevelDeclConsumer(NULL); 110 } 111 }; 112 113 TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromFactoryType) { 114 IndependentFrontendActionCreator Creator; 115 OwningPtr<FrontendActionFactory> Factory( 116 newFrontendActionFactory(&Creator)); 117 OwningPtr<FrontendAction> Action(Factory->create()); 118 EXPECT_TRUE(Action.get() != NULL); 119 } 120 121 TEST(ToolInvocation, TestMapVirtualFile) { 122 clang::FileManager Files((clang::FileSystemOptions())); 123 std::vector<std::string> Args; 124 Args.push_back("tool-executable"); 125 Args.push_back("-Idef"); 126 Args.push_back("-fsyntax-only"); 127 Args.push_back("test.cpp"); 128 clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction, &Files); 129 Invocation.mapVirtualFile("test.cpp", "#include <abc>\n"); 130 Invocation.mapVirtualFile("def/abc", "\n"); 131 EXPECT_TRUE(Invocation.run()); 132 } 133 134 struct VerifyEndCallback : public EndOfSourceFileCallback { 135 VerifyEndCallback() : Called(0), Matched(false) {} 136 virtual void run() { 137 ++Called; 138 } 139 ASTConsumer *newASTConsumer() { 140 return new FindTopLevelDeclConsumer(&Matched); 141 } 142 unsigned Called; 143 bool Matched; 144 }; 145 146 #if !defined(_WIN32) 147 TEST(newFrontendActionFactory, InjectsEndOfSourceFileCallback) { 148 VerifyEndCallback EndCallback; 149 150 FixedCompilationDatabase Compilations("/", std::vector<std::string>()); 151 std::vector<std::string> Sources; 152 Sources.push_back("/a.cc"); 153 Sources.push_back("/b.cc"); 154 ClangTool Tool(Compilations, Sources); 155 156 Tool.mapVirtualFile("/a.cc", "void a() {}"); 157 Tool.mapVirtualFile("/b.cc", "void b() {}"); 158 159 Tool.run(newFrontendActionFactory(&EndCallback, &EndCallback)); 160 161 EXPECT_TRUE(EndCallback.Matched); 162 EXPECT_EQ(2u, EndCallback.Called); 163 } 164 #endif 165 166 struct SkipBodyConsumer : public clang::ASTConsumer { 167 /// Skip the 'skipMe' function. 168 virtual bool shouldSkipFunctionBody(Decl *D) { 169 FunctionDecl *F = dyn_cast<FunctionDecl>(D); 170 return F && F->getNameAsString() == "skipMe"; 171 } 172 }; 173 174 struct SkipBodyAction : public clang::ASTFrontendAction { 175 virtual ASTConsumer *CreateASTConsumer(CompilerInstance &Compiler, 176 StringRef) { 177 Compiler.getFrontendOpts().SkipFunctionBodies = true; 178 return new SkipBodyConsumer; 179 } 180 }; 181 182 TEST(runToolOnCode, TestSkipFunctionBody) { 183 EXPECT_TRUE(runToolOnCode(new SkipBodyAction, 184 "int skipMe() { an_error_here }")); 185 EXPECT_FALSE(runToolOnCode(new SkipBodyAction, 186 "int skipMeNot() { an_error_here }")); 187 } 188 189 } // end namespace tooling 190 } // end namespace clang 191
