diff options
Diffstat (limited to 'unittests/AST/SourceLocationTest.cpp')
| -rw-r--r-- | unittests/AST/SourceLocationTest.cpp | 222 |
1 files changed, 221 insertions, 1 deletions
diff --git a/unittests/AST/SourceLocationTest.cpp b/unittests/AST/SourceLocationTest.cpp index 29156bc96ba6..82bba64334b9 100644 --- a/unittests/AST/SourceLocationTest.cpp +++ b/unittests/AST/SourceLocationTest.cpp @@ -17,11 +17,11 @@ //===----------------------------------------------------------------------===// #include "clang/AST/ASTContext.h" +#include "MatchVerifier.h" #include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchers.h" #include "clang/Tooling/Tooling.h" #include "gtest/gtest.h" -#include "MatchVerifier.h" namespace clang { namespace ast_matchers { @@ -211,6 +211,16 @@ TEST(CXXFunctionalCastExpr, SourceRange) { functionalCastExpr(), Lang_CXX11)); } +TEST(CXXConstructExpr, SourceRange) { + RangeVerifier<CXXConstructExpr> Verifier; + Verifier.expectRange(3, 14, 3, 19); + EXPECT_TRUE(Verifier.match( + "struct A { A(int, int); };\n" + "void f(A a);\n" + "void g() { f({0, 0}); }", + constructExpr(), Lang_CXX11)); +} + TEST(CXXTemporaryObjectExpr, SourceRange) { RangeVerifier<CXXTemporaryObjectExpr> Verifier; Verifier.expectRange(2, 6, 2, 12); @@ -253,6 +263,216 @@ TEST(UnresolvedUsingValueDecl, SourceRange) { unresolvedUsingValueDecl())); } +TEST(FriendDecl, FriendNonMemberFunctionLocation) { + LocationVerifier<FriendDecl> Verifier; + Verifier.expectLocation(2, 13); + EXPECT_TRUE(Verifier.match("struct A {\n" + "friend void f();\n" + "};\n", + friendDecl())); +} + +TEST(FriendDecl, FriendNonMemberFunctionRange) { + RangeVerifier<FriendDecl> Verifier; + Verifier.expectRange(2, 1, 2, 15); + EXPECT_TRUE(Verifier.match("struct A {\n" + "friend void f();\n" + "};\n", + friendDecl())); +} + +TEST(FriendDecl, FriendNonMemberFunctionDefinitionLocation) { + LocationVerifier<FriendDecl> Verifier; + Verifier.expectLocation(2, 12); + EXPECT_TRUE(Verifier.match("struct A {\n" + "friend int f() { return 0; }\n" + "};\n", + friendDecl())); +} + +TEST(FriendDecl, FriendNonMemberFunctionDefinitionRange) { + RangeVerifier<FriendDecl> Verifier; + Verifier.expectRange(2, 1, 2, 28); + EXPECT_TRUE(Verifier.match("struct A {\n" + "friend int f() { return 0; }\n" + "};\n", + friendDecl())); +} + +TEST(FriendDecl, FriendElaboratedTypeLocation) { + LocationVerifier<FriendDecl> Verifier; + Verifier.expectLocation(2, 8); + EXPECT_TRUE(Verifier.match("struct A {\n" + "friend class B;\n" + "};\n", + friendDecl())); +} + +TEST(FriendDecl, FriendElaboratedTypeRange) { + RangeVerifier<FriendDecl> Verifier; + Verifier.expectRange(2, 1, 2, 14); + EXPECT_TRUE(Verifier.match("struct A {\n" + "friend class B;\n" + "};\n", + friendDecl())); +} + +TEST(FriendDecl, FriendSimpleTypeLocation) { + LocationVerifier<FriendDecl> Verifier; + Verifier.expectLocation(3, 8); + EXPECT_TRUE(Verifier.match("class B;\n" + "struct A {\n" + "friend B;\n" + "};\n", + friendDecl(), Lang_CXX11)); +} + +TEST(FriendDecl, FriendSimpleTypeRange) { + RangeVerifier<FriendDecl> Verifier; + Verifier.expectRange(3, 1, 3, 8); + EXPECT_TRUE(Verifier.match("class B;\n" + "struct A {\n" + "friend B;\n" + "};\n", + friendDecl(), Lang_CXX11)); +} + +TEST(FriendDecl, FriendTemplateParameterLocation) { + LocationVerifier<FriendDecl> Verifier; + Verifier.expectLocation(3, 8); + EXPECT_TRUE(Verifier.match("template <typename T>\n" + "struct A {\n" + "friend T;\n" + "};\n", + friendDecl(), Lang_CXX11)); +} + +TEST(FriendDecl, FriendTemplateParameterRange) { + RangeVerifier<FriendDecl> Verifier; + Verifier.expectRange(3, 1, 3, 8); + EXPECT_TRUE(Verifier.match("template <typename T>\n" + "struct A {\n" + "friend T;\n" + "};\n", + friendDecl(), Lang_CXX11)); +} + +TEST(FriendDecl, FriendDecltypeLocation) { + LocationVerifier<FriendDecl> Verifier; + Verifier.expectLocation(4, 8); + EXPECT_TRUE(Verifier.match("struct A;\n" + "A foo();\n" + "struct A {\n" + "friend decltype(foo());\n" + "};\n", + friendDecl(), Lang_CXX11)); +} + +TEST(FriendDecl, FriendDecltypeRange) { + RangeVerifier<FriendDecl> Verifier; + Verifier.expectRange(4, 1, 4, 8); + EXPECT_TRUE(Verifier.match("struct A;\n" + "A foo();\n" + "struct A {\n" + "friend decltype(foo());\n" + "};\n", + friendDecl(), Lang_CXX11)); +} + +TEST(FriendDecl, FriendConstructorDestructorLocation) { + const std::string Code = "struct B {\n" + "B();\n" + "~B();\n" + "};\n" + "struct A {\n" + "friend B::B(), B::~B();\n" + "};\n"; + LocationVerifier<FriendDecl> ConstructorVerifier; + ConstructorVerifier.expectLocation(6, 11); + EXPECT_TRUE(ConstructorVerifier.match( + Code, friendDecl(has(constructorDecl(ofClass(hasName("B"))))))); + LocationVerifier<FriendDecl> DestructorVerifier; + DestructorVerifier.expectLocation(6, 19); + EXPECT_TRUE(DestructorVerifier.match( + Code, friendDecl(has(destructorDecl(ofClass(hasName("B"))))))); +} + +TEST(FriendDecl, FriendConstructorDestructorRange) { + const std::string Code = "struct B {\n" + "B();\n" + "~B();\n" + "};\n" + "struct A {\n" + "friend B::B(), B::~B();\n" + "};\n"; + RangeVerifier<FriendDecl> ConstructorVerifier; + ConstructorVerifier.expectRange(6, 1, 6, 13); + EXPECT_TRUE(ConstructorVerifier.match( + Code, friendDecl(has(constructorDecl(ofClass(hasName("B"))))))); + RangeVerifier<FriendDecl> DestructorVerifier; + DestructorVerifier.expectRange(6, 1, 6, 22); + EXPECT_TRUE(DestructorVerifier.match( + Code, friendDecl(has(destructorDecl(ofClass(hasName("B"))))))); +} + +TEST(FriendDecl, FriendTemplateFunctionLocation) { + LocationVerifier<FriendDecl> Verifier; + Verifier.expectLocation(3, 13); + EXPECT_TRUE(Verifier.match("struct A {\n" + "template <typename T>\n" + "friend void f();\n" + "};\n", + friendDecl())); +} + +TEST(FriendDecl, FriendTemplateFunctionRange) { + RangeVerifier<FriendDecl> Verifier; + Verifier.expectRange(2, 1, 3, 15); + EXPECT_TRUE(Verifier.match("struct A {\n" + "template <typename T>\n" + "friend void f();\n" + "};\n", + friendDecl())); +} + +TEST(FriendDecl, FriendTemplateClassLocation) { + LocationVerifier<FriendDecl> Verifier; + Verifier.expectLocation(3, 14); + EXPECT_TRUE(Verifier.match("struct A {\n" + "template <typename T>\n" + "friend class B;\n" + "};\n", + friendDecl())); +} + +TEST(FriendDecl, FriendTemplateClassRange) { + RangeVerifier<FriendDecl> Verifier; + Verifier.expectRange(2, 1, 3, 14); + EXPECT_TRUE(Verifier.match("struct A {\n" + "template <typename T>\n" + "friend class B;\n" + "};\n", + friendDecl())); +} + +TEST(FriendDecl, FriendInlineFunctionLocation) { + LocationVerifier<FriendDecl> Verifier; + Verifier.expectLocation(2, 19); + EXPECT_TRUE(Verifier.match("struct A {\n" + "int inline friend f() { return 0; }" + "};\n", + friendDecl())); +} + +TEST(FriendDecl, FriendInlineFunctionRange) { + RangeVerifier<FriendDecl> Verifier; + Verifier.expectRange(2, 1, 2, 35); + EXPECT_TRUE(Verifier.match("struct A {\n" + "int inline friend f() { return 0; }" + "};\n", + friendDecl(), Lang_CXX11)); +} + TEST(FriendDecl, InstantiationSourceRange) { RangeVerifier<FriendDecl> Verifier; Verifier.expectRange(4, 3, 4, 35); |