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.isBoolean());
79   EXPECT_FALSE(Value.isDouble());
80   EXPECT_FALSE(Value.isUnsigned());
81   EXPECT_FALSE(Value.isMatcher());
82   EXPECT_EQ("String", Value.getTypeAsString());
83 
84   Value = VariantMatcher::SingleMatcher(recordDecl());
85   EXPECT_TRUE(Value.hasValue());
86   EXPECT_FALSE(Value.isBoolean());
87   EXPECT_FALSE(Value.isDouble());
88   EXPECT_FALSE(Value.isUnsigned());
89   EXPECT_FALSE(Value.isString());
90   EXPECT_TRUE(Value.isMatcher());
91   EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Decl>());
92   EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<UnaryOperator>());
93   EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString());
94 
95   Value = true;
96   EXPECT_TRUE(Value.isBoolean());
97   EXPECT_EQ(true, Value.getBoolean());
98   EXPECT_TRUE(Value.hasValue());
99   EXPECT_FALSE(Value.isUnsigned());
100   EXPECT_FALSE(Value.isMatcher());
101   EXPECT_FALSE(Value.isString());
102 
103   Value = 3.14;
104   EXPECT_TRUE(Value.isDouble());
105   EXPECT_EQ(3.14, Value.getDouble());
106   EXPECT_TRUE(Value.hasValue());
107   EXPECT_FALSE(Value.isBoolean());
108   EXPECT_FALSE(Value.isUnsigned());
109   EXPECT_FALSE(Value.isMatcher());
110   EXPECT_FALSE(Value.isString());
111 
112   Value = 17;
113   EXPECT_TRUE(Value.isUnsigned());
114   EXPECT_EQ(17U, Value.getUnsigned());
115   EXPECT_FALSE(Value.isBoolean());
116   EXPECT_FALSE(Value.isDouble());
117   EXPECT_TRUE(Value.hasValue());
118   EXPECT_FALSE(Value.isMatcher());
119   EXPECT_FALSE(Value.isString());
120 
121   Value = VariantValue();
122   EXPECT_FALSE(Value.hasValue());
123   EXPECT_FALSE(Value.isBoolean());
124   EXPECT_FALSE(Value.isDouble());
125   EXPECT_FALSE(Value.isUnsigned());
126   EXPECT_FALSE(Value.isString());
127   EXPECT_FALSE(Value.isMatcher());
128   EXPECT_EQ("Nothing", Value.getTypeAsString());
129 }
130 
131 TEST(VariantValueTest, ImplicitBool) {
132   VariantValue Value;
133   bool IfTrue = false;
134   if (Value) {
135     IfTrue = true;
136   }
137   EXPECT_FALSE(IfTrue);
138   EXPECT_TRUE(!Value);
139 
140   Value = StringRef();
141   IfTrue = false;
142   if (Value) {
143     IfTrue = true;
144   }
145   EXPECT_TRUE(IfTrue);
146   EXPECT_FALSE(!Value);
147 }
148 
149 TEST(VariantValueTest, Matcher) {
150   EXPECT_TRUE(matches("class X {};", VariantValue(VariantMatcher::SingleMatcher(
151                                                       recordDecl(hasName("X"))))
152                                          .getMatcher()
153                                          .getTypedMatcher<Decl>()));
154   EXPECT_TRUE(
155       matches("int x;", VariantValue(VariantMatcher::SingleMatcher(varDecl()))
156                             .getMatcher()
157                             .getTypedMatcher<Decl>()));
158   EXPECT_TRUE(
159       matches("int foo() { return 1 + 1; }",
160               VariantValue(VariantMatcher::SingleMatcher(functionDecl()))
161                   .getMatcher()
162                   .getTypedMatcher<Decl>()));
163   // Can't get the wrong matcher.
164   EXPECT_FALSE(VariantValue(VariantMatcher::SingleMatcher(varDecl()))
165                    .getMatcher()
166                    .hasTypedMatcher<Stmt>());
167 #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
168   // Trying to get the wrong matcher fails an assertion in Matcher<T>.  We don't
169   // do this test when building with MSVC because its debug C runtime prints the
170   // assertion failure message as a wide string, which gtest doesn't understand.
171   EXPECT_DEATH(VariantValue(VariantMatcher::SingleMatcher(varDecl()))
172                    .getMatcher()
173                    .getTypedMatcher<Stmt>(),
174                "hasTypedMatcher");
175 #endif
176 
177   EXPECT_FALSE(matches(
178       "int x;", VariantValue(VariantMatcher::SingleMatcher(functionDecl()))
179                     .getMatcher()
180                     .getTypedMatcher<Decl>()));
181   EXPECT_FALSE(
182       matches("int foo() { return 1 + 1; }",
183               VariantValue(VariantMatcher::SingleMatcher(declRefExpr()))
184                   .getMatcher()
185                   .getTypedMatcher<Stmt>()));
186 }
187 
188 } // end anonymous namespace
189 } // end namespace dynamic
190 } // end namespace ast_matchers
191 } // end namespace clang
192