#include <cstddef>
#include <limits>
#include <memory>
#include <ostream>
#include <type_traits>
#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_pred_impl.h"

Classes
class	testing::Test

class	testing::TestProperty

class	testing::TestResult

class	testing::TestInfo

class	testing::TestSuite

class	testing::Environment

class	testing::TestEventListener

class	testing::EmptyTestEventListener

class	testing::TestEventListeners

class	testing::UnitTest

struct	testing::internal::faketype

class	testing::internal::EqHelper

class	testing::internal::AssertHelper

class	testing::WithParamInterface< T >

class	testing::TestWithParam< T >

class	testing::ScopedTrace

Namespaces
namespace	testing

namespace	testing::internal

Macros
#define	GTEST_IMPL_CMP_HELPER_(op_name, op)

#define	GTEST_SKIP() GTEST_SKIP_("")

#define	ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")

#define	ADD_FAILURE_AT(file, line)

#define	GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")

#define	GTEST_FAIL_AT(file, line)

#define	FAIL() GTEST_FAIL()

#define	GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")

#define	SUCCEED() GTEST_SUCCEED()

#define	EXPECT_THROW(statement, expected_exception) GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)

#define	EXPECT_NO_THROW(statement) GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)

#define	EXPECT_ANY_THROW(statement) GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)

#define	ASSERT_THROW(statement, expected_exception) GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)

#define	ASSERT_NO_THROW(statement) GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)

#define	ASSERT_ANY_THROW(statement) GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)

#define	GTEST_EXPECT_TRUE(condition)

#define	GTEST_EXPECT_FALSE(condition)

#define	GTEST_ASSERT_TRUE(condition)

#define	GTEST_ASSERT_FALSE(condition)

#define	EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition)

#define	EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition)

#define	ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition)

#define	ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition)

#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_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	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	GTEST_ASSERT_EQ(val1, val2) ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)

#define	GTEST_ASSERT_NE(val1, val2) ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)

#define	GTEST_ASSERT_LE(val1, val2) ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)

#define	GTEST_ASSERT_LT(val1, val2) ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)

#define	GTEST_ASSERT_GE(val1, val2) ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)

#define	GTEST_ASSERT_GT(val1, val2) ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

#define	ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)

#define	ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)

#define	ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)

#define	ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)

#define	ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)

#define	ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)

#define	EXPECT_STREQ(s1, s2) EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)

#define	EXPECT_STRNE(s1, s2) 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) EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

#define	ASSERT_STREQ(s1, s2) ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)

#define	ASSERT_STRNE(s1, s2) 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) ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

#define	EXPECT_FLOAT_EQ(val1, val2)

#define	EXPECT_DOUBLE_EQ(val1, val2)

#define	ASSERT_FLOAT_EQ(val1, val2)

#define	ASSERT_DOUBLE_EQ(val1, val2)

#define	EXPECT_NEAR(val1, val2, abs_error)

#define	ASSERT_NEAR(val1, val2, abs_error)

#define	ASSERT_NO_FATAL_FAILURE(statement) GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)

#define	EXPECT_NO_FATAL_FAILURE(statement) GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)

#define	SCOPED_TRACE(message)

#define	GTEST_TEST(test_suite_name, test_name)

#define	TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name)

#define	TEST_F(test_fixture, test_name)

Typedefs
typedef internal::TimeInMillis	testing::TimeInMillis

Functions
	GTEST_DISABLE_MSC_WARNINGS_PUSH_ (4251) namespace testing

Environment *	testing::AddGlobalTestEnvironment (Environment *env)

GTEST_API_ void	testing::InitGoogleTest (int argc, char *argv)

GTEST_API_ void	testing::InitGoogleTest (int argc, wchar_t *argv)

GTEST_API_ void	testing::InitGoogleTest ()

template<typename T1 , typename T2 >
AssertionResult	testing::internal::CmpHelperEQFailure (const char lhs_expression, const char rhs_expression, const T1 &lhs, const T2 &rhs)

bool	testing::internal::operator== (faketype, faketype)

