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
TEST(VariantValueTest,Unsigned)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
TEST(VariantValueTest,String)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
TEST(VariantValueTest,DynTypedMatcher)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
TEST(VariantValueTest,Assignment)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
TEST(VariantValueTest,ImplicitBool)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
TEST(VariantValueTest,Matcher)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