diff options
Diffstat (limited to 'clang/unittests/ASTMatchers/GtestMatchersTest.cpp')
| -rw-r--r-- | clang/unittests/ASTMatchers/GtestMatchersTest.cpp | 418 |
1 files changed, 0 insertions, 418 deletions
diff --git a/clang/unittests/ASTMatchers/GtestMatchersTest.cpp b/clang/unittests/ASTMatchers/GtestMatchersTest.cpp deleted file mode 100644 index 5ee67a9..0000000 --- a/clang/unittests/ASTMatchers/GtestMatchersTest.cpp +++ /dev/null @@ -1,418 +0,0 @@ -//===- unittests/ASTMatchers/GTestMatchersTest.cpp - GTest matcher unit tests // -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#include "ASTMatchersTest.h" -#include "clang/ASTMatchers/ASTMatchers.h" -#include "clang/ASTMatchers/GtestMatchers.h" - -namespace clang { -namespace ast_matchers { - -constexpr llvm::StringLiteral GtestMockDecls = R"cc( - static int testerr; - -#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - switch (0) \ - case 0: \ - default: // NOLINT - -#define GTEST_NONFATAL_FAILURE_(code) testerr = code - -#define GTEST_FATAL_FAILURE_(code) testerr = code - -#define GTEST_ASSERT_(expression, on_failure) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (const int gtest_ar = (expression)) \ - ; \ - else \ - on_failure(gtest_ar) - - // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2. - // Don't use this in your code. -#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure) \ - GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), on_failure) - -#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ - GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) -#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ - GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) - -#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure) \ - GTEST_ASSERT_(pred_format(#v1, v1), on_failure) - -#define EXPECT_PRED_FORMAT1(pred_format, v1) \ - GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) -#define ASSERT_PRED_FORMAT1(pred_format, v1) \ - GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_) - -#define EXPECT_EQ(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2) -#define EXPECT_NE(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) -#define EXPECT_GE(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) -#define EXPECT_GT(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) -#define EXPECT_LE(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) -#define EXPECT_LT(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) - -#define ASSERT_THAT(value, matcher) \ - ASSERT_PRED_FORMAT1( \ - ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) -#define EXPECT_THAT(value, matcher) \ - EXPECT_PRED_FORMAT1( \ - ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) - -#define ASSERT_EQ(val1, val2) \ - ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2) -#define ASSERT_NE(val1, val2) \ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) - -#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call) \ - ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \ - nullptr) \ - .Setter(nullptr, 0, #mock_expr, #call) - -#define ON_CALL(obj, call) \ - GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call) - -#define EXPECT_CALL(obj, call) \ - GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call) - - namespace testing { - namespace internal { - class EqHelper { - public: - // This templatized version is for the general case. - template <typename T1, typename T2> - static int Compare(const char* lhs_expression, const char* rhs_expression, - const T1& lhs, const T2& rhs) { - return 0; - } - }; - template <typename T1, typename T2> - int CmpHelperNE(const char* expr1, const char* expr2, const T1& val1, - const T2& val2) { - return 0; - } - template <typename T1, typename T2> - int CmpHelperGE(const char* expr1, const char* expr2, const T1& val1, - const T2& val2) { - return 0; - } - template <typename T1, typename T2> - int CmpHelperGT(const char* expr1, const char* expr2, const T1& val1, - const T2& val2) { - return 0; - } - template <typename T1, typename T2> - int CmpHelperLE(const char* expr1, const char* expr2, const T1& val1, - const T2& val2) { - return 0; - } - template <typename T1, typename T2> - int CmpHelperLT(const char* expr1, const char* expr2, const T1& val1, - const T2& val2) { - return 0; - } - - // For implementing ASSERT_THAT() and EXPECT_THAT(). The template - // argument M must be a type that can be converted to a matcher. - template <typename M> - class PredicateFormatterFromMatcher { - public: - explicit PredicateFormatterFromMatcher(M m) : matcher_(m) {} - - // This template () operator allows a PredicateFormatterFromMatcher - // object to act as a predicate-formatter suitable for using with - // Google Test's EXPECT_PRED_FORMAT1() macro. - template <typename T> - int operator()(const char* value_text, const T& x) const { - return 0; - } - - private: - const M matcher_; - }; - - template <typename M> - inline PredicateFormatterFromMatcher<M> MakePredicateFormatterFromMatcher( - M matcher) { - return PredicateFormatterFromMatcher<M>(matcher); - } - - bool GetWithoutMatchers() { return false; } - - template <typename F> - class MockSpec { - public: - MockSpec<F>() {} - - bool InternalDefaultActionSetAt( - const char* file, int line, const char* obj, const char* call) { - return false; - } - - bool InternalExpectedAt( - const char* file, int line, const char* obj, const char* call) { - return false; - } - - MockSpec<F> operator()(bool, void*) { - return *this; - } - }; // class MockSpec - - } // namespace internal - - template <typename T> - int StrEq(T val) { - return 0; - } - template <typename T> - int Eq(T val) { - return 0; - } - - } // namespace testing - - class Mock { - public: - Mock() {} - testing::internal::MockSpec<int> gmock_TwoArgsMethod(int, int) { - return testing::internal::MockSpec<int>(); - } - testing::internal::MockSpec<int> gmock_TwoArgsMethod(bool, void*) { - return testing::internal::MockSpec<int>(); - } - }; // class Mock -)cc"; - -static std::string wrapGtest(llvm::StringRef Input) { - return (GtestMockDecls + Input).str(); -} - -TEST(GtestAssertTest, ShouldMatchAssert) { - std::string Input = R"cc( - void Test() { ASSERT_EQ(1010, 4321); } - )cc"; - EXPECT_TRUE(matches(wrapGtest(Input), - gtestAssert(GtestCmp::Eq, integerLiteral(equals(1010)), - integerLiteral(equals(4321))))); -} - -TEST(GtestAssertTest, ShouldNotMatchExpect) { - std::string Input = R"cc( - void Test() { EXPECT_EQ(2, 3); } - )cc"; - EXPECT_TRUE( - notMatches(wrapGtest(Input), gtestAssert(GtestCmp::Eq, expr(), expr()))); -} - -TEST(GtestAssertTest, ShouldMatchNestedAssert) { - std::string Input = R"cc( - #define WRAPPER(a, b) ASSERT_EQ(a, b) - void Test() { WRAPPER(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestAssert(GtestCmp::Eq, expr(), expr()))); -} - -TEST(GtestExpectTest, ShouldMatchExpect) { - std::string Input = R"cc( - void Test() { EXPECT_EQ(1010, 4321); } - )cc"; - EXPECT_TRUE(matches(wrapGtest(Input), - gtestExpect(GtestCmp::Eq, integerLiteral(equals(1010)), - integerLiteral(equals(4321))))); -} - -TEST(GtestExpectTest, ShouldNotMatchAssert) { - std::string Input = R"cc( - void Test() { ASSERT_EQ(2, 3); } - )cc"; - EXPECT_TRUE( - notMatches(wrapGtest(Input), gtestExpect(GtestCmp::Eq, expr(), expr()))); -} - -TEST(GtestExpectTest, NeShouldMatchExpectNe) { - std::string Input = R"cc( - void Test() { EXPECT_NE(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestExpect(GtestCmp::Ne, expr(), expr()))); -} - -TEST(GtestExpectTest, LeShouldMatchExpectLe) { - std::string Input = R"cc( - void Test() { EXPECT_LE(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestExpect(GtestCmp::Le, expr(), expr()))); -} - -TEST(GtestExpectTest, LtShouldMatchExpectLt) { - std::string Input = R"cc( - void Test() { EXPECT_LT(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestExpect(GtestCmp::Lt, expr(), expr()))); -} - -TEST(GtestExpectTest, GeShouldMatchExpectGe) { - std::string Input = R"cc( - void Test() { EXPECT_GE(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestExpect(GtestCmp::Ge, expr(), expr()))); -} - -TEST(GtestExpectTest, GtShouldMatchExpectGt) { - std::string Input = R"cc( - void Test() { EXPECT_GT(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestExpect(GtestCmp::Gt, expr(), expr()))); -} - -TEST(GtestExpectTest, ThatShouldMatchAssertThat) { - std::string Input = R"cc( - using ::testing::Eq; - void Test() { ASSERT_THAT(2, Eq(2)); } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestAssertThat( - expr(), callExpr(callee(functionDecl(hasName("::testing::Eq"))))))); -} - -TEST(GtestExpectTest, ThatShouldMatchExpectThat) { - std::string Input = R"cc( - using ::testing::Eq; - void Test() { EXPECT_THAT(2, Eq(2)); } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestExpectThat( - expr(), callExpr(callee(functionDecl(hasName("::testing::Eq"))))))); -} - -TEST(GtestOnCallTest, CallShouldMatchOnCallWithoutParams1) { - std::string Input = R"cc( - void Test() { - Mock mock; - ON_CALL(mock, TwoArgsMethod); - } - )cc"; - EXPECT_TRUE(matches(wrapGtest(Input), - gtestOnCall(expr(hasType(cxxRecordDecl(hasName("Mock")))), - "TwoArgsMethod", MockArgs::None))); -} - -TEST(GtestOnCallTest, CallShouldMatchOnCallWithoutParams2) { - std::string Input = R"cc( - void Test() { - Mock mock; - ON_CALL(mock, TwoArgsMethod); - } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestOnCall(cxxMemberCallExpr( - callee(functionDecl(hasName("gmock_TwoArgsMethod")))) - .bind("mock_call"), - MockArgs::None))); -} - -TEST(GtestOnCallTest, CallShouldMatchOnCallWithParams1) { - std::string Input = R"cc( - void Test() { - Mock mock; - ON_CALL(mock, TwoArgsMethod(1, 2)); - } - )cc"; - EXPECT_TRUE(matches(wrapGtest(Input), - gtestOnCall(expr(hasType(cxxRecordDecl(hasName("Mock")))), - "TwoArgsMethod", MockArgs::Some))); -} - -TEST(GtestOnCallTest, CallShouldMatchOnCallWithParams2) { - std::string Input = R"cc( - void Test() { - Mock mock; - ON_CALL(mock, TwoArgsMethod(1, 2)); - } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestOnCall(cxxMemberCallExpr( - callee(functionDecl(hasName("gmock_TwoArgsMethod")))) - .bind("mock_call"), - MockArgs::Some))); -} - -TEST(GtestExpectCallTest, CallShouldMatchExpectCallWithoutParams1) { - std::string Input = R"cc( - void Test() { - Mock mock; - EXPECT_CALL(mock, TwoArgsMethod); - } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), - gtestExpectCall(expr(hasType(cxxRecordDecl(hasName("Mock")))), - "TwoArgsMethod", MockArgs::None))); -} - -TEST(GtestExpectCallTest, CallShouldMatchExpectCallWithoutParams2) { - std::string Input = R"cc( - void Test() { - Mock mock; - EXPECT_CALL(mock, TwoArgsMethod); - } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestExpectCall(cxxMemberCallExpr( - callee(functionDecl(hasName("gmock_TwoArgsMethod")))) - .bind("mock_call"), - MockArgs::None))); -} - -TEST(GtestExpectCallTest, CallShouldMatchExpectCallWithParams1) { - std::string Input = R"cc( - void Test() { - Mock mock; - EXPECT_CALL(mock, TwoArgsMethod(1, 2)); - } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), - gtestExpectCall(expr(hasType(cxxRecordDecl(hasName("Mock")))), - "TwoArgsMethod", MockArgs::Some))); -} - -TEST(GtestExpectCallTest, CallShouldMatchExpectCallWithParams2) { - std::string Input = R"cc( - void Test() { - Mock mock; - EXPECT_CALL(mock, TwoArgsMethod(1, 2)); - } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestExpectCall(cxxMemberCallExpr( - callee(functionDecl(hasName("gmock_TwoArgsMethod")))) - .bind("mock_call"), - MockArgs::Some))); -} - -} // end namespace ast_matchers -} // end namespace clang |