bool	testing::internal::operator!= (faketype, faketype)

template<typename T1 , typename T2 >
AssertionResult	testing::internal::CmpHelperEQ (const char lhs_expression, const char rhs_expression, const T1 &lhs, const T2 &rhs)

template<typename T1 , typename T2 >
AssertionResult	testing::internal::CmpHelperOpFailure (const char expr1, const char expr2, const T1 &val1, const T2 &val2, const char *op)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTREQ (const char s1_expression, const char s2_expression, const char s1, const char s2)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRCASEEQ (const char s1_expression, const char s2_expression, const char s1, const char s2)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRNE (const char s1_expression, const char s2_expression, const char s1, const char s2)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRCASENE (const char s1_expression, const char s2_expression, const char s1, const char s2)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTREQ (const char s1_expression, const char s2_expression, const wchar_t s1, const wchar_t s2)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRNE (const char s1_expression, const char s2_expression, const wchar_t s1, const wchar_t s2)

GTEST_API_ AssertionResult	testing::IsSubstring (const char needle_expr, const char haystack_expr, const char needle, const char haystack)

GTEST_API_ AssertionResult	testing::IsSubstring (const char needle_expr, const char haystack_expr, const wchar_t needle, const wchar_t haystack)

GTEST_API_ AssertionResult	testing::IsNotSubstring (const char needle_expr, const char haystack_expr, const char needle, const char haystack)

GTEST_API_ AssertionResult	testing::IsNotSubstring (const char needle_expr, const char haystack_expr, const wchar_t needle, const wchar_t haystack)

GTEST_API_ AssertionResult	testing::IsSubstring (const char needle_expr, const char haystack_expr, const ::std::string &needle, const ::std::string &haystack)

GTEST_API_ AssertionResult	testing::IsNotSubstring (const char needle_expr, const char haystack_expr, const ::std::string &needle, const ::std::string &haystack)

template<typename RawType >
AssertionResult	testing::internal::CmpHelperFloatingPointEQ (const char lhs_expression, const char rhs_expression, RawType lhs_value, RawType rhs_value)

GTEST_API_ AssertionResult	testing::internal::DoubleNearPredFormat (const char expr1, const char expr2, const char *abs_error_expr, double val1, double val2, double abs_error)

GTEST_API_ AssertionResult	testing::FloatLE (const char expr1, const char expr2, float val1, float val2)

GTEST_API_ AssertionResult	testing::DoubleLE (const char expr1, const char expr2, double val1, double val2)

template<typename T1 , typename T2 >
constexpr bool	testing::StaticAssertTypeEq () noexcept

GTEST_API_ std::string	testing::TempDir ()

template<int &... ExplicitParameterBarrier, typename Factory >
TestInfo *	testing::RegisterTest (const char test_suite_name, const char test_name, const char type_param, const char value_param, const char *file, int line, Factory factory)

int	RUN_ALL_TESTS () GTEST_MUST_USE_RESULT_

Variables
class GTEST_API_ testing::ScopedTrace	testing::GTEST_ATTRIBUTE_UNUSED_

Macro Definition Documentation

◆ ADD_FAILURE

#define ADD_FAILURE ( ) GTEST_NONFATAL_FAILURE_("Failed")

Definition at line 1909 of file gtest.h.

◆ ADD_FAILURE_AT

#define ADD_FAILURE_AT	(	file,
		line
	)

Value:

GTEST_MESSAGE_AT_(file, line, "Failed", \

::testing::TestPartResult::kNonFatalFailure)

GTEST_MESSAGE_AT_

#define GTEST_MESSAGE_AT_(file, line, message, result_type)

Definition: gtest-internal.h:1338

file

Definition: include_gunit.h:36

Definition at line 1913 of file gtest.h.

◆ ASSERT_ANY_THROW

#define ASSERT_ANY_THROW ( statement ) GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)

Definition at line 1959 of file gtest.h.

◆ ASSERT_DOUBLE_EQ

#define ASSERT_DOUBLE_EQ	(	val1,
		val2
	)

Value:

ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \

