1 //===- unittest/ASTMatchers/Dynamic/VariantValueTest.cpp - VariantValue unit tests -===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===-----------------------------------------------------------------------------===// 8 9 #include "../ASTMatchersTest.h" 10 #include "clang/ASTMatchers/Dynamic/VariantValue.h" 11 #include "gtest/gtest.h" 12 13 namespace clang { 14 namespace ast_matchers { 15 namespace dynamic { 16 namespace { 17 18 TEST(VariantValueTest, Unsigned) { 19 const unsigned kUnsigned = 17; 20 VariantValue Value = kUnsigned; 21 22 EXPECT_TRUE(Value.isUnsigned()); 23 EXPECT_EQ(kUnsigned, Value.getUnsigned()); 24 25 EXPECT_TRUE(Value.hasValue()); 26 EXPECT_FALSE(Value.isString()); 27 EXPECT_FALSE(Value.isMatcher()); 28 } 29 30 TEST(VariantValueTest, String) { 31 const StringRef kString = "string"; 32 VariantValue Value = kString; 33 34 EXPECT_TRUE(Value.isString()); 35 EXPECT_EQ(kString, Value.getString()); 36 EXPECT_EQ("String", Value.getTypeAsString()); 37 38 EXPECT_TRUE(Value.hasValue()); 39 EXPECT_FALSE(Value.isUnsigned()); 40 EXPECT_FALSE(Value.isMatcher()); 41 } 42 43 TEST(VariantValueTest, DynTypedMatcher) { 44 VariantValue Value = VariantMatcher::SingleMatcher(stmt()); 45 46 EXPECT_TRUE(Value.hasValue()); 47 EXPECT_FALSE(Value.isUnsigned()); 48 EXPECT_FALSE(Value.isString()); 49 50 EXPECT_TRUE(Value.isMatcher()); 51 EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<Decl>()); 52 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<UnaryOperator>()); 53 EXPECT_EQ("Matcher<Stmt>", Value.getTypeAsString()); 54 55 // Can only convert to compatible matchers. 56 Value = VariantMatcher::SingleMatcher(recordDecl()); 57 EXPECT_TRUE(Value.isMatcher()); 58 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Decl>()); 59 EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<UnaryOperator>()); 60 EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString()); 61 62 Value = VariantMatcher::SingleMatcher(ignoringImpCasts(expr())); 63 EXPECT_TRUE(Value.isMatcher()); 64 EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<Decl>()); 65 EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<Stmt>()); 66 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Expr>()); 67 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<IntegerLiteral>()); 68 EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<GotoStmt>()); 69 EXPECT_EQ("Matcher<Expr>", Value.getTypeAsString()); 70 } 71 72 TEST(VariantValueTest, Assignment) { 73 VariantValue Value = StringRef("A"); 74 EXPECT_TRUE(Value.isString()); 75 EXPECT_EQ("A", Value.getString()); 76 EXPECT_TRUE(Value.hasValue()); 77 EXPECT_FALSE(Value.isBoolean()); 78 EXPECT_FALSE(Value.isDouble()); 79 EXPECT_FALSE(Value.isUnsigned()); 80 EXPECT_FALSE(Value.isMatcher()); 81 EXPECT_EQ("String", Value.getTypeAsString()); 82 83 Value = VariantMatcher::SingleMatcher(recordDecl()); 84 EXPECT_TRUE(Value.hasValue()); 85 EXPECT_FALSE(Value.isBoolean()); 86 EXPECT_FALSE(Value.isDouble()); 87 EXPECT_FALSE(Value.isUnsigned()); 88 EXPECT_FALSE(Value.isString()); 89 EXPECT_TRUE(Value.isMatcher()); 90 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Decl>()); 91 EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<UnaryOperator>()); 92 EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString()); 93 94 Value = true; 95 EXPECT_TRUE(Value.isBoolean()); 96 EXPECT_EQ(true, Value.getBoolean()); 97 EXPECT_TRUE(Value.hasValue()); 98 EXPECT_FALSE(Value.isUnsigned()); 99 EXPECT_FALSE(Value.isMatcher()); 100 EXPECT_FALSE(Value.isString()); 101 102 Value = 3.14; 103 EXPECT_TRUE(Value.isDouble()); 104 EXPECT_EQ(3.14, Value.getDouble()); 105 EXPECT_TRUE(Value.hasValue()); 106 EXPECT_FALSE(Value.isBoolean()); 107 EXPECT_FALSE(Value.isUnsigned()); 108 EXPECT_FALSE(Value.isMatcher()); 109 EXPECT_FALSE(Value.isString()); 110 111 Value = 17; 112 EXPECT_TRUE(Value.isUnsigned()); 113 EXPECT_EQ(17U, Value.getUnsigned()); 114 EXPECT_FALSE(Value.isBoolean()); 115 EXPECT_FALSE(Value.isDouble()); 116 EXPECT_TRUE(Value.hasValue()); 117 EXPECT_FALSE(Value.isMatcher()); 118 EXPECT_FALSE(Value.isString()); 119 120 Value = VariantValue(); 121 EXPECT_FALSE(Value.hasValue()); 122 EXPECT_FALSE(Value.isBoolean()); 123 EXPECT_FALSE(Value.isDouble()); 124 EXPECT_FALSE(Value.isUnsigned()); 125 EXPECT_FALSE(Value.isString()); 126 EXPECT_FALSE(Value.isMatcher()); 127 EXPECT_EQ("Nothing", Value.getTypeAsString()); 128 } 129 130 TEST(VariantValueTest, ImplicitBool) { 131 VariantValue Value; 132 bool IfTrue = false; 133 if (Value) { 134 IfTrue = true; 135 } 136 EXPECT_FALSE(IfTrue); 137 EXPECT_TRUE(!Value); 138 139 Value = StringRef(); 140 IfTrue = false; 141 if (Value) { 142 IfTrue = true; 143 } 144 EXPECT_TRUE(IfTrue); 145 EXPECT_FALSE(!Value); 146 } 147 148 TEST(VariantValueTest, Matcher) { 149 EXPECT_TRUE(matches("class X {};", VariantValue(VariantMatcher::SingleMatcher( 150 recordDecl(hasName("X")))) 151 .getMatcher() 152 .getTypedMatcher<Decl>())); 153 EXPECT_TRUE( 154 matches("int x;", VariantValue(VariantMatcher::SingleMatcher(varDecl())) 155 .getMatcher() 156 .getTypedMatcher<Decl>())); 157 EXPECT_TRUE( 158 matches("int foo() { return 1 + 1; }", 159 VariantValue(VariantMatcher::SingleMatcher(functionDecl())) 160 .getMatcher() 161 .getTypedMatcher<Decl>())); 162 // Can't get the wrong matcher. 163 EXPECT_FALSE(VariantValue(VariantMatcher::SingleMatcher(varDecl())) 164 .getMatcher() 165 .hasTypedMatcher<Stmt>()); 166 #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST 167 // Trying to get the wrong matcher fails an assertion in Matcher<T>. We don't 168 // do this test when building with MSVC because its debug C runtime prints the 169 // assertion failure message as a wide string, which gtest doesn't understand. 170 EXPECT_DEATH(VariantValue(VariantMatcher::SingleMatcher(varDecl())) 171 .getMatcher() 172 .getTypedMatcher<Stmt>(), 173 "hasTypedMatcher"); 174 #endif 175 176 EXPECT_FALSE(matches( 177 "int x;", VariantValue(VariantMatcher::SingleMatcher(functionDecl())) 178 .getMatcher() 179 .getTypedMatcher<Decl>())); 180 EXPECT_FALSE( 181 matches("int foo() { return 1 + 1; }", 182 VariantValue(VariantMatcher::SingleMatcher(declRefExpr())) 183 .getMatcher() 184 .getTypedMatcher<Stmt>())); 185 } 186 187 } // end anonymous namespace 188 } // end namespace dynamic 189 } // end namespace ast_matchers 190 } // end namespace clang 191