head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.10 netbsd-11-0-RC3:1.1.1.10 netbsd-11-0-RC2:1.1.1.10 netbsd-11-0-RC1:1.1.1.10 perseant-exfatfs-base-20250801:1.1.1.10 netbsd-11:1.1.1.10.0.10 netbsd-11-base:1.1.1.10 netbsd-10-1-RELEASE:1.1.1.10 perseant-exfatfs-base-20240630:1.1.1.10 perseant-exfatfs:1.1.1.10.0.8 perseant-exfatfs-base:1.1.1.10 netbsd-8-3-RELEASE:1.1.1.7 netbsd-9-4-RELEASE:1.1.1.9 netbsd-10-0-RELEASE:1.1.1.10 netbsd-10-0-RC6:1.1.1.10 netbsd-10-0-RC5:1.1.1.10 netbsd-10-0-RC4:1.1.1.10 netbsd-10-0-RC3:1.1.1.10 netbsd-10-0-RC2:1.1.1.10 netbsd-10-0-RC1:1.1.1.10 netbsd-10:1.1.1.10.0.6 netbsd-10-base:1.1.1.10 netbsd-9-3-RELEASE:1.1.1.9 cjep_sun2x:1.1.1.10.0.4 cjep_sun2x-base:1.1.1.10 cjep_staticlib_x-base1:1.1.1.10 netbsd-9-2-RELEASE:1.1.1.9 cjep_staticlib_x:1.1.1.10.0.2 cjep_staticlib_x-base:1.1.1.10 netbsd-9-1-RELEASE:1.1.1.9 phil-wifi-20200421:1.1.1.10 phil-wifi-20200411:1.1.1.10 phil-wifi-20200406:1.1.1.10 netbsd-8-2-RELEASE:1.1.1.7 netbsd-9-0-RELEASE:1.1.1.9 netbsd-9-0-RC2:1.1.1.9 netbsd-9-0-RC1:1.1.1.9 netbsd-9:1.1.1.9.0.2 netbsd-9-base:1.1.1.9 phil-wifi-20190609:1.1.1.9 netbsd-8-1-RELEASE:1.1.1.7 netbsd-8-1-RC1:1.1.1.7 pgoyette-compat-merge-20190127:1.1.1.8.2.1 pgoyette-compat-20190127:1.1.1.9 pgoyette-compat-20190118:1.1.1.9 pgoyette-compat-1226:1.1.1.9 pgoyette-compat-1126:1.1.1.9 pgoyette-compat-1020:1.1.1.9 pgoyette-compat-0930:1.1.1.9 pgoyette-compat-0906:1.1.1.9 netbsd-7-2-RELEASE:1.1.1.4.2.1 pgoyette-compat-0728:1.1.1.9 clang-337282:1.1.1.9 netbsd-8-0-RELEASE:1.1.1.7 phil-wifi:1.1.1.8.0.4 phil-wifi-base:1.1.1.8 pgoyette-compat-0625:1.1.1.8 netbsd-8-0-RC2:1.1.1.7 pgoyette-compat-0521:1.1.1.8 pgoyette-compat-0502:1.1.1.8 pgoyette-compat-0422:1.1.1.8 netbsd-8-0-RC1:1.1.1.7 pgoyette-compat-0415:1.1.1.8 pgoyette-compat-0407:1.1.1.8 pgoyette-compat-0330:1.1.1.8 pgoyette-compat-0322:1.1.1.8 pgoyette-compat-0315:1.1.1.8 netbsd-7-1-2-RELEASE:1.1.1.4.2.1 pgoyette-compat:1.1.1.8.0.2 pgoyette-compat-base:1.1.1.8 netbsd-7-1-1-RELEASE:1.1.1.4.2.1 clang-319952:1.1.1.8 matt-nb8-mediatek:1.1.1.7.0.10 matt-nb8-mediatek-base:1.1.1.7 clang-309604:1.1.1.8 perseant-stdc-iso10646:1.1.1.7.0.8 perseant-stdc-iso10646-base:1.1.1.7 netbsd-8:1.1.1.7.0.6 netbsd-8-base:1.1.1.7 prg-localcount2-base3:1.1.1.7 prg-localcount2-base2:1.1.1.7 prg-localcount2-base1:1.1.1.7 prg-localcount2:1.1.1.7.0.4 prg-localcount2-base:1.1.1.7 pgoyette-localcount-20170426:1.1.1.7 bouyer-socketcan-base1:1.1.1.7 pgoyette-localcount-20170320:1.1.1.7 netbsd-7-1:1.1.1.4.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.4.2.1 netbsd-7-1-RC2:1.1.1.4.2.1 clang-294123:1.1.1.7 netbsd-7-nhusb-base-20170116:1.1.1.4.2.1 bouyer-socketcan:1.1.1.7.0.2 bouyer-socketcan-base:1.1.1.7 clang-291444:1.1.1.7 pgoyette-localcount-20170107:1.1.1.6 netbsd-7-1-RC1:1.1.1.4.2.1 pgoyette-localcount-20161104:1.1.1.6 netbsd-7-0-2-RELEASE:1.1.1.4.2.1 localcount-20160914:1.1.1.6 netbsd-7-nhusb:1.1.1.4.2.1.0.4 netbsd-7-nhusb-base:1.1.1.4.2.1 clang-280599:1.1.1.6 pgoyette-localcount-20160806:1.1.1.6 pgoyette-localcount-20160726:1.1.1.6 pgoyette-localcount:1.1.1.6.0.2 pgoyette-localcount-base:1.1.1.6 netbsd-7-0-1-RELEASE:1.1.1.4.2.1 clang-261930:1.1.1.6 netbsd-7-0:1.1.1.4.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.4.2.1 netbsd-7-0-RC3:1.1.1.4.2.1 netbsd-7-0-RC2:1.1.1.4.2.1 netbsd-7-0-RC1:1.1.1.4.2.1 clang-237755:1.1.1.5 clang-232565:1.1.1.5 clang-227398:1.1.1.5 tls-maxphys-base:1.1.1.4 tls-maxphys:1.1.1.4.0.4 netbsd-7:1.1.1.4.0.2 netbsd-7-base:1.1.1.4 clang-215315:1.1.1.4 clang-209886:1.1.1.3 yamt-pagecache:1.1.1.2.0.4 yamt-pagecache-base9:1.1.1.2 tls-earlyentropy:1.1.1.2.0.2 tls-earlyentropy-base:1.1.1.3 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.2 riastradh-drm2-base3:1.1.1.2 clang-202566:1.1.1.2 clang-201163:1.1.1.2 clang-199312:1.1.1.2 clang-198450:1.1.1.1 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.48; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.48; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.15.21.26.18; author joerg; state Exp; branches 1.1.1.2.2.1 1.1.1.2.4.1; next 1.1.1.3; commitid NQXlzzA0SPkc5glx; 1.1.1.3 date 2014.05.30.18.14.50; author joerg; state Exp; branches; next 1.1.1.4; commitid 8q0kdlBlCn09GACx; 1.1.1.4 date 2014.08.10.17.08.25; author joerg; state Exp; branches 1.1.1.4.2.1 1.1.1.4.4.1; next 1.1.1.5; commitid N85tXAN6Ex9VZPLx; 1.1.1.5 date 2015.01.29.19.57.27; author joerg; state Exp; branches; next 1.1.1.6; commitid mlISSizlPKvepX7y; 1.1.1.6 date 2016.02.27.22.11.44; author joerg; state Exp; branches 1.1.1.6.2.1; next 1.1.1.7; commitid tIimz3oDlh1NpBWy; 1.1.1.7 date 2017.01.11.10.33.10; author joerg; state Exp; branches; next 1.1.1.8; commitid CNnUNfII1jgNmxBz; 1.1.1.8 date 2017.08.01.19.34.43; author joerg; state Exp; branches 1.1.1.8.2.1 1.1.1.8.4.1; next 1.1.1.9; commitid pMuDy65V0VicSx1A; 1.1.1.9 date 2018.07.17.18.32.14; author joerg; state Exp; branches; next 1.1.1.10; commitid wDzL46ALjrCZgwKA; 1.1.1.10 date 2019.11.13.22.23.11; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.2.2.1 date 2014.08.10.07.08.25; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.2.4.1 date 2014.01.15.21.26.18; author yamt; state dead; branches; next 1.1.1.2.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.2.4.2 date 2014.05.22.16.19.49; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.4.2.1 date 2015.06.04.20.04.47; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.4.4.1 date 2014.08.10.17.08.25; author tls; state dead; branches; next 1.1.1.4.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.4.4.2 date 2014.08.19.23.49.28; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.6.2.1 date 2017.03.20.06.53.39; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.8.2.1 date 2018.07.28.04.34.19; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.8.4.1 date 2019.06.10.21.46.47; author christos; state Exp; branches; next 1.1.1.8.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.8.4.2 date 2020.04.13.07.50.39; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===- unittest/Tooling/ToolingTest.cpp - Tooling unit tests --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "clang/AST/ASTConsumer.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclGroup.h" #include "clang/Frontend/ASTUnit.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendAction.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Tooling/CompilationDatabase.h" #include "clang/Tooling/Tooling.h" #include "gtest/gtest.h" #include "llvm/ADT/STLExtras.h" #include namespace clang { namespace tooling { namespace { /// Takes an ast consumer and returns it from CreateASTConsumer. This only /// works with single translation unit compilations. class TestAction : public clang::ASTFrontendAction { public: /// Takes ownership of TestConsumer. explicit TestAction(clang::ASTConsumer *TestConsumer) : TestConsumer(TestConsumer) {} protected: virtual clang::ASTConsumer* CreateASTConsumer( clang::CompilerInstance& compiler, StringRef dummy) { /// TestConsumer will be deleted by the framework calling us. return TestConsumer; } private: clang::ASTConsumer * const TestConsumer; }; class FindTopLevelDeclConsumer : public clang::ASTConsumer { public: explicit FindTopLevelDeclConsumer(bool *FoundTopLevelDecl) : FoundTopLevelDecl(FoundTopLevelDecl) {} virtual bool HandleTopLevelDecl(clang::DeclGroupRef DeclGroup) { *FoundTopLevelDecl = true; return true; } private: bool * const FoundTopLevelDecl; }; } // end namespace TEST(runToolOnCode, FindsNoTopLevelDeclOnEmptyCode) { bool FoundTopLevelDecl = false; EXPECT_TRUE(runToolOnCode( new TestAction(new FindTopLevelDeclConsumer(&FoundTopLevelDecl)), "")); #if !defined(_MSC_VER) EXPECT_FALSE(FoundTopLevelDecl); #else // FIXME: LangOpts.MicrosoftExt appends "class type_info;" EXPECT_TRUE(FoundTopLevelDecl); #endif } namespace { class FindClassDeclXConsumer : public clang::ASTConsumer { public: FindClassDeclXConsumer(bool *FoundClassDeclX) : FoundClassDeclX(FoundClassDeclX) {} virtual bool HandleTopLevelDecl(clang::DeclGroupRef GroupRef) { if (CXXRecordDecl* Record = dyn_cast( *GroupRef.begin())) { if (Record->getName() == "X") { *FoundClassDeclX = true; } } return true; } private: bool *FoundClassDeclX; }; bool FindClassDeclX(ASTUnit *AST) { for (std::vector::iterator i = AST->top_level_begin(), e = AST->top_level_end(); i != e; ++i) { if (CXXRecordDecl* Record = dyn_cast(*i)) { if (Record->getName() == "X") { return true; } } } return false; } } // end namespace TEST(runToolOnCode, FindsClassDecl) { bool FoundClassDeclX = false; EXPECT_TRUE(runToolOnCode(new TestAction( new FindClassDeclXConsumer(&FoundClassDeclX)), "class X;")); EXPECT_TRUE(FoundClassDeclX); FoundClassDeclX = false; EXPECT_TRUE(runToolOnCode(new TestAction( new FindClassDeclXConsumer(&FoundClassDeclX)), "class Y;")); EXPECT_FALSE(FoundClassDeclX); } TEST(buildASTFromCode, FindsClassDecl) { OwningPtr AST(buildASTFromCode("class X;")); ASSERT_TRUE(AST.get()); EXPECT_TRUE(FindClassDeclX(AST.get())); AST.reset(buildASTFromCode("class Y;")); ASSERT_TRUE(AST.get()); EXPECT_FALSE(FindClassDeclX(AST.get())); } TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromType) { OwningPtr Factory( newFrontendActionFactory()); OwningPtr Action(Factory->create()); EXPECT_TRUE(Action.get() != NULL); } struct IndependentFrontendActionCreator { ASTConsumer *newASTConsumer() { return new FindTopLevelDeclConsumer(NULL); } }; TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromFactoryType) { IndependentFrontendActionCreator Creator; OwningPtr Factory( newFrontendActionFactory(&Creator)); OwningPtr Action(Factory->create()); EXPECT_TRUE(Action.get() != NULL); } TEST(ToolInvocation, TestMapVirtualFile) { IntrusiveRefCntPtr Files( new clang::FileManager(clang::FileSystemOptions())); std::vector Args; Args.push_back("tool-executable"); Args.push_back("-Idef"); Args.push_back("-fsyntax-only"); Args.push_back("test.cpp"); clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction, Files.getPtr()); Invocation.mapVirtualFile("test.cpp", "#include \n"); Invocation.mapVirtualFile("def/abc", "\n"); EXPECT_TRUE(Invocation.run()); } TEST(ToolInvocation, TestVirtualModulesCompilation) { // FIXME: Currently, this only tests that we don't exit with an error if a // mapped module.map is found on the include path. In the future, expand this // test to run a full modules enabled compilation, so we make sure we can // rerun modules compilations with a virtual file system. IntrusiveRefCntPtr Files( new clang::FileManager(clang::FileSystemOptions())); std::vector Args; Args.push_back("tool-executable"); Args.push_back("-Idef"); Args.push_back("-fsyntax-only"); Args.push_back("test.cpp"); clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction, Files.getPtr()); Invocation.mapVirtualFile("test.cpp", "#include \n"); Invocation.mapVirtualFile("def/abc", "\n"); // Add a module.map file in the include directory of our header, so we trigger // the module.map header search logic. Invocation.mapVirtualFile("def/module.map", "\n"); EXPECT_TRUE(Invocation.run()); } struct VerifyEndCallback : public SourceFileCallbacks { VerifyEndCallback() : BeginCalled(0), EndCalled(0), Matched(false) {} virtual bool handleBeginSource(CompilerInstance &CI, StringRef Filename) LLVM_OVERRIDE { ++BeginCalled; return true; } virtual void handleEndSource() { ++EndCalled; } ASTConsumer *newASTConsumer() { return new FindTopLevelDeclConsumer(&Matched); } unsigned BeginCalled; unsigned EndCalled; bool Matched; }; #if !defined(_WIN32) TEST(newFrontendActionFactory, InjectsSourceFileCallbacks) { VerifyEndCallback EndCallback; FixedCompilationDatabase Compilations("/", std::vector()); std::vector Sources; Sources.push_back("/a.cc"); Sources.push_back("/b.cc"); ClangTool Tool(Compilations, Sources); Tool.mapVirtualFile("/a.cc", "void a() {}"); Tool.mapVirtualFile("/b.cc", "void b() {}"); Tool.run(newFrontendActionFactory(&EndCallback, &EndCallback)); EXPECT_TRUE(EndCallback.Matched); EXPECT_EQ(2u, EndCallback.BeginCalled); EXPECT_EQ(2u, EndCallback.EndCalled); } #endif struct SkipBodyConsumer : public clang::ASTConsumer { /// Skip the 'skipMe' function. virtual bool shouldSkipFunctionBody(Decl *D) { FunctionDecl *F = dyn_cast(D); return F && F->getNameAsString() == "skipMe"; } }; struct SkipBodyAction : public clang::ASTFrontendAction { virtual ASTConsumer *CreateASTConsumer(CompilerInstance &Compiler, StringRef) { Compiler.getFrontendOpts().SkipFunctionBodies = true; return new SkipBodyConsumer; } }; TEST(runToolOnCode, TestSkipFunctionBody) { EXPECT_TRUE(runToolOnCode(new SkipBodyAction, "int skipMe() { an_error_here }")); EXPECT_FALSE(runToolOnCode(new SkipBodyAction, "int skipMeNot() { an_error_here }")); } struct CheckSyntaxOnlyAdjuster: public ArgumentsAdjuster { bool &Found; bool &Ran; CheckSyntaxOnlyAdjuster(bool &Found, bool &Ran) : Found(Found), Ran(Ran) { } virtual CommandLineArguments Adjust(const CommandLineArguments &Args) LLVM_OVERRIDE { Ran = true; for (unsigned I = 0, E = Args.size(); I != E; ++I) { if (Args[I] == "-fsyntax-only") { Found = true; break; } } return Args; } }; TEST(ClangToolTest, ArgumentAdjusters) { FixedCompilationDatabase Compilations("/", std::vector()); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "void a() {}"); bool Found = false; bool Ran = false; Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran)); Tool.run(newFrontendActionFactory()); EXPECT_TRUE(Ran); EXPECT_TRUE(Found); Ran = Found = false; Tool.clearArgumentsAdjusters(); Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran)); Tool.appendArgumentsAdjuster(new ClangSyntaxOnlyAdjuster()); Tool.run(newFrontendActionFactory()); EXPECT_TRUE(Ran); EXPECT_FALSE(Found); } #ifndef _WIN32 TEST(ClangToolTest, BuildASTs) { FixedCompilationDatabase Compilations("/", std::vector()); std::vector Sources; Sources.push_back("/a.cc"); Sources.push_back("/b.cc"); ClangTool Tool(Compilations, Sources); Tool.mapVirtualFile("/a.cc", "void a() {}"); Tool.mapVirtualFile("/b.cc", "void b() {}"); std::vector ASTs; EXPECT_EQ(0, Tool.buildASTs(ASTs)); EXPECT_EQ(2u, ASTs.size()); llvm::DeleteContainerPointers(ASTs); } struct TestDiagnosticConsumer : public DiagnosticConsumer { TestDiagnosticConsumer() : NumDiagnosticsSeen(0) {} virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) { ++NumDiagnosticsSeen; } unsigned NumDiagnosticsSeen; }; TEST(ClangToolTest, InjectDiagnosticConsumer) { FixedCompilationDatabase Compilations("/", std::vector()); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "int x = undeclared;"); TestDiagnosticConsumer Consumer; Tool.setDiagnosticConsumer(&Consumer); Tool.run(newFrontendActionFactory()); EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen); } TEST(ClangToolTest, InjectDiagnosticConsumerInBuildASTs) { FixedCompilationDatabase Compilations("/", std::vector()); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "int x = undeclared;"); TestDiagnosticConsumer Consumer; Tool.setDiagnosticConsumer(&Consumer); std::vector ASTs; Tool.buildASTs(ASTs); EXPECT_EQ(1u, ASTs.size()); EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen); } #endif } // end namespace tooling } // end namespace clang @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import Clang 3.5svn r199312 @ text @d19 1 a20 1 #include "gtest/gtest.h" d63 1 d65 4 @ 1.1.1.2.2.1 log @Rebase. @ text @a19 1 #include "llvm/Config/config.h" d110 1 a110 1 std::unique_ptr AST = buildASTFromCode("class X;"); d114 1 a114 1 AST = buildASTFromCode("class Y;"); d120 1 a120 1 std::unique_ptr Factory( d122 1 a122 1 std::unique_ptr Action(Factory->create()); d134 1 a134 1 std::unique_ptr Factory( d136 1 a136 1 std::unique_ptr Action(Factory->create()); d180 1 a180 1 StringRef Filename) override { d195 1 a195 1 #if !defined(LLVM_ON_WIN32) d208 1 a208 3 std::unique_ptr Action( newFrontendActionFactory(&EndCallback, &EndCallback)); Tool.run(Action.get()); a238 15 TEST(runToolOnCodeWithArgs, TestNoDepFile) { llvm::SmallString<32> DepFilePath; ASSERT_FALSE( llvm::sys::fs::createTemporaryFile("depfile", "d", DepFilePath)); std::vector Args; Args.push_back("-MMD"); Args.push_back("-MT"); Args.push_back(DepFilePath.str()); Args.push_back("-MF"); Args.push_back(DepFilePath.str()); EXPECT_TRUE(runToolOnCodeWithArgs(new SkipBodyAction, "", Args)); EXPECT_FALSE(llvm::sys::fs::exists(DepFilePath.str())); EXPECT_FALSE(llvm::sys::fs::remove(DepFilePath.str())); } d246 1 a246 1 Adjust(const CommandLineArguments &Args) override { a263 3 std::unique_ptr Action( newFrontendActionFactory()); d267 1 a267 1 Tool.run(Action.get()); d275 1 a275 1 Tool.run(Action.get()); d280 1 a280 1 #ifndef LLVM_ON_WIN32 d292 1 a292 1 std::vector> ASTs; d295 2 d314 1 a314 3 std::unique_ptr Action( newFrontendActionFactory()); Tool.run(Action.get()); d324 1 a324 1 std::vector> ASTs; @ 1.1.1.3 log @Import Clang 3.5svn r209886. @ text @a19 1 #include "llvm/Config/config.h" d110 1 a110 1 std::unique_ptr AST = buildASTFromCode("class X;"); d114 1 a114 1 AST = buildASTFromCode("class Y;"); d120 1 a120 1 std::unique_ptr Factory( d122 1 a122 1 std::unique_ptr Action(Factory->create()); d134 1 a134 1 std::unique_ptr Factory( d136 1 a136 1 std::unique_ptr Action(Factory->create()); d180 1 a180 1 StringRef Filename) override { d195 1 a195 1 #if !defined(LLVM_ON_WIN32) d208 1 a208 3 std::unique_ptr Action( newFrontendActionFactory(&EndCallback, &EndCallback)); Tool.run(Action.get()); a238 15 TEST(runToolOnCodeWithArgs, TestNoDepFile) { llvm::SmallString<32> DepFilePath; ASSERT_FALSE( llvm::sys::fs::createTemporaryFile("depfile", "d", DepFilePath)); std::vector Args; Args.push_back("-MMD"); Args.push_back("-MT"); Args.push_back(DepFilePath.str()); Args.push_back("-MF"); Args.push_back(DepFilePath.str()); EXPECT_TRUE(runToolOnCodeWithArgs(new SkipBodyAction, "", Args)); EXPECT_FALSE(llvm::sys::fs::exists(DepFilePath.str())); EXPECT_FALSE(llvm::sys::fs::remove(DepFilePath.str())); } d246 1 a246 1 Adjust(const CommandLineArguments &Args) override { a263 3 std::unique_ptr Action( newFrontendActionFactory()); d267 1 a267 1 Tool.run(Action.get()); d275 1 a275 1 Tool.run(Action.get()); d280 1 a280 1 #ifndef LLVM_ON_WIN32 d292 1 a292 1 std::vector> ASTs; d295 2 d314 1 a314 3 std::unique_ptr Action( newFrontendActionFactory()); Tool.run(Action.get()); d324 1 a324 1 std::vector> ASTs; @ 1.1.1.4 log @Import clang 3.6svn r215315. @ text @d20 1 a20 1 #include "llvm/Config/llvm-config.h" d124 1 a124 1 EXPECT_TRUE(Action.get() != nullptr); d129 1 a129 1 return new FindTopLevelDeclConsumer(nullptr); d138 1 a138 1 EXPECT_TRUE(Action.get() != nullptr); d150 1 a150 1 Files.get()); d169 1 a169 1 Files.get()); @ 1.1.1.4.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a21 1 #include d31 1 a31 1 public: d33 2 a34 2 explicit TestAction(std::unique_ptr TestConsumer) : TestConsumer(std::move(TestConsumer)) {} d36 3 a38 3 protected: virtual std::unique_ptr CreateASTConsumer(clang::CompilerInstance &compiler, StringRef dummy) { d40 1 a40 1 return std::move(TestConsumer); d43 2 a44 2 private: std::unique_ptr TestConsumer; d62 2 a63 4 EXPECT_TRUE( runToolOnCode(new TestAction(llvm::make_unique( &FoundTopLevelDecl)), "")); d100 2 a101 4 EXPECT_TRUE( runToolOnCode(new TestAction(llvm::make_unique( &FoundClassDeclX)), "class X;")); d105 2 a106 4 EXPECT_TRUE( runToolOnCode(new TestAction(llvm::make_unique( &FoundClassDeclX)), "class Y;")); d128 2 a129 2 std::unique_ptr newASTConsumer() { return llvm::make_unique(nullptr); d185 1 a185 1 virtual void handleEndSource() override { d188 2 a189 2 std::unique_ptr newASTConsumer() { return llvm::make_unique(&Matched); d228 2 a229 2 virtual std::unique_ptr CreateASTConsumer(CompilerInstance &Compiler, StringRef) { d231 1 a231 1 return llvm::make_unique(); d257 19 d287 1 a287 8 ArgumentsAdjuster CheckSyntaxOnlyAdjuster = [&Found, &Ran](const CommandLineArguments &Args) { Ran = true; if (std::find(Args.begin(), Args.end(), "-fsyntax-only") != Args.end()) Found = true; return Args; }; Tool.appendArgumentsAdjuster(CheckSyntaxOnlyAdjuster); d294 2 a295 2 Tool.appendArgumentsAdjuster(CheckSyntaxOnlyAdjuster); Tool.appendArgumentsAdjuster(getClangSyntaxOnlyAdjuster()); @ 1.1.1.5 log @Import Clang 3.6RC1 r227398. @ text @a21 1 #include d31 1 a31 1 public: d33 2 a34 2 explicit TestAction(std::unique_ptr TestConsumer) : TestConsumer(std::move(TestConsumer)) {} d36 3 a38 3 protected: virtual std::unique_ptr CreateASTConsumer(clang::CompilerInstance &compiler, StringRef dummy) { d40 1 a40 1 return std::move(TestConsumer); d43 2 a44 2 private: std::unique_ptr TestConsumer; d62 2 a63 4 EXPECT_TRUE( runToolOnCode(new TestAction(llvm::make_unique( &FoundTopLevelDecl)), "")); d100 2 a101 4 EXPECT_TRUE( runToolOnCode(new TestAction(llvm::make_unique( &FoundClassDeclX)), "class X;")); d105 2 a106 4 EXPECT_TRUE( runToolOnCode(new TestAction(llvm::make_unique( &FoundClassDeclX)), "class Y;")); d128 2 a129 2 std::unique_ptr newASTConsumer() { return llvm::make_unique(nullptr); d185 1 a185 1 virtual void handleEndSource() override { d188 2 a189 2 std::unique_ptr newASTConsumer() { return llvm::make_unique(&Matched); d228 2 a229 2 virtual std::unique_ptr CreateASTConsumer(CompilerInstance &Compiler, StringRef) { d231 1 a231 1 return llvm::make_unique(); d257 19 d287 1 a287 8 ArgumentsAdjuster CheckSyntaxOnlyAdjuster = [&Found, &Ran](const CommandLineArguments &Args) { Ran = true; if (std::find(Args.begin(), Args.end(), "-fsyntax-only") != Args.end()) Found = true; return Args; }; Tool.appendArgumentsAdjuster(CheckSyntaxOnlyAdjuster); d294 2 a295 2 Tool.appendArgumentsAdjuster(CheckSyntaxOnlyAdjuster); Tool.appendArgumentsAdjuster(getClangSyntaxOnlyAdjuster()); @ 1.1.1.6 log @Import Clang 3.8.0rc3 r261930. @ text @a20 2 #include "llvm/Support/TargetSelect.h" #include "llvm/Support/TargetRegistry.h" d38 2 a39 3 std::unique_ptr CreateASTConsumer(clang::CompilerInstance &compiler, StringRef dummy) override { d52 1 a52 1 bool HandleTopLevelDecl(clang::DeclGroupRef DeclGroup) override { d75 1 a75 1 bool HandleTopLevelDecl(clang::DeclGroupRef GroupRef) override { d149 2 a150 7 llvm::IntrusiveRefCntPtr OverlayFileSystem( new vfs::OverlayFileSystem(vfs::getRealFileSystem())); llvm::IntrusiveRefCntPtr InMemoryFileSystem( new vfs::InMemoryFileSystem); OverlayFileSystem->pushOverlay(InMemoryFileSystem); llvm::IntrusiveRefCntPtr Files( new FileManager(FileSystemOptions(), OverlayFileSystem)); d158 2 a159 4 InMemoryFileSystem->addFile( "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("#include \n")); InMemoryFileSystem->addFile("def/abc", 0, llvm::MemoryBuffer::getMemBuffer("\n")); d168 2 a169 7 llvm::IntrusiveRefCntPtr OverlayFileSystem( new vfs::OverlayFileSystem(vfs::getRealFileSystem())); llvm::IntrusiveRefCntPtr InMemoryFileSystem( new vfs::InMemoryFileSystem); OverlayFileSystem->pushOverlay(InMemoryFileSystem); llvm::IntrusiveRefCntPtr Files( new FileManager(FileSystemOptions(), OverlayFileSystem)); d177 2 a178 4 InMemoryFileSystem->addFile( "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("#include \n")); InMemoryFileSystem->addFile("def/abc", 0, llvm::MemoryBuffer::getMemBuffer("\n")); d181 1 a181 2 InMemoryFileSystem->addFile("def/module.map", 0, llvm::MemoryBuffer::getMemBuffer("\n")); d187 2 a188 1 bool handleBeginSource(CompilerInstance &CI, StringRef Filename) override { d192 3 a194 1 void handleEndSource() override { ++EndCalled; } d228 1 a228 1 bool shouldSkipFunctionBody(Decl *D) override { d235 2 a236 2 std::unique_ptr CreateASTConsumer(CompilerInstance &Compiler, StringRef) override { d276 1 a276 1 [&Found, &Ran](const CommandLineArguments &Args, StringRef /*unused*/) { a295 80 namespace { /// Find a target name such that looking for it in TargetRegistry by that name /// returns the same target. We expect that there is at least one target /// configured with this property. std::string getAnyTarget() { llvm::InitializeAllTargets(); for (const auto &Target : llvm::TargetRegistry::targets()) { std::string Error; StringRef TargetName(Target.getName()); if (TargetName == "x86-64") TargetName = "x86_64"; if (llvm::TargetRegistry::lookupTarget(TargetName, Error) == &Target) { return TargetName; } } return ""; } } TEST(addTargetAndModeForProgramName, AddsTargetAndMode) { std::string Target = getAnyTarget(); ASSERT_FALSE(Target.empty()); std::vector Args = {"clang", "-foo"}; addTargetAndModeForProgramName(Args, ""); EXPECT_EQ((std::vector{"clang", "-foo"}), Args); addTargetAndModeForProgramName(Args, Target + "-g++"); EXPECT_EQ((std::vector{"clang", "-target", Target, "--driver-mode=g++", "-foo"}), Args); } TEST(addTargetAndModeForProgramName, PathIgnored) { std::string Target = getAnyTarget(); ASSERT_FALSE(Target.empty()); SmallString<32> ToolPath; llvm::sys::path::append(ToolPath, "foo", "bar", Target + "-g++"); std::vector Args = {"clang", "-foo"}; addTargetAndModeForProgramName(Args, ToolPath); EXPECT_EQ((std::vector{"clang", "-target", Target, "--driver-mode=g++", "-foo"}), Args); } TEST(addTargetAndModeForProgramName, IgnoresExistingTarget) { std::string Target = getAnyTarget(); ASSERT_FALSE(Target.empty()); std::vector Args = {"clang", "-foo", "-target", "something"}; addTargetAndModeForProgramName(Args, Target + "-g++"); EXPECT_EQ((std::vector{"clang", "--driver-mode=g++", "-foo", "-target", "something"}), Args); std::vector ArgsAlt = {"clang", "-foo", "-target=something"}; addTargetAndModeForProgramName(ArgsAlt, Target + "-g++"); EXPECT_EQ((std::vector{"clang", "--driver-mode=g++", "-foo", "-target=something"}), ArgsAlt); } TEST(addTargetAndModeForProgramName, IgnoresExistingMode) { std::string Target = getAnyTarget(); ASSERT_FALSE(Target.empty()); std::vector Args = {"clang", "-foo", "--driver-mode=abc"}; addTargetAndModeForProgramName(Args, Target + "-g++"); EXPECT_EQ((std::vector{"clang", "-target", Target, "-foo", "--driver-mode=abc"}), Args); std::vector ArgsAlt = {"clang", "-foo", "--driver-mode", "abc"}; addTargetAndModeForProgramName(ArgsAlt, Target + "-g++"); EXPECT_EQ((std::vector{"clang", "-target", Target, "-foo", "--driver-mode", "abc"}), ArgsAlt); } d315 2 a316 2 void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) override { @ 1.1.1.6.2.1 log @Sync with HEAD @ text @d21 1 a21 1 #include "llvm/Support/Path.h" a22 1 #include "llvm/Support/TargetSelect.h" d244 1 a244 1 NamedDecl *F = dyn_cast(D); a257 3 std::vector Args = {"-std=c++11"}; std::vector Args2 = {"-fno-delayed-template-parsing"}; a261 52 // Test constructors with initializers EXPECT_TRUE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMe { skipMe() : an_error() { more error } };", Args)); EXPECT_TRUE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMe { skipMe(); };" "skipMe::skipMe() : an_error([](){;}) { more error }", Args)); EXPECT_TRUE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMe { skipMe(); };" "skipMe::skipMe() : an_error{[](){;}} { more error }", Args)); EXPECT_TRUE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMe { skipMe(); };" "skipMe::skipMe() : a(e)>>(), f{}, g() { error }", Args)); EXPECT_TRUE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMe { skipMe() : bases()... { error } };", Args)); EXPECT_FALSE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMeNot { skipMeNot() : an_error() { } };", Args)); EXPECT_FALSE(runToolOnCodeWithArgs(new SkipBodyAction, "struct skipMeNot { skipMeNot(); };" "skipMeNot::skipMeNot() : an_error() { }", Args)); // Try/catch EXPECT_TRUE(runToolOnCode( new SkipBodyAction, "void skipMe() try { an_error() } catch(error) { error };")); EXPECT_TRUE(runToolOnCode( new SkipBodyAction, "struct S { void skipMe() try { an_error() } catch(error) { error } };")); EXPECT_TRUE( runToolOnCode(new SkipBodyAction, "void skipMe() try { an_error() } catch(error) { error; }" "catch(error) { error } catch (error) { }")); EXPECT_FALSE(runToolOnCode( new SkipBodyAction, "void skipMe() try something;")); // don't crash while parsing // Template EXPECT_TRUE(runToolOnCode( new SkipBodyAction, "template int skipMe() { an_error_here }" "int x = skipMe();")); EXPECT_FALSE(runToolOnCodeWithArgs( new SkipBodyAction, "template int skipMeNot() { an_error_here }", Args2)); a278 38 struct CheckColoredDiagnosticsAction : public clang::ASTFrontendAction { CheckColoredDiagnosticsAction(bool ShouldShowColor) : ShouldShowColor(ShouldShowColor) {} std::unique_ptr CreateASTConsumer(CompilerInstance &Compiler, StringRef) override { if (Compiler.getDiagnosticOpts().ShowColors != ShouldShowColor) Compiler.getDiagnostics().Report( Compiler.getDiagnostics().getCustomDiagID( DiagnosticsEngine::Fatal, "getDiagnosticOpts().ShowColors != ShouldShowColor")); return llvm::make_unique(); } private: bool ShouldShowColor = true; }; TEST(runToolOnCodeWithArgs, DiagnosticsColor) { EXPECT_TRUE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(true), "", {"-fcolor-diagnostics"})); EXPECT_TRUE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false), "", {"-fno-color-diagnostics"})); EXPECT_TRUE( runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(true), "", {"-fno-color-diagnostics", "-fcolor-diagnostics"})); EXPECT_TRUE( runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false), "", {"-fcolor-diagnostics", "-fno-color-diagnostics"})); EXPECT_TRUE(runToolOnCodeWithArgs( new CheckColoredDiagnosticsAction(true), "", {"-fno-color-diagnostics", "-fdiagnostics-color=always"})); // Check that this test would fail if ShowColors is not what it should. EXPECT_FALSE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false), "", {"-fcolor-diagnostics"})); } @ 1.1.1.7 log @Import Clang pre-4.0.0 r291444. @ text @d21 1 a21 1 #include "llvm/Support/Path.h" a22 1 #include "llvm/Support/TargetSelect.h" d244 1 a244 1 NamedDecl *F = dyn_cast(D); a257 3 std::vector Args = {"-std=c++11"}; std::vector Args2 = {"-fno-delayed-template-parsing"}; a261 52 // Test constructors with initializers EXPECT_TRUE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMe { skipMe() : an_error() { more error } };", Args)); EXPECT_TRUE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMe { skipMe(); };" "skipMe::skipMe() : an_error([](){;}) { more error }", Args)); EXPECT_TRUE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMe { skipMe(); };" "skipMe::skipMe() : an_error{[](){;}} { more error }", Args)); EXPECT_TRUE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMe { skipMe(); };" "skipMe::skipMe() : a(e)>>(), f{}, g() { error }", Args)); EXPECT_TRUE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMe { skipMe() : bases()... { error } };", Args)); EXPECT_FALSE(runToolOnCodeWithArgs( new SkipBodyAction, "struct skipMeNot { skipMeNot() : an_error() { } };", Args)); EXPECT_FALSE(runToolOnCodeWithArgs(new SkipBodyAction, "struct skipMeNot { skipMeNot(); };" "skipMeNot::skipMeNot() : an_error() { }", Args)); // Try/catch EXPECT_TRUE(runToolOnCode( new SkipBodyAction, "void skipMe() try { an_error() } catch(error) { error };")); EXPECT_TRUE(runToolOnCode( new SkipBodyAction, "struct S { void skipMe() try { an_error() } catch(error) { error } };")); EXPECT_TRUE( runToolOnCode(new SkipBodyAction, "void skipMe() try { an_error() } catch(error) { error; }" "catch(error) { error } catch (error) { }")); EXPECT_FALSE(runToolOnCode( new SkipBodyAction, "void skipMe() try something;")); // don't crash while parsing // Template EXPECT_TRUE(runToolOnCode( new SkipBodyAction, "template int skipMe() { an_error_here }" "int x = skipMe();")); EXPECT_FALSE(runToolOnCodeWithArgs( new SkipBodyAction, "template int skipMeNot() { an_error_here }", Args2)); a278 38 struct CheckColoredDiagnosticsAction : public clang::ASTFrontendAction { CheckColoredDiagnosticsAction(bool ShouldShowColor) : ShouldShowColor(ShouldShowColor) {} std::unique_ptr CreateASTConsumer(CompilerInstance &Compiler, StringRef) override { if (Compiler.getDiagnosticOpts().ShowColors != ShouldShowColor) Compiler.getDiagnostics().Report( Compiler.getDiagnostics().getCustomDiagID( DiagnosticsEngine::Fatal, "getDiagnosticOpts().ShowColors != ShouldShowColor")); return llvm::make_unique(); } private: bool ShouldShowColor = true; }; TEST(runToolOnCodeWithArgs, DiagnosticsColor) { EXPECT_TRUE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(true), "", {"-fcolor-diagnostics"})); EXPECT_TRUE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false), "", {"-fno-color-diagnostics"})); EXPECT_TRUE( runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(true), "", {"-fno-color-diagnostics", "-fcolor-diagnostics"})); EXPECT_TRUE( runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false), "", {"-fcolor-diagnostics", "-fno-color-diagnostics"})); EXPECT_TRUE(runToolOnCodeWithArgs( new CheckColoredDiagnosticsAction(true), "", {"-fno-color-diagnostics", "-fdiagnostics-color=always"})); // Check that this test would fail if ShowColors is not what it should. EXPECT_FALSE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false), "", {"-fcolor-diagnostics"})); } @ 1.1.1.8 log @Import clang r309604 from branches/release_50 @ text @d206 1 a206 1 bool handleBeginSource(CompilerInstance &CI) override { @ 1.1.1.8.4.1 log @Sync with HEAD @ text @d20 1 d219 1 a219 1 #if !defined(_WIN32) d322 2 a323 2 ASSERT_FALSE(llvm::sys::fs::getPotentiallyUniqueTempFileName("depfile", "d", DepFilePath)); a404 49 TEST(ClangToolTest, BaseVirtualFileSystemUsage) { FixedCompilationDatabase Compilations("/", std::vector()); llvm::IntrusiveRefCntPtr OverlayFileSystem( new vfs::OverlayFileSystem(vfs::getRealFileSystem())); llvm::IntrusiveRefCntPtr InMemoryFileSystem( new vfs::InMemoryFileSystem); OverlayFileSystem->pushOverlay(InMemoryFileSystem); InMemoryFileSystem->addFile( "a.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int main() {}")); ClangTool Tool(Compilations, std::vector(1, "a.cpp"), std::make_shared(), OverlayFileSystem); std::unique_ptr Action( newFrontendActionFactory()); EXPECT_EQ(0, Tool.run(Action.get())); } // Check getClangStripDependencyFileAdjuster doesn't strip args after -MD/-MMD. TEST(ClangToolTest, StripDependencyFileAdjuster) { FixedCompilationDatabase Compilations("/", {"-MD", "-c", "-MMD", "-w"}); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "void a() {}"); std::unique_ptr Action( newFrontendActionFactory()); CommandLineArguments FinalArgs; ArgumentsAdjuster CheckFlagsAdjuster = [&FinalArgs](const CommandLineArguments &Args, StringRef /*unused*/) { FinalArgs = Args; return Args; }; Tool.clearArgumentsAdjusters(); Tool.appendArgumentsAdjuster(getClangStripDependencyFileAdjuster()); Tool.appendArgumentsAdjuster(CheckFlagsAdjuster); Tool.run(Action.get()); auto HasFlag = [&FinalArgs](const std::string &Flag) { return std::find(FinalArgs.begin(), FinalArgs.end(), Flag) != FinalArgs.end(); }; EXPECT_FALSE(HasFlag("-MD")); EXPECT_FALSE(HasFlag("-MMD")); EXPECT_TRUE(HasFlag("-c")); EXPECT_TRUE(HasFlag("-w")); } d485 1 a485 1 #ifndef _WIN32 a535 26 TEST(runToolOnCode, TestResetDiagnostics) { // This is a tool that resets the diagnostic during the compilation. struct ResetDiagnosticAction : public clang::ASTFrontendAction { std::unique_ptr CreateASTConsumer(CompilerInstance &Compiler, StringRef) override { struct Consumer : public clang::ASTConsumer { bool HandleTopLevelDecl(clang::DeclGroupRef D) override { auto &Diags = (*D.begin())->getASTContext().getDiagnostics(); // Ignore any error Diags.Reset(); // Disable warnings because computing the CFG might crash. Diags.setIgnoreAllWarnings(true); return true; } }; return llvm::make_unique(); } }; // Should not crash EXPECT_FALSE( runToolOnCode(new ResetDiagnosticAction, "struct Foo { Foo(int); ~Foo(); struct Fwd _fwd; };" "void func() { long x; Foo f(x); }")); } @ 1.1.1.8.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.8.2.1 log @Sync with HEAD @ text @d20 1 d219 1 a219 1 #if !defined(_WIN32) d322 2 a323 2 ASSERT_FALSE(llvm::sys::fs::getPotentiallyUniqueTempFileName("depfile", "d", DepFilePath)); a404 49 TEST(ClangToolTest, BaseVirtualFileSystemUsage) { FixedCompilationDatabase Compilations("/", std::vector()); llvm::IntrusiveRefCntPtr OverlayFileSystem( new vfs::OverlayFileSystem(vfs::getRealFileSystem())); llvm::IntrusiveRefCntPtr InMemoryFileSystem( new vfs::InMemoryFileSystem); OverlayFileSystem->pushOverlay(InMemoryFileSystem); InMemoryFileSystem->addFile( "a.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int main() {}")); ClangTool Tool(Compilations, std::vector(1, "a.cpp"), std::make_shared(), OverlayFileSystem); std::unique_ptr Action( newFrontendActionFactory()); EXPECT_EQ(0, Tool.run(Action.get())); } // Check getClangStripDependencyFileAdjuster doesn't strip args after -MD/-MMD. TEST(ClangToolTest, StripDependencyFileAdjuster) { FixedCompilationDatabase Compilations("/", {"-MD", "-c", "-MMD", "-w"}); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "void a() {}"); std::unique_ptr Action( newFrontendActionFactory()); CommandLineArguments FinalArgs; ArgumentsAdjuster CheckFlagsAdjuster = [&FinalArgs](const CommandLineArguments &Args, StringRef /*unused*/) { FinalArgs = Args; return Args; }; Tool.clearArgumentsAdjusters(); Tool.appendArgumentsAdjuster(getClangStripDependencyFileAdjuster()); Tool.appendArgumentsAdjuster(CheckFlagsAdjuster); Tool.run(Action.get()); auto HasFlag = [&FinalArgs](const std::string &Flag) { return std::find(FinalArgs.begin(), FinalArgs.end(), Flag) != FinalArgs.end(); }; EXPECT_FALSE(HasFlag("-MD")); EXPECT_FALSE(HasFlag("-MMD")); EXPECT_TRUE(HasFlag("-c")); EXPECT_TRUE(HasFlag("-w")); } d485 1 a485 1 #ifndef _WIN32 a535 26 TEST(runToolOnCode, TestResetDiagnostics) { // This is a tool that resets the diagnostic during the compilation. struct ResetDiagnosticAction : public clang::ASTFrontendAction { std::unique_ptr CreateASTConsumer(CompilerInstance &Compiler, StringRef) override { struct Consumer : public clang::ASTConsumer { bool HandleTopLevelDecl(clang::DeclGroupRef D) override { auto &Diags = (*D.begin())->getASTContext().getDiagnostics(); // Ignore any error Diags.Reset(); // Disable warnings because computing the CFG might crash. Diags.setIgnoreAllWarnings(true); return true; } }; return llvm::make_unique(); } }; // Should not crash EXPECT_FALSE( runToolOnCode(new ResetDiagnosticAction, "struct Foo { Foo(int); ~Foo(); struct Fwd _fwd; };" "void func() { long x; Foo f(x); }")); } @ 1.1.1.9 log @Import clang r337282 from trunk @ text @d20 1 d219 1 a219 1 #if !defined(_WIN32) d322 2 a323 2 ASSERT_FALSE(llvm::sys::fs::getPotentiallyUniqueTempFileName("depfile", "d", DepFilePath)); a404 49 TEST(ClangToolTest, BaseVirtualFileSystemUsage) { FixedCompilationDatabase Compilations("/", std::vector()); llvm::IntrusiveRefCntPtr OverlayFileSystem( new vfs::OverlayFileSystem(vfs::getRealFileSystem())); llvm::IntrusiveRefCntPtr InMemoryFileSystem( new vfs::InMemoryFileSystem); OverlayFileSystem->pushOverlay(InMemoryFileSystem); InMemoryFileSystem->addFile( "a.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int main() {}")); ClangTool Tool(Compilations, std::vector(1, "a.cpp"), std::make_shared(), OverlayFileSystem); std::unique_ptr Action( newFrontendActionFactory()); EXPECT_EQ(0, Tool.run(Action.get())); } // Check getClangStripDependencyFileAdjuster doesn't strip args after -MD/-MMD. TEST(ClangToolTest, StripDependencyFileAdjuster) { FixedCompilationDatabase Compilations("/", {"-MD", "-c", "-MMD", "-w"}); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "void a() {}"); std::unique_ptr Action( newFrontendActionFactory()); CommandLineArguments FinalArgs; ArgumentsAdjuster CheckFlagsAdjuster = [&FinalArgs](const CommandLineArguments &Args, StringRef /*unused*/) { FinalArgs = Args; return Args; }; Tool.clearArgumentsAdjusters(); Tool.appendArgumentsAdjuster(getClangStripDependencyFileAdjuster()); Tool.appendArgumentsAdjuster(CheckFlagsAdjuster); Tool.run(Action.get()); auto HasFlag = [&FinalArgs](const std::string &Flag) { return std::find(FinalArgs.begin(), FinalArgs.end(), Flag) != FinalArgs.end(); }; EXPECT_FALSE(HasFlag("-MD")); EXPECT_FALSE(HasFlag("-MMD")); EXPECT_TRUE(HasFlag("-c")); EXPECT_TRUE(HasFlag("-w")); } d485 1 a485 1 #ifndef _WIN32 a535 26 TEST(runToolOnCode, TestResetDiagnostics) { // This is a tool that resets the diagnostic during the compilation. struct ResetDiagnosticAction : public clang::ASTFrontendAction { std::unique_ptr CreateASTConsumer(CompilerInstance &Compiler, StringRef) override { struct Consumer : public clang::ASTConsumer { bool HandleTopLevelDecl(clang::DeclGroupRef D) override { auto &Diags = (*D.begin())->getASTContext().getDiagnostics(); // Ignore any error Diags.Reset(); // Disable warnings because computing the CFG might crash. Diags.setIgnoreAllWarnings(true); return true; } }; return llvm::make_unique(); } }; // Should not crash EXPECT_FALSE( runToolOnCode(new ResetDiagnosticAction, "struct Foo { Foo(int); ~Foo(); struct Fwd _fwd; };" "void func() { long x; Foo f(x); }")); } @ 1.1.1.10 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.4.4.1 log @file ToolingTest.cpp was added on branch tls-maxphys on 2014-08-19 23:49:28 +0000 @ text @d1 353 @ 1.1.1.4.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 353 //===- unittest/Tooling/ToolingTest.cpp - Tooling unit tests --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "clang/AST/ASTConsumer.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclGroup.h" #include "clang/Frontend/ASTUnit.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendAction.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Tooling/CompilationDatabase.h" #include "clang/Tooling/Tooling.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Config/llvm-config.h" #include "gtest/gtest.h" #include namespace clang { namespace tooling { namespace { /// Takes an ast consumer and returns it from CreateASTConsumer. This only /// works with single translation unit compilations. class TestAction : public clang::ASTFrontendAction { public: /// Takes ownership of TestConsumer. explicit TestAction(clang::ASTConsumer *TestConsumer) : TestConsumer(TestConsumer) {} protected: virtual clang::ASTConsumer* CreateASTConsumer( clang::CompilerInstance& compiler, StringRef dummy) { /// TestConsumer will be deleted by the framework calling us. return TestConsumer; } private: clang::ASTConsumer * const TestConsumer; }; class FindTopLevelDeclConsumer : public clang::ASTConsumer { public: explicit FindTopLevelDeclConsumer(bool *FoundTopLevelDecl) : FoundTopLevelDecl(FoundTopLevelDecl) {} virtual bool HandleTopLevelDecl(clang::DeclGroupRef DeclGroup) { *FoundTopLevelDecl = true; return true; } private: bool * const FoundTopLevelDecl; }; } // end namespace TEST(runToolOnCode, FindsNoTopLevelDeclOnEmptyCode) { bool FoundTopLevelDecl = false; EXPECT_TRUE(runToolOnCode( new TestAction(new FindTopLevelDeclConsumer(&FoundTopLevelDecl)), "")); EXPECT_FALSE(FoundTopLevelDecl); } namespace { class FindClassDeclXConsumer : public clang::ASTConsumer { public: FindClassDeclXConsumer(bool *FoundClassDeclX) : FoundClassDeclX(FoundClassDeclX) {} virtual bool HandleTopLevelDecl(clang::DeclGroupRef GroupRef) { if (CXXRecordDecl* Record = dyn_cast( *GroupRef.begin())) { if (Record->getName() == "X") { *FoundClassDeclX = true; } } return true; } private: bool *FoundClassDeclX; }; bool FindClassDeclX(ASTUnit *AST) { for (std::vector::iterator i = AST->top_level_begin(), e = AST->top_level_end(); i != e; ++i) { if (CXXRecordDecl* Record = dyn_cast(*i)) { if (Record->getName() == "X") { return true; } } } return false; } } // end namespace TEST(runToolOnCode, FindsClassDecl) { bool FoundClassDeclX = false; EXPECT_TRUE(runToolOnCode(new TestAction( new FindClassDeclXConsumer(&FoundClassDeclX)), "class X;")); EXPECT_TRUE(FoundClassDeclX); FoundClassDeclX = false; EXPECT_TRUE(runToolOnCode(new TestAction( new FindClassDeclXConsumer(&FoundClassDeclX)), "class Y;")); EXPECT_FALSE(FoundClassDeclX); } TEST(buildASTFromCode, FindsClassDecl) { std::unique_ptr AST = buildASTFromCode("class X;"); ASSERT_TRUE(AST.get()); EXPECT_TRUE(FindClassDeclX(AST.get())); AST = buildASTFromCode("class Y;"); ASSERT_TRUE(AST.get()); EXPECT_FALSE(FindClassDeclX(AST.get())); } TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromType) { std::unique_ptr Factory( newFrontendActionFactory()); std::unique_ptr Action(Factory->create()); EXPECT_TRUE(Action.get() != nullptr); } struct IndependentFrontendActionCreator { ASTConsumer *newASTConsumer() { return new FindTopLevelDeclConsumer(nullptr); } }; TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromFactoryType) { IndependentFrontendActionCreator Creator; std::unique_ptr Factory( newFrontendActionFactory(&Creator)); std::unique_ptr Action(Factory->create()); EXPECT_TRUE(Action.get() != nullptr); } TEST(ToolInvocation, TestMapVirtualFile) { IntrusiveRefCntPtr Files( new clang::FileManager(clang::FileSystemOptions())); std::vector Args; Args.push_back("tool-executable"); Args.push_back("-Idef"); Args.push_back("-fsyntax-only"); Args.push_back("test.cpp"); clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction, Files.get()); Invocation.mapVirtualFile("test.cpp", "#include \n"); Invocation.mapVirtualFile("def/abc", "\n"); EXPECT_TRUE(Invocation.run()); } TEST(ToolInvocation, TestVirtualModulesCompilation) { // FIXME: Currently, this only tests that we don't exit with an error if a // mapped module.map is found on the include path. In the future, expand this // test to run a full modules enabled compilation, so we make sure we can // rerun modules compilations with a virtual file system. IntrusiveRefCntPtr Files( new clang::FileManager(clang::FileSystemOptions())); std::vector Args; Args.push_back("tool-executable"); Args.push_back("-Idef"); Args.push_back("-fsyntax-only"); Args.push_back("test.cpp"); clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction, Files.get()); Invocation.mapVirtualFile("test.cpp", "#include \n"); Invocation.mapVirtualFile("def/abc", "\n"); // Add a module.map file in the include directory of our header, so we trigger // the module.map header search logic. Invocation.mapVirtualFile("def/module.map", "\n"); EXPECT_TRUE(Invocation.run()); } struct VerifyEndCallback : public SourceFileCallbacks { VerifyEndCallback() : BeginCalled(0), EndCalled(0), Matched(false) {} virtual bool handleBeginSource(CompilerInstance &CI, StringRef Filename) override { ++BeginCalled; return true; } virtual void handleEndSource() { ++EndCalled; } ASTConsumer *newASTConsumer() { return new FindTopLevelDeclConsumer(&Matched); } unsigned BeginCalled; unsigned EndCalled; bool Matched; }; #if !defined(LLVM_ON_WIN32) TEST(newFrontendActionFactory, InjectsSourceFileCallbacks) { VerifyEndCallback EndCallback; FixedCompilationDatabase Compilations("/", std::vector()); std::vector Sources; Sources.push_back("/a.cc"); Sources.push_back("/b.cc"); ClangTool Tool(Compilations, Sources); Tool.mapVirtualFile("/a.cc", "void a() {}"); Tool.mapVirtualFile("/b.cc", "void b() {}"); std::unique_ptr Action( newFrontendActionFactory(&EndCallback, &EndCallback)); Tool.run(Action.get()); EXPECT_TRUE(EndCallback.Matched); EXPECT_EQ(2u, EndCallback.BeginCalled); EXPECT_EQ(2u, EndCallback.EndCalled); } #endif struct SkipBodyConsumer : public clang::ASTConsumer { /// Skip the 'skipMe' function. virtual bool shouldSkipFunctionBody(Decl *D) { FunctionDecl *F = dyn_cast(D); return F && F->getNameAsString() == "skipMe"; } }; struct SkipBodyAction : public clang::ASTFrontendAction { virtual ASTConsumer *CreateASTConsumer(CompilerInstance &Compiler, StringRef) { Compiler.getFrontendOpts().SkipFunctionBodies = true; return new SkipBodyConsumer; } }; TEST(runToolOnCode, TestSkipFunctionBody) { EXPECT_TRUE(runToolOnCode(new SkipBodyAction, "int skipMe() { an_error_here }")); EXPECT_FALSE(runToolOnCode(new SkipBodyAction, "int skipMeNot() { an_error_here }")); } TEST(runToolOnCodeWithArgs, TestNoDepFile) { llvm::SmallString<32> DepFilePath; ASSERT_FALSE( llvm::sys::fs::createTemporaryFile("depfile", "d", DepFilePath)); std::vector Args; Args.push_back("-MMD"); Args.push_back("-MT"); Args.push_back(DepFilePath.str()); Args.push_back("-MF"); Args.push_back(DepFilePath.str()); EXPECT_TRUE(runToolOnCodeWithArgs(new SkipBodyAction, "", Args)); EXPECT_FALSE(llvm::sys::fs::exists(DepFilePath.str())); EXPECT_FALSE(llvm::sys::fs::remove(DepFilePath.str())); } struct CheckSyntaxOnlyAdjuster: public ArgumentsAdjuster { bool &Found; bool &Ran; CheckSyntaxOnlyAdjuster(bool &Found, bool &Ran) : Found(Found), Ran(Ran) { } virtual CommandLineArguments Adjust(const CommandLineArguments &Args) override { Ran = true; for (unsigned I = 0, E = Args.size(); I != E; ++I) { if (Args[I] == "-fsyntax-only") { Found = true; break; } } return Args; } }; TEST(ClangToolTest, ArgumentAdjusters) { FixedCompilationDatabase Compilations("/", std::vector()); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "void a() {}"); std::unique_ptr Action( newFrontendActionFactory()); bool Found = false; bool Ran = false; Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran)); Tool.run(Action.get()); EXPECT_TRUE(Ran); EXPECT_TRUE(Found); Ran = Found = false; Tool.clearArgumentsAdjusters(); Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran)); Tool.appendArgumentsAdjuster(new ClangSyntaxOnlyAdjuster()); Tool.run(Action.get()); EXPECT_TRUE(Ran); EXPECT_FALSE(Found); } #ifndef LLVM_ON_WIN32 TEST(ClangToolTest, BuildASTs) { FixedCompilationDatabase Compilations("/", std::vector()); std::vector Sources; Sources.push_back("/a.cc"); Sources.push_back("/b.cc"); ClangTool Tool(Compilations, Sources); Tool.mapVirtualFile("/a.cc", "void a() {}"); Tool.mapVirtualFile("/b.cc", "void b() {}"); std::vector> ASTs; EXPECT_EQ(0, Tool.buildASTs(ASTs)); EXPECT_EQ(2u, ASTs.size()); } struct TestDiagnosticConsumer : public DiagnosticConsumer { TestDiagnosticConsumer() : NumDiagnosticsSeen(0) {} virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) { ++NumDiagnosticsSeen; } unsigned NumDiagnosticsSeen; }; TEST(ClangToolTest, InjectDiagnosticConsumer) { FixedCompilationDatabase Compilations("/", std::vector()); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "int x = undeclared;"); TestDiagnosticConsumer Consumer; Tool.setDiagnosticConsumer(&Consumer); std::unique_ptr Action( newFrontendActionFactory()); Tool.run(Action.get()); EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen); } TEST(ClangToolTest, InjectDiagnosticConsumerInBuildASTs) { FixedCompilationDatabase Compilations("/", std::vector()); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "int x = undeclared;"); TestDiagnosticConsumer Consumer; Tool.setDiagnosticConsumer(&Consumer); std::vector> ASTs; Tool.buildASTs(ASTs); EXPECT_EQ(1u, ASTs.size()); EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen); } #endif } // end namespace tooling } // end namespace clang @ 1.1.1.2.4.1 log @file ToolingTest.cpp was added on branch yamt-pagecache on 2014-05-22 16:19:49 +0000 @ text @d1 332 @ 1.1.1.2.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 332 //===- unittest/Tooling/ToolingTest.cpp - Tooling unit tests --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "clang/AST/ASTConsumer.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclGroup.h" #include "clang/Frontend/ASTUnit.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendAction.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Tooling/CompilationDatabase.h" #include "clang/Tooling/Tooling.h" #include "llvm/ADT/STLExtras.h" #include "gtest/gtest.h" #include namespace clang { namespace tooling { namespace { /// Takes an ast consumer and returns it from CreateASTConsumer. This only /// works with single translation unit compilations. class TestAction : public clang::ASTFrontendAction { public: /// Takes ownership of TestConsumer. explicit TestAction(clang::ASTConsumer *TestConsumer) : TestConsumer(TestConsumer) {} protected: virtual clang::ASTConsumer* CreateASTConsumer( clang::CompilerInstance& compiler, StringRef dummy) { /// TestConsumer will be deleted by the framework calling us. return TestConsumer; } private: clang::ASTConsumer * const TestConsumer; }; class FindTopLevelDeclConsumer : public clang::ASTConsumer { public: explicit FindTopLevelDeclConsumer(bool *FoundTopLevelDecl) : FoundTopLevelDecl(FoundTopLevelDecl) {} virtual bool HandleTopLevelDecl(clang::DeclGroupRef DeclGroup) { *FoundTopLevelDecl = true; return true; } private: bool * const FoundTopLevelDecl; }; } // end namespace TEST(runToolOnCode, FindsNoTopLevelDeclOnEmptyCode) { bool FoundTopLevelDecl = false; EXPECT_TRUE(runToolOnCode( new TestAction(new FindTopLevelDeclConsumer(&FoundTopLevelDecl)), "")); EXPECT_FALSE(FoundTopLevelDecl); } namespace { class FindClassDeclXConsumer : public clang::ASTConsumer { public: FindClassDeclXConsumer(bool *FoundClassDeclX) : FoundClassDeclX(FoundClassDeclX) {} virtual bool HandleTopLevelDecl(clang::DeclGroupRef GroupRef) { if (CXXRecordDecl* Record = dyn_cast( *GroupRef.begin())) { if (Record->getName() == "X") { *FoundClassDeclX = true; } } return true; } private: bool *FoundClassDeclX; }; bool FindClassDeclX(ASTUnit *AST) { for (std::vector::iterator i = AST->top_level_begin(), e = AST->top_level_end(); i != e; ++i) { if (CXXRecordDecl* Record = dyn_cast(*i)) { if (Record->getName() == "X") { return true; } } } return false; } } // end namespace TEST(runToolOnCode, FindsClassDecl) { bool FoundClassDeclX = false; EXPECT_TRUE(runToolOnCode(new TestAction( new FindClassDeclXConsumer(&FoundClassDeclX)), "class X;")); EXPECT_TRUE(FoundClassDeclX); FoundClassDeclX = false; EXPECT_TRUE(runToolOnCode(new TestAction( new FindClassDeclXConsumer(&FoundClassDeclX)), "class Y;")); EXPECT_FALSE(FoundClassDeclX); } TEST(buildASTFromCode, FindsClassDecl) { OwningPtr AST(buildASTFromCode("class X;")); ASSERT_TRUE(AST.get()); EXPECT_TRUE(FindClassDeclX(AST.get())); AST.reset(buildASTFromCode("class Y;")); ASSERT_TRUE(AST.get()); EXPECT_FALSE(FindClassDeclX(AST.get())); } TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromType) { OwningPtr Factory( newFrontendActionFactory()); OwningPtr Action(Factory->create()); EXPECT_TRUE(Action.get() != NULL); } struct IndependentFrontendActionCreator { ASTConsumer *newASTConsumer() { return new FindTopLevelDeclConsumer(NULL); } }; TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromFactoryType) { IndependentFrontendActionCreator Creator; OwningPtr Factory( newFrontendActionFactory(&Creator)); OwningPtr Action(Factory->create()); EXPECT_TRUE(Action.get() != NULL); } TEST(ToolInvocation, TestMapVirtualFile) { IntrusiveRefCntPtr Files( new clang::FileManager(clang::FileSystemOptions())); std::vector Args; Args.push_back("tool-executable"); Args.push_back("-Idef"); Args.push_back("-fsyntax-only"); Args.push_back("test.cpp"); clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction, Files.getPtr()); Invocation.mapVirtualFile("test.cpp", "#include \n"); Invocation.mapVirtualFile("def/abc", "\n"); EXPECT_TRUE(Invocation.run()); } TEST(ToolInvocation, TestVirtualModulesCompilation) { // FIXME: Currently, this only tests that we don't exit with an error if a // mapped module.map is found on the include path. In the future, expand this // test to run a full modules enabled compilation, so we make sure we can // rerun modules compilations with a virtual file system. IntrusiveRefCntPtr Files( new clang::FileManager(clang::FileSystemOptions())); std::vector Args; Args.push_back("tool-executable"); Args.push_back("-Idef"); Args.push_back("-fsyntax-only"); Args.push_back("test.cpp"); clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction, Files.getPtr()); Invocation.mapVirtualFile("test.cpp", "#include \n"); Invocation.mapVirtualFile("def/abc", "\n"); // Add a module.map file in the include directory of our header, so we trigger // the module.map header search logic. Invocation.mapVirtualFile("def/module.map", "\n"); EXPECT_TRUE(Invocation.run()); } struct VerifyEndCallback : public SourceFileCallbacks { VerifyEndCallback() : BeginCalled(0), EndCalled(0), Matched(false) {} virtual bool handleBeginSource(CompilerInstance &CI, StringRef Filename) LLVM_OVERRIDE { ++BeginCalled; return true; } virtual void handleEndSource() { ++EndCalled; } ASTConsumer *newASTConsumer() { return new FindTopLevelDeclConsumer(&Matched); } unsigned BeginCalled; unsigned EndCalled; bool Matched; }; #if !defined(_WIN32) TEST(newFrontendActionFactory, InjectsSourceFileCallbacks) { VerifyEndCallback EndCallback; FixedCompilationDatabase Compilations("/", std::vector()); std::vector Sources; Sources.push_back("/a.cc"); Sources.push_back("/b.cc"); ClangTool Tool(Compilations, Sources); Tool.mapVirtualFile("/a.cc", "void a() {}"); Tool.mapVirtualFile("/b.cc", "void b() {}"); Tool.run(newFrontendActionFactory(&EndCallback, &EndCallback)); EXPECT_TRUE(EndCallback.Matched); EXPECT_EQ(2u, EndCallback.BeginCalled); EXPECT_EQ(2u, EndCallback.EndCalled); } #endif struct SkipBodyConsumer : public clang::ASTConsumer { /// Skip the 'skipMe' function. virtual bool shouldSkipFunctionBody(Decl *D) { FunctionDecl *F = dyn_cast(D); return F && F->getNameAsString() == "skipMe"; } }; struct SkipBodyAction : public clang::ASTFrontendAction { virtual ASTConsumer *CreateASTConsumer(CompilerInstance &Compiler, StringRef) { Compiler.getFrontendOpts().SkipFunctionBodies = true; return new SkipBodyConsumer; } }; TEST(runToolOnCode, TestSkipFunctionBody) { EXPECT_TRUE(runToolOnCode(new SkipBodyAction, "int skipMe() { an_error_here }")); EXPECT_FALSE(runToolOnCode(new SkipBodyAction, "int skipMeNot() { an_error_here }")); } struct CheckSyntaxOnlyAdjuster: public ArgumentsAdjuster { bool &Found; bool &Ran; CheckSyntaxOnlyAdjuster(bool &Found, bool &Ran) : Found(Found), Ran(Ran) { } virtual CommandLineArguments Adjust(const CommandLineArguments &Args) LLVM_OVERRIDE { Ran = true; for (unsigned I = 0, E = Args.size(); I != E; ++I) { if (Args[I] == "-fsyntax-only") { Found = true; break; } } return Args; } }; TEST(ClangToolTest, ArgumentAdjusters) { FixedCompilationDatabase Compilations("/", std::vector()); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "void a() {}"); bool Found = false; bool Ran = false; Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran)); Tool.run(newFrontendActionFactory()); EXPECT_TRUE(Ran); EXPECT_TRUE(Found); Ran = Found = false; Tool.clearArgumentsAdjusters(); Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran)); Tool.appendArgumentsAdjuster(new ClangSyntaxOnlyAdjuster()); Tool.run(newFrontendActionFactory()); EXPECT_TRUE(Ran); EXPECT_FALSE(Found); } #ifndef _WIN32 TEST(ClangToolTest, BuildASTs) { FixedCompilationDatabase Compilations("/", std::vector()); std::vector Sources; Sources.push_back("/a.cc"); Sources.push_back("/b.cc"); ClangTool Tool(Compilations, Sources); Tool.mapVirtualFile("/a.cc", "void a() {}"); Tool.mapVirtualFile("/b.cc", "void b() {}"); std::vector ASTs; EXPECT_EQ(0, Tool.buildASTs(ASTs)); EXPECT_EQ(2u, ASTs.size()); llvm::DeleteContainerPointers(ASTs); } struct TestDiagnosticConsumer : public DiagnosticConsumer { TestDiagnosticConsumer() : NumDiagnosticsSeen(0) {} virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) { ++NumDiagnosticsSeen; } unsigned NumDiagnosticsSeen; }; TEST(ClangToolTest, InjectDiagnosticConsumer) { FixedCompilationDatabase Compilations("/", std::vector()); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "int x = undeclared;"); TestDiagnosticConsumer Consumer; Tool.setDiagnosticConsumer(&Consumer); Tool.run(newFrontendActionFactory()); EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen); } TEST(ClangToolTest, InjectDiagnosticConsumerInBuildASTs) { FixedCompilationDatabase Compilations("/", std::vector()); ClangTool Tool(Compilations, std::vector(1, "/a.cc")); Tool.mapVirtualFile("/a.cc", "int x = undeclared;"); TestDiagnosticConsumer Consumer; Tool.setDiagnosticConsumer(&Consumer); std::vector ASTs; Tool.buildASTs(ASTs); EXPECT_EQ(1u, ASTs.size()); EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen); } #endif } // end namespace tooling } // end namespace clang @