1 //===- unittest/ASTMatchers/Dynamic/VariantValueTest.cpp - VariantValue 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 "../ASTMatchersTest.h" 11 #include "clang/ASTMatchers/Dynamic/VariantValue.h" 12 #include "gtest/gtest.h" 13 14 namespace clang { 15 namespace ast_matchers { 16 namespace dynamic { 17 namespace { 18 19 using ast_matchers::internal::DynTypedMatcher; 20 using ast_matchers::internal::Matcher; 21 22 TEST(VariantValueTest, Unsigned) { 23 const unsigned kUnsigned = 17; 24 VariantValue Value = kUnsigned; 25 26 EXPECT_TRUE(Value.isUnsigned()); 27 EXPECT_EQ(kUnsigned, Value.getUnsigned()); 28 29 EXPECT_FALSE(Value.isString()); 30 EXPECT_FALSE(Value.isMatchers()); 31 EXPECT_FALSE(Value.hasTypedMatcher<Decl>()); 32 EXPECT_FALSE(Value.hasTypedMatcher<UnaryOperator>()); 33 } 34 35 TEST(VariantValueTest, String) { 36 const ::std::string kString = "string"; 37 VariantValue Value = kString; 38 39 EXPECT_TRUE(Value.isString()); 40 EXPECT_EQ(kString, Value.getString()); 41 EXPECT_EQ("String", Value.getTypeAsString()); 42 43 EXPECT_FALSE(Value.isUnsigned()); 44 EXPECT_FALSE(Value.isMatchers()); 45 } 46 47 TEST(VariantValueTest, DynTypedMatcher) { 48 VariantValue Value = stmt(); 49 50 EXPECT_FALSE(Value.isUnsigned()); 51 EXPECT_FALSE(Value.isString()); 52 53 EXPECT_TRUE(Value.isMatchers()); 54 EXPECT_FALSE(Value.hasTypedMatcher<Decl>()); 55 EXPECT_TRUE(Value.hasTypedMatcher<UnaryOperator>()); 56 EXPECT_EQ("Matcher<Stmt>", Value.getTypeAsString()); 57 58 // Can only convert to compatible matchers. 59 Value = recordDecl(); 60 EXPECT_TRUE(Value.isMatchers()); 61 EXPECT_TRUE(Value.hasTypedMatcher<Decl>()); 62 EXPECT_FALSE(Value.hasTypedMatcher<UnaryOperator>()); 63 EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString()); 64 65 Value = ignoringImpCasts(expr()); 66 EXPECT_TRUE(Value.isMatchers()); 67 EXPECT_FALSE(Value.hasTypedMatcher<Decl>()); 68 EXPECT_FALSE(Value.hasTypedMatcher<Stmt>()); 69 EXPECT_TRUE(Value.hasTypedMatcher<Expr>()); 70 EXPECT_TRUE(Value.hasTypedMatcher<IntegerLiteral>()); 71 EXPECT_FALSE(Value.hasTypedMatcher<GotoStmt>()); 72 EXPECT_EQ("Matcher<Expr>", Value.getTypeAsString()); 73 } 74 75 TEST(VariantValueTest, Assignment) { 76 VariantValue Value = std::string("A"); 77 EXPECT_TRUE(Value.isString()); 78 EXPECT_EQ("A", Value.getString()); 79 EXPECT_FALSE(Value.isUnsigned()); 80 EXPECT_FALSE(Value.isMatchers()); 81 EXPECT_EQ("String", Value.getTypeAsString()); 82 83 Value = recordDecl(); 84 EXPECT_FALSE(Value.isUnsigned()); 85 EXPECT_FALSE(Value.isString()); 86 EXPECT_TRUE(Value.isMatchers()); 87 EXPECT_TRUE(Value.hasTypedMatcher<Decl>()); 88 EXPECT_FALSE(Value.hasTypedMatcher<UnaryOperator>()); 89 EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString()); 90 91 Value = 17; 92 EXPECT_TRUE(Value.isUnsigned()); 93 EXPECT_EQ(17U, Value.getUnsigned()); 94 EXPECT_FALSE(Value.isMatchers()); 95 EXPECT_FALSE(Value.isString()); 96 97 Value = VariantValue(); 98 EXPECT_FALSE(Value.isUnsigned()); 99 EXPECT_FALSE(Value.isString()); 100 EXPECT_FALSE(Value.isMatchers()); 101 EXPECT_EQ("Nothing", Value.getTypeAsString()); 102 } 103 104 TEST(VariantValueTest, Matcher) { 105 EXPECT_TRUE(matches("class X {};", VariantValue(recordDecl(hasName("X"))) 106 .getTypedMatcher<Decl>())); 107 EXPECT_TRUE( 108 matches("int x;", VariantValue(varDecl()).getTypedMatcher<Decl>())); 109 EXPECT_TRUE(matches("int foo() { return 1 + 1; }", 110 VariantValue(functionDecl()).getTypedMatcher<Decl>())); 111 // Can't get the wrong matcher. 112 EXPECT_FALSE(VariantValue(varDecl()).hasTypedMatcher<Stmt>()); 113 #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST && !defined(_MSC_VER) 114 // Trying to get the wrong matcher fails an assertion in Matcher<T>. We don't 115 // do this test when building with MSVC because its debug C runtime prints the 116 // assertion failure message as a wide string, which gtest doesn't understand. 117 EXPECT_DEATH(VariantValue(varDecl()).getTypedMatcher<Stmt>(), 118 "hasTypedMatcher"); 119 #endif 120 121 EXPECT_FALSE( 122 matches("int x;", VariantValue(functionDecl()).getTypedMatcher<Decl>())); 123 EXPECT_FALSE( 124 matches("int foo() { return 1 + 1; }", 125 126 VariantValue(declRefExpr()).getTypedMatcher<Stmt>())); 127 } 128 129 } // end anonymous namespace 130 } // end namespace dynamic 131 } // end namespace ast_matchers 132 } // end namespace clang 133