eson/googletest
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

misc: Revert formatting changes.

Browse Source
This commit is contained in:
Chris 2019-01-03 21:19:56 -06:00
parent fd1c7976ae
commit 202dcabf39
1 changed files with 176 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

213
googletest/include/gtest/gtest.h
View File

@ -57,16 +57,16 @@
#include <ostream> #include <ostream>
#include <vector> #include <vector>
#include "gtest/internal/gtest-internal.h"
#include "gtest/internal/gtest-string.h"
#include "gtest/gtest-death-test.h" #include "gtest/gtest-death-test.h"
#include "gtest/gtest-matchers.h" #include "gtest/gtest-matchers.h"
#include "gtest/gtest-message.h" #include "gtest/gtest-message.h"
#include "gtest/gtest-param-test.h" #include "gtest/gtest-param-test.h"
#include "gtest/gtest-printers.h" #include "gtest/gtest-printers.h"
#include "gtest/gtest_prod.h"
#include "gtest/gtest-test-part.h" #include "gtest/gtest-test-part.h"
#include "gtest/gtest-typed-test.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 \ GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */) /* class A needs to have dll-interface to be used by clients of class B */)
@ -96,6 +96,7 @@ namespace testing {
# pragma warning(disable:4100) # pragma warning(disable:4100)
#endif #endif
// Declares the flags. // Declares the flags.
// This flag temporary enables the disabled tests. // This flag temporary enables the disabled tests.
@ -337,8 +338,7 @@ class GTEST_API_ AssertionResult {
const char* failure_message() const { return message(); } const char* failure_message() const { return message(); }
// Streams a custom failure message into this object. // Streams a custom failure message into this object.
template <typename T> template <typename T> AssertionResult& operator<<(const T& value) {
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value); AppendMessage(Message() << value);
return *this; return *this;
} }
@ -536,17 +536,24 @@ class TestProperty {
// C'tor. TestProperty does NOT have a default constructor. // C'tor. TestProperty does NOT have a default constructor.
// Always use this constructor (with parameters) to create a // Always use this constructor (with parameters) to create a
// TestProperty object. // TestProperty object.
TestProperty(const std::string& a_key, const std::string& a_value) TestProperty(const std::string& a_key, const std::string& a_value) :
: key_(a_key), value_(a_value) {} key_(a_key), value_(a_value) {
}
// Gets the user supplied key. // 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. // 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. // 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: private:
// The key supplied by the user. // The key supplied by the user.
@ -1039,7 +1046,6 @@ class Environment {
// Override this to define how to tear down the environment. // Override this to define how to tear down the environment.
virtual void TearDown() {} virtual void TearDown() {}
private: private:
// If you see an error about overriding the following function or // If you see an error about overriding the following function or
// about it being private, you have mis-spelled SetUp() as Setup(). // 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; virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
// Fired after each iteration of tests finishes. // 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. // Fired after all test activities have ended.
virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0; 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, // Returns the TestInfo object for the test that's currently running,
// or NULL if no test is 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. // Returns the random seed used at the start of the current test run.
int random_seed() const; int random_seed() const;
@ -1376,7 +1384,8 @@ class GTEST_API_ UnitTest {
// eventually call this to report their results. The user code // eventually call this to report their results. The user code
// should use the assertion macros instead of calling this directly. // should use the assertion macros instead of calling this directly.
void AddTestPartResult(TestPartResult::Type result_type, 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& message,
const std::string& os_stack_trace) const std::string& os_stack_trace)
GTEST_LOCK_EXCLUDED_(mutex_); GTEST_LOCK_EXCLUDED_(mutex_);
@ -1406,7 +1415,8 @@ class GTEST_API_ UnitTest {
friend Environment* AddGlobalTestEnvironment(Environment* env); friend Environment* AddGlobalTestEnvironment(Environment* env);
friend internal::UnitTestImpl* internal::GetUnitTestImpl(); friend internal::UnitTestImpl* internal::GetUnitTestImpl();
friend void internal::ReportFailureInUnknownLocation( friend void internal::ReportFailureInUnknownLocation(
TestPartResult::Type result_type, const std::string& message); TestPartResult::Type result_type,
const std::string& message);
// Creates an empty UnitTest. // Creates an empty UnitTest.
UnitTest(); UnitTest();
@ -1420,7 +1430,8 @@ class GTEST_API_ UnitTest {
GTEST_LOCK_EXCLUDED_(mutex_); GTEST_LOCK_EXCLUDED_(mutex_);
// Pops a trace from the per-thread Google Test trace stack. // 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 // Protects mutable state in *impl_. This is mutable as some const
// methods need to lock it too. // methods need to lock it too.
@ -1480,11 +1491,13 @@ namespace internal {
// when calling EXPECT_* in a tight loop. // when calling EXPECT_* in a tight loop.
template <typename T1, typename T2> template <typename T1, typename T2>
AssertionResult CmpHelperEQFailure(const char* lhs_expression, AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression, const T1& lhs, const char* rhs_expression,
const T2& rhs) { const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression, rhs_expression, return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs), FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs), false); FormatForComparisonFailureMessage(rhs, lhs),
false);
} }
// This block of code defines operator==/!= // This block of code defines operator==/!=
@ -1497,7 +1510,8 @@ inline bool operator!=(faketype, faketype) { return false; }
// The helper function for {ASSERT|EXPECT}_EQ. // The helper function for {ASSERT|EXPECT}_EQ.
template <typename T1, typename T2> template <typename T1, typename T2>
AssertionResult CmpHelperEQ(const char* lhs_expression, AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression, const T1& lhs, const char* rhs_expression,
const T1& lhs,
const T2& rhs) { const T2& rhs) {
if (lhs == rhs) { if (lhs == rhs) {
return AssertionSuccess(); return AssertionSuccess();
@ -1511,7 +1525,8 @@ AssertionResult CmpHelperEQ(const char* lhs_expression,
// can be implicitly cast to BiggestInt. // can be implicitly cast to BiggestInt.
GTEST_API_ AssertionResult CmpHelperEQ(const char* lhs_expression, GTEST_API_ AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression, const char* rhs_expression,
BiggestInt lhs, BiggestInt rhs); BiggestInt lhs,
BiggestInt rhs);
// The helper class for {ASSERT|EXPECT}_EQ. The template argument // The helper class for {ASSERT|EXPECT}_EQ. The template argument
// lhs_is_null_literal is true iff the first argument to ASSERT_EQ() // 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. // This templatized version is for the general case.
template <typename T1, typename T2> template <typename T1, typename T2>
static AssertionResult Compare(const char* lhs_expression, static AssertionResult Compare(const char* lhs_expression,
const char* rhs_expression, const T1& lhs, const char* rhs_expression,
const T1& lhs,
const T2& rhs) { const T2& rhs) {
return CmpHelperEQ(lhs_expression, rhs_expression, lhs, 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 // Even though its body looks the same as the above version, we
// cannot merge the two, as it will make anonymous enums unhappy. // cannot merge the two, as it will make anonymous enums unhappy.
static AssertionResult Compare(const char* lhs_expression, static AssertionResult Compare(const char* lhs_expression,
const char* rhs_expression, BiggestInt lhs, const char* rhs_expression,
BiggestInt lhs,
BiggestInt rhs) { BiggestInt rhs) {
return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
} }
@ -1567,14 +1584,16 @@ class EqHelper<true> {
// pointer, e.g. ASSERT_EQ(NULL, a_pointer). // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
template <typename T> template <typename T>
static AssertionResult Compare( 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 // We used to have a second template parameter instead of Secret*. That
// template parameter would deduce to 'long', making this a better match // template parameter would deduce to 'long', making this a better match
// than the first overload even without the first overload's EnableIf. // than the first overload even without the first overload's EnableIf.
// Unfortunately, gcc with -Wconversion-null warns when "passing NULL to // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
// non-pointer argument" (even a deduced integral argument), so the old // non-pointer argument" (even a deduced integral argument), so the old
// implementation caused warnings in user code. // 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. // We already know that 'lhs' is a null pointer.
return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr), return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr),
rhs); rhs);
@ -1638,42 +1657,49 @@ GTEST_IMPL_CMP_HELPER_(GT, >);
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression, GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
const char* s2_expression, const char* s2_expression,
const char* s1, const char* s2); const char* s1,
const char* s2);
// The helper function for {ASSERT|EXPECT}_STRCASEEQ. // The helper function for {ASSERT|EXPECT}_STRCASEEQ.
// //
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression, GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression,
const char* s2_expression, const char* s2_expression,
const char* s1, const char* s2); const char* s1,
const char* s2);
// The helper function for {ASSERT|EXPECT}_STRNE. // The helper function for {ASSERT|EXPECT}_STRNE.
// //
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
const char* s2_expression, const char* s2_expression,
const char* s1, const char* s2); const char* s1,
const char* s2);
// The helper function for {ASSERT|EXPECT}_STRCASENE. // The helper function for {ASSERT|EXPECT}_STRCASENE.
// //
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression, GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
const char* s2_expression, const char* s2_expression,
const char* s1, const char* s2); const char* s1,
const char* s2);
// Helper function for *_STREQ on wide strings. // Helper function for *_STREQ on wide strings.
// //
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression, GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
const char* s2_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. // Helper function for *_STRNE on wide strings.
// //
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
const char* s2_expression, const char* s2_expression,
const wchar_t* s1, const wchar_t* s2); const wchar_t* s1,
const wchar_t* s2);
} // namespace internal } // namespace internal
@ -1685,40 +1711,32 @@ GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
// //
// The {needle,haystack}_expr arguments are the stringified // The {needle,haystack}_expr arguments are the stringified
// expressions that generated the two real arguments. // expressions that generated the two real arguments.
GTEST_API_ AssertionResult IsSubstring(const char* needle_expr, GTEST_API_ AssertionResult IsSubstring(
const char* haystack_expr, const char* needle_expr, const char* haystack_expr,
const char* needle, const char* needle, const char* haystack);
const char* haystack); GTEST_API_ AssertionResult IsSubstring(
GTEST_API_ AssertionResult IsSubstring(const char* needle_expr, const char* needle_expr, const char* haystack_expr,
const char* haystack_expr, const wchar_t* needle, const wchar_t* haystack);
const wchar_t* needle, GTEST_API_ AssertionResult IsNotSubstring(
const wchar_t* haystack); const char* needle_expr, const char* haystack_expr,
GTEST_API_ AssertionResult IsNotSubstring(const char* needle_expr, const char* needle, const char* haystack);
const char* haystack_expr, GTEST_API_ AssertionResult IsNotSubstring(
const char* needle, const char* needle_expr, const char* haystack_expr,
const char* haystack); const wchar_t* needle, const wchar_t* haystack);
GTEST_API_ AssertionResult IsNotSubstring(const char* needle_expr, GTEST_API_ AssertionResult IsSubstring(
const char* haystack_expr, const char* needle_expr, const char* haystack_expr,
const wchar_t* needle, const ::std::string& needle, const ::std::string& haystack);
const wchar_t* haystack); GTEST_API_ AssertionResult IsNotSubstring(
GTEST_API_ AssertionResult IsSubstring(const char* needle_expr, const char* needle_expr, const char* haystack_expr,
const char* haystack_expr, const ::std::string& needle, const ::std::string& haystack);
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 #if GTEST_HAS_STD_WSTRING
GTEST_API_ AssertionResult IsSubstring(const char* needle_expr, GTEST_API_ AssertionResult IsSubstring(
const char* haystack_expr, const char* needle_expr, const char* haystack_expr,
const ::std::wstring& needle, const ::std::wstring& needle, const ::std::wstring& haystack);
const ::std::wstring& haystack); GTEST_API_ AssertionResult IsNotSubstring(
GTEST_API_ AssertionResult IsNotSubstring(const char* needle_expr, const char* needle_expr, const char* haystack_expr,
const char* haystack_expr, const ::std::wstring& needle, const ::std::wstring& haystack);
const ::std::wstring& needle,
const ::std::wstring& haystack);
#endif // GTEST_HAS_STD_WSTRING #endif // GTEST_HAS_STD_WSTRING
namespace internal { namespace internal {
@ -1733,7 +1751,8 @@ namespace internal {
template <typename RawType> template <typename RawType>
AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression, AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
const char* rhs_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); const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);
if (lhs.AlmostEquals(rhs)) { 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_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
<< rhs_value; << rhs_value;
return EqFailure(lhs_expression, rhs_expression, return EqFailure(lhs_expression,
StringStreamToString(&lhs_ss), StringStreamToString(&rhs_ss), rhs_expression,
StringStreamToString(&lhs_ss),
StringStreamToString(&rhs_ss),
false); false);
} }
@ -1759,7 +1780,8 @@ AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1, GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
const char* expr2, const char* expr2,
const char* abs_error_expr, const char* abs_error_expr,
double val1, double val2, double val1,
double val2,
double abs_error); double abs_error);
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
@ -1767,7 +1789,9 @@ GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
class GTEST_API_ AssertHelper { class GTEST_API_ AssertHelper {
public: public:
// Constructor. // Constructor.
AssertHelper(TestPartResult::Type type, const char* file, int line, AssertHelper(TestPartResult::Type type,
const char* file,
int line,
const char* message); const char* message);
~AssertHelper(); ~AssertHelper();
@ -1781,7 +1805,9 @@ class GTEST_API_ AssertHelper {
// re-using stack space even for temporary variables, so every EXPECT_EQ // re-using stack space even for temporary variables, so every EXPECT_EQ
// reserves stack space for another AssertHelper. // reserves stack space for another AssertHelper.
struct AssertHelperData { 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) const char* msg)
: type(t), file(srcfile), line(line_num), message(msg) { } : type(t), file(srcfile), line(line_num), message(msg) { }
@ -1859,14 +1885,15 @@ class WithParamInterface {
private: private:
// Sets parameter value. The caller is responsible for making sure the value // Sets parameter value. The caller is responsible for making sure the value
// remains alive and unchanged throughout the current test. // 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 value used for accessing parameter during a test lifetime.
static const ParamType* parameter_; static const ParamType* parameter_;
// TestClass must be a subclass of WithParamInterface<T> and Test. // TestClass must be a subclass of WithParamInterface<T> and Test.
template <class TestClass> template <class TestClass> friend class internal::ParameterizedTestFactory;
friend class internal::ParameterizedTestFactory;
}; };
template <typename T> template <typename T>
@ -1876,7 +1903,8 @@ const T* WithParamInterface<T>::parameter_ = nullptr;
// WithParamInterface, and can just inherit from ::testing::TestWithParam. // WithParamInterface, and can just inherit from ::testing::TestWithParam.
template <typename T> 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. // Macros for indicating success/failure in test code.
@ -1961,7 +1989,8 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
GTEST_NONFATAL_FAILURE_) GTEST_NONFATAL_FAILURE_)
#define ASSERT_TRUE(condition) \ #define ASSERT_TRUE(condition) \
GTEST_TEST_BOOLEAN_(condition, #condition, false, true, GTEST_FATAL_FAILURE_) GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
GTEST_FATAL_FAILURE_)
#define ASSERT_FALSE(condition) \ #define ASSERT_FALSE(condition) \
GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
GTEST_FATAL_FAILURE_) GTEST_FATAL_FAILURE_)
@ -2013,8 +2042,8 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
// ASSERT_GT(records.size(), 0) << "There is no record left."; // ASSERT_GT(records.size(), 0) << "There is no record left.";
#define EXPECT_EQ(val1, val2) \ #define EXPECT_EQ(val1, val2) \
EXPECT_PRED_FORMAT2( \ EXPECT_PRED_FORMAT2(::testing::internal:: \
::testing::internal::EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \ EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
val1, val2) val1, val2)
#define EXPECT_NE(val1, val2) \ #define EXPECT_NE(val1, val2) \
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
@ -2028,8 +2057,8 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
#define GTEST_ASSERT_EQ(val1, val2) \ #define GTEST_ASSERT_EQ(val1, val2) \
ASSERT_PRED_FORMAT2( \ ASSERT_PRED_FORMAT2(::testing::internal:: \
::testing::internal::EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \ EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
val1, val2) val1, val2)
#define GTEST_ASSERT_NE(val1, val2) \ #define GTEST_ASSERT_NE(val1, val2) \
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
@ -2134,12 +2163,12 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
val1, val2) val1, val2)
#define EXPECT_NEAR(val1, val2, abs_error)\ #define EXPECT_NEAR(val1, val2, abs_error)\
EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, val1, val2, \ EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
abs_error) val1, val2, abs_error)
#define ASSERT_NEAR(val1, val2, abs_error)\ #define ASSERT_NEAR(val1, val2, abs_error)\
ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, val1, val2, \ ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
abs_error) val1, val2, abs_error)
// These predicate format functions work on floating-point values, and // These predicate format functions work on floating-point values, and
// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g. // 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, GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
double val1, double val2); double val1, double val2);
#if GTEST_OS_WINDOWS #if GTEST_OS_WINDOWS
// Macros that test for HRESULT failure and success, these are only useful // Macros that test for HRESULT failure and success, these are only useful
@ -2263,6 +2293,7 @@ class GTEST_API_ ScopedTrace {
::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\ ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
__FILE__, __LINE__, (message)) __FILE__, __LINE__, (message))
// Compile-time assertion for type equality. // Compile-time assertion for type equality.
// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are // StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
// the same type. The value it returns is not interesting. // the same type. The value it returns is not interesting.
@ -2464,22 +2495,10 @@ TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
// namespace and has an all-caps name. // namespace and has an all-caps name.
int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_; int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
inline int RUN_ALL_TESTS() { return ::testing::UnitTest::GetInstance()->Run(); } 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 void gtest_loop() { RUN_ALL_TESTS(); }
#endif
GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
#endif // GTEST_INCLUDE_GTEST_GTEST_H_ #endif // GTEST_INCLUDE_GTEST_GTEST_H_