diff options
| -rw-r--r-- | googletest/include/gtest/gtest.h | 333 |
1 files changed, 176 insertions, 157 deletions
diff --git a/googletest/include/gtest/gtest.h b/googletest/include/gtest/gtest.h index 62c4c779..a0df29e2 100644 --- a/googletest/include/gtest/gtest.h +++ b/googletest/include/gtest/gtest.h @@ -57,16 +57,16 @@ #include <ostream> #include <vector> +#include "gtest/internal/gtest-internal.h" +#include "gtest/internal/gtest-string.h" #include "gtest/gtest-death-test.h" #include "gtest/gtest-matchers.h" #include "gtest/gtest-message.h" #include "gtest/gtest-param-test.h" #include "gtest/gtest-printers.h" +#include "gtest/gtest_prod.h" #include "gtest/gtest-test-part.h" #include "gtest/gtest-typed-test.h" -#include "gtest/gtest_prod.h" -#include "gtest/internal/gtest-internal.h" -#include "gtest/internal/gtest-string.h" GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ /* class A needs to have dll-interface to be used by clients of class B */) @@ -91,11 +91,12 @@ namespace testing { // Silence C4100 (unreferenced formal parameter) and 4805 // unsafe mix of type 'const int' and type 'const bool' #ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4805) -#pragma warning(disable : 4100) +# pragma warning(push) +# pragma warning(disable:4805) +# pragma warning(disable:4100) #endif + // Declares the flags. // This flag temporary enables the disabled tests. @@ -337,8 +338,7 @@ class GTEST_API_ AssertionResult { const char* failure_message() const { return message(); } // Streams a custom failure message into this object. - template <typename T> - AssertionResult& operator<<(const T& value) { + template <typename T> AssertionResult& operator<<(const T& value) { AppendMessage(Message() << value); return *this; } @@ -536,17 +536,24 @@ class TestProperty { // C'tor. TestProperty does NOT have a default constructor. // Always use this constructor (with parameters) to create a // TestProperty object. - TestProperty(const std::string& a_key, const std::string& a_value) - : key_(a_key), value_(a_value) {} + TestProperty(const std::string& a_key, const std::string& a_value) : + key_(a_key), value_(a_value) { + } // Gets the user supplied key. - const char* key() const { return key_.c_str(); } + const char* key() const { + return key_.c_str(); + } // Gets the user supplied value. - const char* value() const { return value_.c_str(); } + const char* value() const { + return value_.c_str(); + } // Sets a new value, overriding the one supplied in the constructor. - void SetValue(const std::string& new_value) { value_ = new_value; } + void SetValue(const std::string& new_value) { + value_ = new_value; + } private: // The key supplied by the user. @@ -802,11 +809,11 @@ class GTEST_API_ TestInfo { const std::unique_ptr<const ::std::string> value_param_; internal::CodeLocation location_; const internal::TypeId fixture_class_id_; // ID of the test fixture class - bool should_run_; // True iff this test should run - bool is_disabled_; // True iff this test is disabled - bool matches_filter_; // True if this test matches the - // user-specified filter. - bool is_in_another_shard_; // Will be run in another shard. + bool should_run_; // True iff this test should run + bool is_disabled_; // True iff this test is disabled + bool matches_filter_; // True if this test matches the + // user-specified filter. + bool is_in_another_shard_; // Will be run in another shard. internal::TestFactoryBase* const factory_; // The factory that creates // the test object @@ -1039,7 +1046,6 @@ class Environment { // Override this to define how to tear down the environment. virtual void TearDown() {} - private: // If you see an error about overriding the following function or // about it being private, you have mis-spelled SetUp() as Setup(). @@ -1114,7 +1120,8 @@ class TestEventListener { virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0; // Fired after each iteration of tests finishes. - virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration) = 0; + virtual void OnTestIterationEnd(const UnitTest& unit_test, + int iteration) = 0; // Fired after all test activities have ended. virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0; @@ -1271,7 +1278,8 @@ class GTEST_API_ UnitTest { // Returns the TestInfo object for the test that's currently running, // or NULL if no test is running. - const TestInfo* current_test_info() const GTEST_LOCK_EXCLUDED_(mutex_); + const TestInfo* current_test_info() const + GTEST_LOCK_EXCLUDED_(mutex_); // Returns the random seed used at the start of the current test run. int random_seed() const; @@ -1376,7 +1384,8 @@ class GTEST_API_ UnitTest { // eventually call this to report their results. The user code // should use the assertion macros instead of calling this directly. void AddTestPartResult(TestPartResult::Type result_type, - const char* file_name, int line_number, + const char* file_name, + int line_number, const std::string& message, const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_); @@ -1406,7 +1415,8 @@ class GTEST_API_ UnitTest { friend Environment* AddGlobalTestEnvironment(Environment* env); friend internal::UnitTestImpl* internal::GetUnitTestImpl(); friend void internal::ReportFailureInUnknownLocation( - TestPartResult::Type result_type, const std::string& message); + TestPartResult::Type result_type, + const std::string& message); // Creates an empty UnitTest. UnitTest(); @@ -1420,7 +1430,8 @@ class GTEST_API_ UnitTest { GTEST_LOCK_EXCLUDED_(mutex_); // Pops a trace from the per-thread Google Test trace stack. - void PopGTestTrace() GTEST_LOCK_EXCLUDED_(mutex_); + void PopGTestTrace() + GTEST_LOCK_EXCLUDED_(mutex_); // Protects mutable state in *impl_. This is mutable as some const // methods need to lock it too. @@ -1480,11 +1491,13 @@ namespace internal { // when calling EXPECT_* in a tight loop. template <typename T1, typename T2> AssertionResult CmpHelperEQFailure(const char* lhs_expression, - const char* rhs_expression, const T1& lhs, - const T2& rhs) { - return EqFailure(lhs_expression, rhs_expression, + const char* rhs_expression, + const T1& lhs, const T2& rhs) { + return EqFailure(lhs_expression, + rhs_expression, FormatForComparisonFailureMessage(lhs, rhs), - FormatForComparisonFailureMessage(rhs, lhs), false); + FormatForComparisonFailureMessage(rhs, lhs), + false); } // This block of code defines operator==/!= @@ -1497,7 +1510,8 @@ inline bool operator!=(faketype, faketype) { return false; } // The helper function for {ASSERT|EXPECT}_EQ. template <typename T1, typename T2> AssertionResult CmpHelperEQ(const char* lhs_expression, - const char* rhs_expression, const T1& lhs, + const char* rhs_expression, + const T1& lhs, const T2& rhs) { if (lhs == rhs) { return AssertionSuccess(); @@ -1511,7 +1525,8 @@ AssertionResult CmpHelperEQ(const char* lhs_expression, // can be implicitly cast to BiggestInt. GTEST_API_ AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, - BiggestInt lhs, BiggestInt rhs); + BiggestInt lhs, + BiggestInt rhs); // The helper class for {ASSERT|EXPECT}_EQ. The template argument // lhs_is_null_literal is true iff the first argument to ASSERT_EQ() @@ -1523,7 +1538,8 @@ class EqHelper { // This templatized version is for the general case. template <typename T1, typename T2> static AssertionResult Compare(const char* lhs_expression, - const char* rhs_expression, const T1& lhs, + const char* rhs_expression, + const T1& lhs, const T2& rhs) { return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); } @@ -1535,7 +1551,8 @@ class EqHelper { // Even though its body looks the same as the above version, we // cannot merge the two, as it will make anonymous enums unhappy. static AssertionResult Compare(const char* lhs_expression, - const char* rhs_expression, BiggestInt lhs, + const char* rhs_expression, + BiggestInt lhs, BiggestInt rhs) { return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); } @@ -1567,14 +1584,16 @@ class EqHelper<true> { // pointer, e.g. ASSERT_EQ(NULL, a_pointer). template <typename T> static AssertionResult Compare( - const char* lhs_expression, const char* rhs_expression, + const char* lhs_expression, + const char* rhs_expression, // We used to have a second template parameter instead of Secret*. That // template parameter would deduce to 'long', making this a better match // than the first overload even without the first overload's EnableIf. // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to // non-pointer argument" (even a deduced integral argument), so the old // implementation caused warnings in user code. - Secret* /* lhs (NULL) */, T* rhs) { + Secret* /* lhs (NULL) */, + T* rhs) { // We already know that 'lhs' is a null pointer. return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr), rhs); @@ -1605,18 +1624,18 @@ AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2, // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -#define GTEST_IMPL_CMP_HELPER_(op_name, op) \ - template <typename T1, typename T2> \ - AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ - const T1& val1, const T2& val2) { \ - if (val1 op val2) { \ - return AssertionSuccess(); \ - } else { \ - return CmpHelperOpFailure(expr1, expr2, val1, val2, #op); \ - } \ - } \ - GTEST_API_ AssertionResult CmpHelper##op_name( \ - const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2) +#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ +template <typename T1, typename T2>\ +AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ + const T1& val1, const T2& val2) {\ + if (val1 op val2) {\ + return AssertionSuccess();\ + } else {\ + return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\ + }\ +}\ +GTEST_API_ AssertionResult CmpHelper##op_name(\ + const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2) // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. @@ -1638,42 +1657,49 @@ GTEST_IMPL_CMP_HELPER_(GT, >); // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression, const char* s2_expression, - const char* s1, const char* s2); + const char* s1, + const char* s2); // The helper function for {ASSERT|EXPECT}_STRCASEEQ. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression, const char* s2_expression, - const char* s1, const char* s2); + const char* s1, + const char* s2); // The helper function for {ASSERT|EXPECT}_STRNE. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, const char* s2_expression, - const char* s1, const char* s2); + const char* s1, + const char* s2); // The helper function for {ASSERT|EXPECT}_STRCASENE. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression, const char* s2_expression, - const char* s1, const char* s2); + const char* s1, + const char* s2); + // Helper function for *_STREQ on wide strings. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression, const char* s2_expression, - const wchar_t* s1, const wchar_t* s2); + const wchar_t* s1, + const wchar_t* s2); // Helper function for *_STRNE on wide strings. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, const char* s2_expression, - const wchar_t* s1, const wchar_t* s2); + const wchar_t* s1, + const wchar_t* s2); } // namespace internal @@ -1685,40 +1711,32 @@ GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, // // The {needle,haystack}_expr arguments are the stringified // expressions that generated the two real arguments. -GTEST_API_ AssertionResult IsSubstring(const char* needle_expr, - const char* haystack_expr, - const char* needle, - const char* haystack); -GTEST_API_ AssertionResult IsSubstring(const char* needle_expr, - const char* haystack_expr, - const wchar_t* needle, - const wchar_t* haystack); -GTEST_API_ AssertionResult IsNotSubstring(const char* needle_expr, - const char* haystack_expr, - const char* needle, - const char* haystack); -GTEST_API_ AssertionResult IsNotSubstring(const char* needle_expr, - const char* haystack_expr, - const wchar_t* needle, - const wchar_t* haystack); -GTEST_API_ AssertionResult IsSubstring(const char* needle_expr, - const char* haystack_expr, - const ::std::string& needle, - const ::std::string& haystack); -GTEST_API_ AssertionResult IsNotSubstring(const char* needle_expr, - const char* haystack_expr, - const ::std::string& needle, - const ::std::string& haystack); +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const char* needle, const char* haystack); +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const wchar_t* needle, const wchar_t* haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const char* needle, const char* haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const wchar_t* needle, const wchar_t* haystack); +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::string& needle, const ::std::string& haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::string& needle, const ::std::string& haystack); #if GTEST_HAS_STD_WSTRING -GTEST_API_ AssertionResult IsSubstring(const char* needle_expr, - const char* haystack_expr, - const ::std::wstring& needle, - const ::std::wstring& haystack); -GTEST_API_ AssertionResult IsNotSubstring(const char* needle_expr, - const char* haystack_expr, - const ::std::wstring& needle, - const ::std::wstring& haystack); +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::wstring& needle, const ::std::wstring& haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::wstring& needle, const ::std::wstring& haystack); #endif // GTEST_HAS_STD_WSTRING namespace internal { @@ -1733,7 +1751,8 @@ namespace internal { template <typename RawType> AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression, const char* rhs_expression, - RawType lhs_value, RawType rhs_value) { + RawType lhs_value, + RawType rhs_value) { const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value); if (lhs.AlmostEquals(rhs)) { @@ -1748,8 +1767,10 @@ AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression, rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) << rhs_value; - return EqFailure(lhs_expression, rhs_expression, - StringStreamToString(&lhs_ss), StringStreamToString(&rhs_ss), + return EqFailure(lhs_expression, + rhs_expression, + StringStreamToString(&lhs_ss), + StringStreamToString(&rhs_ss), false); } @@ -1759,7 +1780,8 @@ AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression, GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1, const char* expr2, const char* abs_error_expr, - double val1, double val2, + double val1, + double val2, double abs_error); // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. @@ -1767,7 +1789,9 @@ GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1, class GTEST_API_ AssertHelper { public: // Constructor. - AssertHelper(TestPartResult::Type type, const char* file, int line, + AssertHelper(TestPartResult::Type type, + const char* file, + int line, const char* message); ~AssertHelper(); @@ -1781,9 +1805,11 @@ class GTEST_API_ AssertHelper { // re-using stack space even for temporary variables, so every EXPECT_EQ // reserves stack space for another AssertHelper. struct AssertHelperData { - AssertHelperData(TestPartResult::Type t, const char* srcfile, int line_num, + AssertHelperData(TestPartResult::Type t, + const char* srcfile, + int line_num, const char* msg) - : type(t), file(srcfile), line(line_num), message(msg) {} + : type(t), file(srcfile), line(line_num), message(msg) { } TestPartResult::Type const type; const char* const file; @@ -1859,14 +1885,15 @@ class WithParamInterface { private: // Sets parameter value. The caller is responsible for making sure the value // remains alive and unchanged throughout the current test. - static void SetParam(const ParamType* parameter) { parameter_ = parameter; } + static void SetParam(const ParamType* parameter) { + parameter_ = parameter; + } // Static value used for accessing parameter during a test lifetime. static const ParamType* parameter_; // TestClass must be a subclass of WithParamInterface<T> and Test. - template <class TestClass> - friend class internal::ParameterizedTestFactory; + template <class TestClass> friend class internal::ParameterizedTestFactory; }; template <typename T> @@ -1876,7 +1903,8 @@ const T* WithParamInterface<T>::parameter_ = nullptr; // WithParamInterface, and can just inherit from ::testing::TestWithParam. template <typename T> -class TestWithParam : public Test, public WithParamInterface<T> {}; +class TestWithParam : public Test, public WithParamInterface<T> { +}; // Macros for indicating success/failure in test code. @@ -1907,7 +1935,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {}; // Generates a nonfatal failure at the given source file location with // a generic message. -#define ADD_FAILURE_AT(file, line) \ +#define ADD_FAILURE_AT(file, line) \ GTEST_MESSAGE_AT_(file, line, "Failed", \ ::testing::TestPartResult::kNonFatalFailure) @@ -1917,7 +1945,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {}; // Define this macro to 1 to omit the definition of FAIL(), which is a // generic name and clashes with some other libraries. #if !GTEST_DONT_DEFINE_FAIL -#define FAIL() GTEST_FAIL() +# define FAIL() GTEST_FAIL() #endif // Generates a success with a generic message. @@ -1926,7 +1954,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {}; // Define this macro to 1 to omit the definition of SUCCEED(), which // is a generic name and clashes with some other libraries. #if !GTEST_DONT_DEFINE_SUCCEED -#define SUCCEED() GTEST_SUCCEED() +# define SUCCEED() GTEST_SUCCEED() #endif // Macros for testing exceptions. @@ -1954,15 +1982,16 @@ class TestWithParam : public Test, public WithParamInterface<T> {}; // Boolean assertions. Condition can be either a Boolean expression or an // AssertionResult. For more information on how to use AssertionResult with // these macros see comments on that class. -#define EXPECT_TRUE(condition) \ +#define EXPECT_TRUE(condition) \ GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ GTEST_NONFATAL_FAILURE_) -#define EXPECT_FALSE(condition) \ +#define EXPECT_FALSE(condition) \ GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ GTEST_NONFATAL_FAILURE_) #define ASSERT_TRUE(condition) \ - GTEST_TEST_BOOLEAN_(condition, #condition, false, true, GTEST_FATAL_FAILURE_) -#define ASSERT_FALSE(condition) \ + GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ + GTEST_FATAL_FAILURE_) +#define ASSERT_FALSE(condition) \ GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ GTEST_FATAL_FAILURE_) @@ -2012,10 +2041,10 @@ class TestWithParam : public Test, public WithParamInterface<T> {}; // ASSERT_LT(i, array_size); // ASSERT_GT(records.size(), 0) << "There is no record left."; -#define EXPECT_EQ(val1, val2) \ - EXPECT_PRED_FORMAT2( \ - ::testing::internal::EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \ - val1, val2) +#define EXPECT_EQ(val1, val2) \ + EXPECT_PRED_FORMAT2(::testing::internal:: \ + EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \ + val1, val2) #define EXPECT_NE(val1, val2) \ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) #define EXPECT_LE(val1, val2) \ @@ -2027,10 +2056,10 @@ class TestWithParam : public Test, public WithParamInterface<T> {}; #define EXPECT_GT(val1, val2) \ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) -#define GTEST_ASSERT_EQ(val1, val2) \ - ASSERT_PRED_FORMAT2( \ - ::testing::internal::EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \ - val1, val2) +#define GTEST_ASSERT_EQ(val1, val2) \ + ASSERT_PRED_FORMAT2(::testing::internal:: \ + EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \ + val1, val2) #define GTEST_ASSERT_NE(val1, val2) \ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) #define GTEST_ASSERT_LE(val1, val2) \ @@ -2046,27 +2075,27 @@ class TestWithParam : public Test, public WithParamInterface<T> {}; // ASSERT_XY(), which clashes with some users' own code. #if !GTEST_DONT_DEFINE_ASSERT_EQ -#define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2) +# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2) #endif #if !GTEST_DONT_DEFINE_ASSERT_NE -#define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2) +# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2) #endif #if !GTEST_DONT_DEFINE_ASSERT_LE -#define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2) +# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2) #endif #if !GTEST_DONT_DEFINE_ASSERT_LT -#define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2) +# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2) #endif #if !GTEST_DONT_DEFINE_ASSERT_GE -#define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2) +# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2) #endif #if !GTEST_DONT_DEFINE_ASSERT_GT -#define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2) +# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2) #endif // C-string Comparisons. All tests treat NULL and any non-NULL string @@ -2091,7 +2120,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {}; EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) #define EXPECT_STRCASEEQ(s1, s2) \ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2) -#define EXPECT_STRCASENE(s1, s2) \ +#define EXPECT_STRCASENE(s1, s2)\ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) #define ASSERT_STREQ(s1, s2) \ @@ -2100,7 +2129,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {}; ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) #define ASSERT_STRCASEEQ(s1, s2) \ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2) -#define ASSERT_STRCASENE(s1, s2) \ +#define ASSERT_STRCASENE(s1, s2)\ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) // Macros for comparing floating-point numbers. @@ -2117,29 +2146,29 @@ class TestWithParam : public Test, public WithParamInterface<T> {}; // FloatingPoint template class in gtest-internal.h if you are // interested in the implementation details. -#define EXPECT_FLOAT_EQ(val1, val2) \ +#define EXPECT_FLOAT_EQ(val1, val2)\ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ val1, val2) -#define EXPECT_DOUBLE_EQ(val1, val2) \ +#define EXPECT_DOUBLE_EQ(val1, val2)\ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ val1, val2) -#define ASSERT_FLOAT_EQ(val1, val2) \ +#define ASSERT_FLOAT_EQ(val1, val2)\ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ val1, val2) -#define ASSERT_DOUBLE_EQ(val1, val2) \ +#define ASSERT_DOUBLE_EQ(val1, val2)\ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ val1, val2) -#define EXPECT_NEAR(val1, val2, abs_error) \ - EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, val1, val2, \ - abs_error) +#define EXPECT_NEAR(val1, val2, abs_error)\ + EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ + val1, val2, abs_error) -#define ASSERT_NEAR(val1, val2, abs_error) \ - ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, val1, val2, \ - abs_error) +#define ASSERT_NEAR(val1, val2, abs_error)\ + ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ + val1, val2, abs_error) // These predicate format functions work on floating-point values, and // can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g. @@ -2153,6 +2182,7 @@ GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2, GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2, double val1, double val2); + #if GTEST_OS_WINDOWS // Macros that test for HRESULT failure and success, these are only useful @@ -2164,17 +2194,17 @@ GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2, // expected result and the actual result with both a human-readable // string representation of the error, if available, as well as the // hex result code. -#define EXPECT_HRESULT_SUCCEEDED(expr) \ - EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) +# define EXPECT_HRESULT_SUCCEEDED(expr) \ + EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) -#define ASSERT_HRESULT_SUCCEEDED(expr) \ - ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) +# define ASSERT_HRESULT_SUCCEEDED(expr) \ + ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) -#define EXPECT_HRESULT_FAILED(expr) \ - EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) +# define EXPECT_HRESULT_FAILED(expr) \ + EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) -#define ASSERT_HRESULT_FAILED(expr) \ - ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) +# define ASSERT_HRESULT_FAILED(expr) \ + ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) #endif // GTEST_OS_WINDOWS @@ -2189,9 +2219,9 @@ GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2, // ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed"; // #define ASSERT_NO_FATAL_FAILURE(statement) \ - GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_) + GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_) #define EXPECT_NO_FATAL_FAILURE(statement) \ - GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_) + GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_) // Causes a trace (including the given source file path and line number, // and the given message) to be included in every test failure message generated @@ -2259,9 +2289,10 @@ class GTEST_API_ ScopedTrace { // Assuming that each thread maintains its own stack of traces. // Therefore, a SCOPED_TRACE() would (correctly) only affect the // assertions in its own thread. -#define SCOPED_TRACE(message) \ - ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)( \ - __FILE__, __LINE__, (message)) +#define SCOPED_TRACE(message) \ + ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\ + __FILE__, __LINE__, (message)) + // Compile-time assertion for type equality. // StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are @@ -2360,7 +2391,7 @@ bool StaticAssertTypeEq() { // EXPECT_EQ(b_.size(), 1); // } -#define TEST_F(test_fixture, test_name) \ +#define TEST_F(test_fixture, test_name)\ GTEST_TEST_(test_fixture, test_name, test_fixture, \ ::testing::internal::GetTypeId<test_fixture>()) @@ -2369,7 +2400,7 @@ bool StaticAssertTypeEq() { GTEST_API_ std::string TempDir(); #ifdef _MSC_VER -#pragma warning(pop) +# pragma warning(pop) #endif // Dynamically registers a test with the framework. @@ -2464,22 +2495,10 @@ TestInfo* RegisterTest(const char* test_suite_name, const char* test_name, // namespace and has an all-caps name. int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_; -inline int RUN_ALL_TESTS() { return ::testing::UnitTest::GetInstance()->Run(); } - -#ifdef ARDUINO -inline void gtest_setup() { - // Since Arduino doesn't have a command line, fake out the argc/argv arguments - int argc = 1; - const auto arg0 = "PlatformIO"; - char* argv0 = const_cast<char*>(arg0); - char** argv = &argv0; - - testing::InitGoogleTest(&argc, argv); +inline int RUN_ALL_TESTS() { + return ::testing::UnitTest::GetInstance()->Run(); } -inline void gtest_loop() { RUN_ALL_TESTS(); } -#endif - GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 #endif // GTEST_INCLUDE_GTEST_GTEST_H_ |