val1, val2)

ASSERT_PRED_FORMAT2

#define ASSERT_PRED_FORMAT2(pred_format, v1, v2)

Definition: gtest_pred_impl.h:167

Definition at line 2156 of file gtest.h.

◆ ASSERT_EQ

#define ASSERT_EQ	(	val1,
		val2
	)	GTEST_ASSERT_EQ(val1, val2)

Definition at line 2073 of file gtest.h.

◆ ASSERT_FALSE

#define ASSERT_FALSE ( condition ) GTEST_ASSERT_FALSE(condition)

Definition at line 1994 of file gtest.h.

◆ ASSERT_FLOAT_EQ

#define ASSERT_FLOAT_EQ	(	val1,
		val2
	)

Value:

ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \

val1, val2)

Definition at line 2152 of file gtest.h.

◆ ASSERT_GE

#define ASSERT_GE	(	val1,
		val2
	)	GTEST_ASSERT_GE(val1, val2)

Definition at line 2089 of file gtest.h.

◆ ASSERT_GT

#define ASSERT_GT	(	val1,
		val2
	)	GTEST_ASSERT_GT(val1, val2)

Definition at line 2093 of file gtest.h.

◆ ASSERT_LE

#define ASSERT_LE	(	val1,
		val2
	)	GTEST_ASSERT_LE(val1, val2)

Definition at line 2081 of file gtest.h.

◆ ASSERT_LT

#define ASSERT_LT	(	val1,
		val2
	)	GTEST_ASSERT_LT(val1, val2)

Definition at line 2085 of file gtest.h.

◆ ASSERT_NE

#define ASSERT_NE	(	val1,
		val2
	)	GTEST_ASSERT_NE(val1, val2)

Definition at line 2077 of file gtest.h.

◆ ASSERT_NEAR

#define ASSERT_NEAR	(	val1,
		val2,
		abs_error
	)

Value:

ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \

val1, val2, abs_error)

ASSERT_PRED_FORMAT3

#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3)

Definition: gtest_pred_impl.h:222

testing::internal::DoubleNearPredFormat

GTEST_API_ AssertionResult DoubleNearPredFormat(const char *expr1, const char *expr2, const char *abs_error_expr, double val1, double val2, double abs_error)

Definition: gtest.cc:1563

Definition at line 2164 of file gtest.h.

◆ ASSERT_NO_FATAL_FAILURE

#define ASSERT_NO_FATAL_FAILURE ( statement ) GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)

Definition at line 2216 of file gtest.h.

◆ ASSERT_NO_THROW

#define ASSERT_NO_THROW ( statement ) GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)

Definition at line 1957 of file gtest.h.

◆ ASSERT_STRCASEEQ

#define ASSERT_STRCASEEQ	(	s1,
		s2
	)	ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)

Definition at line 2125 of file gtest.h.

◆ ASSERT_STRCASENE

#define ASSERT_STRCASENE	(	s1,
		s2
	)	ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

Definition at line 2127 of file gtest.h.

◆ ASSERT_STREQ

#define ASSERT_STREQ	(	s1,
		s2
	)	ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)

Definition at line 2121 of file gtest.h.

◆ ASSERT_STRNE

#define ASSERT_STRNE	(	s1,
		s2
	)	ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)

Definition at line 2123 of file gtest.h.

◆ ASSERT_THROW

#define ASSERT_THROW	(	statement,
		expected_exception
	)	GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)

Definition at line 1955 of file gtest.h.

◆ ASSERT_TRUE

#define ASSERT_TRUE ( condition ) GTEST_ASSERT_TRUE(condition)

Definition at line 1990 of file gtest.h.

◆ EXPECT_ANY_THROW

#define EXPECT_ANY_THROW ( statement ) GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)

Definition at line 1953 of file gtest.h.

◆ EXPECT_DOUBLE_EQ

#define EXPECT_DOUBLE_EQ	(	val1,
		val2
	)

Value:

EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \

val1, val2)

EXPECT_PRED_FORMAT2

#define EXPECT_PRED_FORMAT2(pred_format, v1, v2)

