Home | History | Annotate | Download | only in Dynamic 
      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.isMatchers());
     31   EXPECT_FALSE(Value.hasTypedMatcher<Decl>());
     32   EXPECT_FALSE(Value.hasTypedMatcher<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.isMatchers());
     45 }
     46 
     47 TEST(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 
     75 TEST(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 
    104 TEST(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