From 952eddef9aff85b1e92626e89baaf7a360e2ac85 Mon Sep 17 00:00:00 2001
From: dim <dim@FreeBSD.org>
Date: Sun, 22 Dec 2013 00:07:40 +0000
Subject: Vendor import of clang release_34 branch r197841 (effectively, 3.4
RC3): https://llvm.org/svn/llvm-project/cfe/branches/release_34@197841
---
unittests/ASTMatchers/Dynamic/VariantValueTest.cpp | 144 +++++++++++++++++++++
1 file changed, 144 insertions(+)
create mode 100644 unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
(limited to 'unittests/ASTMatchers/Dynamic/VariantValueTest.cpp')
diff --git a/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp b/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
new file mode 100644
index 0000000..d2b8a58
--- /dev/null
+++ b/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
@@ -0,0 +1,144 @@
+//===- 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_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_FALSE(Value.isUnsigned());
+ EXPECT_FALSE(Value.isMatcher());
+}
+
+TEST(VariantValueTest, DynTypedMatcher) {
+ VariantValue Value = VariantMatcher::SingleMatcher(stmt());
+
+ 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_FALSE(Value.isUnsigned());
+ EXPECT_FALSE(Value.isMatcher());
+ EXPECT_EQ("String", Value.getTypeAsString());
+
+ Value = VariantMatcher::SingleMatcher(recordDecl());
+ 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_FALSE(Value.isMatcher());
+ EXPECT_FALSE(Value.isString());
+
+ Value = VariantValue();
+ EXPECT_FALSE(Value.isUnsigned());
+ EXPECT_FALSE(Value.isString());
+ EXPECT_FALSE(Value.isMatcher());
+ EXPECT_EQ("Nothing", Value.getTypeAsString());
+}
+
+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 && !defined(_MSC_VER)
+ // 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
--
cgit v1.1