Definition: gtest_pred_impl.h:163

Definition at line 2148 of file gtest.h.

◆ EXPECT_EQ

#define EXPECT_EQ	(	val1,
		val2
	)	EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)

Definition at line 2043 of file gtest.h.

◆ EXPECT_FALSE

#define EXPECT_FALSE ( condition ) GTEST_EXPECT_FALSE(condition)

Definition at line 1986 of file gtest.h.

◆ EXPECT_FLOAT_EQ

#define EXPECT_FLOAT_EQ	(	val1,
		val2
	)

Value:

EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \

val1, val2)

Definition at line 2144 of file gtest.h.

◆ EXPECT_GE

#define EXPECT_GE	(	val1,
		val2
	)	EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)

Definition at line 2051 of file gtest.h.

◆ EXPECT_GT

#define EXPECT_GT	(	val1,
		val2
	)	EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

Definition at line 2053 of file gtest.h.

◆ EXPECT_LE

#define EXPECT_LE	(	val1,
		val2
	)	EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)

Definition at line 2047 of file gtest.h.

◆ EXPECT_LT

#define EXPECT_LT	(	val1,
		val2
	)	EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)

Definition at line 2049 of file gtest.h.

◆ EXPECT_NE

#define EXPECT_NE	(	val1,
		val2
	)	EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)

Definition at line 2045 of file gtest.h.

◆ EXPECT_NEAR

#define EXPECT_NEAR	(	val1,
		val2,
		abs_error
	)

Value:

EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \

val1, val2, abs_error)

EXPECT_PRED_FORMAT3

#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3)

Definition: gtest_pred_impl.h:218

Definition at line 2160 of file gtest.h.

◆ EXPECT_NO_FATAL_FAILURE

#define EXPECT_NO_FATAL_FAILURE ( statement ) GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)

Definition at line 2218 of file gtest.h.

◆ EXPECT_NO_THROW

#define EXPECT_NO_THROW ( statement ) GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)

Definition at line 1951 of file gtest.h.

◆ EXPECT_STRCASEEQ

#define EXPECT_STRCASEEQ	(	s1,
		s2
	)	EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)

Definition at line 2116 of file gtest.h.

◆ EXPECT_STRCASENE

#define EXPECT_STRCASENE	(	s1,
		s2
	)	EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

Definition at line 2118 of file gtest.h.

◆ EXPECT_STREQ

#define EXPECT_STREQ	(	s1,
		s2
	)	EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)

Definition at line 2112 of file gtest.h.

◆ EXPECT_STRNE

#define EXPECT_STRNE	(	s1,
		s2
	)	EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)

Definition at line 2114 of file gtest.h.

◆ EXPECT_THROW

#define EXPECT_THROW	(	statement,
		expected_exception
	)	GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)

Definition at line 1949 of file gtest.h.

◆ EXPECT_TRUE

#define EXPECT_TRUE ( condition ) GTEST_EXPECT_TRUE(condition)

Definition at line 1982 of file gtest.h.

◆ FAIL

#define FAIL ( ) GTEST_FAIL()

Definition at line 1928 of file gtest.h.

◆ GTEST_ASSERT_EQ

#define GTEST_ASSERT_EQ	(	val1,
		val2
	)	ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)

Definition at line 2056 of file gtest.h.

◆ GTEST_ASSERT_FALSE

#define GTEST_ASSERT_FALSE ( condition )

Value:

GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \

GTEST_FATAL_FAILURE_)

GTEST_FATAL_FAILURE_

#define GTEST_FATAL_FAILURE_(message)

Definition: gtest-internal.h:1345

GTEST_TEST_BOOLEAN_

#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail)

Definition: gtest-internal.h:1499

Definition at line 1974 of file gtest.h.

◆ GTEST_ASSERT_GE

#define GTEST_ASSERT_GE	(	val1,
		val2
	)	ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)

Definition at line 2064 of file gtest.h.

◆ GTEST_ASSERT_GT

#define GTEST_ASSERT_GT	(	val1,
		val2
	)	ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

