37#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
38#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
40#include "gtest/internal/gtest-port.h"
44# include <sys/types.h>
49#if GTEST_HAS_EXCEPTIONS
65#include "gtest/gtest-message.h"
66#include "gtest/internal/gtest-filepath.h"
67#include "gtest/internal/gtest-string.h"
68#include "gtest/internal/gtest-type-util.h"
78#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
79#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
90#define GTEST_STRINGIFY_HELPER_(name, ...) #name
91#define GTEST_STRINGIFY_(...) GTEST_STRINGIFY_HELPER_(__VA_ARGS__, )
101class AssertionResult;
109::std::string PrintToString(
const T& value);
119GTEST_API_
extern const char kStackTraceMarker[];
132 template <
typename T,
133 typename std::enable_if<!std::is_convertible<T, Sink>::value,
139GTEST_API_ std::string AppendUserMessage(
140 const std::string& gtest_msg,
const Message& user_msg);
142#if GTEST_HAS_EXCEPTIONS
144GTEST_DISABLE_MSC_WARNINGS_PUSH_(4275 \
153class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
155 explicit GoogleTestFailureException(
const TestPartResult& failure);
158GTEST_DISABLE_MSC_WARNINGS_POP_()
162namespace edit_distance {
168enum EditType { kMatch, kAdd, kRemove, kReplace };
169GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
170 const std::vector<size_t>& left,
const std::vector<size_t>& right);
173GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
174 const std::vector<std::string>& left,
175 const std::vector<std::string>& right);
178GTEST_API_ std::string CreateUnifiedDiff(
const std::vector<std::string>& left,
179 const std::vector<std::string>& right,
188GTEST_API_ std::string DiffStrings(
const std::string& left,
189 const std::string& right,
190 size_t* total_line_count);
207GTEST_API_ AssertionResult EqFailure(
const char* expected_expression,
208 const char* actual_expression,
209 const std::string& expected_value,
210 const std::string& actual_value,
214GTEST_API_ std::string GetBoolAssertionFailureMessage(
215 const AssertionResult& assertion_result,
216 const char* expression_text,
217 const char* actual_predicate_value,
218 const char* expected_predicate_value);
249template <
typename RawType>
254 typedef typename TypeWithSize<
sizeof(RawType)>::UInt Bits;
259 static const size_t kBitCount = 8*
sizeof(RawType);
262 static const size_t kFractionBitCount =
263 std::numeric_limits<RawType>::digits - 1;
266 static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
269 static const Bits kSignBitMask =
static_cast<Bits
>(1) << (kBitCount - 1);
272 static const Bits kFractionBitMask =
273 ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
276 static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
290 static const uint32_t kMaxUlps = 4;
305 static RawType ReinterpretBits(
const Bits bits) {
312 static RawType Infinity() {
313 return ReinterpretBits(kExponentBitMask);
317 static RawType Max();
322 const Bits &bits()
const {
return u_.bits_; }
325 Bits exponent_bits()
const {
return kExponentBitMask & u_.bits_; }
328 Bits fraction_bits()
const {
return kFractionBitMask & u_.bits_; }
331 Bits sign_bit()
const {
return kSignBitMask & u_.bits_; }
334 bool is_nan()
const {
337 return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
349 if (is_nan() || rhs.is_nan())
return false;
351 return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
357 union FloatingPointUnion {
377 static Bits SignAndMagnitudeToBiased(
const Bits &sam) {
378 if (kSignBitMask & sam) {
383 return kSignBitMask | sam;
389 static Bits DistanceBetweenSignAndMagnitudeNumbers(
const Bits &sam1,
391 const Bits biased1 = SignAndMagnitudeToBiased(sam1);
392 const Bits biased2 = SignAndMagnitudeToBiased(sam2);
393 return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
396 FloatingPointUnion u_;
404inline double FloatingPoint<double>::Max() {
return DBL_MAX; }
408typedef FloatingPoint<float> Float;
409typedef FloatingPoint<double> Double;
417typedef const void* TypeId;
448GTEST_API_ TypeId GetTestTypeId();
458 virtual Test* CreateTest() = 0;
469template <
class TestClass>
472 Test* CreateTest()
override {
return new TestClass; }
481GTEST_API_ AssertionResult IsHRESULTSuccess(
const char* expr,
483GTEST_API_ AssertionResult IsHRESULTFailure(
const char* expr,
489using SetUpTestSuiteFunc = void (*)();
490using TearDownTestSuiteFunc = void (*)();
494 : file(a_file), line(a_line) {}
504using SetUpTearDownSuiteFuncType = void (*)();
506inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull(
507 SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) {
508 return a == def ? nullptr : a;
519 typename std::conditional<
sizeof(T) != 0,
::testing::Test,
void>::type;
521 static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(
const char* filename,
523#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
524 SetUpTearDownSuiteFuncType test_case_fp =
525 GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
526 SetUpTearDownSuiteFuncType test_suite_fp =
527 GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);
529 GTEST_CHECK_(!test_case_fp || !test_suite_fp)
530 <<
"Test can not provide both SetUpTestSuite and SetUpTestCase, please "
531 "make sure there is only one present at "
532 << filename <<
":" << line_num;
534 return test_case_fp !=
nullptr ? test_case_fp : test_suite_fp;
538 return &T::SetUpTestSuite;
542 static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(
const char* filename,
544#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
545 SetUpTearDownSuiteFuncType test_case_fp =
546 GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
547 SetUpTearDownSuiteFuncType test_suite_fp =
548 GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);
550 GTEST_CHECK_(!test_case_fp || !test_suite_fp)
551 <<
"Test can not provide both TearDownTestSuite and TearDownTestCase,"
552 " please make sure there is only one present at"
553 << filename <<
":" << line_num;
555 return test_case_fp !=
nullptr ? test_case_fp : test_suite_fp;
559 return &T::TearDownTestSuite;
582GTEST_API_
TestInfo* MakeAndRegisterTestInfo(
583 const char* test_suite_name,
const char* name,
const char* type_param,
585 TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
591GTEST_API_
bool SkipPrefix(
const char* prefix,
const char** pstr);
593GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
597class GTEST_API_ TypedTestSuitePState {
599 TypedTestSuitePState() : registered_(false) {}
604 bool AddTestName(
const char* file,
int line,
const char* case_name,
605 const char* test_name) {
608 "%s Test %s must be defined before "
609 "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n",
610 FormatFileLocation(file, line).c_str(), test_name, case_name);
614 registered_tests_.insert(
615 ::std::make_pair(test_name, CodeLocation(file, line)));
619 bool TestExists(
const std::string& test_name)
const {
620 return registered_tests_.count(test_name) > 0;
623 const CodeLocation& GetCodeLocation(
const std::string& test_name)
const {
624 RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
625 GTEST_CHECK_(it != registered_tests_.end());
632 const char* VerifyRegisteredTestNames(
const char* test_suite_name,
633 const char* file,
int line,
634 const char* registered_tests);
637 typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
640 RegisteredTestsMap registered_tests_;
644#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
645using TypedTestCasePState = TypedTestSuitePState;
648GTEST_DISABLE_MSC_WARNINGS_POP_()
652inline const
char* SkipComma(const
char* str) {
653 const char* comma = strchr(str,
',');
654 if (comma ==
nullptr) {
657 while (IsSpace(*(++comma))) {}
663inline std::string GetPrefixUntilComma(
const char* str) {
664 const char* comma = strchr(str,
',');
665 return comma ==
nullptr ? str : std::string(str, comma);
670void SplitString(const ::std::string& str,
char delimiter,
671 ::std::vector< ::std::string>* dest);
676 template <
typename T>
677 static std::string GetName(
int i) {
678 return StreamableToString(i);
682template <
typename Prov
ided = DefaultNameGenerator>
684 typedef Provided type;
687template <
typename NameGenerator>
688void GenerateNamesRecursively(
internal::None, std::vector<std::string>*,
int) {}
690template <
typename NameGenerator,
typename Types>
691void GenerateNamesRecursively(
Types, std::vector<std::string>* result,
int i) {
692 result->push_back(NameGenerator::template GetName<typename Types::Head>(i));
693 GenerateNamesRecursively<NameGenerator>(
typename Types::Tail(), result,
697template <
typename NameGenerator,
typename Types>
698std::vector<std::string> GenerateNames() {
699 std::vector<std::string> result;
700 GenerateNamesRecursively<NameGenerator>(Types(), &result, 0);
711template <GTEST_TEMPLATE_ Fixture,
class TestSel,
typename Types>
718 static bool Register(
const char* prefix,
const CodeLocation& code_location,
719 const char* case_name,
const char* test_names,
int index,
720 const std::vector<std::string>& type_names =
721 GenerateNames<DefaultNameGenerator, Types>()) {
722 typedef typename Types::Head
Type;
724 typedef typename GTEST_BIND_(TestSel,
Type) TestClass;
728 MakeAndRegisterTestInfo(
729 (std::string(prefix) + (prefix[0] ==
'\0' ?
"" :
"/") + case_name +
730 "/" + type_names[
static_cast<size_t>(index)])
732 StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
733 GetTypeName<Type>().c_str(),
735 code_location, GetTypeId<FixtureClass>(),
737 code_location.file.c_str(), code_location.line),
739 code_location.file.c_str(), code_location.line),
744 typename Types::Tail>::Register(prefix,
754template <GTEST_TEMPLATE_ Fixture,
class TestSel>
758 const char* ,
const char* ,
760 const std::vector<std::string>& =
761 std::vector<std::string>() ) {
766GTEST_API_
void RegisterTypeParameterizedTestSuite(
const char* test_suite_name,
768GTEST_API_
void RegisterTypeParameterizedTestSuiteInstantiation(
769 const char* case_name);
775template <GTEST_TEMPLATE_ Fixture,
typename Tests,
typename Types>
778 static bool Register(
const char* prefix,
CodeLocation code_location,
779 const TypedTestSuitePState* state,
const char* case_name,
780 const char* test_names,
781 const std::vector<std::string>& type_names =
782 GenerateNames<DefaultNameGenerator, Types>()) {
783 RegisterTypeParameterizedTestSuiteInstantiation(case_name);
784 std::string test_name = StripTrailingSpaces(
785 GetPrefixUntilComma(test_names));
786 if (!state->TestExists(test_name)) {
787 fprintf(stderr,
"Failed to get code location for test %s.%s at %s.",
788 case_name, test_name.c_str(),
789 FormatFileLocation(code_location.file.c_str(),
790 code_location.line).c_str());
794 const CodeLocation& test_location = state->GetCodeLocation(test_name);
796 typedef typename Tests::Head Head;
800 prefix, test_location, case_name, test_names, 0, type_names);
804 Types>::Register(prefix, code_location,
806 SkipComma(test_names),
812template <GTEST_TEMPLATE_ Fixture,
typename Types>
816 const TypedTestSuitePState* ,
817 const char* ,
const char* ,
818 const std::vector<std::string>& =
819 std::vector<std::string>() ) {
834GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
835 UnitTest* unit_test,
int skip_count);
841GTEST_API_
bool AlwaysTrue();
844inline bool AlwaysFalse() {
return !AlwaysTrue(); }
851 operator bool()
const {
return true; }
861 explicit operator bool()
const {
return true; }
872 static const uint32_t kMaxRange = 1u << 31;
874 explicit Random(uint32_t seed) : state_(seed) {}
876 void Reseed(uint32_t seed) { state_ = seed; }
880 uint32_t Generate(uint32_t range);
884 GTEST_DISALLOW_COPY_AND_ASSIGN_(
Random);
888#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
889 typename std::remove_const<typename std::remove_reference<T>::type>::type
897 template <
typename C>
898 static auto CheckDebugString(C*) ->
typename std::is_same<
899 std::string,
decltype(std::declval<const C>().DebugString())>::type;
901 static std::false_type CheckDebugString(...);
903 template <
typename C>
904 static auto CheckShortDebugString(C*) ->
typename std::is_same<
905 std::string,
decltype(std::declval<const C>().ShortDebugString())>::type;
907 static std::false_type CheckShortDebugString(...);
909 using HasDebugStringType =
decltype(CheckDebugString<T>(
nullptr));
910 using HasShortDebugStringType =
decltype(CheckShortDebugString<T>(
nullptr));
913 static constexpr bool value =
914 HasDebugStringType::value && HasShortDebugStringType::value;
944typedef int IsContainer;
946 class Iterator =
decltype(::std::declval<const C&>().begin()),
947 class =
decltype(::std::declval<const C&>().end()),
948 class =
decltype(++::std::declval<Iterator&>()),
949 class =
decltype(*::std::declval<Iterator>()),
950 class =
typename C::const_iterator>
951IsContainer IsContainerTest(
int ) {
955typedef char IsNotContainer;
957IsNotContainer IsContainerTest(
long ) {
return '\0'; }
966 template <
typename U>
967 static char test(
typename U::hasher*,
typename U::reverse_iterator*);
968 template <
typename U>
969 static int test(
typename U::hasher*, ...);
970 template <
typename U>
971 static char test(...);
974 static const bool value =
sizeof(test<T>(
nullptr,
nullptr)) ==
sizeof(
int);
981 bool =
sizeof(IsContainerTest<C>(0)) ==
sizeof(IsContainer)>
993 using value_type =
decltype(*std::declval<typename C::const_iterator>());
995 std::is_same<
typename std::remove_const<
996 typename std::remove_reference<value_type>::type>::type,
1006template <
typename C>
1015template <
typename T,
typename U>
1016bool ArrayEq(
const T* lhs,
size_t size,
const U* rhs);
1019template <
typename T,
typename U>
1020inline bool ArrayEq(
const T& lhs,
const U& rhs) {
return lhs == rhs; }
1023template <
typename T,
typename U,
size_t N>
1024inline bool ArrayEq(
const T(&lhs)[N],
const U(&rhs)[N]) {
1025 return internal::ArrayEq(lhs, N, rhs);
1031template <
typename T,
typename U>
1032bool ArrayEq(
const T* lhs,
size_t size,
const U* rhs) {
1033 for (
size_t i = 0; i != size; i++) {
1034 if (!internal::ArrayEq(lhs[i], rhs[i]))
1042template <
typename Iter,
typename Element>
1043Iter ArrayAwareFind(Iter begin, Iter end,
const Element& elem) {
1044 for (Iter it = begin; it != end; ++it) {
1045 if (internal::ArrayEq(*it, elem))
1055template <
typename T,
typename U>
1056void CopyArray(
const T* from,
size_t size, U* to);
1059template <
typename T,
typename U>
1060inline void CopyArray(
const T& from, U* to) { *to = from; }
1063template <
typename T,
typename U,
size_t N>
1064inline void CopyArray(
const T(&from)[N], U(*to)[N]) {
1065 internal::CopyArray(from, N, *to);
1071template <
typename T,
typename U>
1072void CopyArray(
const T* from,
size_t size, U* to) {
1073 for (
size_t i = 0; i != size; i++) {
1074 internal::CopyArray(from[i], to + i);
1093template <
typename Element>
1097 typedef Element value_type;
1098 typedef Element* iterator;
1099 typedef const Element* const_iterator;
1103 InitRef(array, count);
1108 InitCopy(array, count);
1113 (this->*rhs.clone_)(rhs.array_, rhs.size_);
1117 if (clone_ != &NativeArray::InitRef)
1122 size_t size()
const {
return size_; }
1123 const_iterator begin()
const {
return array_; }
1124 const_iterator end()
const {
return array_ + size_; }
1126 return size() == rhs.size() &&
1127 ArrayEq(begin(), size(), rhs.begin());
1131 static_assert(!std::is_const<Element>::value,
"Type must not be const");
1132 static_assert(!std::is_reference<Element>::value,
1133 "Type must not be a reference");
1136 void InitCopy(
const Element* array,
size_t a_size) {
1137 Element*
const copy =
new Element[a_size];
1138 CopyArray(array, a_size, copy);
1141 clone_ = &NativeArray::InitCopy;
1145 void InitRef(
const Element* array,
size_t a_size) {
1148 clone_ = &NativeArray::InitRef;
1151 const Element* array_;
1153 void (
NativeArray::*clone_)(
const Element*, size_t);
1157template <
size_t... Is>
1163template <
bool plus_one,
typename T,
size_t sizeofT>
1165template <
size_t... I,
size_t sizeofT>
1169template <
size_t... I,
size_t sizeofT>
1178 :
DoubleSequence<N % 2 == 1, typename MakeIndexSequenceImpl<N / 2>::type,
1187template <
typename... T>
1188using IndexSequenceFor =
typename MakeIndexSequence<
sizeof...(T)>::type;
1197template <
size_t... I>
1203 template <
typename R>
1207template <
size_t N,
typename... T>
1211 static_cast<T (*)()
>(
nullptr)...));
1216template <
typename... T>
1219template <
typename Derived,
size_t I>
1222template <
typename... T,
size_t I>
1224 using value_type =
typename ElemFromList<I, T...>::type;
1226 template <
typename Arg>
1228 : value(std::forward<Arg>(t)) {}
1232template <
typename Derived,
typename Idx>
1235template <
size_t... Idx,
typename... T>
1240 template <
typename... Args>
1243 std::forward<Args>(args))... {}
1246 const typename ElemFromList<I, T...>::type& Get()
const {
1255 template <
typename F>
1256 auto Apply(F&& f) ->
decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
1257 return std::forward<F>(f)(Get<Idx>()...);
1260 template <
typename F>
1261 auto Apply(F&& f)
const ->
decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
1262 return std::forward<F>(f)(Get<Idx>()...);
1275template <
typename... T>
1278 typename MakeIndexSequence<sizeof...(T)>::type> {
1280 FlatTuple<T...>,
typename MakeIndexSequence<
sizeof...(T)>::type>::Indices;
1284 template <
typename... Args>
1286 : FlatTuple::FlatTupleBase(tag, std::forward<Args>(args)...) {}
1288 using FlatTuple::FlatTupleBase::Apply;
1289 using FlatTuple::FlatTupleBase::Get;
1294GTEST_INTERNAL_DEPRECATED(
1295 "INSTANTIATE_TEST_CASE_P is deprecated, please use "
1296 "INSTANTIATE_TEST_SUITE_P")
1297constexpr
bool InstantiateTestCase_P_IsDeprecated() {
return true; }
1299GTEST_INTERNAL_DEPRECATED(
1300 "TYPED_TEST_CASE_P is deprecated, please use "
1301 "TYPED_TEST_SUITE_P")
1302constexpr
bool TypedTestCase_P_IsDeprecated() {
return true; }
1304GTEST_INTERNAL_DEPRECATED(
1305 "TYPED_TEST_CASE is deprecated, please use "
1307constexpr
bool TypedTestCaseIsDeprecated() {
return true; }
1309GTEST_INTERNAL_DEPRECATED(
1310 "REGISTER_TYPED_TEST_CASE_P is deprecated, please use "
1311 "REGISTER_TYPED_TEST_SUITE_P")
1312constexpr
bool RegisterTypedTestCase_P_IsDeprecated() {
return true; }
1314GTEST_INTERNAL_DEPRECATED(
1315 "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use "
1316 "INSTANTIATE_TYPED_TEST_SUITE_P")
1317constexpr
bool InstantiateTypedTestCase_P_IsDeprecated() {
return true; }
1327#pragma clang diagnostic push
1328#pragma clang diagnostic ignored "-Wmismatched-tags"
1330template <
typename... Ts>
1331struct tuple_size<testing::internal::FlatTuple<Ts...>>
1332 : std::integral_constant<size_t, sizeof...(Ts)> {};
1334#pragma clang diagnostic pop
1338#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
1339 ::testing::internal::AssertHelper(result_type, file, line, message) \
1340 = ::testing::Message()
1342#define GTEST_MESSAGE_(message, result_type) \
1343 GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
1345#define GTEST_FATAL_FAILURE_(message) \
1346 return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
1348#define GTEST_NONFATAL_FAILURE_(message) \
1349 GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
1351#define GTEST_SUCCESS_(message) \
1352 GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
1354#define GTEST_SKIP_(message) \
1355 return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip)
1362#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
1363 if (::testing::internal::AlwaysTrue()) { \
1366 static_assert(true, "")
1368#if GTEST_HAS_EXCEPTIONS
1375 const char* what() const noexcept {
1376 return "this exception should never be thrown";
1385#define GTEST_EXCEPTION_TYPE_(e) ::testing::internal::GetTypeName(typeid(e))
1389#define GTEST_EXCEPTION_TYPE_(e) \
1390 std::string { "an std::exception-derived error" }
1394#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception) \
1395 catch (typename std::conditional< \
1396 std::is_same<typename std::remove_cv<typename std::remove_reference< \
1397 expected_exception>::type>::type, \
1398 std::exception>::value, \
1399 const ::testing::internal::NeverThrown&, const std::exception&>::type \
1401 gtest_msg.value = "Expected: " #statement \
1402 " throws an exception of type " #expected_exception \
1403 ".\n Actual: it throws "; \
1404 gtest_msg.value += GTEST_EXCEPTION_TYPE_(e); \
1405 gtest_msg.value += " with description \""; \
1406 gtest_msg.value += e.what(); \
1407 gtest_msg.value += "\"."; \
1408 goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
1413#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)
1417#define GTEST_TEST_THROW_(statement, expected_exception, fail) \
1418 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1419 if (::testing::internal::TrueWithString gtest_msg{}) { \
1420 bool gtest_caught_expected = false; \
1422 GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1423 } catch (expected_exception const&) { \
1424 gtest_caught_expected = true; \
1426 GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception) \
1428 gtest_msg.value = "Expected: " #statement \
1429 " throws an exception of type " #expected_exception \
1430 ".\n Actual: it throws a different type."; \
1431 goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
1433 if (!gtest_caught_expected) { \
1434 gtest_msg.value = "Expected: " #statement \
1435 " throws an exception of type " #expected_exception \
1436 ".\n Actual: it throws nothing."; \
1437 goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
1440 GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__) \
1441 : fail(gtest_msg.value.c_str())
1443#if GTEST_HAS_EXCEPTIONS
1445#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \
1446 catch (std::exception const& e) { \
1447 gtest_msg.value = "it throws "; \
1448 gtest_msg.value += GTEST_EXCEPTION_TYPE_(e); \
1449 gtest_msg.value += " with description \""; \
1450 gtest_msg.value += e.what(); \
1451 gtest_msg.value += "\"."; \
1452 goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
1457#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()
1461#define GTEST_TEST_NO_THROW_(statement, fail) \
1462 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1463 if (::testing::internal::TrueWithString gtest_msg{}) { \
1465 GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1467 GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \
1469 gtest_msg.value = "it throws."; \
1470 goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
1473 GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
1474 fail(("Expected: " #statement " doesn't throw an exception.\n" \
1475 " Actual: " + gtest_msg.value).c_str())
1477#define GTEST_TEST_ANY_THROW_(statement, fail) \
1478 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1479 if (::testing::internal::AlwaysTrue()) { \
1480 bool gtest_caught_any = false; \
1482 GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1485 gtest_caught_any = true; \
1487 if (!gtest_caught_any) { \
1488 goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
1491 GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
1492 fail("Expected: " #statement " throws an exception.\n" \
1493 " Actual: it doesn't.")
1499#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
1500 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1501 if (const ::testing::AssertionResult gtest_ar_ = \
1502 ::testing::AssertionResult(expression)) \
1505 fail(::testing::internal::GetBoolAssertionFailureMessage(\
1506 gtest_ar_, text, #actual, #expected).c_str())
1508#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
1509 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1510 if (::testing::internal::AlwaysTrue()) { \
1511 ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
1512 GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1513 if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
1514 goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
1517 GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
1518 fail("Expected: " #statement " doesn't generate new fatal " \
1519 "failures in the current thread.\n" \
1520 " Actual: it does.")
1523#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
1524 test_suite_name##_##test_name##_Test
1527#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id) \
1528 static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1, \
1529 "test_suite_name must not be empty"); \
1530 static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1, \
1531 "test_name must not be empty"); \
1532 class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
1533 : public parent_class { \
1535 GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default; \
1536 ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \
1537 GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name, \
1539 GTEST_DISALLOW_MOVE_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name, \
1543 void TestBody() override; \
1544 static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_; \
1547 ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name, \
1548 test_name)::test_info_ = \
1549 ::testing::internal::MakeAndRegisterTestInfo( \
1550 #test_suite_name, #test_name, nullptr, nullptr, \
1551 ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
1552 ::testing::internal::SuiteApiResolver< \
1553 parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__), \
1554 ::testing::internal::SuiteApiResolver< \
1555 parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__), \
1556 new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_( \
1557 test_suite_name, test_name)>); \
1558 void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
Definition gtest_skip_test.cc:42
Definition gtest-message.h:91
Definition gtest-internal.h:1278
Definition gtest-internal.h:250
Definition gtest-internal.h:895
Definition gtest-internal.h:122
Definition gtest-internal.h:1094
Definition gtest-internal.h:870
Definition gtest-internal.h:452
Definition gtest-internal.h:470
Definition gtest-internal.h:420
Definition gtest-internal.h:712
Definition gtest-internal.h:776
Definition gtest-port.h:2170
Iter(n, format, sep='')
Definition gen_gtest_pred_impl.py:190
Type
Type of JSON value.
Definition rapidjson.h:680
Definition gtest-internal.h:492
Definition gtest-internal.h:849
Definition gtest-internal.h:675
Definition gtest-internal.h:1164
Definition gtest-internal.h:1208
Definition gtest-internal.h:1196
Definition gtest-internal.h:1233
Definition gtest-internal.h:1214
Definition gtest-internal.h:1220
Definition gtest-internal.h:1191
Definition gtest-internal.h:1158
Definition gtest-internal.h:964
Definition gtest-internal.h:1007
Definition gtest-internal.h:982
Definition gtest-internal.h:1179
Definition gtest-internal.h:683
Definition gtest-type-util.h:102
Definition gtest-type-util.h:153
Definition gtest-internal.h:1083
Definition gtest-internal.h:1082
Definition gtest-internal.h:515
Definition gtest-internal.h:857
Definition gtest-type-util.h:139