1 //===- unittest/AST/ASTTypeTraits.cpp - AST type traits 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 11 #include "clang/AST/ASTTypeTraits.h" 12 #include "gtest/gtest.h" 13 #include "MatchVerifier.h" 14 15 using namespace clang::ast_matchers; 16 17 namespace clang { 18 namespace ast_type_traits { 19 20 TEST(ASTNodeKind, NoKind) { 21 EXPECT_FALSE(ASTNodeKind().isBaseOf(ASTNodeKind())); 22 EXPECT_FALSE(ASTNodeKind().isSame(ASTNodeKind())); 23 } 24 25 template <typename T> static ASTNodeKind DNT() { 26 return ASTNodeKind::getFromNodeKind<T>(); 27 } 28 29 TEST(ASTNodeKind, Bases) { 30 EXPECT_TRUE(DNT<Decl>().isBaseOf(DNT<VarDecl>())); 31 EXPECT_FALSE(DNT<Decl>().isSame(DNT<VarDecl>())); 32 EXPECT_FALSE(DNT<VarDecl>().isBaseOf(DNT<Decl>())); 33 34 EXPECT_TRUE(DNT<Decl>().isSame(DNT<Decl>())); 35 } 36 37 TEST(ASTNodeKind, SameBase) { 38 EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<CallExpr>())); 39 EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<BinaryOperator>())); 40 EXPECT_FALSE(DNT<CallExpr>().isBaseOf(DNT<BinaryOperator>())); 41 EXPECT_FALSE(DNT<BinaryOperator>().isBaseOf(DNT<CallExpr>())); 42 } 43 44 TEST(ASTNodeKind, DiffBase) { 45 EXPECT_FALSE(DNT<Expr>().isBaseOf(DNT<ArrayType>())); 46 EXPECT_FALSE(DNT<QualType>().isBaseOf(DNT<FunctionDecl>())); 47 EXPECT_FALSE(DNT<Type>().isSame(DNT<QualType>())); 48 } 49 50 struct Foo {}; 51 52 TEST(ASTNodeKind, UnknownKind) { 53 // We can construct one, but it is nowhere in the hierarchy. 54 EXPECT_FALSE(DNT<Foo>().isSame(DNT<Foo>())); 55 } 56 57 TEST(ASTNodeKind, Name) { 58 EXPECT_EQ("Decl", DNT<Decl>().asStringRef()); 59 EXPECT_EQ("CallExpr", DNT<CallExpr>().asStringRef()); 60 EXPECT_EQ("ConstantArrayType", DNT<ConstantArrayType>().asStringRef()); 61 EXPECT_EQ("<None>", ASTNodeKind().asStringRef()); 62 } 63 64 TEST(DynTypedNode, DeclSourceRange) { 65 RangeVerifier<DynTypedNode> Verifier; 66 Verifier.expectRange(1, 1, 1, 11); 67 EXPECT_TRUE(Verifier.match("void f() {}", decl())); 68 } 69 70 TEST(DynTypedNode, StmtSourceRange) { 71 RangeVerifier<DynTypedNode> Verifier; 72 Verifier.expectRange(1, 10, 1, 11); 73 EXPECT_TRUE(Verifier.match("void f() {}", stmt())); 74 } 75 76 TEST(DynTypedNode, TypeLocSourceRange) { 77 RangeVerifier<DynTypedNode> Verifier; 78 Verifier.expectRange(1, 1, 1, 8); 79 EXPECT_TRUE(Verifier.match("void f() {}", typeLoc(loc(functionType())))); 80 } 81 82 TEST(DynTypedNode, NNSLocSourceRange) { 83 RangeVerifier<DynTypedNode> Verifier; 84 Verifier.expectRange(1, 33, 1, 34); 85 EXPECT_TRUE(Verifier.match("namespace N { typedef void T; } N::T f() {}", 86 nestedNameSpecifierLoc())); 87 } 88 89 TEST(DynTypedNode, DeclDump) { 90 DumpVerifier Verifier; 91 Verifier.expectSubstring("FunctionDecl"); 92 EXPECT_TRUE(Verifier.match("void f() {}", functionDecl())); 93 } 94 95 TEST(DynTypedNode, StmtDump) { 96 DumpVerifier Verifier; 97 Verifier.expectSubstring("CompoundStmt"); 98 EXPECT_TRUE(Verifier.match("void f() {}", stmt())); 99 } 100 101 TEST(DynTypedNode, DeclPrint) { 102 PrintVerifier Verifier; 103 Verifier.expectString("void f() {\n}\n\n"); 104 EXPECT_TRUE(Verifier.match("void f() {}", functionDecl())); 105 } 106 107 TEST(DynTypedNode, StmtPrint) { 108 PrintVerifier Verifier; 109 Verifier.expectString("{\n}\n"); 110 EXPECT_TRUE(Verifier.match("void f() {}", stmt())); 111 } 112 113 } // namespace ast_type_traits 114 } // namespace clang 115