Definition at line 2066 of file gtest.h.

◆ GTEST_ASSERT_LE

#define GTEST_ASSERT_LE	(	val1,
		val2
	)	ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)

Definition at line 2060 of file gtest.h.

◆ GTEST_ASSERT_LT

#define GTEST_ASSERT_LT	(	val1,
		val2
	)	ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)

Definition at line 2062 of file gtest.h.

◆ GTEST_ASSERT_NE

#define GTEST_ASSERT_NE	(	val1,
		val2
	)	ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)

Definition at line 2058 of file gtest.h.

◆ GTEST_ASSERT_TRUE

#define GTEST_ASSERT_TRUE ( condition )

Value:

GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \

GTEST_FATAL_FAILURE_)

Definition at line 1971 of file gtest.h.

◆ GTEST_EXPECT_FALSE

#define GTEST_EXPECT_FALSE ( condition )

Value:

GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \

GTEST_NONFATAL_FAILURE_)

GTEST_NONFATAL_FAILURE_

#define GTEST_NONFATAL_FAILURE_(message)

Definition: gtest-internal.h:1348

Definition at line 1968 of file gtest.h.

◆ GTEST_EXPECT_TRUE

#define GTEST_EXPECT_TRUE ( condition )

Value:

GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \

GTEST_NONFATAL_FAILURE_)

Definition at line 1965 of file gtest.h.

◆ GTEST_FAIL

#define GTEST_FAIL ( ) GTEST_FATAL_FAILURE_("Failed")

Definition at line 1918 of file gtest.h.

◆ GTEST_FAIL_AT

#define GTEST_FAIL_AT	(	file,
		line
	)

Value:

GTEST_MESSAGE_AT_(file, line, "Failed", \

::testing::TestPartResult::kFatalFailure)

Definition at line 1921 of file gtest.h.

◆ GTEST_IMPL_CMP_HELPER_

#define GTEST_IMPL_CMP_HELPER_	(	op_name,
		op
	)

Value:

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);\
  }\
}

Definition at line 1610 of file gtest.h.

◆ GTEST_SKIP

#define GTEST_SKIP ( ) GTEST_SKIP_("")

Definition at line 1889 of file gtest.h.

◆ GTEST_SUCCEED

#define GTEST_SUCCEED ( ) GTEST_SUCCESS_("Succeeded")

Definition at line 1932 of file gtest.h.

◆ GTEST_TEST

#define GTEST_TEST	(	test_suite_name,
		test_name
	)

Value:

GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \

::testing::internal::GetTestTypeId())

GTEST_TEST_

#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)

Definition: gtest-internal.h:1527

testing::internal::GetTestTypeId

GTEST_API_ TypeId GetTestTypeId()

Definition: gtest.cc:847

testing::Test

Definition: gtest.h:414

Definition at line 2346 of file gtest.h.

◆ SCOPED_TRACE

#define SCOPED_TRACE ( message )

Value:

::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\

__FILE__, __LINE__, (message))

GTEST_CONCAT_TOKEN_

#define GTEST_CONCAT_TOKEN_(foo, bar)

Definition: gtest-internal.h:78

googletest-output-test.message

tuple message

Definition: googletest-output-test.py:337

testing::ScopedTrace

Definition: gtest.h:2231

Definition at line 2281 of file gtest.h.

◆ SUCCEED

#define SUCCEED ( ) GTEST_SUCCEED()

Definition at line 1937 of file gtest.h.

◆ TEST

#define TEST	(	test_suite_name,
		test_name
	)	GTEST_TEST(test_suite_name, test_name)

Definition at line 2353 of file gtest.h.

◆ TEST_F

#define TEST_F	(	test_fixture,
		test_name
	)

Value:

GTEST_TEST_(test_fixture, test_name, test_fixture, \

::testing::internal::GetTypeId<test_fixture>())

Definition at line 2384 of file gtest.h.

Function Documentation

◆ GTEST_DISABLE_MSC_WARNINGS_PUSH_()

GTEST_DISABLE_MSC_WARNINGS_PUSH_ ( 4251 )

