49#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_H_
50#define GOOGLETEST_INCLUDE_GTEST_GTEST_H_
59#include "gtest/gtest-assertion-result.h"
60#include "gtest/gtest-death-test.h"
61#include "gtest/gtest-matchers.h"
62#include "gtest/gtest-message.h"
63#include "gtest/gtest-param-test.h"
64#include "gtest/gtest-printers.h"
65#include "gtest/gtest-test-part.h"
66#include "gtest/gtest-typed-test.h"
67#include "gtest/gtest_pred_impl.h"
68#include "gtest/gtest_prod.h"
69#include "gtest/internal/gtest-internal.h"
70#include "gtest/internal/gtest-string.h"
72GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
78GTEST_DECLARE_bool_(also_run_disabled_tests);
81GTEST_DECLARE_bool_(break_on_failure);
85GTEST_DECLARE_bool_(catch_exceptions);
90GTEST_DECLARE_string_(color);
94GTEST_DECLARE_bool_(fail_fast);
98GTEST_DECLARE_string_(filter);
102GTEST_DECLARE_bool_(install_failure_signal_handler);
106GTEST_DECLARE_bool_(list_tests);
110GTEST_DECLARE_string_(output);
113GTEST_DECLARE_bool_(brief);
117GTEST_DECLARE_bool_(print_time);
120GTEST_DECLARE_bool_(print_utf8);
123GTEST_DECLARE_int32_(random_seed);
127GTEST_DECLARE_int32_(repeat);
133GTEST_DECLARE_bool_(recreate_environments_when_repeating);
137GTEST_DECLARE_bool_(show_internal_stack_frames);
140GTEST_DECLARE_bool_(shuffle);
144GTEST_DECLARE_int32_(stack_trace_depth);
149GTEST_DECLARE_bool_(throw_on_failure);
154GTEST_DECLARE_string_(stream_result_to);
156#if GTEST_USE_OWN_FLAGFILE_FLAG_
157GTEST_DECLARE_string_(flagfile);
166#pragma warning(disable : 4805)
167#pragma warning(disable : 4100)
171const int kMaxStackTraceDepth = 100;
176class DefaultGlobalTestPartResultReporter;
178class NoExecDeathTest;
179class FinalSuccessChecker;
181class StreamingListenerTest;
182class TestResultAccessor;
183class TestEventListenersAccessor;
184class TestEventRepeater;
185class UnitTestRecordPropertyTestHelper;
186class WindowsDeathTest;
187class FuchsiaDeathTest;
188class UnitTestImpl* GetUnitTestImpl();
189void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
190 const std::string& message);
191std::set<std::string>* GetIgnoredParameterizedTestSuites();
213#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
255 static void SetUpTestSuite() {}
263 static void TearDownTestSuite() {}
267#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
268 static void TearDownTestCase() {}
269 static void SetUpTestCase() {}
273 static bool HasFatalFailure();
276 static bool HasNonfatalFailure();
279 static bool IsSkipped();
283 static bool HasFailure() {
return HasFatalFailure() || HasNonfatalFailure(); }
298 static void RecordProperty(
const std::string& key,
const std::string& value);
299 static void RecordProperty(
const std::string& key,
int value);
306 virtual void SetUp();
309 virtual void TearDown();
314 static bool HasSameFixtureClass();
322 virtual void TestBody() = 0;
329 void DeleteSelf_() {
delete this; }
331 const std::unique_ptr<GTEST_FLAG_SAVER_> gtest_flag_saver_;
349 struct Setup_should_be_spelled_SetUp {};
350 virtual Setup_should_be_spelled_SetUp* Setup() {
return nullptr; }
354 Test& operator=(
const Test&) =
delete;
357typedef internal::TimeInMillis TimeInMillis;
368 TestProperty(
const std::string& a_key,
const std::string& a_value)
369 : key_(a_key), value_(a_value) {}
372 const char* key()
const {
return key_.c_str(); }
375 const char* value()
const {
return value_.c_str(); }
378 void SetValue(
const std::string& new_value) { value_ = new_value; }
403 int total_part_count()
const;
406 int test_property_count()
const;
409 bool Passed()
const {
return !Skipped() && !Failed(); }
412 bool Skipped()
const;
418 bool HasFatalFailure()
const;
421 bool HasNonfatalFailure()
const;
424 TimeInMillis elapsed_time()
const {
return elapsed_time_; }
428 TimeInMillis start_timestamp()
const {
return start_timestamp_; }
432 const TestPartResult& GetTestPartResult(
int i)
const;
444 friend class internal::ExecDeathTest;
447 friend class internal::WindowsDeathTest;
448 friend class internal::FuchsiaDeathTest;
451 const std::vector<TestPartResult>& test_part_results()
const {
452 return test_part_results_;
456 const std::vector<TestProperty>& test_properties()
const {
457 return test_properties_;
461 void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; }
464 void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
472 void RecordProperty(
const std::string& xml_element,
478 static bool ValidateTestProperty(
const std::string& xml_element,
482 void AddTestPartResult(
const TestPartResult& test_part_result);
485 int death_test_count()
const {
return death_test_count_; }
488 int increment_death_test_count() {
return ++death_test_count_; }
491 void ClearTestPartResults();
501 std::vector<TestPartResult> test_part_results_;
503 std::vector<TestProperty> test_properties_;
505 int death_test_count_;
507 TimeInMillis start_timestamp_;
509 TimeInMillis elapsed_time_;
534 const char* test_suite_name()
const {
return test_suite_name_.c_str(); }
537#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
538 const char* test_case_name()
const {
return test_suite_name(); }
542 const char* name()
const {
return name_.c_str(); }
546 const char* type_param()
const {
547 if (type_param_.get() !=
nullptr)
return type_param_->c_str();
553 const char* value_param()
const {
554 if (value_param_.get() !=
nullptr)
return value_param_->c_str();
559 const char* file()
const {
return location_.file.c_str(); }
562 int line()
const {
return location_.line; }
565 bool is_in_another_shard()
const {
return is_in_another_shard_; }
583 bool should_run()
const {
return should_run_; }
586 bool is_reportable()
const {
589 return matches_filter_ && !is_in_another_shard_;
593 const TestResult* result()
const {
return &result_; }
596#if GTEST_HAS_DEATH_TEST
597 friend class internal::DefaultDeathTestFactory;
602 friend class internal::StreamingListenerTest;
603 friend TestInfo* internal::MakeAndRegisterTestInfo(
604 const char* test_suite_name,
const char* name,
const char* type_param,
606 internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc,
607 internal::TearDownTestSuiteFunc tear_down_tc,
612 TestInfo(
const std::string& test_suite_name,
const std::string& name,
613 const char* a_type_param,
614 const char* a_value_param,
616 internal::TypeId fixture_class_id,
621 int increment_death_test_count() {
622 return result_.increment_death_test_count();
632 static void ClearTestResult(
TestInfo* test_info) {
633 test_info->result_.Clear();
637 const std::string test_suite_name_;
638 const std::string name_;
641 const std::unique_ptr<const ::std::string> type_param_;
644 const std::unique_ptr<const ::std::string> value_param_;
646 const internal::TypeId fixture_class_id_;
649 bool matches_filter_;
651 bool is_in_another_shard_;
680 TestSuite(
const char* name,
const char* a_type_param,
681 internal::SetUpTestSuiteFunc set_up_tc,
682 internal::TearDownTestSuiteFunc tear_down_tc);
688 const char* name()
const {
return name_.c_str(); }
692 const char* type_param()
const {
693 if (type_param_.get() !=
nullptr)
return type_param_->c_str();
698 bool should_run()
const {
return should_run_; }
701 int successful_test_count()
const;
704 int skipped_test_count()
const;
707 int failed_test_count()
const;
710 int reportable_disabled_test_count()
const;
713 int disabled_test_count()
const;
716 int reportable_test_count()
const;
719 int test_to_run_count()
const;
722 int total_test_count()
const;
725 bool Passed()
const {
return !Failed(); }
728 bool Failed()
const {
729 return failed_test_count() > 0 || ad_hoc_test_result().Failed();
733 TimeInMillis elapsed_time()
const {
return elapsed_time_; }
737 TimeInMillis start_timestamp()
const {
return start_timestamp_; }
741 const TestInfo* GetTestInfo(
int i)
const;
745 const TestResult& ad_hoc_test_result()
const {
return ad_hoc_test_result_; }
752 std::vector<TestInfo*>& test_info_list() {
return test_info_list_; }
755 const std::vector<TestInfo*>& test_info_list()
const {
756 return test_info_list_;
761 TestInfo* GetMutableTestInfo(
int i);
764 void set_should_run(
bool should) { should_run_ = should; }
768 void AddTestInfo(
TestInfo* test_info);
774 static void ClearTestSuiteResult(
TestSuite* test_suite) {
775 test_suite->ClearResult();
786 void RunSetUpTestSuite() {
787 if (set_up_tc_ !=
nullptr) {
794 void RunTearDownTestSuite() {
795 if (tear_down_tc_ !=
nullptr) {
801 static bool TestPassed(
const TestInfo* test_info) {
802 return test_info->should_run() && test_info->result()->Passed();
806 static bool TestSkipped(
const TestInfo* test_info) {
807 return test_info->should_run() && test_info->result()->Skipped();
811 static bool TestFailed(
const TestInfo* test_info) {
812 return test_info->should_run() && test_info->result()->Failed();
817 static bool TestReportableDisabled(
const TestInfo* test_info) {
818 return test_info->is_reportable() && test_info->is_disabled_;
822 static bool TestDisabled(
const TestInfo* test_info) {
823 return test_info->is_disabled_;
827 static bool TestReportable(
const TestInfo* test_info) {
828 return test_info->is_reportable();
832 static bool ShouldRunTest(
const TestInfo* test_info) {
833 return test_info->should_run();
840 void UnshuffleTests();
846 const std::unique_ptr<const ::std::string> type_param_;
849 std::vector<TestInfo*> test_info_list_;
853 std::vector<int> test_indices_;
855 internal::SetUpTestSuiteFunc set_up_tc_;
857 internal::TearDownTestSuiteFunc tear_down_tc_;
861 TimeInMillis start_timestamp_;
863 TimeInMillis elapsed_time_;
893 virtual void SetUp() {}
896 virtual void TearDown() {}
901 struct Setup_should_be_spelled_SetUp {};
902 virtual Setup_should_be_spelled_SetUp* Setup() {
return nullptr; }
905#if GTEST_HAS_EXCEPTIONS
908class GTEST_API_ AssertionException
909 :
public internal::GoogleTestFailureException {
911 explicit AssertionException(
const TestPartResult& result)
912 : GoogleTestFailureException(result) {}
924 virtual void OnTestProgramStart(
const UnitTest& unit_test) = 0;
929 virtual void OnTestIterationStart(
const UnitTest& unit_test,
933 virtual void OnEnvironmentsSetUpStart(
const UnitTest& unit_test) = 0;
936 virtual void OnEnvironmentsSetUpEnd(
const UnitTest& unit_test) = 0;
939 virtual void OnTestSuiteStart(
const TestSuite& ) {}
942#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
943 virtual void OnTestCaseStart(
const TestCase& ) {}
947 virtual void OnTestStart(
const TestInfo& test_info) = 0;
950 virtual void OnTestDisabled(
const TestInfo& ) {}
955 virtual void OnTestPartResult(
const TestPartResult& test_part_result) = 0;
958 virtual void OnTestEnd(
const TestInfo& test_info) = 0;
961 virtual void OnTestSuiteEnd(
const TestSuite& ) {}
964#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
965 virtual void OnTestCaseEnd(
const TestCase& ) {}
969 virtual void OnEnvironmentsTearDownStart(
const UnitTest& unit_test) = 0;
972 virtual void OnEnvironmentsTearDownEnd(
const UnitTest& unit_test) = 0;
975 virtual void OnTestIterationEnd(
const UnitTest& unit_test,
int iteration) = 0;
978 virtual void OnTestProgramEnd(
const UnitTest& unit_test) = 0;
988 void OnTestProgramStart(
const UnitTest& )
override {}
989 void OnTestIterationStart(
const UnitTest& ,
991 void OnEnvironmentsSetUpStart(
const UnitTest& )
override {}
992 void OnEnvironmentsSetUpEnd(
const UnitTest& )
override {}
993 void OnTestSuiteStart(
const TestSuite& )
override {}
995#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
996 void OnTestCaseStart(
const TestCase& )
override {}
999 void OnTestStart(
const TestInfo& )
override {}
1000 void OnTestDisabled(
const TestInfo& )
override {}
1001 void OnTestPartResult(
const TestPartResult& )
override {}
1002 void OnTestEnd(
const TestInfo& )
override {}
1003 void OnTestSuiteEnd(
const TestSuite& )
override {}
1004#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
1005 void OnTestCaseEnd(
const TestCase& )
override {}
1008 void OnEnvironmentsTearDownStart(
const UnitTest& )
override {}
1009 void OnEnvironmentsTearDownEnd(
const UnitTest& )
override {}
1010 void OnTestIterationEnd(
const UnitTest& ,
1012 void OnTestProgramEnd(
const UnitTest& )
override {}
1037 return default_result_printer_;
1048 return default_xml_generator_;
1055 friend class internal::NoExecDeathTest;
1079 bool EventForwardingEnabled()
const;
1080 void SuppressEventForwarding();
1117 int Run() GTEST_MUST_USE_RESULT_;
1121 const char* original_working_dir()
const;
1125 const TestSuite* current_test_suite()
const GTEST_LOCK_EXCLUDED_(mutex_);
1128#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
1129 const TestCase* current_test_case()
const GTEST_LOCK_EXCLUDED_(mutex_);
1134 const TestInfo* current_test_info()
const GTEST_LOCK_EXCLUDED_(mutex_);
1137 int random_seed()
const;
1144 GTEST_LOCK_EXCLUDED_(mutex_);
1147 int successful_test_suite_count()
const;
1150 int failed_test_suite_count()
const;
1153 int total_test_suite_count()
const;
1157 int test_suite_to_run_count()
const;
1160#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
1161 int successful_test_case_count()
const;
1162 int failed_test_case_count()
const;
1163 int total_test_case_count()
const;
1164 int test_case_to_run_count()
const;
1168 int successful_test_count()
const;
1171 int skipped_test_count()
const;
1174 int failed_test_count()
const;
1177 int reportable_disabled_test_count()
const;
1180 int disabled_test_count()
const;
1183 int reportable_test_count()
const;
1186 int total_test_count()
const;
1189 int test_to_run_count()
const;
1193 TimeInMillis start_timestamp()
const;
1196 TimeInMillis elapsed_time()
const;
1200 bool Passed()
const;
1204 bool Failed()
const;
1208 const TestSuite* GetTestSuite(
int i)
const;
1211#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
1212 const TestCase* GetTestCase(
int i)
const;
1217 const TestResult& ad_hoc_test_result()
const;
1239 void AddTestPartResult(TestPartResult::Type result_type,
1240 const char* file_name,
int line_number,
1241 const std::string& message,
1242 const std::string& os_stack_trace)
1243 GTEST_LOCK_EXCLUDED_(mutex_);
1250 void RecordProperty(
const std::string& key,
const std::string& value);
1265 friend class internal::StreamingListenerTest;
1268 friend std::set<std::string>* internal::GetIgnoredParameterizedTestSuites();
1270 friend void internal::ReportFailureInUnknownLocation(
1271 TestPartResult::Type result_type,
const std::string& message);
1282 GTEST_LOCK_EXCLUDED_(mutex_);
1285 void PopGTestTrace() GTEST_LOCK_EXCLUDED_(mutex_);
1321 return UnitTest::GetInstance()->AddEnvironment(env);
1333GTEST_API_
void InitGoogleTest(
int* argc,
char** argv);
1337GTEST_API_
void InitGoogleTest(
int* argc,
wchar_t** argv);
1341GTEST_API_
void InitGoogleTest();
1348template <
typename T1,
typename T2>
1349AssertionResult CmpHelperEQFailure(
const char* lhs_expression,
1350 const char* rhs_expression,
const T1& lhs,
1352 return EqFailure(lhs_expression, rhs_expression,
1353 FormatForComparisonFailureMessage(lhs, rhs),
1354 FormatForComparisonFailureMessage(rhs, lhs),
false);
1362inline bool operator!=(faketype, faketype) {
return false; }
1365template <
typename T1,
typename T2>
1366AssertionResult CmpHelperEQ(
const char* lhs_expression,
1367 const char* rhs_expression,
const T1& lhs,
1370 return AssertionSuccess();
1373 return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
1380 typename T1,
typename T2,
1383 typename std::enable_if<!std::is_integral<T1>::value ||
1384 !std::is_pointer<T2>::value>::type* =
nullptr>
1385 static AssertionResult Compare(
const char* lhs_expression,
1386 const char* rhs_expression,
const T1& lhs,
1388 return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
1397 static AssertionResult Compare(
const char* lhs_expression,
1398 const char* rhs_expression, BiggestInt lhs,
1400 return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
1403 template <
typename T>
1404 static AssertionResult Compare(
1405 const char* lhs_expression,
const char* rhs_expression,
1407 std::nullptr_t , T* rhs) {
1409 return CmpHelperEQ(lhs_expression, rhs_expression,
static_cast<T*
>(
nullptr),
1417template <
typename T1,
typename T2>
1418AssertionResult CmpHelperOpFailure(
const char* expr1,
const char* expr2,
1419 const T1& val1,
const T2& val2,
1421 return AssertionFailure()
1422 <<
"Expected: (" << expr1 <<
") " << op <<
" (" << expr2
1423 <<
"), actual: " << FormatForComparisonFailureMessage(val1, val2)
1424 <<
" vs " << FormatForComparisonFailureMessage(val2, val1);
1433#define GTEST_IMPL_CMP_HELPER_(op_name, op) \
1434 template <typename T1, typename T2> \
1435 AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
1436 const T1& val1, const T2& val2) { \
1437 if (val1 op val2) { \
1438 return AssertionSuccess(); \
1440 return CmpHelperOpFailure(expr1, expr2, val1, val2, #op); \
1447GTEST_IMPL_CMP_HELPER_(NE, !=)
1449GTEST_IMPL_CMP_HELPER_(LE, <=)
1451GTEST_IMPL_CMP_HELPER_(LT, <)
1453GTEST_IMPL_CMP_HELPER_(GE, >=)
1455GTEST_IMPL_CMP_HELPER_(GT, >)
1457#undef GTEST_IMPL_CMP_HELPER_
1462GTEST_API_ AssertionResult CmpHelperSTREQ(
const char* s1_expression,
1463 const char* s2_expression,
1464 const char* s1,
const char* s2);
1469GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(
const char* s1_expression,
1470 const char* s2_expression,
1471 const char* s1,
const char* s2);
1476GTEST_API_ AssertionResult CmpHelperSTRNE(
const char* s1_expression,
1477 const char* s2_expression,
1478 const char* s1,
const char* s2);
1483GTEST_API_ AssertionResult CmpHelperSTRCASENE(
const char* s1_expression,
1484 const char* s2_expression,
1485 const char* s1,
const char* s2);
1490GTEST_API_ AssertionResult CmpHelperSTREQ(
const char* s1_expression,
1491 const char* s2_expression,
1492 const wchar_t* s1,
const wchar_t* s2);
1497GTEST_API_ AssertionResult CmpHelperSTRNE(
const char* s1_expression,
1498 const char* s2_expression,
1499 const wchar_t* s1,
const wchar_t* s2);
1511GTEST_API_ AssertionResult IsSubstring(
const char* needle_expr,
1512 const char* haystack_expr,
1514 const char* haystack);
1515GTEST_API_ AssertionResult IsSubstring(
const char* needle_expr,
1516 const char* haystack_expr,
1517 const wchar_t* needle,
1518 const wchar_t* haystack);
1519GTEST_API_ AssertionResult IsNotSubstring(
const char* needle_expr,
1520 const char* haystack_expr,
1522 const char* haystack);
1523GTEST_API_ AssertionResult IsNotSubstring(
const char* needle_expr,
1524 const char* haystack_expr,
1525 const wchar_t* needle,
1526 const wchar_t* haystack);
1527GTEST_API_ AssertionResult IsSubstring(
const char* needle_expr,
1528 const char* haystack_expr,
1529 const ::std::string& needle,
1530 const ::std::string& haystack);
1531GTEST_API_ AssertionResult IsNotSubstring(
const char* needle_expr,
1532 const char* haystack_expr,
1533 const ::std::string& needle,
1534 const ::std::string& haystack);
1536#if GTEST_HAS_STD_WSTRING
1537GTEST_API_ AssertionResult IsSubstring(
const char* needle_expr,
1538 const char* haystack_expr,
1539 const ::std::wstring& needle,
1540 const ::std::wstring& haystack);
1541GTEST_API_ AssertionResult IsNotSubstring(
const char* needle_expr,
1542 const char* haystack_expr,
1543 const ::std::wstring& needle,
1544 const ::std::wstring& haystack);
1556template <
typename RawType>
1557AssertionResult CmpHelperFloatingPointEQ(
const char* lhs_expression,
1558 const char* rhs_expression,
1559 RawType lhs_value, RawType rhs_value) {
1560 const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);
1562 if (lhs.AlmostEquals(rhs)) {
1563 return AssertionSuccess();
1566 ::std::stringstream lhs_ss;
1567 lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
1570 ::std::stringstream rhs_ss;
1571 rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
1574 return EqFailure(lhs_expression, rhs_expression,
1575 StringStreamToString(&lhs_ss), StringStreamToString(&rhs_ss),
1582GTEST_API_ AssertionResult DoubleNearPredFormat(
const char* expr1,
1584 const char* abs_error_expr,
1585 double val1,
double val2,
1593 AssertHelper(TestPartResult::Type type,
const char* file,
int line,
1594 const char* message);
1599 void operator=(
const Message& message)
const;
1606 struct AssertHelperData {
1607 AssertHelperData(TestPartResult::Type t,
const char* srcfile,
int line_num,
1609 : type(t), file(srcfile), line(line_num), message(msg) {}
1611 TestPartResult::Type
const type;
1612 const char*
const file;
1614 std::string
const message;
1617 AssertHelperData(
const AssertHelperData&) =
delete;
1618 AssertHelperData& operator=(
const AssertHelperData&) =
delete;
1621 AssertHelperData*
const data_;
1663template <
typename T>
1666 typedef T ParamType;
1671 static const ParamType& GetParam() {
1672 GTEST_CHECK_(parameter_ !=
nullptr)
1673 <<
"GetParam() can only be called inside a value-parameterized test "
1674 <<
"-- did you intend to write TEST_P instead of TEST_F?";
1681 static void SetParam(
const ParamType* parameter) { parameter_ = parameter; }
1684 static const ParamType* parameter_;
1687 template <
class TestClass>
1691template <
typename T>
1697template <
typename T>
1705#define GTEST_SKIP() GTEST_SKIP_("")
1725#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
1729#define ADD_FAILURE_AT(file, line) \
1730 GTEST_MESSAGE_AT_(file, line, "Failed", \
1731 ::testing::TestPartResult::kNonFatalFailure)
1734#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
1737#define GTEST_FAIL_AT(file, line) \
1738 GTEST_MESSAGE_AT_(file, line, "Failed", \
1739 ::testing::TestPartResult::kFatalFailure)
1743#if !GTEST_DONT_DEFINE_FAIL
1744#define FAIL() GTEST_FAIL()
1748#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
1752#if !GTEST_DONT_DEFINE_SUCCEED
1753#define SUCCEED() GTEST_SUCCEED()
1765#define EXPECT_THROW(statement, expected_exception) \
1766 GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
1767#define EXPECT_NO_THROW(statement) \
1768 GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
1769#define EXPECT_ANY_THROW(statement) \
1770 GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
1771#define ASSERT_THROW(statement, expected_exception) \
1772 GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
1773#define ASSERT_NO_THROW(statement) \
1774 GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
1775#define ASSERT_ANY_THROW(statement) \
1776 GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
1781#define GTEST_EXPECT_TRUE(condition) \
1782 GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
1783 GTEST_NONFATAL_FAILURE_)
1784#define GTEST_EXPECT_FALSE(condition) \
1785 GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
1786 GTEST_NONFATAL_FAILURE_)
1787#define GTEST_ASSERT_TRUE(condition) \
1788 GTEST_TEST_BOOLEAN_(condition, #condition, false, true, GTEST_FATAL_FAILURE_)
1789#define GTEST_ASSERT_FALSE(condition) \
1790 GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
1791 GTEST_FATAL_FAILURE_)
1796#if !GTEST_DONT_DEFINE_EXPECT_TRUE
1797#define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition)
1800#if !GTEST_DONT_DEFINE_EXPECT_FALSE
1801#define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition)
1804#if !GTEST_DONT_DEFINE_ASSERT_TRUE
1805#define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition)
1808#if !GTEST_DONT_DEFINE_ASSERT_FALSE
1809#define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition)
1858#define EXPECT_EQ(val1, val2) \
1859 EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
1860#define EXPECT_NE(val1, val2) \
1861 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
1862#define EXPECT_LE(val1, val2) \
1863 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
1864#define EXPECT_LT(val1, val2) \
1865 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
1866#define EXPECT_GE(val1, val2) \
1867 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
1868#define EXPECT_GT(val1, val2) \
1869 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
1871#define GTEST_ASSERT_EQ(val1, val2) \
1872 ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
1873#define GTEST_ASSERT_NE(val1, val2) \
1874 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
1875#define GTEST_ASSERT_LE(val1, val2) \
1876 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
1877#define GTEST_ASSERT_LT(val1, val2) \
1878 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
1879#define GTEST_ASSERT_GE(val1, val2) \
1880 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
1881#define GTEST_ASSERT_GT(val1, val2) \
1882 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
1887#if !GTEST_DONT_DEFINE_ASSERT_EQ
1888#define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
1891#if !GTEST_DONT_DEFINE_ASSERT_NE
1892#define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
1895#if !GTEST_DONT_DEFINE_ASSERT_LE
1896#define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
1899#if !GTEST_DONT_DEFINE_ASSERT_LT
1900#define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
1903#if !GTEST_DONT_DEFINE_ASSERT_GE
1904#define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
1907#if !GTEST_DONT_DEFINE_ASSERT_GT
1908#define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
1927#define EXPECT_STREQ(s1, s2) \
1928 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
1929#define EXPECT_STRNE(s1, s2) \
1930 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
1931#define EXPECT_STRCASEEQ(s1, s2) \
1932 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
1933#define EXPECT_STRCASENE(s1, s2) \
1934 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
1936#define ASSERT_STREQ(s1, s2) \
1937 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
1938#define ASSERT_STRNE(s1, s2) \
1939 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
1940#define ASSERT_STRCASEEQ(s1, s2) \
1941 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
1942#define ASSERT_STRCASENE(s1, s2) \
1943 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
1959#define EXPECT_FLOAT_EQ(val1, val2) \
1960 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
1963#define EXPECT_DOUBLE_EQ(val1, val2) \
1964 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
1967#define ASSERT_FLOAT_EQ(val1, val2) \
1968 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
1971#define ASSERT_DOUBLE_EQ(val1, val2) \
1972 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
1975#define EXPECT_NEAR(val1, val2, abs_error) \
1976 EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, val1, val2, \
1979#define ASSERT_NEAR(val1, val2, abs_error) \
1980 ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, val1, val2, \
1990GTEST_API_ AssertionResult FloatLE(
const char* expr1,
const char* expr2,
1991 float val1,
float val2);
1992GTEST_API_ AssertionResult DoubleLE(
const char* expr1,
const char* expr2,
1993 double val1,
double val2);
2006#define EXPECT_HRESULT_SUCCEEDED(expr) \
2007 EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
2009#define ASSERT_HRESULT_SUCCEEDED(expr) \
2010 ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
2012#define EXPECT_HRESULT_FAILED(expr) \
2013 EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
2015#define ASSERT_HRESULT_FAILED(expr) \
2016 ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
2030#define ASSERT_NO_FATAL_FAILURE(statement) \
2031 GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
2032#define EXPECT_NO_FATAL_FAILURE(statement) \
2033 GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
2052 template <
typename T>
2053 ScopedTrace(
const char* file,
int line,
const T& message) {
2054 PushTrace(file, line, (
Message() << message).GetString());
2058 ScopedTrace(
const char* file,
int line,
const char* message) {
2059 PushTrace(file, line, message ? message :
"(null)");
2062 ScopedTrace(
const char* file,
int line,
const std::string& message) {
2063 PushTrace(file, line, message);
2073 void PushTrace(
const char* file,
int line, std::string message);
2077} GTEST_ATTRIBUTE_UNUSED_;
2096#define SCOPED_TRACE(message) \
2097 ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)( \
2098 __FILE__, __LINE__, (message))
2130template <
typename T1,
typename T2>
2131constexpr bool StaticAssertTypeEq() noexcept {
2132 static_assert(std::is_same<T1, T2>::value,
"T1 and T2 are not the same type");
2161#define GTEST_TEST(test_suite_name, test_name) \
2162 GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \
2163 ::testing::internal::GetTestTypeId())
2167#if !GTEST_DONT_DEFINE_TEST
2168#define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name)
2196#define GTEST_TEST_F(test_fixture, test_name) \
2197 GTEST_TEST_(test_fixture, test_name, test_fixture, \
2198 ::testing::internal::GetTypeId<test_fixture>())
2199#if !GTEST_DONT_DEFINE_TEST_F
2200#define TEST_F(test_fixture, test_name) GTEST_TEST_F(test_fixture, test_name)
2205GTEST_API_ std::string TempDir();
2269template <
int&... ExplicitParameterBarrier,
typename Factory>
2270TestInfo* RegisterTest(
const char* test_suite_name,
const char* test_name,
2271 const char* type_param,
const char* value_param,
2272 const char* file,
int line, Factory factory) {
2273 using TestT =
typename std::remove_pointer<
decltype(factory())>::type;
2275 class FactoryImpl :
public internal::TestFactoryBase {
2277 explicit FactoryImpl(Factory f) : factory_(std::move(f)) {}
2278 Test* CreateTest()
override {
return factory_(); }
2284 return internal::MakeAndRegisterTestInfo(
2285 test_suite_name, test_name, type_param, value_param,
2286 internal::CodeLocation(file, line), internal::GetTypeId<TestT>(),
2287 internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(file, line),
2288 internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file, line),
2289 new FactoryImpl{std::move(factory)});
2302int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
2304inline
int RUN_ALL_TESTS() { return ::testing::UnitTest::GetInstance()->Run(); }
2306GTEST_DISABLE_MSC_WARNINGS_POP_()
Definition gtest-message.h:92
Definition gtest-internal-inl.h:465
Definition gtest-port.h:1842
Definition gtest-param-util.h:396
Definition gtest-param-util.h:689
Definition gtest-internal.h:868
Definition gtest_unittest.cc:153
Definition gtest-internal.h:449
Definition gtest-internal-inl.h:1035
Definition gtest-internal-inl.h:504
Definition gtest_unittest.cc:177
Definition gtest-internal.h:490
Definition gtest-internal-inl.h:456