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 "MatchVerifier.h" 13 #include "gtest/gtest.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, BaseDistances) { 38 unsigned Distance = 1; 39 EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<Expr>(), &Distance)); 40 EXPECT_EQ(0u, Distance); 41 42 EXPECT_TRUE(DNT<Stmt>().isBaseOf(DNT<IfStmt>(), &Distance)); 43 EXPECT_EQ(1u, Distance); 44 45 Distance = 3; 46 EXPECT_TRUE(DNT<DeclaratorDecl>().isBaseOf(DNT<ParmVarDecl>(), &Distance)); 47 EXPECT_EQ(2u, Distance); 48 } 49 50 TEST(ASTNodeKind, SameBase) { 51 EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<CallExpr>())); 52 EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<BinaryOperator>())); 53 EXPECT_FALSE(DNT<CallExpr>().isBaseOf(DNT<BinaryOperator>())); 54 EXPECT_FALSE(DNT<BinaryOperator>().isBaseOf(DNT<CallExpr>())); 55 } 56 57 TEST(ASTNodeKind, DiffBase) { 58 EXPECT_FALSE(DNT<Expr>().isBaseOf(DNT<ArrayType>())); 59 EXPECT_FALSE(DNT<QualType>().isBaseOf(DNT<FunctionDecl>())); 60 EXPECT_FALSE(DNT<Type>().isSame(DNT<QualType>())); 61 } 62 63 struct Foo {}; 64 65 TEST(ASTNodeKind, UnknownKind) { 66 // We can construct one, but it is nowhere in the hierarchy. 67 EXPECT_FALSE(DNT<Foo>().isSame(DNT<Foo>())); 68 } 69 70 TEST(ASTNodeKind, Name) { 71 EXPECT_EQ("Decl", DNT<Decl>().asStringRef()); 72 EXPECT_EQ("CallExpr", DNT<CallExpr>().asStringRef()); 73 EXPECT_EQ("ConstantArrayType", DNT<ConstantArrayType>().asStringRef()); 74 EXPECT_EQ("<None>", ASTNodeKind().asStringRef()); 75 } 76 77 TEST(DynTypedNode, DeclSourceRange) { 78 RangeVerifier<DynTypedNode> Verifier; 79 Verifier.expectRange(1, 1, 1, 11); 80 EXPECT_TRUE(Verifier.match("void f() {}", decl())); 81 } 82 83 TEST(DynTypedNode, StmtSourceRange) { 84 RangeVerifier<DynTypedNode> Verifier; 85 Verifier.expectRange(1, 10, 1, 11); 86 EXPECT_TRUE(Verifier.match("void f() {}", stmt())); 87 } 88 89 TEST(DynTypedNode, TypeLocSourceRange) { 90 RangeVerifier<DynTypedNode> Verifier; 91 Verifier.expectRange(1, 1, 1, 8); 92 EXPECT_TRUE(Verifier.match("void f() {}", typeLoc(loc(functionType())))); 93 } 94 95 TEST(DynTypedNode, NNSLocSourceRange) { 96 RangeVerifier<DynTypedNode> Verifier; 97 Verifier.expectRange(1, 33, 1, 34); 98 EXPECT_TRUE(Verifier.match("namespace N { typedef void T; } N::T f() {}", 99 nestedNameSpecifierLoc())); 100 } 101 102 TEST(DynTypedNode, DeclDump) { 103 DumpVerifier Verifier; 104 Verifier.expectSubstring("FunctionDecl"); 105 EXPECT_TRUE(Verifier.match("void f() {}", functionDecl())); 106 } 107 108 TEST(DynTypedNode, StmtDump) { 109 DumpVerifier Verifier; 110 Verifier.expectSubstring("CompoundStmt"); 111 EXPECT_TRUE(Verifier.match("void f() {}", stmt())); 112 } 113 114 TEST(DynTypedNode, DeclPrint) { 115 PrintVerifier Verifier; 116 Verifier.expectString("void f() {\n}\n\n"); 117 EXPECT_TRUE(Verifier.match("void f() {}", functionDecl())); 118 } 119 120 TEST(DynTypedNode, StmtPrint) { 121 PrintVerifier Verifier; 122 Verifier.expectString("{\n}\n"); 123 EXPECT_TRUE(Verifier.match("void f() {}", stmt())); 124 } 125 126 } // namespace ast_type_traits 127 } // namespace clang 128