Definition at line 73 of file gtest.h.

                  {
 
// 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)
#endif
 
 
// Declares the flags.
 
// This flag temporary enables the disabled tests.
GTEST_DECLARE_bool_(also_run_disabled_tests);
 
// This flag brings the debugger on an assertion failure.
GTEST_DECLARE_bool_(break_on_failure);
 
// This flag controls whether Google Test catches all test-thrown exceptions
// and logs them as failures.
GTEST_DECLARE_bool_(catch_exceptions);
 
// This flag enables using colors in terminal output. Available values are
// "yes" to enable colors, "no" (disable colors), or "auto" (the default)
// to let Google Test decide.
GTEST_DECLARE_string_(color);
 
// This flag controls whether the test runner should continue execution past
// first failure.
GTEST_DECLARE_bool_(fail_fast);
 
// This flag sets up the filter to select by name using a glob pattern
// the tests to run. If the filter is not given all tests are executed.
GTEST_DECLARE_string_(filter);
 
// This flag controls whether Google Test installs a signal handler that dumps
// debugging information when fatal signals are raised.
GTEST_DECLARE_bool_(install_failure_signal_handler);
 
// This flag causes the Google Test to list tests. None of the tests listed
// are actually run if the flag is provided.
GTEST_DECLARE_bool_(list_tests);
 
// This flag controls whether Google Test emits a detailed XML report to a file
// in addition to its normal textual output.
GTEST_DECLARE_string_(output);
 
// This flags control whether Google Test prints only test failures.
GTEST_DECLARE_bool_(brief);
 
// This flags control whether Google Test prints the elapsed time for each
// test.
GTEST_DECLARE_bool_(print_time);
 
// This flags control whether Google Test prints UTF8 characters as text.
GTEST_DECLARE_bool_(print_utf8);
 
// This flag specifies the random number seed.
GTEST_DECLARE_int32_(random_seed);
 
// This flag sets how many times the tests are repeated. The default value
// is 1. If the value is -1 the tests are repeating forever.
GTEST_DECLARE_int32_(repeat);
 
// This flag controls whether Google Test includes Google Test internal
// stack frames in failure stack traces.
GTEST_DECLARE_bool_(show_internal_stack_frames);
 
// When this flag is specified, tests' order is randomized on every iteration.
GTEST_DECLARE_bool_(shuffle);
 
// This flag specifies the maximum number of stack frames to be
// printed in a failure message.
GTEST_DECLARE_int32_(stack_trace_depth);
 
// When this flag is specified, a failed assertion will throw an
// exception if exceptions are enabled, or exit the program with a
// non-zero code otherwise. For use with an external test framework.
GTEST_DECLARE_bool_(throw_on_failure);
 
// When this flag is set with a "host:port" string, on supported
// platforms test results are streamed to the specified port on
// the specified host machine.
GTEST_DECLARE_string_(stream_result_to);
 
#if GTEST_USE_OWN_FLAGFILE_FLAG_
GTEST_DECLARE_string_(flagfile);
#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
 
// The upper limit for valid stack trace depths.
const int kMaxStackTraceDepth = 100;
 
namespace internal {
 
class AssertHelper;
class DefaultGlobalTestPartResultReporter;
class ExecDeathTest;
class NoExecDeathTest;
class FinalSuccessChecker;
class GTestFlagSaver;
class StreamingListenerTest;
class TestResultAccessor;
class TestEventListenersAccessor;
class TestEventRepeater;
class UnitTestRecordPropertyTestHelper;
class WindowsDeathTest;
class FuchsiaDeathTest;
class UnitTestImpl* GetUnitTestImpl();
void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
                                    const std::string& message);
std::set<std::string>* GetIgnoredParameterizedTestSuites();
 
}  // namespace internal
 
// The friend relationship of some of these classes is cyclic.
// If we don't forward declare them the compiler might confuse the classes
// in friendship clauses with same named classes on the scope.
class Test;
class TestSuite;
 
