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.isMatcher()); 31 EXPECT_FALSE(Value.isTypedMatcher<clang::Decl>()); 32 EXPECT_FALSE(Value.isTypedMatcher<clang::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 42 EXPECT_FALSE(Value.isUnsigned()); 43 EXPECT_FALSE(Value.isMatcher()); 44 EXPECT_FALSE(Value.isTypedMatcher<clang::Decl>()); 45 EXPECT_FALSE(Value.isTypedMatcher<clang::UnaryOperator>()); 46 } 47 48 TEST(VariantValueTest, DynTypedMatcher) { 49 VariantValue Value = stmt(); 50 51 EXPECT_FALSE(Value.isUnsigned()); 52 EXPECT_FALSE(Value.isString()); 53 54 EXPECT_TRUE(Value.isMatcher()); 55 EXPECT_TRUE(Value.isTypedMatcher<clang::Decl>()); 56 EXPECT_TRUE(Value.isTypedMatcher<clang::UnaryOperator>()); 57 58 // Conversion to any type of matcher works. 59 // If they are not compatible it would just return a matcher that matches 60 // nothing. We test this below. 61 Value = recordDecl(); 62 EXPECT_TRUE(Value.isMatcher()); 63 EXPECT_TRUE(Value.isTypedMatcher<clang::Decl>()); 64 EXPECT_TRUE(Value.isTypedMatcher<clang::UnaryOperator>()); 65 66 Value = unaryOperator(); 67 EXPECT_TRUE(Value.isMatcher()); 68 EXPECT_TRUE(Value.isTypedMatcher<clang::Decl>()); 69 EXPECT_TRUE(Value.isTypedMatcher<clang::Stmt>()); 70 EXPECT_TRUE(Value.isTypedMatcher<clang::UnaryOperator>()); 71 } 72 73 TEST(VariantValueTest, Assignment) { 74 VariantValue Value = std::string("A"); 75 EXPECT_TRUE(Value.isString()); 76 EXPECT_EQ("A", Value.getString()); 77 EXPECT_FALSE(Value.isUnsigned()); 78 EXPECT_FALSE(Value.isMatcher()); 79 80 Value = recordDecl(); 81 EXPECT_FALSE(Value.isUnsigned()); 82 EXPECT_FALSE(Value.isString()); 83 EXPECT_TRUE(Value.isMatcher()); 84 EXPECT_TRUE(Value.isTypedMatcher<clang::Decl>()); 85 EXPECT_TRUE(Value.isTypedMatcher<clang::UnaryOperator>()); 86 87 Value = 17; 88 EXPECT_TRUE(Value.isUnsigned()); 89 EXPECT_EQ(17U, Value.getUnsigned()); 90 EXPECT_FALSE(Value.isMatcher()); 91 EXPECT_FALSE(Value.isString()); 92 93 Value = VariantValue(); 94 EXPECT_FALSE(Value.isUnsigned()); 95 EXPECT_FALSE(Value.isString()); 96 EXPECT_FALSE(Value.isMatcher()); 97 } 98 99 TEST(GeneicValueTest, Matcher) { 100 EXPECT_TRUE(matchesDynamic( 101 "class X {};", VariantValue(recordDecl(hasName("X"))).getMatcher())); 102 EXPECT_TRUE(matchesDynamic( 103 "int x;", VariantValue(varDecl()).getTypedMatcher<clang::Decl>())); 104 EXPECT_TRUE(matchesDynamic("int foo() { return 1 + 1; }", 105 VariantValue(functionDecl()).getMatcher())); 106 // Going through the wrong Matcher<T> will fail to match, even if the 107 // underlying matcher is correct. 108 EXPECT_FALSE(matchesDynamic( 109 "int x;", VariantValue(varDecl()).getTypedMatcher<clang::Stmt>())); 110 111 EXPECT_FALSE( 112 matchesDynamic("int x;", VariantValue(functionDecl()).getMatcher())); 113 EXPECT_FALSE(matchesDynamic( 114 "int foo() { return 1 + 1; }", 115 VariantValue(declRefExpr()).getTypedMatcher<clang::DeclRefExpr>())); 116 } 117 118 } // end anonymous namespace 119 } // end namespace dynamic 120 } // end namespace ast_matchers 121 } // end namespace clang 122