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
14namespace clang {
15namespace ast_matchers {
16namespace dynamic {
17namespace {
18
19using ast_matchers::internal::DynTypedMatcher;
20using ast_matchers::internal::Matcher;
21
22TEST(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.isMatchers());
31  EXPECT_FALSE(Value.hasTypedMatcher<Decl>());
32  EXPECT_FALSE(Value.hasTypedMatcher<UnaryOperator>());
33}
34
35TEST(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.isMatchers());
45}
46
47TEST(VariantValueTest, DynTypedMatcher) {
48  VariantValue Value = stmt();
49
50  EXPECT_FALSE(Value.isUnsigned());
51  EXPECT_FALSE(Value.isString());
52
53  EXPECT_TRUE(Value.isMatchers());
54  EXPECT_FALSE(Value.hasTypedMatcher<Decl>());
55  EXPECT_TRUE(Value.hasTypedMatcher<UnaryOperator>());
56  EXPECT_EQ("Matcher<Stmt>", Value.getTypeAsString());
57
58  // Can only convert to compatible matchers.
59  Value = recordDecl();
60  EXPECT_TRUE(Value.isMatchers());
61  EXPECT_TRUE(Value.hasTypedMatcher<Decl>());
62  EXPECT_FALSE(Value.hasTypedMatcher<UnaryOperator>());
63  EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString());
64
65  Value = ignoringImpCasts(expr());
66  EXPECT_TRUE(Value.isMatchers());
67  EXPECT_FALSE(Value.hasTypedMatcher<Decl>());
68  EXPECT_FALSE(Value.hasTypedMatcher<Stmt>());
69  EXPECT_TRUE(Value.hasTypedMatcher<Expr>());
70  EXPECT_TRUE(Value.hasTypedMatcher<IntegerLiteral>());
71  EXPECT_FALSE(Value.hasTypedMatcher<GotoStmt>());
72  EXPECT_EQ("Matcher<Expr>", Value.getTypeAsString());
73}
74
75TEST(VariantValueTest, Assignment) {
76  VariantValue Value = std::string("A");
77  EXPECT_TRUE(Value.isString());
78  EXPECT_EQ("A", Value.getString());
79  EXPECT_FALSE(Value.isUnsigned());
80  EXPECT_FALSE(Value.isMatchers());
81  EXPECT_EQ("String", Value.getTypeAsString());
82
83  Value = recordDecl();
84  EXPECT_FALSE(Value.isUnsigned());
85  EXPECT_FALSE(Value.isString());
86  EXPECT_TRUE(Value.isMatchers());
87  EXPECT_TRUE(Value.hasTypedMatcher<Decl>());
88  EXPECT_FALSE(Value.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_FALSE(Value.isMatchers());
95  EXPECT_FALSE(Value.isString());
96
97  Value = VariantValue();
98  EXPECT_FALSE(Value.isUnsigned());
99  EXPECT_FALSE(Value.isString());
100  EXPECT_FALSE(Value.isMatchers());
101  EXPECT_EQ("Nothing", Value.getTypeAsString());
102}
103
104TEST(VariantValueTest, Matcher) {
105  EXPECT_TRUE(matches("class X {};", VariantValue(recordDecl(hasName("X")))
106                                         .getTypedMatcher<Decl>()));
107  EXPECT_TRUE(
108      matches("int x;", VariantValue(varDecl()).getTypedMatcher<Decl>()));
109  EXPECT_TRUE(matches("int foo() { return 1 + 1; }",
110                      VariantValue(functionDecl()).getTypedMatcher<Decl>()));
111  // Can't get the wrong matcher.
112  EXPECT_FALSE(VariantValue(varDecl()).hasTypedMatcher<Stmt>());
113#if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST && !defined(_MSC_VER)
114  // Trying to get the wrong matcher fails an assertion in Matcher<T>.  We don't
115  // do this test when building with MSVC because its debug C runtime prints the
116  // assertion failure message as a wide string, which gtest doesn't understand.
117  EXPECT_DEATH(VariantValue(varDecl()).getTypedMatcher<Stmt>(),
118               "hasTypedMatcher");
119#endif
120
121  EXPECT_FALSE(
122      matches("int x;", VariantValue(functionDecl()).getTypedMatcher<Decl>()));
123  EXPECT_FALSE(
124      matches("int foo() { return 1 + 1; }",
125
126              VariantValue(declRefExpr()).getTypedMatcher<Stmt>()));
127}
128
129} // end anonymous namespace
130} // end namespace dynamic
131} // end namespace ast_matchers
132} // end namespace clang
133