// Old API is still available but deprecated
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
using TestCase = TestSuite;
#endif
class TestInfo;
class UnitTest;
 
// A class for indicating whether an assertion was successful.  When
// the assertion wasn't successful, the AssertionResult object
// remembers a non-empty message that describes how it failed.
//
// To create an instance of this class, use one of the factory functions
// (AssertionSuccess() and AssertionFailure()).
//
// This class is useful for two purposes:
//   1. Defining predicate functions to be used with Boolean test assertions
//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
//   2. Defining predicate-format functions to be
//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
//
// For example, if you define IsEven predicate:
//
//   testing::AssertionResult IsEven(int n) {
//     if ((n % 2) == 0)
//       return testing::AssertionSuccess();
//     else
//       return testing::AssertionFailure() << n << " is odd";
//   }
//
// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
// will print the message
//
//   Value of: IsEven(Fib(5))
//     Actual: false (5 is odd)
//   Expected: true
//
// instead of a more opaque
//
//   Value of: IsEven(Fib(5))
//     Actual: false
//   Expected: true
//
// in case IsEven is a simple Boolean predicate.
//
// If you expect your predicate to be reused and want to support informative
// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
// about half as often as positive ones in our tests), supply messages for
// both success and failure cases:
//
//   testing::AssertionResult IsEven(int n) {
//     if ((n % 2) == 0)
//       return testing::AssertionSuccess() << n << " is even";
//     else
//       return testing::AssertionFailure() << n << " is odd";
//   }
//
// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
//
//   Value of: IsEven(Fib(6))
//     Actual: true (8 is even)
//   Expected: false
//
// NB: Predicates that support negative Boolean assertions have reduced
// performance in positive ones so be careful not to use them in tests
// that have lots (tens of thousands) of positive Boolean assertions.
//
// To use this class with EXPECT_PRED_FORMAT assertions such as:
//
//   // Verifies that Foo() returns an even number.
//   EXPECT_PRED_FORMAT1(IsEven, Foo());
//
// you need to define:
//
//   testing::AssertionResult IsEven(const char* expr, int n) {
//     if ((n % 2) == 0)
//       return testing::AssertionSuccess();
//     else
//       return testing::AssertionFailure()
//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
//   }
//
// If Foo() returns 5, you will see the following message:
//
//   Expected: Foo() is even
//     Actual: it's 5
//
class GTEST_API_ AssertionResult {
 public:
  // Copy constructor.
  // Used in EXPECT_TRUE/FALSE(assertion_result).
  AssertionResult(const AssertionResult& other);
 
// C4800 is a level 3 warning in Visual Studio 2015 and earlier.
// This warning is not emitted in Visual Studio 2017.
// This warning is off by default starting in Visual Studio 2019 but can be
// enabled with command-line options.
#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
#endif
 
  // Used in the EXPECT_TRUE/FALSE(bool_expression).
  //
  // T must be contextually convertible to bool.
  //
  // The second parameter prevents this overload from being considered if
  // the argument is implicitly convertible to AssertionResult. In that case
  // we want AssertionResult's copy constructor to be used.
  template <typename T>
  explicit AssertionResult(
      const T& success,
      typename std::enable_if<
          !std::is_convertible<T, AssertionResult>::value>::type*
      /*enabler*/
      = nullptr)
      : success_(success) {}
 
#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
  GTEST_DISABLE_MSC_WARNINGS_POP_()
#endif
 
  // Assignment operator.
  AssertionResult& operator=(AssertionResult other) {
    swap(other);
    return *this;
  }
 
  // Returns true if and only if the assertion succeeded.
  operator bool() const { return success_; }  // NOLINT
 
  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
  AssertionResult operator!() const;
 
  // Returns the text streamed into this AssertionResult. Test assertions
  // use it when they fail (i.e., the predicate's outcome doesn't match the
  // assertion's expectation). When nothing has been streamed into the
  // object, returns an empty string.
  const char* message() const {
    return message_.get() != nullptr ? message_->c_str() : "";
  }
  // Deprecated; please use message() instead.
  const char* failure_message() const { return message(); }
 
