//===- unittest/ASTMatchers/Dynamic/VariantValueTest.cpp - VariantValue unit tests -===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===-----------------------------------------------------------------------------===// #include "../ASTMatchersTest.h" #include "clang/ASTMatchers/Dynamic/VariantValue.h" #include "gtest/gtest.h" namespace clang { namespace ast_matchers { namespace dynamic { namespace { using ast_matchers::internal::DynTypedMatcher; using ast_matchers::internal::Matcher; TEST(VariantValueTest, Unsigned) { const unsigned kUnsigned = 17; VariantValue Value = kUnsigned; EXPECT_TRUE(Value.isUnsigned()); EXPECT_EQ(kUnsigned, Value.getUnsigned()); EXPECT_TRUE(Value.hasValue()); EXPECT_FALSE(Value.isString()); EXPECT_FALSE(Value.isMatcher()); } TEST(VariantValueTest, String) { const ::std::string kString = "string"; VariantValue Value = kString; EXPECT_TRUE(Value.isString()); EXPECT_EQ(kString, Value.getString()); EXPECT_EQ("String", Value.getTypeAsString()); EXPECT_TRUE(Value.hasValue()); EXPECT_FALSE(Value.isUnsigned()); EXPECT_FALSE(Value.isMatcher()); } TEST(VariantValueTest, DynTypedMatcher) { VariantValue Value = VariantMatcher::SingleMatcher(stmt()); EXPECT_TRUE(Value.hasValue()); EXPECT_FALSE(Value.isUnsigned()); EXPECT_FALSE(Value.isString()); EXPECT_TRUE(Value.isMatcher()); EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<Decl>()); EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<UnaryOperator>()); EXPECT_EQ("Matcher<Stmt>", Value.getTypeAsString()); // Can only convert to compatible matchers. Value = VariantMatcher::SingleMatcher(recordDecl()); EXPECT_TRUE(Value.isMatcher()); EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Decl>()); EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<UnaryOperator>()); EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString()); Value = VariantMatcher::SingleMatcher(ignoringImpCasts(expr())); EXPECT_TRUE(Value.isMatcher()); EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<Decl>()); EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<Stmt>()); EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Expr>()); EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<IntegerLiteral>()); EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<GotoStmt>()); EXPECT_EQ("Matcher<Expr>", Value.getTypeAsString()); } TEST(VariantValueTest, Assignment) { VariantValue Value = std::string("A"); EXPECT_TRUE(Value.isString()); EXPECT_EQ("A", Value.getString()); EXPECT_TRUE(Value.hasValue()); EXPECT_FALSE(Value.isUnsigned()); EXPECT_FALSE(Value.isMatcher()); EXPECT_EQ("String", Value.getTypeAsString()); Value = VariantMatcher::SingleMatcher(recordDecl()); EXPECT_TRUE(Value.hasValue()); EXPECT_FALSE(Value.isUnsigned()); EXPECT_FALSE(Value.isString()); EXPECT_TRUE(Value.isMatcher()); EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Decl>()); EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<UnaryOperator>()); EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString()); Value = 17; EXPECT_TRUE(Value.isUnsigned()); EXPECT_EQ(17U, Value.getUnsigned()); EXPECT_TRUE(Value.hasValue()); EXPECT_FALSE(Value.isMatcher()); EXPECT_FALSE(Value.isString()); Value = VariantValue(); EXPECT_FALSE(Value.hasValue()); EXPECT_FALSE(Value.isUnsigned()); EXPECT_FALSE(Value.isString()); EXPECT_FALSE(Value.isMatcher()); EXPECT_EQ("Nothing", Value.getTypeAsString()); } TEST(VariantValueTest, ImplicitBool) { VariantValue Value; bool IfTrue = false; if (Value) { IfTrue = true; } EXPECT_FALSE(IfTrue); EXPECT_TRUE(!Value); Value = std::string(); IfTrue = false; if (Value) { IfTrue = true; } EXPECT_TRUE(IfTrue); EXPECT_FALSE(!Value); } TEST(VariantValueTest, Matcher) { EXPECT_TRUE(matches("class X {};", VariantValue(VariantMatcher::SingleMatcher( recordDecl(hasName("X")))) .getMatcher() .getTypedMatcher<Decl>())); EXPECT_TRUE( matches("int x;", VariantValue(VariantMatcher::SingleMatcher(varDecl())) .getMatcher() .getTypedMatcher<Decl>())); EXPECT_TRUE( matches("int foo() { return 1 + 1; }", VariantValue(VariantMatcher::SingleMatcher(functionDecl())) .getMatcher() .getTypedMatcher<Decl>())); // Can't get the wrong matcher. EXPECT_FALSE(VariantValue(VariantMatcher::SingleMatcher(varDecl())) .getMatcher() .hasTypedMatcher<Stmt>()); #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST // Trying to get the wrong matcher fails an assertion in Matcher<T>. We don't // do this test when building with MSVC because its debug C runtime prints the // assertion failure message as a wide string, which gtest doesn't understand. EXPECT_DEATH(VariantValue(VariantMatcher::SingleMatcher(varDecl())) .getMatcher() .getTypedMatcher<Stmt>(), "hasTypedMatcher"); #endif EXPECT_FALSE(matches( "int x;", VariantValue(VariantMatcher::SingleMatcher(functionDecl())) .getMatcher() .getTypedMatcher<Decl>())); EXPECT_FALSE( matches("int foo() { return 1 + 1; }", VariantValue(VariantMatcher::SingleMatcher(declRefExpr())) .getMatcher() .getTypedMatcher<Stmt>())); } } // end anonymous namespace } // end namespace dynamic } // end namespace ast_matchers } // end namespace clang