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.hasTypedMatcher<clang::Decl>());
32   EXPECT_FALSE(Value.hasTypedMatcher<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   EXPECT_EQ("String", Value.getTypeAsString());
42 
43   EXPECT_FALSE(Value.isUnsigned());
44   EXPECT_FALSE(Value.isMatcher());
45   EXPECT_FALSE(Value.hasTypedMatcher<clang::Decl>());
46   EXPECT_FALSE(Value.hasTypedMatcher<clang::UnaryOperator>());
47 }
48 
49 TEST(VariantValueTest, DynTypedMatcher) {
50   VariantValue Value = stmt();
51 
52   EXPECT_FALSE(Value.isUnsigned());
53   EXPECT_FALSE(Value.isString());
54 
55   EXPECT_TRUE(Value.isMatcher());
56   EXPECT_FALSE(Value.hasTypedMatcher<clang::Decl>());
57   EXPECT_TRUE(Value.hasTypedMatcher<clang::UnaryOperator>());
58   EXPECT_EQ("Matcher<Stmt>", Value.getTypeAsString());
59 
60   // Can only convert to compatible matchers.
61   Value = recordDecl();
62   EXPECT_TRUE(Value.isMatcher());
63   EXPECT_TRUE(Value.hasTypedMatcher<clang::Decl>());
64   EXPECT_FALSE(Value.hasTypedMatcher<clang::UnaryOperator>());
65   EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString());
66 
67   Value = ignoringImpCasts(expr());
68   EXPECT_TRUE(Value.isMatcher());
69   EXPECT_FALSE(Value.hasTypedMatcher<clang::Decl>());
70   EXPECT_FALSE(Value.hasTypedMatcher<clang::Stmt>());
71   EXPECT_TRUE(Value.hasTypedMatcher<clang::Expr>());
72   EXPECT_TRUE(Value.hasTypedMatcher<clang::IntegerLiteral>());
73   EXPECT_FALSE(Value.hasTypedMatcher<clang::GotoStmt>());
74   EXPECT_EQ("Matcher<Expr>", Value.getTypeAsString());
75 }
76 
77 TEST(VariantValueTest, Assignment) {
78   VariantValue Value = std::string("A");
79   EXPECT_TRUE(Value.isString());
80   EXPECT_EQ("A", Value.getString());
81   EXPECT_FALSE(Value.isUnsigned());
82   EXPECT_FALSE(Value.isMatcher());
83   EXPECT_EQ("String", Value.getTypeAsString());
84 
85   Value = recordDecl();
86   EXPECT_FALSE(Value.isUnsigned());
87   EXPECT_FALSE(Value.isString());
88   EXPECT_TRUE(Value.isMatcher());
89   EXPECT_TRUE(Value.hasTypedMatcher<clang::Decl>());
90   EXPECT_FALSE(Value.hasTypedMatcher<clang::UnaryOperator>());
91   EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString());
92 
93   Value = 17;
94   EXPECT_TRUE(Value.isUnsigned());
95   EXPECT_EQ(17U, Value.getUnsigned());
96   EXPECT_FALSE(Value.isMatcher());
97   EXPECT_FALSE(Value.isString());
98 
99   Value = VariantValue();
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(GeneicValueTest, Matcher) {
107   EXPECT_TRUE(matches("class X {};", VariantValue(recordDecl(hasName("X")))
108                                          .getTypedMatcher<Decl>()));
109   EXPECT_TRUE(
110       matches("int x;", VariantValue(varDecl()).getTypedMatcher<Decl>()));
111   EXPECT_TRUE(matches("int foo() { return 1 + 1; }",
112                       VariantValue(functionDecl()).getTypedMatcher<Decl>()));
113   // Can't get the wrong matcher.
114   EXPECT_FALSE(VariantValue(varDecl()).hasTypedMatcher<Stmt>());
115 #if GTEST_HAS_DEATH_TEST and DEBUG
116   // Trying to get the wrong matcher fails an assertion in Matcher<T>.
117   EXPECT_DEATH(VariantValue(varDecl()).getTypedMatcher<Stmt>(),
118                "canConstructFrom");
119 #endif
120 
121   EXPECT_FALSE(
122       matches("int x;", VariantValue(functionDecl()).getTypedMatcher<Decl>()));
123   EXPECT_FALSE(matches("int foo() { return 1 + 1; }",
124                        VariantValue(declRefExpr()).getTypedMatcher<Stmt>()));
125 }
126 
127 } // end anonymous namespace
128 } // end namespace dynamic
129 } // end namespace ast_matchers
130 } // end namespace clang
131