33#include "gtest/gtest.h"
34#include "gtest/internal/custom/gtest.h"
35#include "gtest/gtest-spi.h"
75#elif GTEST_OS_WINDOWS_MOBILE
90# include <sys/timeb.h>
91# include <sys/types.h>
94# if GTEST_OS_WINDOWS_MINGW
102# include <sys/time.h>
107#if GTEST_HAS_EXCEPTIONS
111#if GTEST_CAN_STREAM_RESULTS_
112# include <arpa/inet.h>
114# include <sys/socket.h>
115# include <sys/types.h>
118#include "src/gtest-internal-inl.h"
121# define vsnprintf _vsnprintf
126#include <crt_externs.h>
131#include "absl/debugging/failure_signal_handler.h"
132#include "absl/debugging/stacktrace.h"
133#include "absl/debugging/symbolize.h"
134#include "absl/strings/str_cat.h"
139using internal::CountIf;
140using internal::ForEach;
141using internal::GetElementOr;
142using internal::Shuffle;
148static const char kDisableTestFilter[] =
"DISABLED_*:*/DISABLED_*";
153static const char kDeathTestSuiteFilter[] =
"*DeathTest:*DeathTest/*";
156static const char kUniversalFilter[] =
"*";
159static const char kDefaultOutputFormat[] =
"xml";
161static const char kDefaultOutputFile[] =
"test_detail";
164static const char kTestShardIndex[] =
"GTEST_SHARD_INDEX";
166static const char kTestTotalShards[] =
"GTEST_TOTAL_SHARDS";
168static const char kTestShardStatusFile[] =
"GTEST_SHARD_STATUS_FILE";
174const char kStackTraceMarker[] =
"\nStack trace:\n";
178bool g_help_flag =
false;
181static FILE* OpenFileForWriting(
const std::string& output_file) {
182 FILE* fileout =
nullptr;
183 FilePath output_file_path(output_file);
184 FilePath output_dir(output_file_path.RemoveFileName());
186 if (output_dir.CreateDirectoriesRecursively()) {
187 fileout = posix::FOpen(output_file.c_str(),
"w");
189 if (fileout ==
nullptr) {
190 GTEST_LOG_(FATAL) <<
"Unable to open file \"" << output_file <<
"\"";
199static const char* GetDefaultFilter() {
200 const char*
const testbridge_test_only =
201 internal::posix::GetEnv(
"TESTBRIDGE_TEST_ONLY");
202 if (testbridge_test_only !=
nullptr) {
203 return testbridge_test_only;
205 return kUniversalFilter;
210static bool GetDefaultFailFast() {
211 const char*
const testbridge_test_runner_fail_fast =
212 internal::posix::GetEnv(
"TESTBRIDGE_TEST_RUNNER_FAIL_FAST");
213 if (testbridge_test_runner_fail_fast !=
nullptr) {
214 return strcmp(testbridge_test_runner_fail_fast,
"1") == 0;
220 fail_fast, internal::BoolFromGTestEnv(
"fail_fast", GetDefaultFailFast()),
221 "True if and only if a test failure should stop further test execution.");
224 also_run_disabled_tests,
225 internal::BoolFromGTestEnv(
"also_run_disabled_tests",
false),
226 "Run disabled tests too, in addition to the tests normally being run.");
229 break_on_failure, internal::BoolFromGTestEnv(
"break_on_failure",
false),
230 "True if and only if a failed assertion should be a debugger "
233GTEST_DEFINE_bool_(catch_exceptions,
234 internal::BoolFromGTestEnv(
"catch_exceptions",
true),
235 "True if and only if " GTEST_NAME_
236 " should catch exceptions and treat them as test failures.");
240 internal::StringFromGTestEnv(
"color",
"auto"),
241 "Whether to use colors in the output. Valid values: yes, no, "
242 "and auto. 'auto' means to use colors if the output is "
243 "being sent to a terminal and the TERM environment variable "
244 "is set to a terminal type that supports colors.");
248 internal::StringFromGTestEnv(
"filter", GetDefaultFilter()),
249 "A colon-separated list of glob (not regex) patterns "
250 "for filtering the tests to run, optionally followed by a "
251 "'-' and a : separated list of negative patterns (tests to "
252 "exclude). A test is run if it matches one of the positive "
253 "patterns and does not match any of the negative patterns.");
256 install_failure_signal_handler,
257 internal::BoolFromGTestEnv(
"install_failure_signal_handler",
false),
258 "If true and supported on the current platform, " GTEST_NAME_
" should "
259 "install a signal handler that dumps debugging information when fatal "
260 "signals are raised.");
262GTEST_DEFINE_bool_(list_tests,
false,
263 "List all tests without running them.");
272 internal::StringFromGTestEnv(
"output",
273 internal::OutputFlagAlsoCheckEnvVar().c_str()),
274 "A format (defaults to \"xml\" but can be specified to be \"json\"), "
275 "optionally followed by a colon and an output file name or directory. "
276 "A directory is indicated by a trailing pathname separator. "
277 "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "
278 "If a directory is specified, output files will be created "
279 "within that directory, with file-names based on the test "
280 "executable's name and, if necessary, made unique by adding "
284 brief, internal::BoolFromGTestEnv(
"brief",
false),
285 "True if only test failures should be displayed in text output.");
287GTEST_DEFINE_bool_(print_time, internal::BoolFromGTestEnv(
"print_time",
true),
288 "True if and only if " GTEST_NAME_
289 " should display elapsed time in text output.");
291GTEST_DEFINE_bool_(print_utf8, internal::BoolFromGTestEnv(
"print_utf8",
true),
292 "True if and only if " GTEST_NAME_
293 " prints UTF8 characters as text.");
297 internal::Int32FromGTestEnv(
"random_seed", 0),
298 "Random number seed to use when shuffling test orders. Must be in range "
299 "[1, 99999], or 0 to use a seed based on the current time.");
303 internal::Int32FromGTestEnv(
"repeat", 1),
304 "How many times to repeat each test. Specify a negative number "
305 "for repeating forever. Useful for shaking out flaky tests.");
307GTEST_DEFINE_bool_(show_internal_stack_frames,
false,
308 "True if and only if " GTEST_NAME_
309 " should include internal stack frames when "
310 "printing test failure stack traces.");
312GTEST_DEFINE_bool_(shuffle, internal::BoolFromGTestEnv(
"shuffle",
false),
313 "True if and only if " GTEST_NAME_
314 " should randomize tests' order on every run.");
318 internal::Int32FromGTestEnv(
"stack_trace_depth", kMaxStackTraceDepth),
319 "The maximum number of stack frames to print when an "
320 "assertion fails. The valid range is 0 through 100, inclusive.");
324 internal::StringFromGTestEnv(
"stream_result_to",
""),
325 "This flag specifies the host name and the port number on which to stream "
326 "test results. Example: \"localhost:555\". The flag is effective only on "
331 internal::BoolFromGTestEnv(
"throw_on_failure",
false),
332 "When this flag is specified, a failed assertion will throw an exception "
333 "if exceptions are enabled or exit the program with a non-zero code "
334 "otherwise. For use with an external test framework.");
336#if GTEST_USE_OWN_FLAGFILE_FLAG_
339 internal::StringFromGTestEnv(
"flagfile",
""),
340 "This flag specifies the flagfile to read command-line flags from.");
348uint32_t Random::Generate(uint32_t range) {
351 state_ =
static_cast<uint32_t
>(1103515245ULL*state_ + 12345U) % kMaxRange;
353 GTEST_CHECK_(range > 0)
354 <<
"Cannot generate a number in the range [0, 0).";
355 GTEST_CHECK_(range <= kMaxRange)
356 <<
"Generation of a number in [0, " << range <<
") was requested, "
357 <<
"but this can only generate numbers in [0, " << kMaxRange <<
").";
362 return state_ % range;
368static bool GTestIsInitialized() {
return GetArgvs().size() > 0; }
373static int SumOverTestSuiteList(
const std::vector<TestSuite*>& case_list,
374 int (TestSuite::*method)()
const) {
376 for (
size_t i = 0; i < case_list.size(); i++) {
377 sum += (case_list[i]->*method)();
383static bool TestSuitePassed(
const TestSuite* test_suite) {
384 return test_suite->should_run() && test_suite->Passed();
388static bool TestSuiteFailed(
const TestSuite* test_suite) {
389 return test_suite->should_run() && test_suite->Failed();
394static bool ShouldRunTestSuite(
const TestSuite* test_suite) {
395 return test_suite->should_run();
399AssertHelper::AssertHelper(TestPartResult::Type type,
403 : data_(new AssertHelperData(type, file, line, message)) {
406AssertHelper::~AssertHelper() {
411void AssertHelper::operator=(
const Message& message)
const {
412 UnitTest::GetInstance()->
413 AddTestPartResult(data_->type, data_->file, data_->line,
414 AppendUserMessage(data_->message, message),
415 UnitTest::GetInstance()->impl()
416 ->CurrentOsStackTraceExceptTop(1)
428constexpr bool kErrorOnUninstantiatedParameterizedTest =
true;
429constexpr bool kErrorOnUninstantiatedTypeParameterizedTest =
true;
432class FailureTest :
public Test {
434 explicit FailureTest(
const CodeLocation& loc, std::string error_message,
437 error_message_(std::move(error_message)),
438 as_error_(as_error) {}
440 void TestBody()
override {
442 AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
443 loc_.line,
"") = Message() << error_message_;
445 std::cout << error_message_ << std::endl;
450 const CodeLocation loc_;
451 const std::string error_message_;
452 const bool as_error_;
458std::set<std::string>* GetIgnoredParameterizedTestSuites() {
459 return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites();
463MarkAsIgnored::MarkAsIgnored(
const char* test_suite) {
464 GetIgnoredParameterizedTestSuites()->insert(test_suite);
469void InsertSyntheticTestCase(
const std::string& name, CodeLocation location,
471 const auto& ignored = *GetIgnoredParameterizedTestSuites();
472 if (ignored.find(name) != ignored.end())
return;
474 const char kMissingInstantiation[] =
475 " is defined via TEST_P, but never instantiated. None of the test cases "
476 "will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only "
477 "ones provided expand to nothing."
479 "Ideally, TEST_P definitions should only ever be included as part of "
480 "binaries that intend to use them. (As opposed to, for example, being "
481 "placed in a library that may be linked in to get other utilities.)";
483 const char kMissingTestCase[] =
484 " is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are "
485 "defined via TEST_P . No test cases will run."
487 "Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from "
488 "code that always depend on code that provides TEST_P. Failing to do "
489 "so is often an indication of dead code, e.g. the last TEST_P was "
490 "removed but the rest got left behind.";
492 std::string message =
493 "Parameterized test suite " + name +
494 (has_test_p ? kMissingInstantiation : kMissingTestCase) +
496 "To suppress this error for this test suite, insert the following line "
497 "(in a non-header) in the namespace it is defined in:"
499 "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + name +
");";
501 std::string full_name =
"UninstantiatedParameterizedTestSuite<" + name +
">";
503 "GoogleTestVerification", full_name.c_str(),
506 location.file.c_str(), location.line, [message, location] {
507 return new FailureTest(location, message,
508 kErrorOnUninstantiatedParameterizedTest);
512void RegisterTypeParameterizedTestSuite(
const char* test_suite_name,
513 CodeLocation code_location) {
514 GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
515 test_suite_name, code_location);
518void RegisterTypeParameterizedTestSuiteInstantiation(
const char* case_name) {
520 ->type_parameterized_test_registry()
521 .RegisterInstantiation(case_name);
524void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
525 const char* test_suite_name, CodeLocation code_location) {
526 suites_.emplace(std::string(test_suite_name),
527 TypeParameterizedTestSuiteInfo(code_location));
530void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
531 const char* test_suite_name) {
532 auto it = suites_.find(std::string(test_suite_name));
533 if (it != suites_.end()) {
534 it->second.instantiated =
true;
536 GTEST_LOG_(ERROR) <<
"Unknown type parameterized test suit '"
537 << test_suite_name <<
"'";
541void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
542 const auto& ignored = *GetIgnoredParameterizedTestSuites();
543 for (
const auto& testcase : suites_) {
544 if (testcase.second.instantiated)
continue;
545 if (ignored.find(testcase.first) != ignored.end())
continue;
547 std::string message =
548 "Type parameterized test suite " + testcase.first +
549 " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "
550 "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."
552 "Ideally, TYPED_TEST_P definitions should only ever be included as "
553 "part of binaries that intend to use them. (As opposed to, for "
554 "example, being placed in a library that may be linked in to get other "
557 "To suppress this error for this test suite, insert the following line "
558 "(in a non-header) in the namespace it is defined in:"
560 "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
561 testcase.first +
");";
563 std::string full_name =
564 "UninstantiatedTypeParameterizedTestSuite<" + testcase.first +
">";
566 "GoogleTestVerification", full_name.c_str(),
569 testcase.second.code_location.file.c_str(),
570 testcase.second.code_location.line, [message, testcase] {
571 return new FailureTest(testcase.second.code_location, message,
572 kErrorOnUninstantiatedTypeParameterizedTest);
578static ::std::vector<std::string> g_argvs;
580::std::vector<std::string> GetArgvs() {
581#if defined(GTEST_CUSTOM_GET_ARGVS_)
584 const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
585 return ::std::vector<std::string>(custom.begin(), custom.end());
593FilePath GetCurrentExecutableName() {
596#if GTEST_OS_WINDOWS || GTEST_OS_OS2
597 result.Set(FilePath(GetArgvs()[0]).RemoveExtension(
"exe"));
599 result.Set(FilePath(GetArgvs()[0]));
602 return result.RemoveDirectoryName();
608std::string UnitTestOptions::GetOutputFormat() {
609 const char*
const gtest_output_flag = GTEST_FLAG(output).c_str();
610 const char*
const colon = strchr(gtest_output_flag,
':');
611 return (colon ==
nullptr)
612 ? std::string(gtest_output_flag)
613 : std::string(gtest_output_flag,
614 static_cast<size_t>(colon - gtest_output_flag));
619std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
620 const char*
const gtest_output_flag = GTEST_FLAG(output).c_str();
622 std::string format = GetOutputFormat();
624 format = std::string(kDefaultOutputFormat);
626 const char*
const colon = strchr(gtest_output_flag,
':');
627 if (colon ==
nullptr)
628 return internal::FilePath::MakeFileName(
630 UnitTest::GetInstance()->original_working_dir()),
631 internal::FilePath(kDefaultOutputFile), 0,
632 format.c_str()).string();
634 internal::FilePath output_name(colon + 1);
635 if (!output_name.IsAbsolutePath())
636 output_name = internal::FilePath::ConcatPaths(
637 internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
638 internal::FilePath(colon + 1));
640 if (!output_name.IsDirectory())
641 return output_name.string();
643 internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
644 output_name, internal::GetCurrentExecutableName(),
645 GetOutputFormat().c_str()));
646 return result.string();
655static bool PatternMatchesString(
const std::string& name_str,
656 const char* pattern,
const char* pattern_end) {
657 const char* name = name_str.c_str();
658 const char*
const name_begin = name;
659 const char*
const name_end = name + name_str.size();
661 const char* pattern_next = pattern;
662 const char* name_next = name;
664 while (pattern < pattern_end || name < name_end) {
665 if (pattern < pattern_end) {
668 if (name < name_end && *name == *pattern) {
675 if (name < name_end) {
685 pattern_next = pattern;
686 name_next = name + 1;
692 if (name_begin < name_next && name_next <= name_end) {
693 pattern = pattern_next;
702bool UnitTestOptions::MatchesFilter(
const std::string& name_str,
703 const char* filter) {
705 const char* pattern = filter;
708 const char*
const next_sep = strchr(pattern,
':');
709 const char*
const pattern_end =
710 next_sep !=
nullptr ? next_sep : pattern + strlen(pattern);
713 if (PatternMatchesString(name_str, pattern, pattern_end)) {
719 if (next_sep ==
nullptr) {
722 pattern = next_sep + 1;
729bool UnitTestOptions::FilterMatchesTest(
const std::string& test_suite_name,
730 const std::string& test_name) {
731 const std::string& full_name = test_suite_name +
"." + test_name.c_str();
735 const char*
const p = GTEST_FLAG(filter).c_str();
736 const char*
const dash = strchr(p,
'-');
737 std::string positive;
738 std::string negative;
739 if (dash ==
nullptr) {
740 positive = GTEST_FLAG(filter).c_str();
743 positive = std::string(p, dash);
744 negative = std::string(dash + 1);
745 if (positive.empty()) {
747 positive = kUniversalFilter;
753 return (MatchesFilter(full_name, positive.c_str()) &&
754 !MatchesFilter(full_name, negative.c_str()));
761int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
770 const DWORD kCxxExceptionCode = 0xe06d7363;
772 bool should_handle =
true;
774 if (!GTEST_FLAG(catch_exceptions))
775 should_handle =
false;
776 else if (exception_code == EXCEPTION_BREAKPOINT)
777 should_handle =
false;
778 else if (exception_code == kCxxExceptionCode)
779 should_handle =
false;
781 return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
790ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
791 TestPartResultArray* result)
792 : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
800ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
801 InterceptMode intercept_mode, TestPartResultArray* result)
802 : intercept_mode_(intercept_mode),
807void ScopedFakeTestPartResultReporter::Init() {
808 internal::UnitTestImpl*
const impl = internal::GetUnitTestImpl();
809 if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
810 old_reporter_ = impl->GetGlobalTestPartResultReporter();
811 impl->SetGlobalTestPartResultReporter(
this);
813 old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
814 impl->SetTestPartResultReporterForCurrentThread(
this);
820ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
821 internal::UnitTestImpl*
const impl = internal::GetUnitTestImpl();
822 if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
823 impl->SetGlobalTestPartResultReporter(old_reporter_);
825 impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
831void ScopedFakeTestPartResultReporter::ReportTestPartResult(
832 const TestPartResult& result) {
833 result_->Append(result);
847TypeId GetTestTypeId() {
848 return GetTypeId<Test>();
853extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();
858static AssertionResult HasOneFailure(
const char* ,
861 const TestPartResultArray& results,
862 TestPartResult::Type type,
863 const std::string& substr) {
864 const std::string expected(type == TestPartResult::kFatalFailure ?
866 "1 non-fatal failure");
868 if (results.size() != 1) {
869 msg <<
"Expected: " << expected <<
"\n"
870 <<
" Actual: " << results.size() <<
" failures";
871 for (
int i = 0; i < results.size(); i++) {
872 msg <<
"\n" << results.GetTestPartResult(i);
874 return AssertionFailure() << msg;
877 const TestPartResult& r = results.GetTestPartResult(0);
878 if (r.type() != type) {
879 return AssertionFailure() <<
"Expected: " << expected <<
"\n"
884 if (strstr(r.message(), substr.c_str()) ==
nullptr) {
885 return AssertionFailure() <<
"Expected: " << expected <<
" containing \""
891 return AssertionSuccess();
897SingleFailureChecker::SingleFailureChecker(
const TestPartResultArray* results,
898 TestPartResult::Type type,
899 const std::string& substr)
900 : results_(results), type_(type), substr_(substr) {}
906SingleFailureChecker::~SingleFailureChecker() {
907 EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
910DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
911 UnitTestImpl* unit_test) : unit_test_(unit_test) {}
913void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
914 const TestPartResult& result) {
915 unit_test_->current_test_result()->AddTestPartResult(result);
916 unit_test_->listeners()->repeater()->OnTestPartResult(result);
919DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
920 UnitTestImpl* unit_test) : unit_test_(unit_test) {}
922void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
923 const TestPartResult& result) {
924 unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
928TestPartResultReporterInterface*
929UnitTestImpl::GetGlobalTestPartResultReporter() {
930 internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
931 return global_test_part_result_repoter_;
935void UnitTestImpl::SetGlobalTestPartResultReporter(
936 TestPartResultReporterInterface* reporter) {
937 internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
938 global_test_part_result_repoter_ = reporter;
942TestPartResultReporterInterface*
943UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
944 return per_thread_test_part_result_reporter_.get();
948void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
949 TestPartResultReporterInterface* reporter) {
950 per_thread_test_part_result_reporter_.set(reporter);
954int UnitTestImpl::successful_test_suite_count()
const {
955 return CountIf(test_suites_, TestSuitePassed);
959int UnitTestImpl::failed_test_suite_count()
const {
960 return CountIf(test_suites_, TestSuiteFailed);
964int UnitTestImpl::total_test_suite_count()
const {
965 return static_cast<int>(test_suites_.size());
970int UnitTestImpl::test_suite_to_run_count()
const {
971 return CountIf(test_suites_, ShouldRunTestSuite);
975int UnitTestImpl::successful_test_count()
const {
976 return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count);
980int UnitTestImpl::skipped_test_count()
const {
981 return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count);
985int UnitTestImpl::failed_test_count()
const {
986 return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count);
990int UnitTestImpl::reportable_disabled_test_count()
const {
991 return SumOverTestSuiteList(test_suites_,
992 &TestSuite::reportable_disabled_test_count);
996int UnitTestImpl::disabled_test_count()
const {
997 return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count);
1001int UnitTestImpl::reportable_test_count()
const {
1002 return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count);
1006int UnitTestImpl::total_test_count()
const {
1007 return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count);
1011int UnitTestImpl::test_to_run_count()
const {
1012 return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
1025std::string UnitTestImpl::CurrentOsStackTraceExceptTop(
int skip_count) {
1026 return os_stack_trace_getter()->CurrentStackTrace(
1027 static_cast<int>(GTEST_FLAG(stack_trace_depth)),
1037 Timer() : start_(std::chrono::steady_clock::now()) {}
1040 TimeInMillis Elapsed() {
1041 return std::chrono::duration_cast<std::chrono::milliseconds>(
1042 std::chrono::steady_clock::now() - start_)
1047 std::chrono::time_point<std::chrono::steady_clock> start_;
1053TimeInMillis GetTimeInMillis() {
1054 return std::chrono::duration_cast<std::chrono::milliseconds>(
1055 std::chrono::system_clock::now() -
1056 std::chrono::system_clock::from_time_t(0))
1064#if GTEST_OS_WINDOWS_MOBILE
1069LPCWSTR String::AnsiToUtf16(
const char* ansi) {
1070 if (!ansi)
return nullptr;
1071 const int length = strlen(ansi);
1072 const int unicode_length =
1073 MultiByteToWideChar(CP_ACP, 0, ansi, length,
nullptr, 0);
1074 WCHAR* unicode =
new WCHAR[unicode_length + 1];
1075 MultiByteToWideChar(CP_ACP, 0, ansi, length,
1076 unicode, unicode_length);
1077 unicode[unicode_length] = 0;
1085const char* String::Utf16ToAnsi(LPCWSTR utf16_str) {
1086 if (!utf16_str)
return nullptr;
1087 const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
nullptr,
1088 0,
nullptr,
nullptr);
1089 char* ansi =
new char[ansi_length + 1];
1090 WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length,
nullptr,
1092 ansi[ansi_length] = 0;
1104bool String::CStringEquals(
const char * lhs,
const char * rhs) {
1105 if (lhs ==
nullptr)
return rhs ==
nullptr;
1107 if (rhs ==
nullptr)
return false;
1109 return strcmp(lhs, rhs) == 0;
1112#if GTEST_HAS_STD_WSTRING
1116static void StreamWideCharsToMessage(
const wchar_t* wstr,
size_t length,
1118 for (
size_t i = 0; i != length; ) {
1119 if (wstr[i] != L
'\0') {
1120 *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
1121 while (i != length && wstr[i] != L
'\0')
1132void SplitString(const ::std::string& str,
char delimiter,
1133 ::std::vector< ::std::string>* dest) {
1134 ::std::vector< ::std::string> parsed;
1135 ::std::string::size_type pos = 0;
1136 while (::testing::internal::AlwaysTrue()) {
1137 const ::std::string::size_type colon = str.find(delimiter, pos);
1138 if (colon == ::std::string::npos) {
1139 parsed.push_back(str.substr(pos));
1142 parsed.push_back(str.substr(pos, colon - pos));
1156Message::Message() : ss_(new ::std::stringstream) {
1159 *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
1164Message& Message::operator <<(
const wchar_t* wide_c_str) {
1165 return *
this << internal::String::ShowWideCString(wide_c_str);
1167Message& Message::operator <<(
wchar_t* wide_c_str) {
1168 return *
this << internal::String::ShowWideCString(wide_c_str);
1171#if GTEST_HAS_STD_WSTRING
1174Message& Message::operator <<(const ::std::wstring& wstr) {
1175 internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(),
this);
1182std::string Message::GetString()
const {
1183 return internal::StringStreamToString(ss_.get());
1188AssertionResult::AssertionResult(
const AssertionResult& other)
1189 : success_(other.success_),
1190 message_(other.message_.get() != nullptr
1191 ? new ::std::string(*other.message_)
1192 : static_cast< ::std::string*>(nullptr)) {}
1195void AssertionResult::swap(AssertionResult& other) {
1197 swap(success_, other.success_);
1198 swap(message_, other.message_);
1202AssertionResult AssertionResult::operator!()
const {
1203 AssertionResult negation(!success_);
1204 if (message_.get() !=
nullptr) negation << *message_;
1209AssertionResult AssertionSuccess() {
1210 return AssertionResult(
true);
1214AssertionResult AssertionFailure() {
1215 return AssertionResult(
false);
1220AssertionResult AssertionFailure(
const Message& message) {
1221 return AssertionFailure() << message;
1226namespace edit_distance {
1227std::vector<EditType> CalculateOptimalEdits(
const std::vector<size_t>& left,
1228 const std::vector<size_t>& right) {
1229 std::vector<std::vector<double> > costs(
1230 left.size() + 1, std::vector<double>(right.size() + 1));
1231 std::vector<std::vector<EditType> > best_move(
1232 left.size() + 1, std::vector<EditType>(right.size() + 1));
1235 for (
size_t l_i = 0; l_i < costs.size(); ++l_i) {
1236 costs[l_i][0] =
static_cast<double>(l_i);
1237 best_move[l_i][0] = kRemove;
1240 for (
size_t r_i = 1; r_i < costs[0].size(); ++r_i) {
1241 costs[0][r_i] =
static_cast<double>(r_i);
1242 best_move[0][r_i] = kAdd;
1245 for (
size_t l_i = 0; l_i < left.size(); ++l_i) {
1246 for (
size_t r_i = 0; r_i < right.size(); ++r_i) {
1247 if (left[l_i] == right[r_i]) {
1249 costs[l_i + 1][r_i + 1] = costs[l_i][r_i];
1250 best_move[l_i + 1][r_i + 1] = kMatch;
1254 const double add = costs[l_i + 1][r_i];
1255 const double remove = costs[l_i][r_i + 1];
1256 const double replace = costs[l_i][r_i];
1257 if (add < remove && add < replace) {
1258 costs[l_i + 1][r_i + 1] = add + 1;
1259 best_move[l_i + 1][r_i + 1] = kAdd;
1260 }
else if (remove < add && remove < replace) {
1261 costs[l_i + 1][r_i + 1] = remove + 1;
1262 best_move[l_i + 1][r_i + 1] = kRemove;
1266 costs[l_i + 1][r_i + 1] = replace + 1.00001;
1267 best_move[l_i + 1][r_i + 1] = kReplace;
1273 std::vector<EditType> best_path;
1274 for (
size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {
1275 EditType move = best_move[l_i][r_i];
1276 best_path.push_back(move);
1277 l_i -= move != kAdd;
1278 r_i -= move != kRemove;
1280 std::reverse(best_path.begin(), best_path.end());
1287class InternalStrings {
1289 size_t GetId(
const std::string& str) {
1290 IdMap::iterator it = ids_.find(str);
1291 if (it != ids_.end())
return it->second;
1292 size_t id = ids_.size();
1293 return ids_[str] = id;
1297 typedef std::map<std::string, size_t> IdMap;
1303std::vector<EditType> CalculateOptimalEdits(
1304 const std::vector<std::string>& left,
1305 const std::vector<std::string>& right) {
1306 std::vector<size_t> left_ids, right_ids;
1308 InternalStrings intern_table;
1309 for (
size_t i = 0; i < left.size(); ++i) {
1310 left_ids.push_back(intern_table.GetId(left[i]));
1312 for (
size_t i = 0; i < right.size(); ++i) {
1313 right_ids.push_back(intern_table.GetId(right[i]));
1316 return CalculateOptimalEdits(left_ids, right_ids);
1327 Hunk(
size_t left_start,
size_t right_start)
1328 : left_start_(left_start),
1329 right_start_(right_start),
1334 void PushLine(
char edit,
const char* line) {
1339 hunk_.push_back(std::make_pair(
' ', line));
1343 hunk_removes_.push_back(std::make_pair(
'-', line));
1347 hunk_adds_.push_back(std::make_pair(
'+', line));
1352 void PrintTo(std::ostream* os) {
1355 for (std::list<std::pair<char, const char*> >::const_iterator it =
1357 it != hunk_.end(); ++it) {
1358 *os << it->first << it->second <<
"\n";
1362 bool has_edits()
const {
return adds_ || removes_; }
1366 hunk_.splice(hunk_.end(), hunk_removes_);
1367 hunk_.splice(hunk_.end(), hunk_adds_);
1374 void PrintHeader(std::ostream* ss)
const {
1377 *ss <<
"-" << left_start_ <<
"," << (removes_ + common_);
1379 if (removes_ && adds_) {
1383 *ss <<
"+" << right_start_ <<
"," << (adds_ + common_);
1388 size_t left_start_, right_start_;
1389 size_t adds_, removes_, common_;
1390 std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_;
1402std::string CreateUnifiedDiff(
const std::vector<std::string>& left,
1403 const std::vector<std::string>& right,
1405 const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
1407 size_t l_i = 0, r_i = 0, edit_i = 0;
1408 std::stringstream ss;
1409 while (edit_i < edits.size()) {
1411 while (edit_i < edits.size() && edits[edit_i] == kMatch) {
1418 const size_t prefix_context = std::min(l_i, context);
1419 Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
1420 for (
size_t i = prefix_context; i > 0; --i) {
1421 hunk.PushLine(
' ', left[l_i - i].c_str());
1426 size_t n_suffix = 0;
1427 for (; edit_i < edits.size(); ++edit_i) {
1428 if (n_suffix >= context) {
1430 auto it = edits.begin() +
static_cast<int>(edit_i);
1431 while (it != edits.end() && *it == kMatch) ++it;
1432 if (it == edits.end() ||
1433 static_cast<size_t>(it - edits.begin()) - edit_i >= context) {
1439 EditType edit = edits[edit_i];
1441 n_suffix = edit == kMatch ? n_suffix + 1 : 0;
1443 if (edit == kMatch || edit == kRemove || edit == kReplace) {
1444 hunk.PushLine(edit == kMatch ?
' ' :
'-', left[l_i].c_str());
1446 if (edit == kAdd || edit == kReplace) {
1447 hunk.PushLine(
'+', right[r_i].c_str());
1451 l_i += edit != kAdd;
1452 r_i += edit != kRemove;
1455 if (!hunk.has_edits()) {
1472std::vector<std::string> SplitEscapedString(
const std::string& str) {
1473 std::vector<std::string> lines;
1474 size_t start = 0, end = str.size();
1475 if (end > 2 && str[0] ==
'"' && str[end - 1] ==
'"') {
1479 bool escaped =
false;
1480 for (
size_t i = start; i + 1 < end; ++i) {
1483 if (str[i] ==
'n') {
1484 lines.push_back(str.substr(start, i - start - 1));
1488 escaped = str[i] ==
'\\';
1491 lines.push_back(str.substr(start, end - start));
1512AssertionResult EqFailure(
const char* lhs_expression,
1513 const char* rhs_expression,
1514 const std::string& lhs_value,
1515 const std::string& rhs_value,
1516 bool ignoring_case) {
1518 msg <<
"Expected equality of these values:";
1519 msg <<
"\n " << lhs_expression;
1520 if (lhs_value != lhs_expression) {
1521 msg <<
"\n Which is: " << lhs_value;
1523 msg <<
"\n " << rhs_expression;
1524 if (rhs_value != rhs_expression) {
1525 msg <<
"\n Which is: " << rhs_value;
1528 if (ignoring_case) {
1529 msg <<
"\nIgnoring case";
1532 if (!lhs_value.empty() && !rhs_value.empty()) {
1533 const std::vector<std::string> lhs_lines =
1534 SplitEscapedString(lhs_value);
1535 const std::vector<std::string> rhs_lines =
1536 SplitEscapedString(rhs_value);
1537 if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
1538 msg <<
"\nWith diff:\n"
1539 << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
1543 return AssertionFailure() << msg;
1547std::string GetBoolAssertionFailureMessage(
1548 const AssertionResult& assertion_result,
1549 const char* expression_text,
1550 const char* actual_predicate_value,
1551 const char* expected_predicate_value) {
1552 const char* actual_message = assertion_result.message();
1554 msg <<
"Value of: " << expression_text
1555 <<
"\n Actual: " << actual_predicate_value;
1556 if (actual_message[0] !=
'\0')
1557 msg <<
" (" << actual_message <<
")";
1558 msg <<
"\nExpected: " << expected_predicate_value;
1559 return msg.GetString();
1563AssertionResult DoubleNearPredFormat(
const char* expr1,
1565 const char* abs_error_expr,
1569 const double diff = fabs(val1 - val2);
1570 if (diff <= abs_error)
return AssertionSuccess();
1573 const double min_abs = std::min(fabs(val1), fabs(val2));
1575 const double epsilon =
1576 nextafter(min_abs, std::numeric_limits<double>::infinity()) - min_abs;
1583 if (!(std::isnan)(val1) && !(std::isnan)(val2) && abs_error > 0 &&
1584 abs_error < epsilon) {
1585 return AssertionFailure()
1586 <<
"The difference between " << expr1 <<
" and " << expr2 <<
" is "
1587 << diff <<
", where\n"
1588 << expr1 <<
" evaluates to " << val1 <<
",\n"
1589 << expr2 <<
" evaluates to " << val2 <<
".\nThe abs_error parameter "
1590 << abs_error_expr <<
" evaluates to " << abs_error
1591 <<
" which is smaller than the minimum distance between doubles for "
1592 "numbers of this magnitude which is "
1594 <<
", thus making this EXPECT_NEAR check equivalent to "
1595 "EXPECT_EQUAL. Consider using EXPECT_DOUBLE_EQ instead.";
1597 return AssertionFailure()
1598 <<
"The difference between " << expr1 <<
" and " << expr2
1599 <<
" is " << diff <<
", which exceeds " << abs_error_expr <<
", where\n"
1600 << expr1 <<
" evaluates to " << val1 <<
",\n"
1601 << expr2 <<
" evaluates to " << val2 <<
", and\n"
1602 << abs_error_expr <<
" evaluates to " << abs_error <<
".";
1607template <
typename RawType>
1608AssertionResult FloatingPointLE(
const char* expr1,
1614 return AssertionSuccess();
1618 const FloatingPoint<RawType> lhs(val1), rhs(val2);
1619 if (lhs.AlmostEquals(rhs)) {
1620 return AssertionSuccess();
1627 ::std::stringstream val1_ss;
1628 val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
1631 ::std::stringstream val2_ss;
1632 val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
1635 return AssertionFailure()
1636 <<
"Expected: (" << expr1 <<
") <= (" << expr2 <<
")\n"
1637 <<
" Actual: " << StringStreamToString(&val1_ss) <<
" vs "
1638 << StringStreamToString(&val2_ss);
1645AssertionResult FloatLE(
const char* expr1,
const char* expr2,
1646 float val1,
float val2) {
1647 return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
1652AssertionResult DoubleLE(
const char* expr1,
const char* expr2,
1653 double val1,
double val2) {
1654 return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
1660AssertionResult CmpHelperSTREQ(
const char* lhs_expression,
1661 const char* rhs_expression,
1664 if (String::CStringEquals(lhs, rhs)) {
1665 return AssertionSuccess();
1668 return EqFailure(lhs_expression,
1676AssertionResult CmpHelperSTRCASEEQ(
const char* lhs_expression,
1677 const char* rhs_expression,
1680 if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
1681 return AssertionSuccess();
1684 return EqFailure(lhs_expression,
1692AssertionResult CmpHelperSTRNE(
const char* s1_expression,
1693 const char* s2_expression,
1696 if (!String::CStringEquals(s1, s2)) {
1697 return AssertionSuccess();
1699 return AssertionFailure() <<
"Expected: (" << s1_expression <<
") != ("
1700 << s2_expression <<
"), actual: \""
1701 << s1 <<
"\" vs \"" << s2 <<
"\"";
1706AssertionResult CmpHelperSTRCASENE(
const char* s1_expression,
1707 const char* s2_expression,
1710 if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
1711 return AssertionSuccess();
1713 return AssertionFailure()
1714 <<
"Expected: (" << s1_expression <<
") != ("
1715 << s2_expression <<
") (ignoring case), actual: \""
1716 << s1 <<
"\" vs \"" << s2 <<
"\"";
1730bool IsSubstringPred(
const char* needle,
const char* haystack) {
1731 if (needle ==
nullptr || haystack ==
nullptr)
return needle == haystack;
1733 return strstr(haystack, needle) !=
nullptr;
1736bool IsSubstringPred(
const wchar_t* needle,
const wchar_t* haystack) {
1737 if (needle ==
nullptr || haystack ==
nullptr)
return needle == haystack;
1739 return wcsstr(haystack, needle) !=
nullptr;
1743template <
typename StringType>
1744bool IsSubstringPred(
const StringType& needle,
1745 const StringType& haystack) {
1746 return haystack.find(needle) != StringType::npos;
1753template <
typename StringType>
1754AssertionResult IsSubstringImpl(
1755 bool expected_to_be_substring,
1756 const char* needle_expr,
const char* haystack_expr,
1757 const StringType& needle,
const StringType& haystack) {
1758 if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
1759 return AssertionSuccess();
1761 const bool is_wide_string =
sizeof(needle[0]) > 1;
1762 const char*
const begin_string_quote = is_wide_string ?
"L\"" :
"\"";
1763 return AssertionFailure()
1764 <<
"Value of: " << needle_expr <<
"\n"
1765 <<
" Actual: " << begin_string_quote << needle <<
"\"\n"
1766 <<
"Expected: " << (expected_to_be_substring ?
"" :
"not ")
1767 <<
"a substring of " << haystack_expr <<
"\n"
1768 <<
"Which is: " << begin_string_quote << haystack <<
"\"";
1777AssertionResult IsSubstring(
1778 const char* needle_expr,
const char* haystack_expr,
1779 const char* needle,
const char* haystack) {
1780 return IsSubstringImpl(
true, needle_expr, haystack_expr, needle, haystack);
1783AssertionResult IsSubstring(
1784 const char* needle_expr,
const char* haystack_expr,
1785 const wchar_t* needle,
const wchar_t* haystack) {
1786 return IsSubstringImpl(
true, needle_expr, haystack_expr, needle, haystack);
1789AssertionResult IsNotSubstring(
1790 const char* needle_expr,
const char* haystack_expr,
1791 const char* needle,
const char* haystack) {
1792 return IsSubstringImpl(
false, needle_expr, haystack_expr, needle, haystack);
1795AssertionResult IsNotSubstring(
1796 const char* needle_expr,
const char* haystack_expr,
1797 const wchar_t* needle,
const wchar_t* haystack) {
1798 return IsSubstringImpl(
false, needle_expr, haystack_expr, needle, haystack);
1801AssertionResult IsSubstring(
1802 const char* needle_expr,
const char* haystack_expr,
1803 const ::std::string& needle, const ::std::string& haystack) {
1804 return IsSubstringImpl(
true, needle_expr, haystack_expr, needle, haystack);
1807AssertionResult IsNotSubstring(
1808 const char* needle_expr,
const char* haystack_expr,
1809 const ::std::string& needle, const ::std::string& haystack) {
1810 return IsSubstringImpl(
false, needle_expr, haystack_expr, needle, haystack);
1813#if GTEST_HAS_STD_WSTRING
1814AssertionResult IsSubstring(
1815 const char* needle_expr,
const char* haystack_expr,
1816 const ::std::wstring& needle, const ::std::wstring& haystack) {
1817 return IsSubstringImpl(
true, needle_expr, haystack_expr, needle, haystack);
1820AssertionResult IsNotSubstring(
1821 const char* needle_expr,
const char* haystack_expr,
1822 const ::std::wstring& needle, const ::std::wstring& haystack) {
1823 return IsSubstringImpl(
false, needle_expr, haystack_expr, needle, haystack);
1834AssertionResult HRESULTFailureHelper(
const char* expr,
1835 const char* expected,
1837# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE
1840 const char error_text[] =
"";
1847 const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
1848 FORMAT_MESSAGE_IGNORE_INSERTS;
1849 const DWORD kBufSize = 4096;
1851 char error_text[kBufSize] = {
'\0' };
1852 DWORD message_length = ::FormatMessageA(kFlags,
1854 static_cast<DWORD
>(hr),
1860 for (; message_length && IsSpace(error_text[message_length - 1]);
1862 error_text[message_length - 1] =
'\0';
1867 const std::string error_hex(
"0x" + String::FormatHexInt(hr));
1868 return ::testing::AssertionFailure()
1869 <<
"Expected: " << expr <<
" " << expected <<
".\n"
1870 <<
" Actual: " << error_hex <<
" " << error_text <<
"\n";
1875AssertionResult IsHRESULTSuccess(
const char* expr,
long hr) {
1876 if (SUCCEEDED(hr)) {
1877 return AssertionSuccess();
1879 return HRESULTFailureHelper(expr,
"succeeds", hr);
1882AssertionResult IsHRESULTFailure(
const char* expr,
long hr) {
1884 return AssertionSuccess();
1886 return HRESULTFailureHelper(expr,
"fails", hr);
1904constexpr uint32_t kMaxCodePoint1 = (
static_cast<uint32_t
>(1) << 7) - 1;
1907constexpr uint32_t kMaxCodePoint2 = (
static_cast<uint32_t
>(1) << (5 + 6)) - 1;
1910constexpr uint32_t kMaxCodePoint3 = (
static_cast<uint32_t
>(1) << (4 + 2*6)) - 1;
1913constexpr uint32_t kMaxCodePoint4 = (
static_cast<uint32_t
>(1) << (3 + 3*6)) - 1;
1918inline uint32_t ChopLowBits(uint32_t* bits,
int n) {
1919 const uint32_t low_bits = *bits & ((
static_cast<uint32_t
>(1) << n) - 1);
1930std::string CodePointToUtf8(uint32_t code_point) {
1931 if (code_point > kMaxCodePoint4) {
1932 return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) +
")";
1936 if (code_point <= kMaxCodePoint1) {
1938 str[0] =
static_cast<char>(code_point);
1939 }
else if (code_point <= kMaxCodePoint2) {
1941 str[1] =
static_cast<char>(0x80 | ChopLowBits(&code_point, 6));
1942 str[0] =
static_cast<char>(0xC0 | code_point);
1943 }
else if (code_point <= kMaxCodePoint3) {
1945 str[2] =
static_cast<char>(0x80 | ChopLowBits(&code_point, 6));
1946 str[1] =
static_cast<char>(0x80 | ChopLowBits(&code_point, 6));
1947 str[0] =
static_cast<char>(0xE0 | code_point);
1950 str[3] =
static_cast<char>(0x80 | ChopLowBits(&code_point, 6));
1951 str[2] =
static_cast<char>(0x80 | ChopLowBits(&code_point, 6));
1952 str[1] =
static_cast<char>(0x80 | ChopLowBits(&code_point, 6));
1953 str[0] =
static_cast<char>(0xF0 | code_point);
1965inline bool IsUtf16SurrogatePair(
wchar_t first,
wchar_t second) {
1966 return sizeof(wchar_t) == 2 &&
1967 (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
1971inline uint32_t CreateCodePointFromUtf16SurrogatePair(
wchar_t first,
1973 const auto first_u =
static_cast<uint32_t
>(first);
1974 const auto second_u =
static_cast<uint32_t
>(second);
1975 const uint32_t mask = (1 << 10) - 1;
1976 return (
sizeof(
wchar_t) == 2)
1977 ? (((first_u & mask) << 10) | (second_u & mask)) + 0x10000
1997std::string WideStringToUtf8(
const wchar_t* str,
int num_chars) {
1998 if (num_chars == -1)
1999 num_chars =
static_cast<int>(wcslen(str));
2001 ::std::stringstream stream;
2002 for (
int i = 0; i < num_chars; ++i) {
2003 uint32_t unicode_code_point;
2005 if (str[i] == L
'\0') {
2007 }
else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
2008 unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
2012 unicode_code_point =
static_cast<uint32_t
>(str[i]);
2015 stream << CodePointToUtf8(unicode_code_point);
2017 return StringStreamToString(&stream);
2022std::string String::ShowWideCString(
const wchar_t * wide_c_str) {
2023 if (wide_c_str ==
nullptr)
return "(null)";
2025 return internal::WideStringToUtf8(wide_c_str, -1);
2034bool String::WideCStringEquals(
const wchar_t * lhs,
const wchar_t * rhs) {
2035 if (lhs ==
nullptr)
return rhs ==
nullptr;
2037 if (rhs ==
nullptr)
return false;
2039 return wcscmp(lhs, rhs) == 0;
2043AssertionResult CmpHelperSTREQ(
const char* lhs_expression,
2044 const char* rhs_expression,
2046 const wchar_t* rhs) {
2047 if (String::WideCStringEquals(lhs, rhs)) {
2048 return AssertionSuccess();
2051 return EqFailure(lhs_expression,
2059AssertionResult CmpHelperSTRNE(
const char* s1_expression,
2060 const char* s2_expression,
2062 const wchar_t* s2) {
2063 if (!String::WideCStringEquals(s1, s2)) {
2064 return AssertionSuccess();
2067 return AssertionFailure() <<
"Expected: (" << s1_expression <<
") != ("
2068 << s2_expression <<
"), actual: "
2069 << PrintToString(s1)
2070 <<
" vs " << PrintToString(s2);
2079bool String::CaseInsensitiveCStringEquals(
const char * lhs,
const char * rhs) {
2080 if (lhs ==
nullptr)
return rhs ==
nullptr;
2081 if (rhs ==
nullptr)
return false;
2082 return posix::StrCaseCmp(lhs, rhs) == 0;
2097bool String::CaseInsensitiveWideCStringEquals(
const wchar_t* lhs,
2098 const wchar_t* rhs) {
2099 if (lhs ==
nullptr)
return rhs ==
nullptr;
2101 if (rhs ==
nullptr)
return false;
2104 return _wcsicmp(lhs, rhs) == 0;
2105#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
2106 return wcscasecmp(lhs, rhs) == 0;
2112 left = towlower(
static_cast<wint_t
>(*lhs++));
2113 right = towlower(
static_cast<wint_t
>(*rhs++));
2114 }
while (left && left == right);
2115 return left == right;
2121bool String::EndsWithCaseInsensitive(
2122 const std::string& str,
const std::string& suffix) {
2123 const size_t str_len = str.length();
2124 const size_t suffix_len = suffix.length();
2125 return (str_len >= suffix_len) &&
2126 CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
2131std::string String::FormatIntWidth2(
int value) {
2132 return FormatIntWidthN(value, 2);
2136std::string String::FormatIntWidthN(
int value,
int width) {
2137 std::stringstream ss;
2138 ss << std::setfill(
'0') << std::setw(width) << value;
2143std::string String::FormatHexUInt32(uint32_t value) {
2144 std::stringstream ss;
2145 ss << std::hex << std::uppercase << value;
2150std::string String::FormatHexInt(
int value) {
2151 return FormatHexUInt32(
static_cast<uint32_t
>(value));
2155std::string String::FormatByte(
unsigned char value) {
2156 std::stringstream ss;
2157 ss << std::setfill(
'0') << std::setw(2) << std::hex << std::uppercase
2158 <<
static_cast<unsigned int>(value);
2164std::string StringStreamToString(::std::stringstream* ss) {
2165 const ::std::string& str = ss->str();
2166 const char*
const start = str.c_str();
2167 const char*
const end = start + str.length();
2170 result.reserve(
static_cast<size_t>(2 * (end - start)));
2171 for (
const char* ch = start; ch != end; ++ch) {
2183std::string AppendUserMessage(
const std::string& gtest_msg,
2184 const Message& user_msg) {
2186 const std::string user_msg_string = user_msg.GetString();
2187 if (user_msg_string.empty()) {
2190 if (gtest_msg.empty()) {
2191 return user_msg_string;
2193 return gtest_msg +
"\n" + user_msg_string;
2201TestResult::TestResult()
2202 : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
2205TestResult::~TestResult() {
2211const TestPartResult& TestResult::GetTestPartResult(
int i)
const {
2212 if (i < 0 || i >= total_part_count())
2213 internal::posix::Abort();
2214 return test_part_results_.at(
static_cast<size_t>(i));
2220const TestProperty& TestResult::GetTestProperty(
int i)
const {
2221 if (i < 0 || i >= test_property_count())
2222 internal::posix::Abort();
2223 return test_properties_.at(
static_cast<size_t>(i));
2227void TestResult::ClearTestPartResults() {
2228 test_part_results_.clear();
2232void TestResult::AddTestPartResult(
const TestPartResult& test_part_result) {
2233 test_part_results_.push_back(test_part_result);
2239void TestResult::RecordProperty(
const std::string& xml_element,
2240 const TestProperty& test_property) {
2241 if (!ValidateTestProperty(xml_element, test_property)) {
2244 internal::MutexLock lock(&test_properites_mutex_);
2245 const std::vector<TestProperty>::iterator property_with_matching_key =
2246 std::find_if(test_properties_.begin(), test_properties_.end(),
2247 internal::TestPropertyKeyIs(test_property.key()));
2248 if (property_with_matching_key == test_properties_.end()) {
2249 test_properties_.push_back(test_property);
2252 property_with_matching_key->SetValue(test_property.value());
2257static const char*
const kReservedTestSuitesAttributes[] = {
2270static const char*
const kReservedTestSuiteAttributes[] = {
2271 "disabled",
"errors",
"failures",
"name",
2272 "tests",
"time",
"timestamp",
"skipped"};
2275static const char*
const kReservedTestCaseAttributes[] = {
2276 "classname",
"name",
"status",
"time",
"type_param",
2277 "value_param",
"file",
"line"};
2281static const char*
const kReservedOutputTestCaseAttributes[] = {
2282 "classname",
"name",
"status",
"time",
"type_param",
2283 "value_param",
"file",
"line",
"result",
"timestamp"};
2285template <
size_t kSize>
2286std::vector<std::string> ArrayAsVector(
const char*
const (&array)[kSize]) {
2287 return std::vector<std::string>(array, array + kSize);
2290static std::vector<std::string> GetReservedAttributesForElement(
2291 const std::string& xml_element) {
2292 if (xml_element ==
"testsuites") {
2293 return ArrayAsVector(kReservedTestSuitesAttributes);
2294 }
else if (xml_element ==
"testsuite") {
2295 return ArrayAsVector(kReservedTestSuiteAttributes);
2296 }
else if (xml_element ==
"testcase") {
2297 return ArrayAsVector(kReservedTestCaseAttributes);
2299 GTEST_CHECK_(
false) <<
"Unrecognized xml_element provided: " << xml_element;
2302 return std::vector<std::string>();
2306static std::vector<std::string> GetReservedOutputAttributesForElement(
2307 const std::string& xml_element) {
2308 if (xml_element ==
"testsuites") {
2309 return ArrayAsVector(kReservedTestSuitesAttributes);
2310 }
else if (xml_element ==
"testsuite") {
2311 return ArrayAsVector(kReservedTestSuiteAttributes);
2312 }
else if (xml_element ==
"testcase") {
2313 return ArrayAsVector(kReservedOutputTestCaseAttributes);
2315 GTEST_CHECK_(
false) <<
"Unrecognized xml_element provided: " << xml_element;
2318 return std::vector<std::string>();
2321static std::string FormatWordList(
const std::vector<std::string>& words) {
2323 for (
size_t i = 0; i < words.size(); ++i) {
2324 if (i > 0 && words.size() > 2) {
2327 if (i == words.size() - 1) {
2328 word_list <<
"and ";
2330 word_list <<
"'" << words[i] <<
"'";
2332 return word_list.GetString();
2335static bool ValidateTestPropertyName(
2336 const std::string& property_name,
2337 const std::vector<std::string>& reserved_names) {
2338 if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
2339 reserved_names.end()) {
2340 ADD_FAILURE() <<
"Reserved key used in RecordProperty(): " << property_name
2341 <<
" (" << FormatWordList(reserved_names)
2342 <<
" are reserved by " << GTEST_NAME_ <<
")";
2350bool TestResult::ValidateTestProperty(
const std::string& xml_element,
2351 const TestProperty& test_property) {
2352 return ValidateTestPropertyName(test_property.key(),
2353 GetReservedAttributesForElement(xml_element));
2357void TestResult::Clear() {
2358 test_part_results_.clear();
2359 test_properties_.clear();
2360 death_test_count_ = 0;
2365static bool TestPartSkipped(
const TestPartResult& result) {
2366 return result.skipped();
2370bool TestResult::Skipped()
const {
2371 return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
2375bool TestResult::Failed()
const {
2376 for (
int i = 0; i < total_part_count(); ++i) {
2377 if (GetTestPartResult(i).failed())
2384static bool TestPartFatallyFailed(
const TestPartResult& result) {
2385 return result.fatally_failed();
2389bool TestResult::HasFatalFailure()
const {
2390 return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
2394static bool TestPartNonfatallyFailed(
const TestPartResult& result) {
2395 return result.nonfatally_failed();
2399bool TestResult::HasNonfatalFailure()
const {
2400 return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
2405int TestResult::total_part_count()
const {
2406 return static_cast<int>(test_part_results_.size());
2410int TestResult::test_property_count()
const {
2411 return static_cast<int>(test_properties_.size());
2420 : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
2438void Test::TearDown() {
2442void Test::RecordProperty(
const std::string& key,
const std::string& value) {
2443 UnitTest::GetInstance()->RecordProperty(key, value);
2447void Test::RecordProperty(
const std::string& key,
int value) {
2448 Message value_message;
2449 value_message << value;
2450 RecordProperty(key, value_message.GetString().c_str());
2455void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
2456 const std::string& message) {
2459 UnitTest::GetInstance()->AddTestPartResult(
2474bool Test::HasSameFixtureClass() {
2475 internal::UnitTestImpl*
const impl = internal::GetUnitTestImpl();
2476 const TestSuite*
const test_suite = impl->current_test_suite();
2479 const TestInfo*
const first_test_info = test_suite->test_info_list()[0];
2480 const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
2481 const char*
const first_test_name = first_test_info->name();
2484 const TestInfo*
const this_test_info = impl->current_test_info();
2485 const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
2486 const char*
const this_test_name = this_test_info->name();
2488 if (this_fixture_id != first_fixture_id) {
2490 const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
2492 const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
2494 if (first_is_TEST || this_is_TEST) {
2501 const char*
const TEST_name =
2502 first_is_TEST ? first_test_name : this_test_name;
2503 const char*
const TEST_F_name =
2504 first_is_TEST ? this_test_name : first_test_name;
2507 <<
"All tests in the same test suite must use the same test fixture\n"
2508 <<
"class, so mixing TEST_F and TEST in the same test suite is\n"
2509 <<
"illegal. In test suite " << this_test_info->test_suite_name()
2511 <<
"test " << TEST_F_name <<
" is defined using TEST_F but\n"
2512 <<
"test " << TEST_name <<
" is defined using TEST. You probably\n"
2513 <<
"want to change the TEST to TEST_F or move it to another test\n"
2519 <<
"All tests in the same test suite must use the same test fixture\n"
2520 <<
"class. However, in test suite "
2521 << this_test_info->test_suite_name() <<
",\n"
2522 <<
"you defined test " << first_test_name <<
" and test "
2523 << this_test_name <<
"\n"
2524 <<
"using two different test fixture classes. This can happen if\n"
2525 <<
"the two classes are from different namespaces or translation\n"
2526 <<
"units and have the same name. You should probably rename one\n"
2527 <<
"of the classes to put the tests into different test suites.";
2541static std::string* FormatSehExceptionMessage(DWORD exception_code,
2542 const char* location) {
2544 message <<
"SEH exception with code 0x" << std::setbase(16) <<
2545 exception_code << std::setbase(10) <<
" thrown in " << location <<
".";
2547 return new std::string(message.GetString());
2554#if GTEST_HAS_EXCEPTIONS
2557static std::string FormatCxxExceptionMessage(
const char* description,
2558 const char* location) {
2560 if (description !=
nullptr) {
2561 message <<
"C++ exception with description \"" << description <<
"\"";
2563 message <<
"Unknown C++ exception";
2565 message <<
" thrown in " << location <<
".";
2567 return message.GetString();
2570static std::string PrintTestPartResultToString(
2571 const TestPartResult& test_part_result);
2573GoogleTestFailureException::GoogleTestFailureException(
2574 const TestPartResult& failure)
2575 : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
2587template <
class T,
typename Result>
2588Result HandleSehExceptionsInMethodIfSupported(
2589 T*
object, Result (T::*method)(),
const char* location) {
2592 return (object->*method)();
2593 } __except (internal::UnitTestOptions::GTestShouldProcessSEH(
2594 GetExceptionCode())) {
2598 std::string* exception_message = FormatSehExceptionMessage(
2599 GetExceptionCode(), location);
2600 internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
2601 *exception_message);
2602 delete exception_message;
2603 return static_cast<Result
>(0);
2607 return (object->*method)();
2614template <
class T,
typename Result>
2615Result HandleExceptionsInMethodIfSupported(
2616 T*
object, Result (T::*method)(),
const char* location) {
2640 if (internal::GetUnitTestImpl()->catch_exceptions()) {
2641#if GTEST_HAS_EXCEPTIONS
2643 return HandleSehExceptionsInMethodIfSupported(
object, method, location);
2644 }
catch (
const AssertionException&) {
2646 }
catch (
const internal::GoogleTestFailureException&) {
2651 }
catch (
const std::exception& e) {
2652 internal::ReportFailureInUnknownLocation(
2653 TestPartResult::kFatalFailure,
2654 FormatCxxExceptionMessage(e.what(), location));
2656 internal::ReportFailureInUnknownLocation(
2657 TestPartResult::kFatalFailure,
2658 FormatCxxExceptionMessage(
nullptr, location));
2660 return static_cast<Result
>(0);
2662 return HandleSehExceptionsInMethodIfSupported(
object, method, location);
2665 return (object->*method)();
2673 if (!HasSameFixtureClass())
return;
2675 internal::UnitTestImpl*
const impl = internal::GetUnitTestImpl();
2676 impl->os_stack_trace_getter()->UponLeavingGTest();
2677 internal::HandleExceptionsInMethodIfSupported(
this, &Test::SetUp,
"SetUp()");
2680 if (!HasFatalFailure() && !IsSkipped()) {
2681 impl->os_stack_trace_getter()->UponLeavingGTest();
2682 internal::HandleExceptionsInMethodIfSupported(
2683 this, &Test::TestBody,
"the test body");
2689 impl->os_stack_trace_getter()->UponLeavingGTest();
2690 internal::HandleExceptionsInMethodIfSupported(
2691 this, &Test::TearDown,
"TearDown()");
2695bool Test::HasFatalFailure() {
2696 return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
2700bool Test::HasNonfatalFailure() {
2701 return internal::GetUnitTestImpl()->current_test_result()->
2702 HasNonfatalFailure();
2706bool Test::IsSkipped() {
2707 return internal::GetUnitTestImpl()->current_test_result()->Skipped();
2714TestInfo::TestInfo(
const std::string& a_test_suite_name,
2715 const std::string& a_name,
const char* a_type_param,
2716 const char* a_value_param,
2717 internal::CodeLocation a_code_location,
2718 internal::TypeId fixture_class_id,
2719 internal::TestFactoryBase* factory)
2720 : test_suite_name_(a_test_suite_name),
2722 type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
2723 value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
2724 location_(a_code_location),
2725 fixture_class_id_(fixture_class_id),
2727 is_disabled_(false),
2728 matches_filter_(false),
2729 is_in_another_shard_(false),
2734TestInfo::~TestInfo() {
delete factory_; }
2756TestInfo* MakeAndRegisterTestInfo(
2757 const char* test_suite_name,
const char* name,
const char* type_param,
2758 const char* value_param, CodeLocation code_location,
2759 TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
2760 TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
2761 TestInfo*
const test_info =
2762 new TestInfo(test_suite_name, name, type_param, value_param,
2763 code_location, fixture_class_id, factory);
2764 GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
2768void ReportInvalidTestSuiteType(
const char* test_suite_name,
2769 CodeLocation code_location) {
2772 <<
"Attempted redefinition of test suite " << test_suite_name <<
".\n"
2773 <<
"All tests in the same test suite must use the same test fixture\n"
2774 <<
"class. However, in test suite " << test_suite_name <<
", you tried\n"
2775 <<
"to define a test using a fixture class different from the one\n"
2776 <<
"used earlier. This can happen if the two fixture classes are\n"
2777 <<
"from different namespaces and have the same name. You should\n"
2778 <<
"probably rename one of the classes to put the tests into different\n"
2781 GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
2783 <<
" " << errors.GetString();
2802 explicit TestNameIs(
const char* name)
2806 bool operator()(
const TestInfo * test_info)
const {
2807 return test_info && test_info->name() == name_;
2821void UnitTestImpl::RegisterParameterizedTests() {
2822 if (!parameterized_tests_registered_) {
2823 parameterized_test_registry_.RegisterTests();
2824 type_parameterized_test_registry_.CheckForInstantiations();
2825 parameterized_tests_registered_ =
true;
2833void TestInfo::Run() {
2834 if (!should_run_)
return;
2837 internal::UnitTestImpl*
const impl = internal::GetUnitTestImpl();
2838 impl->set_current_test_info(
this);
2840 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
2843 repeater->OnTestStart(*
this);
2845 result_.set_start_timestamp(internal::GetTimeInMillis());
2846 internal::Timer timer;
2848 impl->os_stack_trace_getter()->UponLeavingGTest();
2851 Test*
const test = internal::HandleExceptionsInMethodIfSupported(
2852 factory_, &internal::TestFactoryBase::CreateTest,
2853 "the test fixture's constructor");
2858 if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
2864 if (test !=
nullptr) {
2866 impl->os_stack_trace_getter()->UponLeavingGTest();
2867 internal::HandleExceptionsInMethodIfSupported(
2868 test, &Test::DeleteSelf_,
"the test fixture's destructor");
2871 result_.set_elapsed_time(timer.Elapsed());
2874 repeater->OnTestEnd(*
this);
2878 impl->set_current_test_info(
nullptr);
2882void TestInfo::Skip() {
2883 if (!should_run_)
return;
2885 internal::UnitTestImpl*
const impl = internal::GetUnitTestImpl();
2886 impl->set_current_test_info(
this);
2888 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
2891 repeater->OnTestStart(*
this);
2893 const TestPartResult test_part_result =
2894 TestPartResult(TestPartResult::kSkip, this->file(), this->line(),
"");
2895 impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
2899 repeater->OnTestEnd(*
this);
2900 impl->set_current_test_info(
nullptr);
2906int TestSuite::successful_test_count()
const {
2907 return CountIf(test_info_list_, TestPassed);
2911int TestSuite::skipped_test_count()
const {
2912 return CountIf(test_info_list_, TestSkipped);
2916int TestSuite::failed_test_count()
const {
2917 return CountIf(test_info_list_, TestFailed);
2921int TestSuite::reportable_disabled_test_count()
const {
2922 return CountIf(test_info_list_, TestReportableDisabled);
2926int TestSuite::disabled_test_count()
const {
2927 return CountIf(test_info_list_, TestDisabled);
2931int TestSuite::reportable_test_count()
const {
2932 return CountIf(test_info_list_, TestReportable);
2936int TestSuite::test_to_run_count()
const {
2937 return CountIf(test_info_list_, ShouldRunTest);
2941int TestSuite::total_test_count()
const {
2942 return static_cast<int>(test_info_list_.size());
2954TestSuite::TestSuite(
const char* a_name,
const char* a_type_param,
2955 internal::SetUpTestSuiteFunc set_up_tc,
2956 internal::TearDownTestSuiteFunc tear_down_tc)
2958 type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
2959 set_up_tc_(set_up_tc),
2960 tear_down_tc_(tear_down_tc),
2962 start_timestamp_(0),
2966TestSuite::~TestSuite() {
2968 ForEach(test_info_list_, internal::Delete<TestInfo>);
2973const TestInfo* TestSuite::GetTestInfo(
int i)
const {
2974 const int index = GetElementOr(test_indices_, i, -1);
2975 return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
2980TestInfo* TestSuite::GetMutableTestInfo(
int i) {
2981 const int index = GetElementOr(test_indices_, i, -1);
2982 return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
2987void TestSuite::AddTestInfo(TestInfo* test_info) {
2988 test_info_list_.push_back(test_info);
2989 test_indices_.push_back(
static_cast<int>(test_indices_.size()));
2993void TestSuite::Run() {
2994 if (!should_run_)
return;
2996 internal::UnitTestImpl*
const impl = internal::GetUnitTestImpl();
2997 impl->set_current_test_suite(
this);
2999 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
3002 repeater->OnTestSuiteStart(*
this);
3004#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3005 repeater->OnTestCaseStart(*
this);
3008 impl->os_stack_trace_getter()->UponLeavingGTest();
3009 internal::HandleExceptionsInMethodIfSupported(
3010 this, &TestSuite::RunSetUpTestSuite,
"SetUpTestSuite()");
3012 start_timestamp_ = internal::GetTimeInMillis();
3013 internal::Timer timer;
3014 for (
int i = 0; i < total_test_count(); i++) {
3015 GetMutableTestInfo(i)->Run();
3016 if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) {
3017 for (
int j = i + 1; j < total_test_count(); j++) {
3018 GetMutableTestInfo(j)->Skip();
3023 elapsed_time_ = timer.Elapsed();
3025 impl->os_stack_trace_getter()->UponLeavingGTest();
3026 internal::HandleExceptionsInMethodIfSupported(
3027 this, &TestSuite::RunTearDownTestSuite,
"TearDownTestSuite()");
3030 repeater->OnTestSuiteEnd(*
this);
3032#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3033 repeater->OnTestCaseEnd(*
this);
3036 impl->set_current_test_suite(
nullptr);
3040void TestSuite::Skip() {
3041 if (!should_run_)
return;
3043 internal::UnitTestImpl*
const impl = internal::GetUnitTestImpl();
3044 impl->set_current_test_suite(
this);
3046 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
3049 repeater->OnTestSuiteStart(*
this);
3051#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3052 repeater->OnTestCaseStart(*
this);
3055 for (
int i = 0; i < total_test_count(); i++) {
3056 GetMutableTestInfo(i)->Skip();
3060 repeater->OnTestSuiteEnd(*
this);
3062#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3063 repeater->OnTestCaseEnd(*
this);
3066 impl->set_current_test_suite(
nullptr);
3070void TestSuite::ClearResult() {
3071 ad_hoc_test_result_.Clear();
3072 ForEach(test_info_list_, TestInfo::ClearTestResult);
3076void TestSuite::ShuffleTests(internal::Random* random) {
3077 Shuffle(random, &test_indices_);
3081void TestSuite::UnshuffleTests() {
3082 for (
size_t i = 0; i < test_indices_.size(); i++) {
3083 test_indices_[i] =
static_cast<int>(i);
3092static std::string FormatCountableNoun(
int count,
3093 const char * singular_form,
3094 const char * plural_form) {
3095 return internal::StreamableToString(count) +
" " +
3096 (count == 1 ? singular_form : plural_form);
3100static std::string FormatTestCount(
int test_count) {
3101 return FormatCountableNoun(test_count,
"test",
"tests");
3105static std::string FormatTestSuiteCount(
int test_suite_count) {
3106 return FormatCountableNoun(test_suite_count,
"test suite",
"test suites");
3113static const char * TestPartResultTypeToString(TestPartResult::Type type) {
3115 case TestPartResult::kSkip:
3117 case TestPartResult::kSuccess:
3120 case TestPartResult::kNonFatalFailure:
3121 case TestPartResult::kFatalFailure:
3128 return "Unknown result type";
3134enum class GTestColor { kDefault, kRed, kGreen, kYellow };
3138static std::string PrintTestPartResultToString(
3139 const TestPartResult& test_part_result) {
3141 << internal::FormatFileLocation(test_part_result.file_name(),
3142 test_part_result.line_number())
3143 <<
" " << TestPartResultTypeToString(test_part_result.type())
3144 << test_part_result.message()).GetString();
3148static void PrintTestPartResult(
const TestPartResult& test_part_result) {
3149 const std::string& result =
3150 PrintTestPartResultToString(test_part_result);
3151 printf(
"%s\n", result.c_str());
3157#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
3161 ::OutputDebugStringA(result.c_str());
3162 ::OutputDebugStringA(
"\n");
3167#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
3168 !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
3171static WORD GetColorAttribute(GTestColor color) {
3173 case GTestColor::kRed:
3174 return FOREGROUND_RED;
3175 case GTestColor::kGreen:
3176 return FOREGROUND_GREEN;
3177 case GTestColor::kYellow:
3178 return FOREGROUND_RED | FOREGROUND_GREEN;
3183static int GetBitOffset(WORD color_mask) {
3184 if (color_mask == 0)
return 0;
3187 while ((color_mask & 1) == 0) {
3194static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
3196 static const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN |
3197 BACKGROUND_RED | BACKGROUND_INTENSITY;
3198 static const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN |
3199 FOREGROUND_RED | FOREGROUND_INTENSITY;
3200 const WORD existing_bg = old_color_attrs & background_mask;
3203 GetColorAttribute(color) | existing_bg | FOREGROUND_INTENSITY;
3204 static const int bg_bitOffset = GetBitOffset(background_mask);
3205 static const int fg_bitOffset = GetBitOffset(foreground_mask);
3207 if (((new_color & background_mask) >> bg_bitOffset) ==
3208 ((new_color & foreground_mask) >> fg_bitOffset)) {
3209 new_color ^= FOREGROUND_INTENSITY;
3218static const char* GetAnsiColorCode(GTestColor color) {
3220 case GTestColor::kRed:
3222 case GTestColor::kGreen:
3224 case GTestColor::kYellow:
3234bool ShouldUseColor(
bool stdout_is_tty) {
3235 const char*
const gtest_color = GTEST_FLAG(color).c_str();
3237 if (String::CaseInsensitiveCStringEquals(gtest_color,
"auto")) {
3238#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
3241 return stdout_is_tty;
3244 const char*
const term = posix::GetEnv(
"TERM");
3245 const bool term_supports_color =
3246 String::CStringEquals(term,
"xterm") ||
3247 String::CStringEquals(term,
"xterm-color") ||
3248 String::CStringEquals(term,
"xterm-256color") ||
3249 String::CStringEquals(term,
"screen") ||
3250 String::CStringEquals(term,
"screen-256color") ||
3251 String::CStringEquals(term,
"tmux") ||
3252 String::CStringEquals(term,
"tmux-256color") ||
3253 String::CStringEquals(term,
"rxvt-unicode") ||
3254 String::CStringEquals(term,
"rxvt-unicode-256color") ||
3255 String::CStringEquals(term,
"linux") ||
3256 String::CStringEquals(term,
"cygwin");
3257 return stdout_is_tty && term_supports_color;
3261 return String::CaseInsensitiveCStringEquals(gtest_color,
"yes") ||
3262 String::CaseInsensitiveCStringEquals(gtest_color,
"true") ||
3263 String::CaseInsensitiveCStringEquals(gtest_color,
"t") ||
3264 String::CStringEquals(gtest_color,
"1");
3275GTEST_ATTRIBUTE_PRINTF_(2, 3)
3276static
void ColoredPrintf(GTestColor color, const
char *fmt, ...) {
3278 va_start(args, fmt);
3280#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
3281 GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
3282 const bool use_color = AlwaysFalse();
3284 static const bool in_color_mode =
3285 ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
3286 const bool use_color = in_color_mode && (color != GTestColor::kDefault);
3295#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
3296 !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
3297 const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
3300 CONSOLE_SCREEN_BUFFER_INFO buffer_info;
3301 GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
3302 const WORD old_color_attrs = buffer_info.wAttributes;
3303 const WORD new_color = GetNewColor(color, old_color_attrs);
3309 SetConsoleTextAttribute(stdout_handle, new_color);
3315 SetConsoleTextAttribute(stdout_handle, old_color_attrs);
3317 printf(
"\033[0;3%sm", GetAnsiColorCode(color));
3326static const char kTypeParamLabel[] =
"TypeParam";
3327static const char kValueParamLabel[] =
"GetParam()";
3329static void PrintFullTestCommentIfPresent(
const TestInfo& test_info) {
3330 const char*
const type_param = test_info.type_param();
3331 const char*
const value_param = test_info.value_param();
3333 if (type_param !=
nullptr || value_param !=
nullptr) {
3335 if (type_param !=
nullptr) {
3336 printf(
"%s = %s", kTypeParamLabel, type_param);
3337 if (value_param !=
nullptr) printf(
" and ");
3339 if (value_param !=
nullptr) {
3340 printf(
"%s = %s", kValueParamLabel, value_param);
3351 static void PrintTestName(
const char* test_suite,
const char* test) {
3352 printf(
"%s.%s", test_suite, test);
3356 void OnTestProgramStart(
const UnitTest& )
override {}
3357 void OnTestIterationStart(
const UnitTest& unit_test,
int iteration)
override;
3358 void OnEnvironmentsSetUpStart(
const UnitTest& unit_test)
override;
3359 void OnEnvironmentsSetUpEnd(
const UnitTest& )
override {}
3360#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3361 void OnTestCaseStart(
const TestCase& test_case)
override;
3363 void OnTestSuiteStart(
const TestSuite& test_suite)
override;
3366 void OnTestStart(
const TestInfo& test_info)
override;
3368 void OnTestPartResult(
const TestPartResult& result)
override;
3369 void OnTestEnd(
const TestInfo& test_info)
override;
3370#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3371 void OnTestCaseEnd(
const TestCase& test_case)
override;
3373 void OnTestSuiteEnd(
const TestSuite& test_suite)
override;
3376 void OnEnvironmentsTearDownStart(
const UnitTest& unit_test)
override;
3377 void OnEnvironmentsTearDownEnd(
const UnitTest& )
override {}
3378 void OnTestIterationEnd(
const UnitTest& unit_test,
int iteration)
override;
3379 void OnTestProgramEnd(
const UnitTest& )
override {}
3382 static void PrintFailedTests(
const UnitTest& unit_test);
3383 static void PrintFailedTestSuites(
const UnitTest& unit_test);
3384 static void PrintSkippedTests(
const UnitTest& unit_test);
3388void PrettyUnitTestResultPrinter::OnTestIterationStart(
3389 const UnitTest& unit_test,
int iteration) {
3390 if (GTEST_FLAG(repeat) != 1)
3391 printf(
"\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
3393 const char*
const filter = GTEST_FLAG(filter).c_str();
3397 if (!String::CStringEquals(filter, kUniversalFilter)) {
3398 ColoredPrintf(GTestColor::kYellow,
"Note: %s filter = %s\n", GTEST_NAME_,
3402 if (internal::ShouldShard(kTestTotalShards, kTestShardIndex,
false)) {
3403 const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
3404 ColoredPrintf(GTestColor::kYellow,
"Note: This is test shard %d of %s.\n",
3405 static_cast<int>(shard_index) + 1,
3406 internal::posix::GetEnv(kTestTotalShards));
3409 if (GTEST_FLAG(shuffle)) {
3410 ColoredPrintf(GTestColor::kYellow,
3411 "Note: Randomizing tests' orders with a seed of %d .\n",
3412 unit_test.random_seed());
3415 ColoredPrintf(GTestColor::kGreen,
"[==========] ");
3416 printf(
"Running %s from %s.\n",
3417 FormatTestCount(unit_test.test_to_run_count()).c_str(),
3418 FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
3422void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
3424 ColoredPrintf(GTestColor::kGreen,
"[----------] ");
3425 printf(
"Global test environment set-up.\n");
3429#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3430void PrettyUnitTestResultPrinter::OnTestCaseStart(
const TestCase& test_case) {
3431 const std::string counts =
3432 FormatCountableNoun(test_case.test_to_run_count(),
"test",
"tests");
3433 ColoredPrintf(GTestColor::kGreen,
"[----------] ");
3434 printf(
"%s from %s", counts.c_str(), test_case.name());
3435 if (test_case.type_param() ==
nullptr) {
3438 printf(
", where %s = %s\n", kTypeParamLabel, test_case.type_param());
3443void PrettyUnitTestResultPrinter::OnTestSuiteStart(
3444 const TestSuite& test_suite) {
3445 const std::string counts =
3446 FormatCountableNoun(test_suite.test_to_run_count(),
"test",
"tests");
3447 ColoredPrintf(GTestColor::kGreen,
"[----------] ");
3448 printf(
"%s from %s", counts.c_str(), test_suite.name());
3449 if (test_suite.type_param() ==
nullptr) {
3452 printf(
", where %s = %s\n", kTypeParamLabel, test_suite.type_param());
3458void PrettyUnitTestResultPrinter::OnTestStart(
const TestInfo& test_info) {
3459 ColoredPrintf(GTestColor::kGreen,
"[ RUN ] ");
3460 PrintTestName(test_info.test_suite_name(), test_info.name());
3466void PrettyUnitTestResultPrinter::OnTestPartResult(
3467 const TestPartResult& result) {
3468 switch (result.type()) {
3470 case TestPartResult::kSuccess:
3475 PrintTestPartResult(result);
3480void PrettyUnitTestResultPrinter::OnTestEnd(
const TestInfo& test_info) {
3481 if (test_info.result()->Passed()) {
3482 ColoredPrintf(GTestColor::kGreen,
"[ OK ] ");
3483 }
else if (test_info.result()->Skipped()) {
3484 ColoredPrintf(GTestColor::kGreen,
"[ SKIPPED ] ");
3486 ColoredPrintf(GTestColor::kRed,
"[ FAILED ] ");
3488 PrintTestName(test_info.test_suite_name(), test_info.name());
3489 if (test_info.result()->Failed())
3490 PrintFullTestCommentIfPresent(test_info);
3492 if (GTEST_FLAG(print_time)) {
3493 printf(
" (%s ms)\n", internal::StreamableToString(
3494 test_info.result()->elapsed_time()).c_str());
3501#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3502void PrettyUnitTestResultPrinter::OnTestCaseEnd(
const TestCase& test_case) {
3503 if (!GTEST_FLAG(print_time))
return;
3505 const std::string counts =
3506 FormatCountableNoun(test_case.test_to_run_count(),
"test",
"tests");
3507 ColoredPrintf(GTestColor::kGreen,
"[----------] ");
3508 printf(
"%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(),
3509 internal::StreamableToString(test_case.elapsed_time()).c_str());
3513void PrettyUnitTestResultPrinter::OnTestSuiteEnd(
const TestSuite& test_suite) {
3514 if (!GTEST_FLAG(print_time))
return;
3516 const std::string counts =
3517 FormatCountableNoun(test_suite.test_to_run_count(),
"test",
"tests");
3518 ColoredPrintf(GTestColor::kGreen,
"[----------] ");
3519 printf(
"%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name(),
3520 internal::StreamableToString(test_suite.elapsed_time()).c_str());
3525void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
3527 ColoredPrintf(GTestColor::kGreen,
"[----------] ");
3528 printf(
"Global test environment tear-down\n");
3533void PrettyUnitTestResultPrinter::PrintFailedTests(
const UnitTest& unit_test) {
3534 const int failed_test_count = unit_test.failed_test_count();
3535 ColoredPrintf(GTestColor::kRed,
"[ FAILED ] ");
3536 printf(
"%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
3538 for (
int i = 0; i < unit_test.total_test_suite_count(); ++i) {
3539 const TestSuite& test_suite = *unit_test.GetTestSuite(i);
3540 if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) {
3543 for (
int j = 0; j < test_suite.total_test_count(); ++j) {
3544 const TestInfo& test_info = *test_suite.GetTestInfo(j);
3545 if (!test_info.should_run() || !test_info.result()->Failed()) {
3548 ColoredPrintf(GTestColor::kRed,
"[ FAILED ] ");
3549 printf(
"%s.%s", test_suite.name(), test_info.name());
3550 PrintFullTestCommentIfPresent(test_info);
3554 printf(
"\n%2d FAILED %s\n", failed_test_count,
3555 failed_test_count == 1 ?
"TEST" :
"TESTS");
3560void PrettyUnitTestResultPrinter::PrintFailedTestSuites(
3561 const UnitTest& unit_test) {
3562 int suite_failure_count = 0;
3563 for (
int i = 0; i < unit_test.total_test_suite_count(); ++i) {
3564 const TestSuite& test_suite = *unit_test.GetTestSuite(i);
3565 if (!test_suite.should_run()) {
3568 if (test_suite.ad_hoc_test_result().Failed()) {
3569 ColoredPrintf(GTestColor::kRed,
"[ FAILED ] ");
3570 printf(
"%s: SetUpTestSuite or TearDownTestSuite\n", test_suite.name());
3571 ++suite_failure_count;
3574 if (suite_failure_count > 0) {
3575 printf(
"\n%2d FAILED TEST %s\n", suite_failure_count,
3576 suite_failure_count == 1 ?
"SUITE" :
"SUITES");
3581void PrettyUnitTestResultPrinter::PrintSkippedTests(
const UnitTest& unit_test) {
3582 const int skipped_test_count = unit_test.skipped_test_count();
3583 if (skipped_test_count == 0) {
3587 for (
int i = 0; i < unit_test.total_test_suite_count(); ++i) {
3588 const TestSuite& test_suite = *unit_test.GetTestSuite(i);
3589 if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) {
3592 for (
int j = 0; j < test_suite.total_test_count(); ++j) {
3593 const TestInfo& test_info = *test_suite.GetTestInfo(j);
3594 if (!test_info.should_run() || !test_info.result()->Skipped()) {
3597 ColoredPrintf(GTestColor::kGreen,
"[ SKIPPED ] ");
3598 printf(
"%s.%s", test_suite.name(), test_info.name());
3604void PrettyUnitTestResultPrinter::OnTestIterationEnd(
const UnitTest& unit_test,
3606 ColoredPrintf(GTestColor::kGreen,
"[==========] ");
3607 printf(
"%s from %s ran.",
3608 FormatTestCount(unit_test.test_to_run_count()).c_str(),
3609 FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
3610 if (GTEST_FLAG(print_time)) {
3611 printf(
" (%s ms total)",
3612 internal::StreamableToString(unit_test.elapsed_time()).c_str());
3615 ColoredPrintf(GTestColor::kGreen,
"[ PASSED ] ");
3616 printf(
"%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
3618 const int skipped_test_count = unit_test.skipped_test_count();
3619 if (skipped_test_count > 0) {
3620 ColoredPrintf(GTestColor::kGreen,
"[ SKIPPED ] ");
3621 printf(
"%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());
3622 PrintSkippedTests(unit_test);
3625 if (!unit_test.Passed()) {
3626 PrintFailedTests(unit_test);
3627 PrintFailedTestSuites(unit_test);
3630 int num_disabled = unit_test.reportable_disabled_test_count();
3631 if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
3632 if (unit_test.Passed()) {
3635 ColoredPrintf(GTestColor::kYellow,
" YOU HAVE %d DISABLED %s\n\n",
3636 num_disabled, num_disabled == 1 ?
"TEST" :
"TESTS");
3650 static void PrintTestName(
const char* test_suite,
const char* test) {
3651 printf(
"%s.%s", test_suite, test);
3655 void OnTestProgramStart(
const UnitTest& )
override {}
3656 void OnTestIterationStart(
const UnitTest& ,
3658 void OnEnvironmentsSetUpStart(
const UnitTest& )
override {}
3659 void OnEnvironmentsSetUpEnd(
const UnitTest& )
override {}
3660#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3661 void OnTestCaseStart(
const TestCase& )
override {}
3663 void OnTestSuiteStart(
const TestSuite& )
override {}
3666 void OnTestStart(
const TestInfo& )
override {}
3668 void OnTestPartResult(
const TestPartResult& result)
override;
3669 void OnTestEnd(
const TestInfo& test_info)
override;
3670#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3671 void OnTestCaseEnd(
const TestCase& )
override {}
3673 void OnTestSuiteEnd(
const TestSuite& )
override {}
3676 void OnEnvironmentsTearDownStart(
const UnitTest& )
override {}
3677 void OnEnvironmentsTearDownEnd(
const UnitTest& )
override {}
3678 void OnTestIterationEnd(
const UnitTest& unit_test,
int iteration)
override;
3679 void OnTestProgramEnd(
const UnitTest& )
override {}
3683void BriefUnitTestResultPrinter::OnTestPartResult(
3684 const TestPartResult& result) {
3685 switch (result.type()) {
3687 case TestPartResult::kSuccess:
3692 PrintTestPartResult(result);
3697void BriefUnitTestResultPrinter::OnTestEnd(
const TestInfo& test_info) {
3698 if (test_info.result()->Failed()) {
3699 ColoredPrintf(GTestColor::kRed,
"[ FAILED ] ");
3700 PrintTestName(test_info.test_suite_name(), test_info.name());
3701 PrintFullTestCommentIfPresent(test_info);
3703 if (GTEST_FLAG(print_time)) {
3704 printf(
" (%s ms)\n",
3705 internal::StreamableToString(test_info.result()->elapsed_time())
3714void BriefUnitTestResultPrinter::OnTestIterationEnd(
const UnitTest& unit_test,
3716 ColoredPrintf(GTestColor::kGreen,
"[==========] ");
3717 printf(
"%s from %s ran.",
3718 FormatTestCount(unit_test.test_to_run_count()).c_str(),
3719 FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
3720 if (GTEST_FLAG(print_time)) {
3721 printf(
" (%s ms total)",
3722 internal::StreamableToString(unit_test.elapsed_time()).c_str());
3725 ColoredPrintf(GTestColor::kGreen,
"[ PASSED ] ");
3726 printf(
"%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
3728 const int skipped_test_count = unit_test.skipped_test_count();
3729 if (skipped_test_count > 0) {
3730 ColoredPrintf(GTestColor::kGreen,
"[ SKIPPED ] ");
3731 printf(
"%s.\n", FormatTestCount(skipped_test_count).c_str());
3734 int num_disabled = unit_test.reportable_disabled_test_count();
3735 if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
3736 if (unit_test.Passed()) {
3739 ColoredPrintf(GTestColor::kYellow,
" YOU HAVE %d DISABLED %s\n\n",
3740 num_disabled, num_disabled == 1 ?
"TEST" :
"TESTS");
3760 bool forwarding_enabled()
const {
return forwarding_enabled_; }
3761 void set_forwarding_enabled(
bool enable) { forwarding_enabled_ = enable; }
3763 void OnTestProgramStart(
const UnitTest& unit_test)
override;
3764 void OnTestIterationStart(
const UnitTest& unit_test,
int iteration)
override;
3765 void OnEnvironmentsSetUpStart(
const UnitTest& unit_test)
override;
3766 void OnEnvironmentsSetUpEnd(
const UnitTest& unit_test)
override;
3768#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3769 void OnTestCaseStart(
const TestSuite& parameter)
override;
3771 void OnTestSuiteStart(
const TestSuite& parameter)
override;
3772 void OnTestStart(
const TestInfo& test_info)
override;
3773 void OnTestPartResult(
const TestPartResult& result)
override;
3774 void OnTestEnd(
const TestInfo& test_info)
override;
3776#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3777 void OnTestCaseEnd(
const TestCase& parameter)
override;
3779 void OnTestSuiteEnd(
const TestSuite& parameter)
override;
3780 void OnEnvironmentsTearDownStart(
const UnitTest& unit_test)
override;
3781 void OnEnvironmentsTearDownEnd(
const UnitTest& unit_test)
override;
3782 void OnTestIterationEnd(
const UnitTest& unit_test,
int iteration)
override;
3783 void OnTestProgramEnd(
const UnitTest& unit_test)
override;
3788 bool forwarding_enabled_;
3790 std::vector<TestEventListener*> listeners_;
3795TestEventRepeater::~TestEventRepeater() {
3796 ForEach(listeners_, Delete<TestEventListener>);
3800 listeners_.push_back(listener);
3803TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
3804 for (
size_t i = 0; i < listeners_.size(); ++i) {
3805 if (listeners_[i] == listener) {
3806 listeners_.erase(listeners_.begin() +
static_cast<int>(i));
3816#define GTEST_REPEATER_METHOD_(Name, Type) \
3817void TestEventRepeater::Name(const Type& parameter) { \
3818 if (forwarding_enabled_) { \
3819 for (size_t i = 0; i < listeners_.size(); i++) { \
3820 listeners_[i]->Name(parameter); \
3826#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \
3827 void TestEventRepeater::Name(const Type& parameter) { \
3828 if (forwarding_enabled_) { \
3829 for (size_t i = listeners_.size(); i != 0; i--) { \
3830 listeners_[i - 1]->Name(parameter); \
3835GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
3836GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
3838#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3839GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite)
3841GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite)
3842GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
3843GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
3844GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
3845GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
3846GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
3847GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
3849#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3850GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite)
3852GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite)
3853GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
3855#undef GTEST_REPEATER_METHOD_
3856#undef GTEST_REVERSE_REPEATER_METHOD_
3858void TestEventRepeater::OnTestIterationStart(
const UnitTest& unit_test,
3860 if (forwarding_enabled_) {
3861 for (
size_t i = 0; i < listeners_.size(); i++) {
3862 listeners_[i]->OnTestIterationStart(unit_test, iteration);
3867void TestEventRepeater::OnTestIterationEnd(
const UnitTest& unit_test,
3869 if (forwarding_enabled_) {
3870 for (
size_t i = listeners_.size(); i > 0; i--) {
3871 listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);
3883 void OnTestIterationEnd(
const UnitTest& unit_test,
int iteration)
override;
3884 void ListTestsMatchingFilter(
const std::vector<TestSuite*>& test_suites);
3887 static void PrintXmlTestsList(std::ostream* stream,
3888 const std::vector<TestSuite*>& test_suites);
3893 static bool IsNormalizableWhitespace(
char c) {
3894 return c == 0x9 || c == 0xA || c == 0xD;
3898 static bool IsValidXmlCharacter(
char c) {
3899 return IsNormalizableWhitespace(c) || c >= 0x20;
3906 static std::string EscapeXml(
const std::string& str,
bool is_attribute);
3909 static std::string RemoveInvalidXmlCharacters(
const std::string& str);
3912 static std::string EscapeXmlAttribute(
const std::string& str) {
3913 return EscapeXml(str,
true);
3917 static std::string EscapeXmlText(
const char* str) {
3918 return EscapeXml(str,
false);
3923 static void OutputXmlAttribute(std::ostream* stream,
3924 const std::string& element_name,
3925 const std::string& name,
3926 const std::string& value);
3929 static void OutputXmlCDataSection(::std::ostream* stream,
const char* data);
3934 static void OutputXmlTestSuiteForTestResult(::std::ostream* stream,
3938 static void OutputXmlTestResult(::std::ostream* stream,
3942 static void OutputXmlTestInfo(::std::ostream* stream,
3943 const char* test_suite_name,
3947 static void PrintXmlTestSuite(::std::ostream* stream,
3951 static void PrintXmlUnitTest(::std::ostream* stream,
3958 static std::string TestPropertiesAsXmlAttributes(
const TestResult& result);
3962 static void OutputXmlTestProperties(std::ostream* stream,
3966 const std::string output_file_;
3972XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(
const char* output_file)
3973 : output_file_(output_file) {
3974 if (output_file_.empty()) {
3975 GTEST_LOG_(FATAL) <<
"XML output file may not be null";
3980void XmlUnitTestResultPrinter::OnTestIterationEnd(
const UnitTest& unit_test,
3982 FILE* xmlout = OpenFileForWriting(output_file_);
3983 std::stringstream stream;
3984 PrintXmlUnitTest(&stream, unit_test);
3985 fprintf(xmlout,
"%s", StringStreamToString(&stream).c_str());
3989void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
3990 const std::vector<TestSuite*>& test_suites) {
3991 FILE* xmlout = OpenFileForWriting(output_file_);
3992 std::stringstream stream;
3993 PrintXmlTestsList(&stream, test_suites);
3994 fprintf(xmlout,
"%s", StringStreamToString(&stream).c_str());
4008std::string XmlUnitTestResultPrinter::EscapeXml(
4009 const std::string& str,
bool is_attribute) {
4012 for (
size_t i = 0; i < str.size(); ++i) {
4013 const char ch = str[i];
4037 if (IsValidXmlCharacter(ch)) {
4038 if (is_attribute && IsNormalizableWhitespace(ch))
4039 m <<
"&#x" << String::FormatByte(
static_cast<unsigned char>(ch))
4048 return m.GetString();
4054std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
4055 const std::string& str) {
4057 output.reserve(str.size());
4058 for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
4059 if (IsValidXmlCharacter(*it))
4060 output.push_back(*it);
4083std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
4084 ::std::stringstream ss;
4085 ss << (static_cast<double>(ms) * 1e-3);
4089static bool PortableLocaltime(time_t seconds,
struct tm* out) {
4090#if defined(_MSC_VER)
4091 return localtime_s(out, &seconds) == 0;
4092#elif defined(__MINGW32__) || defined(__MINGW64__)
4095 struct tm* tm_ptr = localtime(&seconds);
4096 if (tm_ptr ==
nullptr)
return false;
4100 return localtime_r(&seconds, out) !=
nullptr;
4106std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
4107 struct tm time_struct;
4108 if (!PortableLocaltime(
static_cast<time_t
>(ms / 1000), &time_struct))
4111 return StreamableToString(time_struct.tm_year + 1900) +
"-" +
4112 String::FormatIntWidth2(time_struct.tm_mon + 1) +
"-" +
4113 String::FormatIntWidth2(time_struct.tm_mday) +
"T" +
4114 String::FormatIntWidth2(time_struct.tm_hour) +
":" +
4115 String::FormatIntWidth2(time_struct.tm_min) +
":" +
4116 String::FormatIntWidth2(time_struct.tm_sec) +
"." +
4117 String::FormatIntWidthN(
static_cast<int>(ms % 1000), 3);
4121void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
4123 const char* segment = data;
4124 *stream <<
"<![CDATA[";
4126 const char*
const next_segment = strstr(segment,
"]]>");
4127 if (next_segment !=
nullptr) {
4129 segment,
static_cast<std::streamsize
>(next_segment - segment));
4130 *stream <<
"]]>]]><![CDATA[";
4131 segment = next_segment + strlen(
"]]>");
4140void XmlUnitTestResultPrinter::OutputXmlAttribute(
4141 std::ostream* stream,
4142 const std::string& element_name,
4143 const std::string& name,
4144 const std::string& value) {
4145 const std::vector<std::string>& allowed_names =
4146 GetReservedOutputAttributesForElement(element_name);
4148 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
4149 allowed_names.end())
4150 <<
"Attribute " << name <<
" is not allowed for element <" << element_name
4153 *stream <<
" " << name <<
"=\"" << EscapeXmlAttribute(value) <<
"\"";
4157void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(
4158 ::std::ostream* stream,
const TestResult& result) {
4160 *stream <<
" <testsuite";
4161 OutputXmlAttribute(stream,
"testsuite",
"name",
"NonTestSuiteFailure");
4162 OutputXmlAttribute(stream,
"testsuite",
"tests",
"1");
4163 OutputXmlAttribute(stream,
"testsuite",
"failures",
"1");
4164 OutputXmlAttribute(stream,
"testsuite",
"disabled",
"0");
4165 OutputXmlAttribute(stream,
"testsuite",
"skipped",
"0");
4166 OutputXmlAttribute(stream,
"testsuite",
"errors",
"0");
4167 OutputXmlAttribute(stream,
"testsuite",
"time",
4168 FormatTimeInMillisAsSeconds(result.elapsed_time()));
4170 stream,
"testsuite",
"timestamp",
4171 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
4175 *stream <<
" <testcase";
4176 OutputXmlAttribute(stream,
"testcase",
"name",
"");
4177 OutputXmlAttribute(stream,
"testcase",
"status",
"run");
4178 OutputXmlAttribute(stream,
"testcase",
"result",
"completed");
4179 OutputXmlAttribute(stream,
"testcase",
"classname",
"");
4180 OutputXmlAttribute(stream,
"testcase",
"time",
4181 FormatTimeInMillisAsSeconds(result.elapsed_time()));
4183 stream,
"testcase",
"timestamp",
4184 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
4187 OutputXmlTestResult(stream, result);
4190 *stream <<
" </testsuite>\n";
4194void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
4195 const char* test_suite_name,
4196 const TestInfo& test_info) {
4197 const TestResult& result = *test_info.result();
4198 const std::string kTestsuite =
"testcase";
4200 if (test_info.is_in_another_shard()) {
4204 *stream <<
" <testcase";
4205 OutputXmlAttribute(stream, kTestsuite,
"name", test_info.name());
4207 if (test_info.value_param() !=
nullptr) {
4208 OutputXmlAttribute(stream, kTestsuite,
"value_param",
4209 test_info.value_param());
4211 if (test_info.type_param() !=
nullptr) {
4212 OutputXmlAttribute(stream, kTestsuite,
"type_param",
4213 test_info.type_param());
4215 if (GTEST_FLAG(list_tests)) {
4216 OutputXmlAttribute(stream, kTestsuite,
"file", test_info.file());
4217 OutputXmlAttribute(stream, kTestsuite,
"line",
4218 StreamableToString(test_info.line()));
4223 OutputXmlAttribute(stream, kTestsuite,
"status",
4224 test_info.should_run() ?
"run" :
"notrun");
4225 OutputXmlAttribute(stream, kTestsuite,
"result",
4226 test_info.should_run()
4227 ? (result.Skipped() ?
"skipped" :
"completed")
4229 OutputXmlAttribute(stream, kTestsuite,
"time",
4230 FormatTimeInMillisAsSeconds(result.elapsed_time()));
4232 stream, kTestsuite,
"timestamp",
4233 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
4234 OutputXmlAttribute(stream, kTestsuite,
"classname", test_suite_name);
4236 OutputXmlTestResult(stream, result);
4239void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream,
4240 const TestResult& result) {
4243 for (
int i = 0; i < result.total_part_count(); ++i) {
4244 const TestPartResult& part = result.GetTestPartResult(i);
4245 if (part.failed()) {
4246 if (++failures == 1 && skips == 0) {
4249 const std::string location =
4250 internal::FormatCompilerIndependentFileLocation(part.file_name(),
4251 part.line_number());
4252 const std::string summary = location +
"\n" + part.summary();
4253 *stream <<
" <failure message=\""
4254 << EscapeXmlAttribute(summary)
4256 const std::string detail = location +
"\n" + part.message();
4257 OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
4258 *stream <<
"</failure>\n";
4259 }
else if (part.skipped()) {
4260 if (++skips == 1 && failures == 0) {
4263 const std::string location =
4264 internal::FormatCompilerIndependentFileLocation(part.file_name(),
4265 part.line_number());
4266 const std::string summary = location +
"\n" + part.summary();
4267 *stream <<
" <skipped message=\""
4268 << EscapeXmlAttribute(summary.c_str()) <<
"\">";
4269 const std::string detail = location +
"\n" + part.message();
4270 OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
4271 *stream <<
"</skipped>\n";
4275 if (failures == 0 && skips == 0 && result.test_property_count() == 0) {
4278 if (failures == 0 && skips == 0) {
4281 OutputXmlTestProperties(stream, result);
4282 *stream <<
" </testcase>\n";
4287void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
4288 const TestSuite& test_suite) {
4289 const std::string kTestsuite =
"testsuite";
4290 *stream <<
" <" << kTestsuite;
4291 OutputXmlAttribute(stream, kTestsuite,
"name", test_suite.name());
4292 OutputXmlAttribute(stream, kTestsuite,
"tests",
4293 StreamableToString(test_suite.reportable_test_count()));
4294 if (!GTEST_FLAG(list_tests)) {
4295 OutputXmlAttribute(stream, kTestsuite,
"failures",
4296 StreamableToString(test_suite.failed_test_count()));
4298 stream, kTestsuite,
"disabled",
4299 StreamableToString(test_suite.reportable_disabled_test_count()));
4300 OutputXmlAttribute(stream, kTestsuite,
"skipped",
4301 StreamableToString(test_suite.skipped_test_count()));
4303 OutputXmlAttribute(stream, kTestsuite,
"errors",
"0");
4305 OutputXmlAttribute(stream, kTestsuite,
"time",
4306 FormatTimeInMillisAsSeconds(test_suite.elapsed_time()));
4308 stream, kTestsuite,
"timestamp",
4309 FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp()));
4310 *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());
4313 for (
int i = 0; i < test_suite.total_test_count(); ++i) {
4314 if (test_suite.GetTestInfo(i)->is_reportable())
4315 OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
4317 *stream <<
" </" << kTestsuite <<
">\n";
4321void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
4322 const UnitTest& unit_test) {
4323 const std::string kTestsuites =
"testsuites";
4325 *stream <<
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
4326 *stream <<
"<" << kTestsuites;
4328 OutputXmlAttribute(stream, kTestsuites,
"tests",
4329 StreamableToString(unit_test.reportable_test_count()));
4330 OutputXmlAttribute(stream, kTestsuites,
"failures",
4331 StreamableToString(unit_test.failed_test_count()));
4333 stream, kTestsuites,
"disabled",
4334 StreamableToString(unit_test.reportable_disabled_test_count()));
4335 OutputXmlAttribute(stream, kTestsuites,
"errors",
"0");
4336 OutputXmlAttribute(stream, kTestsuites,
"time",
4337 FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
4339 stream, kTestsuites,
"timestamp",
4340 FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
4342 if (GTEST_FLAG(shuffle)) {
4343 OutputXmlAttribute(stream, kTestsuites,
"random_seed",
4344 StreamableToString(unit_test.random_seed()));
4346 *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
4348 OutputXmlAttribute(stream, kTestsuites,
"name",
"AllTests");
4351 for (
int i = 0; i < unit_test.total_test_suite_count(); ++i) {
4352 if (unit_test.GetTestSuite(i)->reportable_test_count() > 0)
4353 PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i));
4358 if (unit_test.ad_hoc_test_result().Failed()) {
4359 OutputXmlTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
4362 *stream <<
"</" << kTestsuites <<
">\n";
4365void XmlUnitTestResultPrinter::PrintXmlTestsList(
4366 std::ostream* stream,
const std::vector<TestSuite*>& test_suites) {
4367 const std::string kTestsuites =
"testsuites";
4369 *stream <<
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
4370 *stream <<
"<" << kTestsuites;
4372 int total_tests = 0;
4373 for (
auto test_suite : test_suites) {
4374 total_tests += test_suite->total_test_count();
4376 OutputXmlAttribute(stream, kTestsuites,
"tests",
4377 StreamableToString(total_tests));
4378 OutputXmlAttribute(stream, kTestsuites,
"name",
"AllTests");
4381 for (
auto test_suite : test_suites) {
4382 PrintXmlTestSuite(stream, *test_suite);
4384 *stream <<
"</" << kTestsuites <<
">\n";
4389std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
4390 const TestResult& result) {
4392 for (
int i = 0; i < result.test_property_count(); ++i) {
4393 const TestProperty&
property = result.GetTestProperty(i);
4394 attributes <<
" " <<
property.key() <<
"="
4395 <<
"\"" << EscapeXmlAttribute(property.value()) <<
"\"";
4397 return attributes.GetString();
4400void XmlUnitTestResultPrinter::OutputXmlTestProperties(
4401 std::ostream* stream,
const TestResult& result) {
4402 const std::string kProperties =
"properties";
4403 const std::string kProperty =
"property";
4405 if (result.test_property_count() <= 0) {
4409 *stream <<
"<" << kProperties <<
">\n";
4410 for (
int i = 0; i < result.test_property_count(); ++i) {
4411 const TestProperty&
property = result.GetTestProperty(i);
4412 *stream <<
"<" << kProperty;
4413 *stream <<
" name=\"" << EscapeXmlAttribute(property.key()) <<
"\"";
4414 *stream <<
" value=\"" << EscapeXmlAttribute(property.value()) <<
"\"";
4417 *stream <<
"</" << kProperties <<
">\n";
4427 void OnTestIterationEnd(
const UnitTest& unit_test,
int iteration)
override;
4430 static void PrintJsonTestList(::std::ostream* stream,
4431 const std::vector<TestSuite*>& test_suites);
4435 static std::string EscapeJson(
const std::string& str);
4439 static void OutputJsonKey(std::ostream* stream,
4440 const std::string& element_name,
4441 const std::string& name,
4442 const std::string& value,
4443 const std::string& indent,
4445 static void OutputJsonKey(std::ostream* stream,
4446 const std::string& element_name,
4447 const std::string& name,
4449 const std::string& indent,
4455 static void OutputJsonTestSuiteForTestResult(::std::ostream* stream,
4459 static void OutputJsonTestResult(::std::ostream* stream,
4463 static void OutputJsonTestInfo(::std::ostream* stream,
4464 const char* test_suite_name,
4468 static void PrintJsonTestSuite(::std::ostream* stream,
4472 static void PrintJsonUnitTest(::std::ostream* stream,
4477 static std::string TestPropertiesAsJson(
const TestResult& result,
4478 const std::string& indent);
4481 const std::string output_file_;
4487JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(
const char* output_file)
4488 : output_file_(output_file) {
4489 if (output_file_.empty()) {
4490 GTEST_LOG_(FATAL) <<
"JSON output file may not be null";
4494void JsonUnitTestResultPrinter::OnTestIterationEnd(
const UnitTest& unit_test,
4496 FILE* jsonout = OpenFileForWriting(output_file_);
4497 std::stringstream stream;
4498 PrintJsonUnitTest(&stream, unit_test);
4499 fprintf(jsonout,
"%s", StringStreamToString(&stream).c_str());
4504std::string JsonUnitTestResultPrinter::EscapeJson(
const std::string& str) {
4507 for (
size_t i = 0; i < str.size(); ++i) {
4508 const char ch = str[i];
4532 m <<
"\\u00" << String::FormatByte(
static_cast<unsigned char>(ch));
4540 return m.GetString();
4547static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
4548 ::std::stringstream ss;
4549 ss << (static_cast<double>(ms) * 1e-3) <<
"s";
4555static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
4556 struct tm time_struct;
4557 if (!PortableLocaltime(
static_cast<time_t
>(ms / 1000), &time_struct))
4560 return StreamableToString(time_struct.tm_year + 1900) +
"-" +
4561 String::FormatIntWidth2(time_struct.tm_mon + 1) +
"-" +
4562 String::FormatIntWidth2(time_struct.tm_mday) +
"T" +
4563 String::FormatIntWidth2(time_struct.tm_hour) +
":" +
4564 String::FormatIntWidth2(time_struct.tm_min) +
":" +
4565 String::FormatIntWidth2(time_struct.tm_sec) +
"Z";
4568static inline std::string Indent(
size_t width) {
4569 return std::string(width,
' ');
4572void JsonUnitTestResultPrinter::OutputJsonKey(
4573 std::ostream* stream,
4574 const std::string& element_name,
4575 const std::string& name,
4576 const std::string& value,
4577 const std::string& indent,
4579 const std::vector<std::string>& allowed_names =
4580 GetReservedOutputAttributesForElement(element_name);
4582 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
4583 allowed_names.end())
4584 <<
"Key \"" << name <<
"\" is not allowed for value \"" << element_name
4587 *stream << indent <<
"\"" << name <<
"\": \"" << EscapeJson(value) <<
"\"";
4592void JsonUnitTestResultPrinter::OutputJsonKey(
4593 std::ostream* stream,
4594 const std::string& element_name,
4595 const std::string& name,
4597 const std::string& indent,
4599 const std::vector<std::string>& allowed_names =
4600 GetReservedOutputAttributesForElement(element_name);
4602 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
4603 allowed_names.end())
4604 <<
"Key \"" << name <<
"\" is not allowed for value \"" << element_name
4607 *stream << indent <<
"\"" << name <<
"\": " << StreamableToString(value);
4613void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(
4614 ::std::ostream* stream,
const TestResult& result) {
4616 *stream << Indent(4) <<
"{\n";
4617 OutputJsonKey(stream,
"testsuite",
"name",
"NonTestSuiteFailure", Indent(6));
4618 OutputJsonKey(stream,
"testsuite",
"tests", 1, Indent(6));
4619 if (!GTEST_FLAG(list_tests)) {
4620 OutputJsonKey(stream,
"testsuite",
"failures", 1, Indent(6));
4621 OutputJsonKey(stream,
"testsuite",
"disabled", 0, Indent(6));
4622 OutputJsonKey(stream,
"testsuite",
"skipped", 0, Indent(6));
4623 OutputJsonKey(stream,
"testsuite",
"errors", 0, Indent(6));
4624 OutputJsonKey(stream,
"testsuite",
"time",
4625 FormatTimeInMillisAsDuration(result.elapsed_time()),
4627 OutputJsonKey(stream,
"testsuite",
"timestamp",
4628 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
4631 *stream << Indent(6) <<
"\"testsuite\": [\n";
4634 *stream << Indent(8) <<
"{\n";
4635 OutputJsonKey(stream,
"testcase",
"name",
"", Indent(10));
4636 OutputJsonKey(stream,
"testcase",
"status",
"RUN", Indent(10));
4637 OutputJsonKey(stream,
"testcase",
"result",
"COMPLETED", Indent(10));
4638 OutputJsonKey(stream,
"testcase",
"timestamp",
4639 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
4641 OutputJsonKey(stream,
"testcase",
"time",
4642 FormatTimeInMillisAsDuration(result.elapsed_time()),
4644 OutputJsonKey(stream,
"testcase",
"classname",
"", Indent(10),
false);
4645 *stream << TestPropertiesAsJson(result, Indent(10));
4648 OutputJsonTestResult(stream, result);
4651 *stream <<
"\n" << Indent(6) <<
"]\n" << Indent(4) <<
"}";
4655void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
4656 const char* test_suite_name,
4657 const TestInfo& test_info) {
4658 const TestResult& result = *test_info.result();
4659 const std::string kTestsuite =
"testcase";
4660 const std::string kIndent = Indent(10);
4662 *stream << Indent(8) <<
"{\n";
4663 OutputJsonKey(stream, kTestsuite,
"name", test_info.name(), kIndent);
4665 if (test_info.value_param() !=
nullptr) {
4666 OutputJsonKey(stream, kTestsuite,
"value_param", test_info.value_param(),
4669 if (test_info.type_param() !=
nullptr) {
4670 OutputJsonKey(stream, kTestsuite,
"type_param", test_info.type_param(),
4673 if (GTEST_FLAG(list_tests)) {
4674 OutputJsonKey(stream, kTestsuite,
"file", test_info.file(), kIndent);
4675 OutputJsonKey(stream, kTestsuite,
"line", test_info.line(), kIndent,
false);
4676 *stream <<
"\n" << Indent(8) <<
"}";
4680 OutputJsonKey(stream, kTestsuite,
"status",
4681 test_info.should_run() ?
"RUN" :
"NOTRUN", kIndent);
4682 OutputJsonKey(stream, kTestsuite,
"result",
4683 test_info.should_run()
4684 ? (result.Skipped() ?
"SKIPPED" :
"COMPLETED")
4687 OutputJsonKey(stream, kTestsuite,
"timestamp",
4688 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
4690 OutputJsonKey(stream, kTestsuite,
"time",
4691 FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent);
4692 OutputJsonKey(stream, kTestsuite,
"classname", test_suite_name, kIndent,
4694 *stream << TestPropertiesAsJson(result, kIndent);
4696 OutputJsonTestResult(stream, result);
4699void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
4700 const TestResult& result) {
4701 const std::string kIndent = Indent(10);
4704 for (
int i = 0; i < result.total_part_count(); ++i) {
4705 const TestPartResult& part = result.GetTestPartResult(i);
4706 if (part.failed()) {
4708 if (++failures == 1) {
4709 *stream << kIndent <<
"\"" <<
"failures" <<
"\": [\n";
4711 const std::string location =
4712 internal::FormatCompilerIndependentFileLocation(part.file_name(),
4713 part.line_number());
4714 const std::string message = EscapeJson(location +
"\n" + part.message());
4715 *stream << kIndent <<
" {\n"
4716 << kIndent <<
" \"failure\": \"" << message <<
"\",\n"
4717 << kIndent <<
" \"type\": \"\"\n"
4723 *stream <<
"\n" << kIndent <<
"]";
4724 *stream <<
"\n" << Indent(8) <<
"}";
4728void JsonUnitTestResultPrinter::PrintJsonTestSuite(
4729 std::ostream* stream,
const TestSuite& test_suite) {
4730 const std::string kTestsuite =
"testsuite";
4731 const std::string kIndent = Indent(6);
4733 *stream << Indent(4) <<
"{\n";
4734 OutputJsonKey(stream, kTestsuite,
"name", test_suite.name(), kIndent);
4735 OutputJsonKey(stream, kTestsuite,
"tests", test_suite.reportable_test_count(),
4737 if (!GTEST_FLAG(list_tests)) {
4738 OutputJsonKey(stream, kTestsuite,
"failures",
4739 test_suite.failed_test_count(), kIndent);
4740 OutputJsonKey(stream, kTestsuite,
"disabled",
4741 test_suite.reportable_disabled_test_count(), kIndent);
4742 OutputJsonKey(stream, kTestsuite,
"errors", 0, kIndent);
4744 stream, kTestsuite,
"timestamp",
4745 FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()),
4747 OutputJsonKey(stream, kTestsuite,
"time",
4748 FormatTimeInMillisAsDuration(test_suite.elapsed_time()),
4750 *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent)
4754 *stream << kIndent <<
"\"" << kTestsuite <<
"\": [\n";
4757 for (
int i = 0; i < test_suite.total_test_count(); ++i) {
4758 if (test_suite.GetTestInfo(i)->is_reportable()) {
4764 OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
4767 *stream <<
"\n" << kIndent <<
"]\n" << Indent(4) <<
"}";
4771void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
4772 const UnitTest& unit_test) {
4773 const std::string kTestsuites =
"testsuites";
4774 const std::string kIndent = Indent(2);
4777 OutputJsonKey(stream, kTestsuites,
"tests", unit_test.reportable_test_count(),
4779 OutputJsonKey(stream, kTestsuites,
"failures", unit_test.failed_test_count(),
4781 OutputJsonKey(stream, kTestsuites,
"disabled",
4782 unit_test.reportable_disabled_test_count(), kIndent);
4783 OutputJsonKey(stream, kTestsuites,
"errors", 0, kIndent);
4784 if (GTEST_FLAG(shuffle)) {
4785 OutputJsonKey(stream, kTestsuites,
"random_seed", unit_test.random_seed(),
4788 OutputJsonKey(stream, kTestsuites,
"timestamp",
4789 FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()),
4791 OutputJsonKey(stream, kTestsuites,
"time",
4792 FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent,
4795 *stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent)
4798 OutputJsonKey(stream, kTestsuites,
"name",
"AllTests", kIndent);
4799 *stream << kIndent <<
"\"" << kTestsuites <<
"\": [\n";
4802 for (
int i = 0; i < unit_test.total_test_suite_count(); ++i) {
4803 if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) {
4809 PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i));
4815 if (unit_test.ad_hoc_test_result().Failed()) {
4816 OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
4819 *stream <<
"\n" << kIndent <<
"]\n" <<
"}\n";
4822void JsonUnitTestResultPrinter::PrintJsonTestList(
4823 std::ostream* stream,
const std::vector<TestSuite*>& test_suites) {
4824 const std::string kTestsuites =
"testsuites";
4825 const std::string kIndent = Indent(2);
4827 int total_tests = 0;
4828 for (
auto test_suite : test_suites) {
4829 total_tests += test_suite->total_test_count();
4831 OutputJsonKey(stream, kTestsuites,
"tests", total_tests, kIndent);
4833 OutputJsonKey(stream, kTestsuites,
"name",
"AllTests", kIndent);
4834 *stream << kIndent <<
"\"" << kTestsuites <<
"\": [\n";
4836 for (
size_t i = 0; i < test_suites.size(); ++i) {
4840 PrintJsonTestSuite(stream, *test_suites[i]);
4849std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
4850 const TestResult& result,
const std::string& indent) {
4852 for (
int i = 0; i < result.test_property_count(); ++i) {
4853 const TestProperty&
property = result.GetTestProperty(i);
4854 attributes <<
",\n" << indent <<
"\"" <<
property.key() <<
"\": "
4855 <<
"\"" << EscapeJson(property.value()) <<
"\"";
4857 return attributes.GetString();
4862#if GTEST_CAN_STREAM_RESULTS_
4869std::string StreamingListener::UrlEncode(
const char* str) {
4871 result.reserve(strlen(str) + 1);
4872 for (
char ch = *str; ch !=
'\0'; ch = *++str) {
4878 result.append(
"%" + String::FormatByte(
static_cast<unsigned char>(ch)));
4881 result.push_back(ch);
4888void StreamingListener::SocketWriter::MakeConnection() {
4889 GTEST_CHECK_(sockfd_ == -1)
4890 <<
"MakeConnection() can't be called when there is already a connection.";
4893 memset(&hints, 0,
sizeof(hints));
4894 hints.ai_family = AF_UNSPEC;
4895 hints.ai_socktype = SOCK_STREAM;
4896 addrinfo* servinfo =
nullptr;
4900 const int error_num = getaddrinfo(
4901 host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
4902 if (error_num != 0) {
4903 GTEST_LOG_(WARNING) <<
"stream_result_to: getaddrinfo() failed: "
4904 << gai_strerror(error_num);
4908 for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr !=
nullptr;
4909 cur_addr = cur_addr->ai_next) {
4911 cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
4912 if (sockfd_ != -1) {
4914 if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
4921 freeaddrinfo(servinfo);
4923 if (sockfd_ == -1) {
4924 GTEST_LOG_(WARNING) <<
"stream_result_to: failed to connect to "
4925 << host_name_ <<
":" << port_num_;
4934const char*
const OsStackTraceGetterInterface::kElidedFramesMarker =
4935 "... " GTEST_NAME_
" internal frames ...";
4937std::string OsStackTraceGetter::CurrentStackTrace(
int max_depth,
int skip_count)
4938 GTEST_LOCK_EXCLUDED_(mutex_) {
4942 if (max_depth <= 0) {
4946 max_depth = std::min(max_depth, kMaxStackTraceDepth);
4948 std::vector<void*> raw_stack(max_depth);
4950 const int raw_stack_size =
4951 absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1);
4953 void* caller_frame =
nullptr;
4955 MutexLock lock(&mutex_);
4956 caller_frame = caller_frame_;
4959 for (
int i = 0; i < raw_stack_size; ++i) {
4960 if (raw_stack[i] == caller_frame &&
4961 !GTEST_FLAG(show_internal_stack_frames)) {
4963 absl::StrAppend(&result, kElidedFramesMarker,
"\n");
4968 const char* symbol =
"(unknown)";
4969 if (absl::Symbolize(raw_stack[i], tmp,
sizeof(tmp))) {
4974 snprintf(line,
sizeof(line),
" %p: %s\n", raw_stack[i], symbol);
4981 static_cast<void>(max_depth);
4982 static_cast<void>(skip_count);
4987void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
4989 void* caller_frame =
nullptr;
4990 if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
4991 caller_frame =
nullptr;
4994 MutexLock lock(&mutex_);
4995 caller_frame_ = caller_frame;
5004 : premature_exit_filepath_(premature_exit_filepath ?
5005 premature_exit_filepath :
"") {
5007 if (!premature_exit_filepath_.empty()) {
5011 FILE* pfile = posix::FOpen(premature_exit_filepath,
"w");
5012 fwrite(
"0", 1, 1, pfile);
5018#if !defined GTEST_OS_ESP8266
5019 if (!premature_exit_filepath_.empty()) {
5020 int retval = remove(premature_exit_filepath_.c_str());
5022 GTEST_LOG_(ERROR) <<
"Failed to remove premature exit filepath \""
5023 << premature_exit_filepath_ <<
"\" with error "
5031 const std::string premature_exit_filepath_;
5040TestEventListeners::TestEventListeners()
5041 : repeater_(new internal::TestEventRepeater()),
5042 default_result_printer_(nullptr),
5043 default_xml_generator_(nullptr) {}
5045TestEventListeners::~TestEventListeners() {
delete repeater_; }
5051void TestEventListeners::Append(TestEventListener* listener) {
5052 repeater_->Append(listener);
5058TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
5059 if (listener == default_result_printer_)
5060 default_result_printer_ =
nullptr;
5061 else if (listener == default_xml_generator_)
5062 default_xml_generator_ =
nullptr;
5063 return repeater_->Release(listener);
5068TestEventListener* TestEventListeners::repeater() {
return repeater_; }
5075void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
5076 if (default_result_printer_ != listener) {
5079 delete Release(default_result_printer_);
5080 default_result_printer_ = listener;
5081 if (listener !=
nullptr) Append(listener);
5090void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
5091 if (default_xml_generator_ != listener) {
5094 delete Release(default_xml_generator_);
5095 default_xml_generator_ = listener;
5096 if (listener !=
nullptr) Append(listener);
5102bool TestEventListeners::EventForwardingEnabled()
const {
5103 return repeater_->forwarding_enabled();
5106void TestEventListeners::SuppressEventForwarding() {
5107 repeater_->set_forwarding_enabled(
false);
5119UnitTest* UnitTest::GetInstance() {
5124#if defined(__BORLANDC__)
5125 static UnitTest*
const instance =
new UnitTest;
5128 static UnitTest instance;
5134int UnitTest::successful_test_suite_count()
const {
5135 return impl()->successful_test_suite_count();
5139int UnitTest::failed_test_suite_count()
const {
5140 return impl()->failed_test_suite_count();
5144int UnitTest::total_test_suite_count()
const {
5145 return impl()->total_test_suite_count();
5150int UnitTest::test_suite_to_run_count()
const {
5151 return impl()->test_suite_to_run_count();
5155#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5156int UnitTest::successful_test_case_count()
const {
5157 return impl()->successful_test_suite_count();
5159int UnitTest::failed_test_case_count()
const {
5160 return impl()->failed_test_suite_count();
5162int UnitTest::total_test_case_count()
const {
5163 return impl()->total_test_suite_count();
5165int UnitTest::test_case_to_run_count()
const {
5166 return impl()->test_suite_to_run_count();
5171int UnitTest::successful_test_count()
const {
5172 return impl()->successful_test_count();
5176int UnitTest::skipped_test_count()
const {
5177 return impl()->skipped_test_count();
5181int UnitTest::failed_test_count()
const {
return impl()->failed_test_count(); }
5184int UnitTest::reportable_disabled_test_count()
const {
5185 return impl()->reportable_disabled_test_count();
5189int UnitTest::disabled_test_count()
const {
5190 return impl()->disabled_test_count();
5194int UnitTest::reportable_test_count()
const {
5195 return impl()->reportable_test_count();
5199int UnitTest::total_test_count()
const {
return impl()->total_test_count(); }
5202int UnitTest::test_to_run_count()
const {
return impl()->test_to_run_count(); }
5206internal::TimeInMillis UnitTest::start_timestamp()
const {
5207 return impl()->start_timestamp();
5211internal::TimeInMillis UnitTest::elapsed_time()
const {
5212 return impl()->elapsed_time();
5217bool UnitTest::Passed()
const {
return impl()->Passed(); }
5221bool UnitTest::Failed()
const {
return impl()->Failed(); }
5225const TestSuite* UnitTest::GetTestSuite(
int i)
const {
5226 return impl()->GetTestSuite(i);
5230#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5231const TestCase* UnitTest::GetTestCase(
int i)
const {
5232 return impl()->GetTestCase(i);
5238const TestResult& UnitTest::ad_hoc_test_result()
const {
5239 return *impl()->ad_hoc_test_result();
5244TestSuite* UnitTest::GetMutableTestSuite(
int i) {
5245 return impl()->GetMutableSuiteCase(i);
5250TestEventListeners& UnitTest::listeners() {
5251 return *impl()->listeners();
5264Environment* UnitTest::AddEnvironment(Environment* env) {
5265 if (env ==
nullptr) {
5269 impl_->environments().push_back(env);
5277void UnitTest::AddTestPartResult(
5278 TestPartResult::Type result_type,
5279 const char* file_name,
5281 const std::string& message,
5282 const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
5286 internal::MutexLock lock(&mutex_);
5287 if (impl_->gtest_trace_stack().size() > 0) {
5288 msg <<
"\n" << GTEST_NAME_ <<
" trace:";
5290 for (
size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) {
5291 const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
5292 msg <<
"\n" << internal::FormatFileLocation(trace.file, trace.line)
5293 <<
" " << trace.message;
5297 if (os_stack_trace.c_str() !=
nullptr && !os_stack_trace.empty()) {
5298 msg << internal::kStackTraceMarker << os_stack_trace;
5301 const TestPartResult result = TestPartResult(
5302 result_type, file_name, line_number, msg.GetString().c_str());
5303 impl_->GetTestPartResultReporterForCurrentThread()->
5304 ReportTestPartResult(result);
5306 if (result_type != TestPartResult::kSuccess &&
5307 result_type != TestPartResult::kSkip) {
5313 if (GTEST_FLAG(break_on_failure)) {
5314#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
5319#elif (!defined(__native_client__)) && \
5320 ((defined(__clang__) || defined(__GNUC__)) && \
5321 (defined(__x86_64__) || defined(__i386__)))
5328 *
static_cast<volatile int*
>(
nullptr) = 1;
5330 }
else if (GTEST_FLAG(throw_on_failure)) {
5331#if GTEST_HAS_EXCEPTIONS
5332 throw internal::GoogleTestFailureException(result);
5347void UnitTest::RecordProperty(
const std::string& key,
5348 const std::string& value) {
5349 impl_->RecordProperty(TestProperty(key, value));
5357int UnitTest::Run() {
5358 const bool in_death_test_child_process =
5359 internal::GTEST_FLAG(internal_run_death_test).length() > 0;
5382 const internal::ScopedPrematureExitFile premature_exit_file(
5383 in_death_test_child_process
5385 : internal::posix::GetEnv(
"TEST_PREMATURE_EXIT_FILE"));
5389 impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
5396 if (impl()->catch_exceptions() || in_death_test_child_process) {
5397# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
5399 SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
5400 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
5403# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
5407 _set_error_mode(_OUT_TO_STDERR);
5410# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
5416 if (!GTEST_FLAG(break_on_failure))
5417 _set_abort_behavior(
5419 _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
5425 if (!IsDebuggerPresent()) {
5426 (void)_CrtSetReportMode(_CRT_ASSERT,
5427 _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
5428 (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
5434 return internal::HandleExceptionsInMethodIfSupported(
5436 &internal::UnitTestImpl::RunAllTests,
5437 "auxiliary test code (environments or event listeners)") ? 0 : 1;
5442const char* UnitTest::original_working_dir()
const {
5443 return impl_->original_working_dir_.c_str();
5448const TestSuite* UnitTest::current_test_suite() const
5449 GTEST_LOCK_EXCLUDED_(mutex_) {
5450 internal::MutexLock lock(&mutex_);
5451 return impl_->current_test_suite();
5455#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5456const TestCase* UnitTest::current_test_case() const
5457 GTEST_LOCK_EXCLUDED_(mutex_) {
5458 internal::MutexLock lock(&mutex_);
5459 return impl_->current_test_suite();
5465const TestInfo* UnitTest::current_test_info() const
5466 GTEST_LOCK_EXCLUDED_(mutex_) {
5467 internal::MutexLock lock(&mutex_);
5468 return impl_->current_test_info();
5472int UnitTest::random_seed()
const {
return impl_->random_seed(); }
5476internal::ParameterizedTestSuiteRegistry&
5477UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {
5478 return impl_->parameterized_test_registry();
5482UnitTest::UnitTest() {
5483 impl_ =
new internal::UnitTestImpl(
this);
5487UnitTest::~UnitTest() {
5493void UnitTest::PushGTestTrace(
const internal::TraceInfo& trace)
5494 GTEST_LOCK_EXCLUDED_(mutex_) {
5495 internal::MutexLock lock(&mutex_);
5496 impl_->gtest_trace_stack().push_back(trace);
5500void UnitTest::PopGTestTrace()
5501 GTEST_LOCK_EXCLUDED_(mutex_) {
5502 internal::MutexLock lock(&mutex_);
5503 impl_->gtest_trace_stack().pop_back();
5508UnitTestImpl::UnitTestImpl(UnitTest* parent)
5510 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 )
5511 default_global_test_part_result_reporter_(this),
5512 default_per_thread_test_part_result_reporter_(this),
5513 GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_(
5514 &default_global_test_part_result_reporter_),
5515 per_thread_test_part_result_reporter_(
5516 &default_per_thread_test_part_result_reporter_),
5517 parameterized_test_registry_(),
5518 parameterized_tests_registered_(false),
5519 last_death_test_suite_(-1),
5520 current_test_suite_(nullptr),
5521 current_test_info_(nullptr),
5522 ad_hoc_test_result_(),
5523 os_stack_trace_getter_(nullptr),
5524 post_flag_parse_init_performed_(false),
5527 start_timestamp_(0),
5529#if GTEST_HAS_DEATH_TEST
5530 death_test_factory_(new DefaultDeathTestFactory),
5533 catch_exceptions_(false) {
5534 listeners()->SetDefaultResultPrinter(
new PrettyUnitTestResultPrinter);
5537UnitTestImpl::~UnitTestImpl() {
5539 ForEach(test_suites_, internal::Delete<TestSuite>);
5542 ForEach(environments_, internal::Delete<Environment>);
5544 delete os_stack_trace_getter_;
5552void UnitTestImpl::RecordProperty(
const TestProperty& test_property) {
5553 std::string xml_element;
5554 TestResult* test_result;
5556 if (current_test_info_ !=
nullptr) {
5557 xml_element =
"testcase";
5558 test_result = &(current_test_info_->result_);
5559 }
else if (current_test_suite_ !=
nullptr) {
5560 xml_element =
"testsuite";
5561 test_result = &(current_test_suite_->ad_hoc_test_result_);
5563 xml_element =
"testsuites";
5564 test_result = &ad_hoc_test_result_;
5566 test_result->RecordProperty(xml_element, test_property);
5569#if GTEST_HAS_DEATH_TEST
5572void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
5573 if (internal_run_death_test_flag_.get() !=
nullptr)
5574 listeners()->SuppressEventForwarding();
5580void UnitTestImpl::ConfigureXmlOutput() {
5581 const std::string& output_format = UnitTestOptions::GetOutputFormat();
5582 if (output_format ==
"xml") {
5583 listeners()->SetDefaultXmlGenerator(
new XmlUnitTestResultPrinter(
5584 UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
5585 }
else if (output_format ==
"json") {
5586 listeners()->SetDefaultXmlGenerator(
new JsonUnitTestResultPrinter(
5587 UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
5588 }
else if (output_format !=
"") {
5589 GTEST_LOG_(WARNING) <<
"WARNING: unrecognized output format \""
5590 << output_format <<
"\" ignored.";
5594#if GTEST_CAN_STREAM_RESULTS_
5597void UnitTestImpl::ConfigureStreamingOutput() {
5598 const std::string& target = GTEST_FLAG(stream_result_to);
5599 if (!target.empty()) {
5600 const size_t pos = target.find(
':');
5601 if (pos != std::string::npos) {
5602 listeners()->Append(
new StreamingListener(target.substr(0, pos),
5603 target.substr(pos+1)));
5605 GTEST_LOG_(WARNING) <<
"unrecognized streaming target \"" << target
5617void UnitTestImpl::PostFlagParsingInit() {
5619 if (!post_flag_parse_init_performed_) {
5620 post_flag_parse_init_performed_ =
true;
5622#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
5624 listeners()->Append(
new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
5627#if GTEST_HAS_DEATH_TEST
5628 InitDeathTestSubprocessControlInfo();
5629 SuppressTestEventsIfInSubprocess();
5635 RegisterParameterizedTests();
5639 ConfigureXmlOutput();
5641 if (GTEST_FLAG(brief)) {
5642 listeners()->SetDefaultResultPrinter(
new BriefUnitTestResultPrinter);
5645#if GTEST_CAN_STREAM_RESULTS_
5647 ConfigureStreamingOutput();
5651 if (GTEST_FLAG(install_failure_signal_handler)) {
5652 absl::FailureSignalHandlerOptions options;
5653 absl::InstallFailureSignalHandler(options);
5673 bool operator()(
const TestSuite* test_suite)
const {
5674 return test_suite !=
nullptr &&
5675 strcmp(test_suite->name(), name_.c_str()) == 0;
5695 const char* test_suite_name,
const char* type_param,
5696 internal::SetUpTestSuiteFunc set_up_tc,
5697 internal::TearDownTestSuiteFunc tear_down_tc) {
5699 const auto test_suite =
5700 std::find_if(test_suites_.rbegin(), test_suites_.rend(),
5703 if (test_suite != test_suites_.rend())
return *test_suite;
5706 auto*
const new_test_suite =
5707 new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
5710 if (internal::UnitTestOptions::MatchesFilter(test_suite_name,
5711 kDeathTestSuiteFilter)) {
5716 ++last_death_test_suite_;
5717 test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
5721 test_suites_.push_back(new_test_suite);
5724 test_suite_indices_.push_back(
static_cast<int>(test_suite_indices_.size()));
5725 return new_test_suite;
5730static void SetUpEnvironment(Environment* env) { env->SetUp(); }
5731static void TearDownEnvironment(Environment* env) { env->TearDown(); }
5742bool UnitTestImpl::RunAllTests() {
5745 const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
5753 PostFlagParsingInit();
5758 internal::WriteToShardStatusFileIfNeeded();
5762 bool in_subprocess_for_death_test =
false;
5764#if GTEST_HAS_DEATH_TEST
5765 in_subprocess_for_death_test =
5766 (internal_run_death_test_flag_.get() !=
nullptr);
5767# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
5768 if (in_subprocess_for_death_test) {
5769 GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
5774 const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
5775 in_subprocess_for_death_test);
5779 const bool has_tests_to_run = FilterTests(should_shard
5780 ? HONOR_SHARDING_PROTOCOL
5781 : IGNORE_SHARDING_PROTOCOL) > 0;
5784 if (GTEST_FLAG(list_tests)) {
5786 ListTestsMatchingFilter();
5790 random_seed_ = GTEST_FLAG(shuffle) ?
5791 GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
5794 bool failed =
false;
5796 TestEventListener* repeater = listeners()->repeater();
5798 start_timestamp_ = GetTimeInMillis();
5799 repeater->OnTestProgramStart(*parent_);
5803 const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
5805 const bool gtest_repeat_forever = repeat < 0;
5806 for (
int i = 0; gtest_repeat_forever || i != repeat; i++) {
5809 ClearNonAdHocTestResult();
5814 if (has_tests_to_run && GTEST_FLAG(shuffle)) {
5815 random()->Reseed(
static_cast<uint32_t
>(random_seed_));
5823 repeater->OnTestIterationStart(*parent_, i);
5826 if (has_tests_to_run) {
5828 repeater->OnEnvironmentsSetUpStart(*parent_);
5829 ForEach(environments_, SetUpEnvironment);
5830 repeater->OnEnvironmentsSetUpEnd(*parent_);
5834 if (Test::IsSkipped()) {
5837 TestResult& test_result =
5838 *internal::GetUnitTestImpl()->current_test_result();
5839 for (
int j = 0; j < test_result.total_part_count(); ++j) {
5840 const TestPartResult& test_part_result =
5841 test_result.GetTestPartResult(j);
5842 if (test_part_result.type() == TestPartResult::kSkip) {
5843 const std::string& result = test_part_result.message();
5844 printf(
"%s\n", result.c_str());
5848 }
else if (!Test::HasFatalFailure()) {
5849 for (
int test_index = 0; test_index < total_test_suite_count();
5851 GetMutableSuiteCase(test_index)->Run();
5852 if (GTEST_FLAG(fail_fast) &&
5853 GetMutableSuiteCase(test_index)->Failed()) {
5854 for (
int j = test_index + 1; j < total_test_suite_count(); j++) {
5855 GetMutableSuiteCase(j)->Skip();
5860 }
else if (Test::HasFatalFailure()) {
5864 for (
int test_index = 0; test_index < total_test_suite_count();
5866 GetMutableSuiteCase(test_index)->Skip();
5871 repeater->OnEnvironmentsTearDownStart(*parent_);
5872 std::for_each(environments_.rbegin(), environments_.rend(),
5873 TearDownEnvironment);
5874 repeater->OnEnvironmentsTearDownEnd(*parent_);
5877 elapsed_time_ = timer.Elapsed();
5880 repeater->OnTestIterationEnd(*parent_, i);
5895 if (GTEST_FLAG(shuffle)) {
5897 random_seed_ = GetNextRandomSeed(random_seed_);
5901 repeater->OnTestProgramEnd(*parent_);
5903 if (!gtest_is_initialized_before_run_all_tests) {
5906 "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
5907 "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
5908 "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
5909 " will start to enforce the valid usage. "
5910 "Please fix it ASAP, or IT WILL START TO FAIL.\n");
5911#if GTEST_FOR_GOOGLE_
5912 ColoredPrintf(GTestColor::kRed,
5913 "For more details, see http://wiki/Main/ValidGUnitMain.\n");
5924void WriteToShardStatusFileIfNeeded() {
5925 const char*
const test_shard_file = posix::GetEnv(kTestShardStatusFile);
5926 if (test_shard_file !=
nullptr) {
5927 FILE*
const file = posix::FOpen(test_shard_file,
"w");
5928 if (file ==
nullptr) {
5929 ColoredPrintf(GTestColor::kRed,
5930 "Could not write to the test shard status file \"%s\" "
5931 "specified by the %s environment variable.\n",
5932 test_shard_file, kTestShardStatusFile);
5946bool ShouldShard(
const char* total_shards_env,
5947 const char* shard_index_env,
5948 bool in_subprocess_for_death_test) {
5949 if (in_subprocess_for_death_test) {
5953 const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
5954 const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);
5956 if (total_shards == -1 && shard_index == -1) {
5958 }
else if (total_shards == -1 && shard_index != -1) {
5959 const Message msg = Message()
5960 <<
"Invalid environment variables: you have "
5961 << kTestShardIndex <<
" = " << shard_index
5962 <<
", but have left " << kTestTotalShards <<
" unset.\n";
5963 ColoredPrintf(GTestColor::kRed,
"%s", msg.GetString().c_str());
5966 }
else if (total_shards != -1 && shard_index == -1) {
5967 const Message msg = Message()
5968 <<
"Invalid environment variables: you have "
5969 << kTestTotalShards <<
" = " << total_shards
5970 <<
", but have left " << kTestShardIndex <<
" unset.\n";
5971 ColoredPrintf(GTestColor::kRed,
"%s", msg.GetString().c_str());
5974 }
else if (shard_index < 0 || shard_index >= total_shards) {
5975 const Message msg = Message()
5976 <<
"Invalid environment variables: we require 0 <= "
5977 << kTestShardIndex <<
" < " << kTestTotalShards
5978 <<
", but you have " << kTestShardIndex <<
"=" << shard_index
5979 <<
", " << kTestTotalShards <<
"=" << total_shards <<
".\n";
5980 ColoredPrintf(GTestColor::kRed,
"%s", msg.GetString().c_str());
5985 return total_shards > 1;
5991int32_t Int32FromEnvOrDie(
const char* var, int32_t default_val) {
5992 const char* str_val = posix::GetEnv(var);
5993 if (str_val ==
nullptr) {
5998 if (!ParseInt32(Message() <<
"The value of environment variable " << var,
5999 str_val, &result)) {
6009bool ShouldRunTestOnShard(
int total_shards,
int shard_index,
int test_id) {
6010 return (test_id % total_shards) == shard_index;
6020int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
6021 const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
6022 Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
6023 const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
6024 Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
6030 int num_runnable_tests = 0;
6031 int num_selected_tests = 0;
6032 for (
auto* test_suite : test_suites_) {
6033 const std::string& test_suite_name = test_suite->name();
6034 test_suite->set_should_run(
false);
6036 for (
size_t j = 0; j < test_suite->test_info_list().size(); j++) {
6037 TestInfo*
const test_info = test_suite->test_info_list()[j];
6038 const std::string test_name(test_info->name());
6041 const bool is_disabled = internal::UnitTestOptions::MatchesFilter(
6042 test_suite_name, kDisableTestFilter) ||
6043 internal::UnitTestOptions::MatchesFilter(
6044 test_name, kDisableTestFilter);
6045 test_info->is_disabled_ = is_disabled;
6047 const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest(
6048 test_suite_name, test_name);
6049 test_info->matches_filter_ = matches_filter;
6051 const bool is_runnable =
6052 (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
6055 const bool is_in_another_shard =
6056 shard_tests != IGNORE_SHARDING_PROTOCOL &&
6057 !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
6058 test_info->is_in_another_shard_ = is_in_another_shard;
6059 const bool is_selected = is_runnable && !is_in_another_shard;
6061 num_runnable_tests += is_runnable;
6062 num_selected_tests += is_selected;
6064 test_info->should_run_ = is_selected;
6065 test_suite->set_should_run(test_suite->should_run() || is_selected);
6068 return num_selected_tests;
6075static void PrintOnOneLine(
const char* str,
int max_length) {
6076 if (str !=
nullptr) {
6077 for (
int i = 0; *str !=
'\0'; ++str) {
6078 if (i >= max_length) {
6094void UnitTestImpl::ListTestsMatchingFilter() {
6096 const int kMaxParamLength = 250;
6098 for (
auto* test_suite : test_suites_) {
6099 bool printed_test_suite_name =
false;
6101 for (
size_t j = 0; j < test_suite->test_info_list().size(); j++) {
6102 const TestInfo*
const test_info = test_suite->test_info_list()[j];
6103 if (test_info->matches_filter_) {
6104 if (!printed_test_suite_name) {
6105 printed_test_suite_name =
true;
6106 printf(
"%s.", test_suite->name());
6107 if (test_suite->type_param() !=
nullptr) {
6108 printf(
" # %s = ", kTypeParamLabel);
6111 PrintOnOneLine(test_suite->type_param(), kMaxParamLength);
6115 printf(
" %s", test_info->name());
6116 if (test_info->value_param() !=
nullptr) {
6117 printf(
" # %s = ", kValueParamLabel);
6120 PrintOnOneLine(test_info->value_param(), kMaxParamLength);
6127 const std::string& output_format = UnitTestOptions::GetOutputFormat();
6128 if (output_format ==
"xml" || output_format ==
"json") {
6129 FILE* fileout = OpenFileForWriting(
6130 UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
6131 std::stringstream stream;
6132 if (output_format ==
"xml") {
6133 XmlUnitTestResultPrinter(
6134 UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
6135 .PrintXmlTestsList(&stream, test_suites_);
6136 }
else if (output_format ==
"json") {
6137 JsonUnitTestResultPrinter(
6138 UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
6139 .PrintJsonTestList(&stream, test_suites_);
6141 fprintf(fileout,
"%s", StringStreamToString(&stream).c_str());
6151void UnitTestImpl::set_os_stack_trace_getter(
6152 OsStackTraceGetterInterface* getter) {
6153 if (os_stack_trace_getter_ != getter) {
6154 delete os_stack_trace_getter_;
6155 os_stack_trace_getter_ = getter;
6162OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
6163 if (os_stack_trace_getter_ ==
nullptr) {
6164#ifdef GTEST_OS_STACK_TRACE_GETTER_
6165 os_stack_trace_getter_ =
new GTEST_OS_STACK_TRACE_GETTER_;
6167 os_stack_trace_getter_ =
new OsStackTraceGetter;
6171 return os_stack_trace_getter_;
6175TestResult* UnitTestImpl::current_test_result() {
6176 if (current_test_info_ !=
nullptr) {
6177 return ¤t_test_info_->result_;
6179 if (current_test_suite_ !=
nullptr) {
6180 return ¤t_test_suite_->ad_hoc_test_result_;
6182 return &ad_hoc_test_result_;
6187void UnitTestImpl::ShuffleTests() {
6189 ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
6192 ShuffleRange(random(), last_death_test_suite_ + 1,
6193 static_cast<int>(test_suites_.size()), &test_suite_indices_);
6196 for (
auto& test_suite : test_suites_) {
6197 test_suite->ShuffleTests(random());
6202void UnitTestImpl::UnshuffleTests() {
6203 for (
size_t i = 0; i < test_suites_.size(); i++) {
6205 test_suites_[i]->UnshuffleTests();
6207 test_suite_indices_[i] =
static_cast<int>(i);
6221std::string GetCurrentOsStackTraceExceptTop(UnitTest* ,
6225 return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
6231class ClassUniqueToAlwaysTrue {};
6234bool IsTrue(
bool condition) {
return condition; }
6237#if GTEST_HAS_EXCEPTIONS
6241 throw ClassUniqueToAlwaysTrue();
6249bool SkipPrefix(
const char* prefix,
const char** pstr) {
6250 const size_t prefix_len = strlen(prefix);
6251 if (strncmp(*pstr, prefix, prefix_len) == 0) {
6252 *pstr += prefix_len;
6263static const char* ParseFlagValue(
const char* str,
const char* flag,
6264 bool def_optional) {
6266 if (str ==
nullptr || flag ==
nullptr)
return nullptr;
6269 const std::string flag_str = std::string(
"--") + GTEST_FLAG_PREFIX_ + flag;
6270 const size_t flag_len = flag_str.length();
6271 if (strncmp(str, flag_str.c_str(), flag_len) != 0)
return nullptr;
6274 const char* flag_end = str + flag_len;
6277 if (def_optional && (flag_end[0] ==
'\0')) {
6284 if (flag_end[0] !=
'=')
return nullptr;
6287 return flag_end + 1;
6300static bool ParseBoolFlag(
const char* str,
const char* flag,
bool* value) {
6302 const char*
const value_str = ParseFlagValue(str, flag,
true);
6305 if (value_str ==
nullptr)
return false;
6308 *value = !(*value_str ==
'0' || *value_str ==
'f' || *value_str ==
'F');
6316bool ParseInt32Flag(
const char* str,
const char* flag, int32_t* value) {
6318 const char*
const value_str = ParseFlagValue(str, flag,
false);
6321 if (value_str ==
nullptr)
return false;
6324 return ParseInt32(Message() <<
"The value of flag --" << flag,
6332template <
typename String>
6333static bool ParseStringFlag(
const char* str,
const char* flag, String* value) {
6335 const char*
const value_str = ParseFlagValue(str, flag,
false);
6338 if (value_str ==
nullptr)
return false;
6351static bool HasGoogleTestFlagPrefix(
const char* str) {
6352 return (SkipPrefix(
"--", &str) ||
6353 SkipPrefix(
"-", &str) ||
6354 SkipPrefix(
"/", &str)) &&
6355 !SkipPrefix(GTEST_FLAG_PREFIX_
"internal_", &str) &&
6356 (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
6357 SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
6369static void PrintColorEncoded(
const char* str) {
6370 GTestColor color = GTestColor::kDefault;
6377 const char* p = strchr(str,
'@');
6379 ColoredPrintf(color,
"%s", str);
6383 ColoredPrintf(color,
"%s", std::string(str, p).c_str());
6385 const char ch = p[1];
6388 ColoredPrintf(color,
"@");
6389 }
else if (ch ==
'D') {
6390 color = GTestColor::kDefault;
6391 }
else if (ch ==
'R') {
6392 color = GTestColor::kRed;
6393 }
else if (ch ==
'G') {
6394 color = GTestColor::kGreen;
6395 }
else if (ch ==
'Y') {
6396 color = GTestColor::kYellow;
6403static const char kColorEncodedHelpMessage[] =
6404 "This program contains tests written using " GTEST_NAME_
6405 ". You can use the\n"
6406 "following command line flags to control its behavior:\n"
6409 " @G--" GTEST_FLAG_PREFIX_
6411 " List the names of all tests instead of running them. The name of\n"
6412 " TEST(Foo, Bar) is \"Foo.Bar\".\n"
6413 " @G--" GTEST_FLAG_PREFIX_
6414 "filter=@YPOSITIVE_PATTERNS"
6415 "[@G-@YNEGATIVE_PATTERNS]@D\n"
6416 " Run only the tests whose name matches one of the positive patterns "
6418 " none of the negative patterns. '?' matches any single character; "
6420 " matches any substring; ':' separates two patterns.\n"
6421 " @G--" GTEST_FLAG_PREFIX_
6422 "also_run_disabled_tests@D\n"
6423 " Run all disabled tests too.\n"
6426 " @G--" GTEST_FLAG_PREFIX_
6427 "repeat=@Y[COUNT]@D\n"
6428 " Run the tests repeatedly; use a negative count to repeat forever.\n"
6429 " @G--" GTEST_FLAG_PREFIX_
6431 " Randomize tests' orders on every iteration.\n"
6432 " @G--" GTEST_FLAG_PREFIX_
6433 "random_seed=@Y[NUMBER]@D\n"
6434 " Random number seed to use for shuffling test orders (between 1 and\n"
6435 " 99999, or 0 to use a seed based on the current time).\n"
6438 " @G--" GTEST_FLAG_PREFIX_
6439 "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
6440 " Enable/disable colored output. The default is @Gauto@D.\n"
6441 " @G--" GTEST_FLAG_PREFIX_
6443 " Only print test failures.\n"
6444 " @G--" GTEST_FLAG_PREFIX_
6446 " Don't print the elapsed time of each test.\n"
6447 " @G--" GTEST_FLAG_PREFIX_
6448 "output=@Y(@Gjson@Y|@Gxml@Y)[@G:@YDIRECTORY_PATH@G" GTEST_PATH_SEP_
6449 "@Y|@G:@YFILE_PATH]@D\n"
6450 " Generate a JSON or XML report in the given directory or with the "
6452 " file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n"
6453# if GTEST_CAN_STREAM_RESULTS_
6454 " @G--" GTEST_FLAG_PREFIX_
6455 "stream_result_to=@YHOST@G:@YPORT@D\n"
6456 " Stream test results to the given server.\n"
6459 "Assertion Behavior:\n"
6460# if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
6461 " @G--" GTEST_FLAG_PREFIX_
6462 "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
6463 " Set the default death test style.\n"
6465 " @G--" GTEST_FLAG_PREFIX_
6466 "break_on_failure@D\n"
6467 " Turn assertion failures into debugger break-points.\n"
6468 " @G--" GTEST_FLAG_PREFIX_
6469 "throw_on_failure@D\n"
6470 " Turn assertion failures into C++ exceptions for use by an external\n"
6471 " test framework.\n"
6472 " @G--" GTEST_FLAG_PREFIX_
6473 "catch_exceptions=0@D\n"
6474 " Do not report exceptions as test failures. Instead, allow them\n"
6475 " to crash the program or throw a pop-up (on Windows).\n"
6477 "Except for @G--" GTEST_FLAG_PREFIX_
6478 "list_tests@D, you can alternatively set "
6479 "the corresponding\n"
6480 "environment variable of a flag (all letters in upper-case). For example, "
6482 "disable colored text output, you can either specify "
6483 "@G--" GTEST_FLAG_PREFIX_
6484 "color=no@D or set\n"
6485 "the @G" GTEST_FLAG_PREFIX_UPPER_
6486 "COLOR@D environment variable to @Gno@D.\n"
6488 "For more information, please read the " GTEST_NAME_
6489 " documentation at\n"
6490 "@G" GTEST_PROJECT_URL_
"@D. If you find a bug in " GTEST_NAME_
6492 "(not one in your own code or tests), please report it to\n"
6493 "@G<" GTEST_DEV_EMAIL_
">@D.\n";
6495static bool ParseGoogleTestFlag(
const char*
const arg) {
6496 return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
6497 >EST_FLAG(also_run_disabled_tests)) ||
6498 ParseBoolFlag(arg, kBreakOnFailureFlag,
6499 >EST_FLAG(break_on_failure)) ||
6500 ParseBoolFlag(arg, kCatchExceptionsFlag,
6501 >EST_FLAG(catch_exceptions)) ||
6502 ParseStringFlag(arg, kColorFlag, >EST_FLAG(color)) ||
6503 ParseStringFlag(arg, kDeathTestStyleFlag,
6504 >EST_FLAG(death_test_style)) ||
6505 ParseBoolFlag(arg, kDeathTestUseFork,
6506 >EST_FLAG(death_test_use_fork)) ||
6507 ParseBoolFlag(arg, kFailFast, >EST_FLAG(fail_fast)) ||
6508 ParseStringFlag(arg, kFilterFlag, >EST_FLAG(filter)) ||
6509 ParseStringFlag(arg, kInternalRunDeathTestFlag,
6510 >EST_FLAG(internal_run_death_test)) ||
6511 ParseBoolFlag(arg, kListTestsFlag, >EST_FLAG(list_tests)) ||
6512 ParseStringFlag(arg, kOutputFlag, >EST_FLAG(output)) ||
6513 ParseBoolFlag(arg, kBriefFlag, >EST_FLAG(brief)) ||
6514 ParseBoolFlag(arg, kPrintTimeFlag, >EST_FLAG(print_time)) ||
6515 ParseBoolFlag(arg, kPrintUTF8Flag, >EST_FLAG(print_utf8)) ||
6516 ParseInt32Flag(arg, kRandomSeedFlag, >EST_FLAG(random_seed)) ||
6517 ParseInt32Flag(arg, kRepeatFlag, >EST_FLAG(repeat)) ||
6518 ParseBoolFlag(arg, kShuffleFlag, >EST_FLAG(shuffle)) ||
6519 ParseInt32Flag(arg, kStackTraceDepthFlag,
6520 >EST_FLAG(stack_trace_depth)) ||
6521 ParseStringFlag(arg, kStreamResultToFlag,
6522 >EST_FLAG(stream_result_to)) ||
6523 ParseBoolFlag(arg, kThrowOnFailureFlag, >EST_FLAG(throw_on_failure));
6526#if GTEST_USE_OWN_FLAGFILE_FLAG_
6527static void LoadFlagsFromFile(
const std::string& path) {
6528 FILE* flagfile = posix::FOpen(path.c_str(),
"r");
6530 GTEST_LOG_(FATAL) <<
"Unable to open file \"" << GTEST_FLAG(flagfile)
6533 std::string contents(ReadEntireFile(flagfile));
6534 posix::FClose(flagfile);
6535 std::vector<std::string> lines;
6536 SplitString(contents,
'\n', &lines);
6537 for (
size_t i = 0; i < lines.size(); ++i) {
6538 if (lines[i].empty())
6540 if (!ParseGoogleTestFlag(lines[i].c_str()))
6549template <
typename CharType>
6550void ParseGoogleTestFlagsOnlyImpl(
int* argc, CharType** argv) {
6551 for (
int i = 1; i < *argc; i++) {
6552 const std::string arg_string = StreamableToString(argv[i]);
6553 const char*
const arg = arg_string.c_str();
6555 using internal::ParseBoolFlag;
6556 using internal::ParseInt32Flag;
6557 using internal::ParseStringFlag;
6559 bool remove_flag =
false;
6560 if (ParseGoogleTestFlag(arg)) {
6562#if GTEST_USE_OWN_FLAGFILE_FLAG_
6563 }
else if (ParseStringFlag(arg, kFlagfileFlag, >EST_FLAG(flagfile))) {
6564 LoadFlagsFromFile(GTEST_FLAG(flagfile));
6567 }
else if (arg_string ==
"--help" || arg_string ==
"-h" ||
6568 arg_string ==
"-?" || arg_string ==
"/?" ||
6569 HasGoogleTestFlagPrefix(arg)) {
6580 for (
int j = i; j != *argc; j++) {
6581 argv[j] = argv[j + 1];
6597 PrintColorEncoded(kColorEncodedHelpMessage);
6603void ParseGoogleTestFlagsOnly(
int* argc,
char** argv) {
6604 ParseGoogleTestFlagsOnlyImpl(argc, argv);
6611 if (*_NSGetArgv() == argv) {
6612 *_NSGetArgc() = *argc;
6617void ParseGoogleTestFlagsOnly(
int* argc,
wchar_t** argv) {
6618 ParseGoogleTestFlagsOnlyImpl(argc, argv);
6625template <
typename CharType>
6626void InitGoogleTestImpl(
int* argc, CharType** argv) {
6628 if (GTestIsInitialized())
return;
6630 if (*argc <= 0)
return;
6633 for (
int i = 0; i != *argc; i++) {
6634 g_argvs.push_back(StreamableToString(argv[i]));
6638 absl::InitializeSymbolizer(g_argvs[0].c_str());
6641 ParseGoogleTestFlagsOnly(argc, argv);
6642 GetUnitTestImpl()->PostFlagParsingInit();
6656void InitGoogleTest(
int* argc,
char** argv) {
6657#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6658 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
6660 internal::InitGoogleTestImpl(argc, argv);
6666void InitGoogleTest(
int* argc,
wchar_t** argv) {
6667#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6668 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
6670 internal::InitGoogleTestImpl(argc, argv);
6676void InitGoogleTest() {
6679 const auto arg0 =
"dummy";
6680 char* argv0 =
const_cast<char*
>(arg0);
6681 char** argv = &argv0;
6683#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6684 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
6686 internal::InitGoogleTestImpl(&argc, argv);
6690std::string TempDir() {
6691#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
6692 return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
6693#elif GTEST_OS_WINDOWS_MOBILE
6695#elif GTEST_OS_WINDOWS
6696 const char* temp_dir = internal::posix::GetEnv(
"TEMP");
6697 if (temp_dir ==
nullptr || temp_dir[0] ==
'\0') {
6699 }
else if (temp_dir[strlen(temp_dir) - 1] ==
'\\') {
6702 return std::string(temp_dir) +
"\\";
6704#elif GTEST_OS_LINUX_ANDROID
6705 const char* temp_dir = internal::posix::GetEnv(
"TEST_TMPDIR");
6706 if (temp_dir ==
nullptr || temp_dir[0] ==
'\0') {
6707 return "/data/local/tmp/";
6712 const char* temp_dir = internal::posix::GetEnv(
"TEST_TMPDIR");
6713 if (temp_dir ==
nullptr || temp_dir[0] ==
'\0') {
6727void ScopedTrace::PushTrace(
const char* file,
int line, std::string message) {
6728 internal::TraceInfo trace;
6731 trace.message.swap(message);
6733 UnitTest::GetInstance()->PushGTestTrace(trace);
6737ScopedTrace::~ScopedTrace()
6738 GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
6739 UnitTest::GetInstance()->PopGTestTrace();