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 TEST(VariantValueTest, Unsigned) { 20 const unsigned kUnsigned = 17; 21 VariantValue Value = kUnsigned; 22 23 EXPECT_TRUE(Value.isUnsigned()); 24 EXPECT_EQ(kUnsigned, Value.getUnsigned()); 25 26 EXPECT_TRUE(Value.hasValue()); 27 EXPECT_FALSE(Value.isString()); 28 EXPECT_FALSE(Value.isMatcher()); 29 } 30 31 TEST(VariantValueTest, String) { 32 const StringRef kString = "string"; 33 VariantValue Value = kString; 34 35 EXPECT_TRUE(Value.isString()); 36 EXPECT_EQ(kString, Value.getString()); 37 EXPECT_EQ("String", Value.getTypeAsString()); 38 39 EXPECT_TRUE(Value.hasValue()); 40 EXPECT_FALSE(Value.isUnsigned()); 41 EXPECT_FALSE(Value.isMatcher()); 42 } 43 44 TEST(VariantValueTest, DynTypedMatcher) { 45 VariantValue Value = VariantMatcher::SingleMatcher(stmt()); 46 47 EXPECT_TRUE(Value.hasValue()); 48 EXPECT_FALSE(Value.isUnsigned()); 49 EXPECT_FALSE(Value.isString()); 50 51 EXPECT_TRUE(Value.isMatcher()); 52 EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<Decl>()); 53 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<UnaryOperator>()); 54 EXPECT_EQ("Matcher<Stmt>", Value.getTypeAsString()); 55 56 // Can only convert to compatible matchers. 57 Value = VariantMatcher::SingleMatcher(recordDecl()); 58 EXPECT_TRUE(Value.isMatcher()); 59 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Decl>()); 60 EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<UnaryOperator>()); 61 EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString()); 62 63 Value = VariantMatcher::SingleMatcher(ignoringImpCasts(expr())); 64 EXPECT_TRUE(Value.isMatcher()); 65 EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<Decl>()); 66 EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<Stmt>()); 67 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Expr>()); 68 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<IntegerLiteral>()); 69 EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<GotoStmt>()); 70 EXPECT_EQ("Matcher<Expr>", Value.getTypeAsString()); 71 } 72 73 TEST(VariantValueTest, Assignment) { 74 VariantValue Value = StringRef("A"); 75 EXPECT_TRUE(Value.isString()); 76 EXPECT_EQ("A", Value.getString()); 77 EXPECT_TRUE(Value.hasValue()); 78 EXPECT_FALSE(Value.isUnsigned()); 79 EXPECT_FALSE(Value.isMatcher()); 80 EXPECT_EQ("String", Value.getTypeAsString()); 81 82 Value = VariantMatcher::SingleMatcher(recordDecl()); 83 EXPECT_TRUE(Value.hasValue()); 84 EXPECT_FALSE(Value.isUnsigned()); 85 EXPECT_FALSE(Value.isString()); 86 EXPECT_TRUE(Value.isMatcher()); 87 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Decl>()); 88 EXPECT_FALSE(Value.getMatcher().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_TRUE(Value.hasValue()); 95 EXPECT_FALSE(Value.isMatcher()); 96 EXPECT_FALSE(Value.isString()); 97 98 Value = VariantValue(); 99 EXPECT_FALSE(Value.hasValue()); 100 EXPECT_FALSE(Value.isUnsigned()); 101 EXPECT_FALSE(Value.isString()); 102 EXPECT_FALSE(Value.isMatcher()); 103 EXPECT_EQ("Nothing", Value.getTypeAsString()); 104 } 105 106 TEST(VariantValueTest, ImplicitBool) { 107 VariantValue Value; 108 bool IfTrue = false; 109 if (Value) { 110 IfTrue = true; 111 } 112 EXPECT_FALSE(IfTrue); 113 EXPECT_TRUE(!Value); 114 115 Value = StringRef(); 116 IfTrue = false; 117 if (Value) { 118 IfTrue = true; 119 } 120 EXPECT_TRUE(IfTrue); 121 EXPECT_FALSE(!Value); 122 } 123 124 TEST(VariantValueTest, Matcher) { 125 EXPECT_TRUE(matches("class X {};", VariantValue(VariantMatcher::SingleMatcher( 126 recordDecl(hasName("X")))) 127 .getMatcher() 128 .getTypedMatcher<Decl>())); 129 EXPECT_TRUE( 130 matches("int x;", VariantValue(VariantMatcher::SingleMatcher(varDecl())) 131 .getMatcher() 132 .getTypedMatcher<Decl>())); 133 EXPECT_TRUE( 134 matches("int foo() { return 1 + 1; }", 135 VariantValue(VariantMatcher::SingleMatcher(functionDecl())) 136 .getMatcher() 137 .getTypedMatcher<Decl>())); 138 // Can't get the wrong matcher. 139 EXPECT_FALSE(VariantValue(VariantMatcher::SingleMatcher(varDecl())) 140 .getMatcher() 141 .hasTypedMatcher<Stmt>()); 142 #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST 143 // Trying to get the wrong matcher fails an assertion in Matcher<T>. We don't 144 // do this test when building with MSVC because its debug C runtime prints the 145 // assertion failure message as a wide string, which gtest doesn't understand. 146 EXPECT_DEATH(VariantValue(VariantMatcher::SingleMatcher(varDecl())) 147 .getMatcher() 148 .getTypedMatcher<Stmt>(), 149 "hasTypedMatcher"); 150 #endif 151 152 EXPECT_FALSE(matches( 153 "int x;", VariantValue(VariantMatcher::SingleMatcher(functionDecl())) 154 .getMatcher() 155 .getTypedMatcher<Decl>())); 156 EXPECT_FALSE( 157 matches("int foo() { return 1 + 1; }", 158 VariantValue(VariantMatcher::SingleMatcher(declRefExpr())) 159 .getMatcher() 160 .getTypedMatcher<Stmt>())); 161 } 162 163 } // end anonymous namespace 164 } // end namespace dynamic 165 } // end namespace ast_matchers 166 } // end namespace clang 167
