39#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
40#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
42#include "gtest/internal/gtest-port.h"
51#if GTEST_HAS_EXCEPTIONS
69#include "gtest/gtest-message.h"
70#include "gtest/internal/gtest-filepath.h"
71#include "gtest/internal/gtest-string.h"
72#include "gtest/internal/gtest-type-util.h"
82#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
83#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo##bar
94#define GTEST_STRINGIFY_HELPER_(name, ...) #name
95#define GTEST_STRINGIFY_(...) GTEST_STRINGIFY_HELPER_(__VA_ARGS__, )
105class AssertionResult;
113::std::string PrintToString(
const T& value);
123GTEST_API_
extern const char kStackTraceMarker[];
137 template <
typename T,
138 typename std::enable_if<!std::is_convertible<T, Sink>::value,
144GTEST_API_ std::string AppendUserMessage(
const std::string& gtest_msg,
147#if GTEST_HAS_EXCEPTIONS
149GTEST_DISABLE_MSC_WARNINGS_PUSH_(
158class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
160 explicit GoogleTestFailureException(
const TestPartResult& failure);
163GTEST_DISABLE_MSC_WARNINGS_POP_()
167namespace edit_distance {
173enum EditType { kMatch, kAdd, kRemove, kReplace };
174GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
175 const std::vector<size_t>& left,
const std::vector<size_t>& right);
178GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
179 const std::vector<std::string>& left,
180 const std::vector<std::string>& right);
183GTEST_API_ std::string CreateUnifiedDiff(
const std::vector<std::string>& left,
184 const std::vector<std::string>& right,
204GTEST_API_ AssertionResult EqFailure(
const char* expected_expression,
205 const char* actual_expression,
206 const std::string& expected_value,
207 const std::string& actual_value,
211GTEST_API_ std::string GetBoolAssertionFailureMessage(
212 const AssertionResult& assertion_result,
const char* expression_text,
213 const char* actual_predicate_value,
const char* expected_predicate_value);
244template <
typename RawType>
249 typedef typename TypeWithSize<
sizeof(RawType)>::UInt Bits;
254 static const size_t kBitCount = 8 *
sizeof(RawType);
257 static const size_t kFractionBitCount =
258 std::numeric_limits<RawType>::digits - 1;
261 static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
264 static const Bits kSignBitMask =
static_cast<Bits
>(1) << (kBitCount - 1);
267 static const Bits kFractionBitMask = ~static_cast<Bits>(0) >>
268 (kExponentBitCount + 1);
271 static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
285 static const uint32_t kMaxUlps = 4;
300 static RawType ReinterpretBits(
const Bits bits) {
307 static RawType Infinity() {
return ReinterpretBits(kExponentBitMask); }
310 static RawType Max();
315 const Bits& bits()
const {
return u_.bits_; }
318 Bits exponent_bits()
const {
return kExponentBitMask & u_.bits_; }
321 Bits fraction_bits()
const {
return kFractionBitMask & u_.bits_; }
324 Bits sign_bit()
const {
return kSignBitMask & u_.bits_; }
327 bool is_nan()
const {
330 return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
342 if (is_nan() || rhs.is_nan())
return false;
344 return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) <=
350 union FloatingPointUnion {
370 static Bits SignAndMagnitudeToBiased(
const Bits& sam) {
371 if (kSignBitMask & sam) {
376 return kSignBitMask | sam;
382 static Bits DistanceBetweenSignAndMagnitudeNumbers(
const Bits& sam1,
384 const Bits biased1 = SignAndMagnitudeToBiased(sam1);
385 const Bits biased2 = SignAndMagnitudeToBiased(sam2);
386 return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
389 FloatingPointUnion u_;
399inline double FloatingPoint<double>::Max() {
405typedef FloatingPoint<float> Float;
406typedef FloatingPoint<double> Double;
414typedef const void* TypeId;
445GTEST_API_ TypeId GetTestTypeId();
455 virtual Test* CreateTest() = 0;
467template <
class TestClass>
470 Test* CreateTest()
override {
return new TestClass; }
479GTEST_API_ AssertionResult IsHRESULTSuccess(
const char* expr,
481GTEST_API_ AssertionResult IsHRESULTFailure(
const char* expr,
487using SetUpTestSuiteFunc = void (*)();
488using TearDownTestSuiteFunc = void (*)();
492 : file(a_file), line(a_line) {}
502using SetUpTearDownSuiteFuncType = void (*)();
504inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull(
505 SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) {
506 return a == def ? nullptr : a;
517 typename std::conditional<
sizeof(T) != 0,
::testing::Test,
void>::type;
519 static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(
const char* filename,
521#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
522 SetUpTearDownSuiteFuncType test_case_fp =
523 GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
524 SetUpTearDownSuiteFuncType test_suite_fp =
525 GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);
527 GTEST_CHECK_(!test_case_fp || !test_suite_fp)
528 <<
"Test can not provide both SetUpTestSuite and SetUpTestCase, please "
529 "make sure there is only one present at "
530 << filename <<
":" << line_num;
532 return test_case_fp !=
nullptr ? test_case_fp : test_suite_fp;
536 return &T::SetUpTestSuite;
540 static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(
const char* filename,
542#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
543 SetUpTearDownSuiteFuncType test_case_fp =
544 GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
545 SetUpTearDownSuiteFuncType test_suite_fp =
546 GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);
548 GTEST_CHECK_(!test_case_fp || !test_suite_fp)
549 <<
"Test can not provide both TearDownTestSuite and TearDownTestCase,"
550 " please make sure there is only one present at"
551 << filename <<
":" << line_num;
553 return test_case_fp !=
nullptr ? test_case_fp : test_suite_fp;
557 return &T::TearDownTestSuite;
580GTEST_API_
TestInfo* MakeAndRegisterTestInfo(
581 const char* test_suite_name,
const char* name,
const char* type_param,
583 TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
589GTEST_API_
bool SkipPrefix(
const char* prefix,
const char** pstr);
591GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
595class GTEST_API_ TypedTestSuitePState {
597 TypedTestSuitePState() : registered_(false) {}
602 bool AddTestName(
const char* file,
int line,
const char* case_name,
603 const char* test_name) {
606 "%s Test %s must be defined before "
607 "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n",
608 FormatFileLocation(file, line).c_str(), test_name, case_name);
612 registered_tests_.insert(
613 ::std::make_pair(test_name, CodeLocation(file, line)));
617 bool TestExists(
const std::string& test_name)
const {
618 return registered_tests_.count(test_name) > 0;
621 const CodeLocation& GetCodeLocation(
const std::string& test_name)
const {
622 RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
623 GTEST_CHECK_(it != registered_tests_.end());
630 const char* VerifyRegisteredTestNames(
const char* test_suite_name,
631 const char* file,
int line,
632 const char* registered_tests);
635 typedef ::std::map<std::string, CodeLocation, std::less<>> RegisteredTestsMap;
638 RegisteredTestsMap registered_tests_;
642#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
643using TypedTestCasePState = TypedTestSuitePState;
646GTEST_DISABLE_MSC_WARNINGS_POP_()
650inline const
char* SkipComma(const
char* str) {
651 const char* comma = strchr(str,
',');
652 if (comma ==
nullptr) {
655 while (IsSpace(*(++comma))) {
662inline std::string GetPrefixUntilComma(
const char* str) {
663 const char* comma = strchr(str,
',');
664 return comma ==
nullptr ? str : std::string(str, comma);
669void SplitString(const ::std::string& str,
char delimiter,
670 ::std::vector<::std::string>* dest);
675 template <
typename T>
676 static std::string GetName(
int i) {
677 return StreamableToString(i);
681template <
typename Prov
ided = DefaultNameGenerator>
683 typedef Provided type;
686template <
typename NameGenerator>
687void GenerateNamesRecursively(
internal::None, std::vector<std::string>*,
int) {}
689template <
typename NameGenerator,
typename Types>
690void GenerateNamesRecursively(
Types, std::vector<std::string>* result,
int i) {
691 result->push_back(NameGenerator::template GetName<typename Types::Head>(i));
692 GenerateNamesRecursively<NameGenerator>(
typename Types::Tail(), result,
696template <
typename NameGenerator,
typename Types>
697std::vector<std::string> GenerateNames() {
698 std::vector<std::string> result;
699 GenerateNamesRecursively<NameGenerator>(Types(), &result, 0);
710template <GTEST_TEMPLATE_ Fixture,
class TestSel,
typename Types>
717 static bool Register(
const char* prefix,
const CodeLocation& code_location,
718 const char* case_name,
const char* test_names,
int index,
719 const std::vector<std::string>& type_names =
720 GenerateNames<DefaultNameGenerator, Types>()) {
721 typedef typename Types::Head Type;
723 typedef typename GTEST_BIND_(TestSel, Type) TestClass;
727 MakeAndRegisterTestInfo(
728 (std::string(prefix) + (prefix[0] ==
'\0' ?
"" :
"/") + case_name +
729 "/" + type_names[
static_cast<size_t>(index)])
731 StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
732 GetTypeName<Type>().c_str(),
734 code_location, GetTypeId<FixtureClass>(),
736 code_location.file.c_str(), code_location.line),
738 code_location.file.c_str(), code_location.line),
743 typename Types::Tail>::Register(prefix,
753template <GTEST_TEMPLATE_ Fixture,
class TestSel>
757 const char* ,
const char* ,
759 const std::vector<std::string>& =
760 std::vector<std::string>() ) {
765GTEST_API_
void RegisterTypeParameterizedTestSuite(
const char* test_suite_name,
767GTEST_API_
void RegisterTypeParameterizedTestSuiteInstantiation(
768 const char* case_name);
774template <GTEST_TEMPLATE_ Fixture,
typename Tests,
typename Types>
777 static bool Register(
const char* prefix,
CodeLocation code_location,
778 const TypedTestSuitePState* state,
const char* case_name,
779 const char* test_names,
780 const std::vector<std::string>& type_names =
781 GenerateNames<DefaultNameGenerator, Types>()) {
782 RegisterTypeParameterizedTestSuiteInstantiation(case_name);
783 std::string test_name =
784 StripTrailingSpaces(GetPrefixUntilComma(test_names));
785 if (!state->TestExists(test_name)) {
786 fprintf(stderr,
"Failed to get code location for test %s.%s at %s.",
787 case_name, test_name.c_str(),
788 FormatFileLocation(code_location.file.c_str(), code_location.line)
793 const CodeLocation& test_location = state->GetCodeLocation(test_name);
795 typedef typename Tests::Head Head;
799 prefix, test_location, case_name, test_names, 0, type_names);
803 Types>::Register(prefix, code_location,
805 SkipComma(test_names),
811template <GTEST_TEMPLATE_ Fixture,
typename Types>
815 const TypedTestSuitePState* ,
816 const char* ,
const char* ,
817 const std::vector<std::string>& =
818 std::vector<std::string>() ) {
833GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
int skip_count);
839GTEST_API_
bool AlwaysTrue();
842inline bool AlwaysFalse() {
return !AlwaysTrue(); }
849 operator bool()
const {
return true; }
859 explicit operator bool()
const {
return true; }
870 static const uint32_t kMaxRange = 1u << 31;
872 explicit Random(uint32_t seed) : state_(seed) {}
874 void Reseed(uint32_t seed) { state_ = seed; }
878 uint32_t Generate(uint32_t range);
887#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
888 typename std::remove_const<typename std::remove_reference<T>::type>::type
896 template <
typename C>
897 static auto CheckDebugString(C*) ->
typename std::is_same<
898 std::string,
decltype(std::declval<const C>().DebugString())>::type;
900 static std::false_type CheckDebugString(...);
902 template <
typename C>
903 static auto CheckShortDebugString(C*) ->
typename std::is_same<
904 std::string,
decltype(std::declval<const C>().ShortDebugString())>::type;
906 static std::false_type CheckShortDebugString(...);
908 using HasDebugStringType =
decltype(CheckDebugString<T>(
nullptr));
909 using HasShortDebugStringType =
decltype(CheckShortDebugString<T>(
nullptr));
912 static constexpr bool value =
913 HasDebugStringType::value && HasShortDebugStringType::value;
943typedef int IsContainer;
945 class Iterator =
decltype(::std::declval<const C&>().begin()),
946 class =
decltype(::std::declval<const C&>().end()),
947 class =
decltype(++::std::declval<Iterator&>()),
948 class =
decltype(*::std::declval<Iterator>()),
949 class =
typename C::const_iterator>
950IsContainer IsContainerTest(
int ) {
954typedef char IsNotContainer;
956IsNotContainer IsContainerTest(
long ) {
967 template <
typename U>
968 static char test(
typename U::hasher*,
typename U::reverse_iterator*);
969 template <
typename U>
970 static int test(
typename U::hasher*, ...);
971 template <
typename U>
972 static char test(...);
975 static const bool value =
sizeof(test<T>(
nullptr,
nullptr)) ==
sizeof(
int);
982 bool =
sizeof(IsContainerTest<C>(0)) ==
sizeof(IsContainer)>
994 using value_type =
decltype(*std::declval<typename C::const_iterator>());
996 std::is_same<
typename std::remove_const<
997 typename std::remove_reference<value_type>::type>::type,
1007template <
typename C>
1016template <
typename T,
typename U>
1017bool ArrayEq(
const T* lhs,
size_t size,
const U* rhs);
1020template <
typename T,
typename U>
1021inline bool ArrayEq(
const T& lhs,
const U& rhs) {
1026template <
typename T,
typename U,
size_t N>
1027inline bool ArrayEq(
const T (&lhs)[N],
const U (&rhs)[N]) {
1028 return internal::ArrayEq(lhs, N, rhs);
1034template <
typename T,
typename U>
1035bool ArrayEq(
const T* lhs,
size_t size,
const U* rhs) {
1036 for (
size_t i = 0; i != size; i++) {
1037 if (!internal::ArrayEq(lhs[i], rhs[i]))
return false;
1044template <
typename Iter,
typename Element>
1045Iter ArrayAwareFind(Iter begin, Iter end,
const Element& elem) {
1046 for (Iter it = begin; it != end; ++it) {
1047 if (internal::ArrayEq(*it, elem))
return it;
1056template <
typename T,
typename U>
1057void CopyArray(
const T* from,
size_t size, U* to);
1060template <
typename T,
typename U>
1061inline void CopyArray(
const T& from, U* to) {
1066template <
typename T,
typename U,
size_t N>
1067inline void CopyArray(
const T (&from)[N], U (*to)[N]) {
1068 internal::CopyArray(from, N, *to);
1074template <
typename T,
typename U>
1075void CopyArray(
const T* from,
size_t size, U* to) {
1076 for (
size_t i = 0; i != size; i++) {
1077 internal::CopyArray(from[i], to + i);
1096template <
typename Element>
1100 typedef Element value_type;
1101 typedef Element* iterator;
1102 typedef const Element* const_iterator;
1106 InitRef(array, count);
1111 InitCopy(array, count);
1116 (this->*rhs.clone_)(rhs.array_, rhs.size_);
1120 if (clone_ != &NativeArray::InitRef)
delete[] array_;
1124 size_t size()
const {
return size_; }
1125 const_iterator begin()
const {
return array_; }
1126 const_iterator end()
const {
return array_ + size_; }
1128 return size() == rhs.size() && ArrayEq(begin(), size(), rhs.begin());
1132 static_assert(!std::is_const<Element>::value,
"Type must not be const");
1133 static_assert(!std::is_reference<Element>::value,
1134 "Type must not be a reference");
1137 void InitCopy(
const Element* array,
size_t a_size) {
1138 Element*
const copy =
new Element[a_size];
1139 CopyArray(array, a_size, copy);
1142 clone_ = &NativeArray::InitCopy;
1146 void InitRef(
const Element* array,
size_t a_size) {
1149 clone_ = &NativeArray::InitRef;
1152 const Element* array_;
1154 void (
NativeArray::*clone_)(
const Element*, size_t);
1158template <
size_t... Is>
1164template <
bool plus_one,
typename T,
size_t sizeofT>
1166template <
size_t... I,
size_t sizeofT>
1170template <
size_t... I,
size_t sizeofT>
1179 :
DoubleSequence<N % 2 == 1, typename MakeIndexSequenceImpl<N / 2>::type,
1188template <
typename... T>
1189using IndexSequenceFor =
typename MakeIndexSequence<
sizeof...(T)>::type;
1198template <
size_t... I>
1204 template <
typename R>
1208template <
size_t N,
typename... T>
1212 static_cast<T (*)()
>(
nullptr)...));
1217template <
typename... T>
1220template <
typename Derived,
size_t I>
1223template <
typename... T,
size_t I>
1225 using value_type =
typename ElemFromList<I, T...>::type;
1227 template <
typename Arg>
1229 : value(std::forward<Arg>(t)) {}
1233template <
typename Derived,
typename Idx>
1236template <
size_t... Idx,
typename... T>
1241 template <
typename... Args>
1244 std::forward<Args>(args))... {}
1247 const typename ElemFromList<I, T...>::type& Get()
const {
1256 template <
typename F>
1257 auto Apply(F&& f) ->
decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
1258 return std::forward<F>(f)(Get<Idx>()...);
1261 template <
typename F>
1262 auto Apply(F&& f)
const ->
decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
1263 return std::forward<F>(f)(Get<Idx>()...);
1276template <
typename... T>
1279 typename MakeIndexSequence<sizeof...(T)>::type> {
1281 FlatTuple<T...>,
typename MakeIndexSequence<
sizeof...(T)>::type>::Indices;
1285 template <
typename... Args>
1287 : FlatTuple::FlatTupleBase(tag, std::forward<Args>(args)...) {}
1289 using FlatTuple::FlatTupleBase::Apply;
1290 using FlatTuple::FlatTupleBase::Get;
1295GTEST_INTERNAL_DEPRECATED(
1296 "INSTANTIATE_TEST_CASE_P is deprecated, please use "
1297 "INSTANTIATE_TEST_SUITE_P")
1298constexpr
bool InstantiateTestCase_P_IsDeprecated() {
return true; }
1300GTEST_INTERNAL_DEPRECATED(
1301 "TYPED_TEST_CASE_P is deprecated, please use "
1302 "TYPED_TEST_SUITE_P")
1303constexpr
bool TypedTestCase_P_IsDeprecated() {
return true; }
1305GTEST_INTERNAL_DEPRECATED(
1306 "TYPED_TEST_CASE is deprecated, please use "
1308constexpr
bool TypedTestCaseIsDeprecated() {
return true; }
1310GTEST_INTERNAL_DEPRECATED(
1311 "REGISTER_TYPED_TEST_CASE_P is deprecated, please use "
1312 "REGISTER_TYPED_TEST_SUITE_P")
1313constexpr
bool RegisterTypedTestCase_P_IsDeprecated() {
return true; }
1315GTEST_INTERNAL_DEPRECATED(
1316 "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use "
1317 "INSTANTIATE_TYPED_TEST_SUITE_P")
1318constexpr
bool InstantiateTypedTestCase_P_IsDeprecated() {
return true; }
1328#pragma clang diagnostic push
1329#pragma clang diagnostic ignored "-Wmismatched-tags"
1331template <
typename... Ts>
1332struct tuple_size<testing::internal::FlatTuple<Ts...>>
1333 : std::integral_constant<size_t, sizeof...(Ts)> {};
1335#pragma clang diagnostic pop
1339#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
1340 ::testing::internal::AssertHelper(result_type, file, line, message) = \
1341 ::testing::Message()
1343#define GTEST_MESSAGE_(message, result_type) \
1344 GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
1346#define GTEST_FATAL_FAILURE_(message) \
1347 return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
1349#define GTEST_NONFATAL_FAILURE_(message) \
1350 GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
1352#define GTEST_SUCCESS_(message) \
1353 GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
1355#define GTEST_SKIP_(message) \
1356 return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip)
1363#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
1364 if (::testing::internal::AlwaysTrue()) { \
1367 static_assert(true, "")
1369#if GTEST_HAS_EXCEPTIONS
1376 const char* what() const noexcept {
1377 return "this exception should never be thrown";
1386#define GTEST_EXCEPTION_TYPE_(e) ::testing::internal::GetTypeName(typeid(e))
1390#define GTEST_EXCEPTION_TYPE_(e) \
1391 std::string { "an std::exception-derived error" }
1395#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception) \
1396 catch (typename std::conditional< \
1397 std::is_same<typename std::remove_cv<typename std::remove_reference< \
1398 expected_exception>::type>::type, \
1399 std::exception>::value, \
1400 const ::testing::internal::NeverThrown&, const std::exception&>::type \
1402 gtest_msg.value = "Expected: " #statement \
1403 " throws an exception of type " #expected_exception \
1404 ".\n Actual: it throws "; \
1405 gtest_msg.value += GTEST_EXCEPTION_TYPE_(e); \
1406 gtest_msg.value += " with description \""; \
1407 gtest_msg.value += e.what(); \
1408 gtest_msg.value += "\"."; \
1409 goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
1414#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)
1418#define GTEST_TEST_THROW_(statement, expected_exception, fail) \
1419 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1420 if (::testing::internal::TrueWithString gtest_msg{}) { \
1421 bool gtest_caught_expected = false; \
1423 GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1424 } catch (expected_exception const&) { \
1425 gtest_caught_expected = true; \
1427 GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception) \
1429 gtest_msg.value = "Expected: " #statement \
1430 " throws an exception of type " #expected_exception \
1431 ".\n Actual: it throws a different type."; \
1432 goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
1434 if (!gtest_caught_expected) { \
1435 gtest_msg.value = "Expected: " #statement \
1436 " throws an exception of type " #expected_exception \
1437 ".\n Actual: it throws nothing."; \
1438 goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
1441 GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__) \
1442 : fail(gtest_msg.value.c_str())
1444#if GTEST_HAS_EXCEPTIONS
1446#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \
1447 catch (std::exception const& e) { \
1448 gtest_msg.value = "it throws "; \
1449 gtest_msg.value += GTEST_EXCEPTION_TYPE_(e); \
1450 gtest_msg.value += " with description \""; \
1451 gtest_msg.value += e.what(); \
1452 gtest_msg.value += "\"."; \
1453 goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
1458#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()
1462#define GTEST_TEST_NO_THROW_(statement, fail) \
1463 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1464 if (::testing::internal::TrueWithString gtest_msg{}) { \
1466 GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1468 GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \
1470 gtest_msg.value = "it throws."; \
1471 goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
1474 GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__) \
1475 : fail(("Expected: " #statement " doesn't throw an exception.\n" \
1480#define GTEST_TEST_ANY_THROW_(statement, fail) \
1481 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1482 if (::testing::internal::AlwaysTrue()) { \
1483 bool gtest_caught_any = false; \
1485 GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1487 gtest_caught_any = true; \
1489 if (!gtest_caught_any) { \
1490 goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
1493 GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__) \
1494 : fail("Expected: " #statement \
1495 " throws an exception.\n" \
1496 " Actual: it doesn't.")
1501#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
1502 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1503 if (const ::testing::AssertionResult gtest_ar_ = \
1504 ::testing::AssertionResult(expression)) \
1507 fail(::testing::internal::GetBoolAssertionFailureMessage( \
1508 gtest_ar_, text, #actual, #expected) \
1511#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
1512 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1513 if (::testing::internal::AlwaysTrue()) { \
1514 ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
1515 GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1516 if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
1517 goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
1520 GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__) \
1521 : fail("Expected: " #statement \
1522 " doesn't generate new fatal " \
1523 "failures in the current thread.\n" \
1524 " Actual: it does.")
1527#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
1528 test_suite_name##_##test_name##_Test
1531#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id) \
1532 static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1, \
1533 "test_suite_name must not be empty"); \
1534 static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1, \
1535 "test_name must not be empty"); \
1536 class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
1537 : public parent_class { \
1539 GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default; \
1540 ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \
1541 GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
1542 (const GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) &) = delete; \
1543 GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) & operator=( \
1544 const GTEST_TEST_CLASS_NAME_(test_suite_name, \
1545 test_name) &) = delete; \
1546 GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
1547 (GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) &&) noexcept = delete; \
1548 GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) & operator=( \
1549 GTEST_TEST_CLASS_NAME_(test_suite_name, \
1550 test_name) &&) noexcept = delete; \
1553 void TestBody() override; \
1554 static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_; \
1557 ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name, \
1558 test_name)::test_info_ = \
1559 ::testing::internal::MakeAndRegisterTestInfo( \
1560 #test_suite_name, #test_name, nullptr, nullptr, \
1561 ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
1562 ::testing::internal::SuiteApiResolver< \
1563 parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__), \
1564 ::testing::internal::SuiteApiResolver< \
1565 parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__), \
1566 new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_( \
1567 test_suite_name, test_name)>); \
1568 void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
Definition gtest_skip_test.cc:42
Definition gtest-message.h:92
Definition gtest-internal.h:1279
Definition gtest-internal.h:245
Definition gtest-internal.h:894
Definition gtest-internal.h:126
Definition gtest-internal.h:1097
Definition gtest-internal.h:868
Definition gtest-internal.h:449
Definition gtest-internal.h:468
Definition gtest-internal.h:417
Definition gtest-internal.h:711
Definition gtest-internal.h:775
Definition gtest-port.h:2160
Definition gtest-internal.h:490
Definition gtest-internal.h:847
Definition gtest-internal.h:674
Definition gtest-internal.h:1165
Definition gtest-internal.h:1209
Definition gtest-internal.h:1197
Definition gtest-internal.h:1234
Definition gtest-internal.h:1215
Definition gtest-internal.h:1221
Definition gtest-internal.h:1192
Definition gtest-internal.h:1159
Definition gtest-internal.h:965
Definition gtest-internal.h:1008
Definition gtest-internal.h:983
Definition gtest-internal.h:1180
Definition gtest-internal.h:682
Definition gtest-type-util.h:104
Definition gtest-type-util.h:156
Definition gtest-internal.h:1086
Definition gtest-internal.h:1085
Definition gtest-internal.h:513
Definition gtest-internal.h:855
Definition gtest-type-util.h:142