  // Streams a custom failure message into this object.
  template <typename T> AssertionResult& operator<<(const T& value) {
    AppendMessage(Message() << value);
    return *this;
  }
 
  // Allows streaming basic output manipulators such as endl or flush into
  // this object.
  AssertionResult& operator<<(
      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
    AppendMessage(Message() << basic_manipulator);
    return *this;
  }
 
 private:
  // Appends the contents of message to message_.
  void AppendMessage(const Message& a_message) {
    if (message_.get() == nullptr) message_.reset(new ::std::string);
    message_->append(a_message.GetString().c_str());
  }
 
  // Swap the contents of this AssertionResult with other.
  void swap(AssertionResult& other);
 
  // Stores result of the assertion predicate.
  bool success_;
  // Stores the message describing the condition in case the expectation
  // construct is not satisfied with the predicate's outcome.
  // Referenced via a pointer to avoid taking too much stack frame space
  // with test assertions.
  std::unique_ptr< ::std::string> message_;
};
 
// Makes a successful assertion result.
GTEST_API_ AssertionResult AssertionSuccess();
 
// Makes a failed assertion result.
GTEST_API_ AssertionResult AssertionFailure();
 
// Makes a failed assertion result with the given failure message.
// Deprecated; use AssertionFailure() << msg.
GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
 
}  // namespace testing

◆ RUN_ALL_TESTS()

int RUN_ALL_TESTS ( )

inline

Definition at line 2489 of file gtest.h.

                           {
  return ::testing::UnitTest::GetInstance()->Run();
}

Classes

Namespaces

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ ADD_FAILURE

◆ ADD_FAILURE_AT

◆ ASSERT_ANY_THROW

◆ ASSERT_DOUBLE_EQ

◆ ASSERT_EQ

◆ ASSERT_FALSE

◆ ASSERT_FLOAT_EQ

◆ ASSERT_GE

◆ ASSERT_GT

◆ ASSERT_LE

◆ ASSERT_LT

◆ ASSERT_NE

◆ ASSERT_NEAR

◆ ASSERT_NO_FATAL_FAILURE

◆ ASSERT_NO_THROW

◆ ASSERT_STRCASEEQ

◆ ASSERT_STRCASENE

◆ ASSERT_STREQ

◆ ASSERT_STRNE

◆ ASSERT_THROW

◆ ASSERT_TRUE

◆ EXPECT_ANY_THROW

◆ EXPECT_DOUBLE_EQ

◆ EXPECT_EQ

◆ EXPECT_FALSE

◆ EXPECT_FLOAT_EQ

◆ EXPECT_GE

◆ EXPECT_GT

◆ EXPECT_LE

◆ EXPECT_LT

◆ EXPECT_NE

◆ EXPECT_NEAR

◆ EXPECT_NO_FATAL_FAILURE

◆ EXPECT_NO_THROW

◆ EXPECT_STRCASEEQ

◆ EXPECT_STRCASENE

◆ EXPECT_STREQ

◆ EXPECT_STRNE

◆ EXPECT_THROW

◆ EXPECT_TRUE

◆ FAIL

◆ GTEST_ASSERT_EQ

◆ GTEST_ASSERT_FALSE

◆ GTEST_ASSERT_GE

◆ GTEST_ASSERT_GT

◆ GTEST_ASSERT_LE

◆ GTEST_ASSERT_LT

◆ GTEST_ASSERT_NE

◆ GTEST_ASSERT_TRUE

◆ GTEST_EXPECT_FALSE

◆ GTEST_EXPECT_TRUE

◆ GTEST_FAIL

◆ GTEST_FAIL_AT

◆ GTEST_IMPL_CMP_HELPER_

◆ GTEST_SKIP

◆ GTEST_SUCCEED

◆ GTEST_TEST

◆ SCOPED_TRACE

◆ SUCCEED

◆ TEST

◆ TEST_F

Function Documentation

◆ GTEST_DISABLE_MSC_WARNINGS_PUSH_()

◆ RUN_ALL_TESTS()