1 // Copyright 2005, Google Inc.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
14 // * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 // The Google C++ Testing and Mocking Framework (Google Test)
33 #include "gtest/gtest.h"
34 #include "gtest/internal/custom/gtest.h"
35 #include "gtest/gtest-spi.h"
46 #include <chrono> // NOLINT
53 #include <ostream> // NOLINT
59 # include <fcntl.h> // NOLINT
60 # include <limits.h> // NOLINT
61 # include <sched.h> // NOLINT
62 // Declares vsnprintf(). This header is not available on Windows.
63 # include <strings.h> // NOLINT
64 # include <sys/mman.h> // NOLINT
65 # include <sys/time.h> // NOLINT
66 # include <unistd.h> // NOLINT
70 # include <sys/time.h> // NOLINT
72 // On z/OS we additionally need strings.h for strcasecmp.
73 # include <strings.h> // NOLINT
75 #elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE.
77 # include <windows.h> // NOLINT
80 #elif GTEST_OS_WINDOWS // We are on Windows proper.
82 # include <windows.h> // NOLINT
86 # include <crtdbg.h> // NOLINT
89 # include <io.h> // NOLINT
90 # include <sys/timeb.h> // NOLINT
91 # include <sys/types.h> // NOLINT
92 # include <sys/stat.h> // NOLINT
94 # if GTEST_OS_WINDOWS_MINGW
95 # include <sys/time.h> // NOLINT
96 # endif // GTEST_OS_WINDOWS_MINGW
100 // cpplint thinks that the header is already included, so we want to
102 # include <sys/time.h> // NOLINT
103 # include <unistd.h> // NOLINT
105 #endif // GTEST_OS_LINUX
107 #if GTEST_HAS_EXCEPTIONS
108 # include <stdexcept>
111 #if GTEST_CAN_STREAM_RESULTS_
112 # include <arpa/inet.h> // NOLINT
113 # include <netdb.h> // NOLINT
114 # include <sys/socket.h> // NOLINT
115 # include <sys/types.h> // NOLINT
118 #include "src/gtest-internal-inl.h"
121 # define vsnprintf _vsnprintf
122 #endif // GTEST_OS_WINDOWS
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"
135 #endif // GTEST_HAS_ABSL
139 using internal::CountIf;
140 using internal::ForEach;
141 using internal::GetElementOr;
142 using internal::Shuffle;
146 // A test whose test suite name or test name matches this filter is
147 // disabled and not run.
148 static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
150 // A test suite whose name matches this filter is considered a death
151 // test suite and will be run before test suites whose name doesn't
152 // match this filter.
153 static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*";
155 // A test filter that matches everything.
156 static const char kUniversalFilter[] = "*";
158 // The default output format.
159 static const char kDefaultOutputFormat[] = "xml";
160 // The default output file.
161 static const char kDefaultOutputFile[] = "test_detail";
163 // The environment variable name for the test shard index.
164 static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
165 // The environment variable name for the total number of test shards.
166 static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
167 // The environment variable name for the test shard status file.
168 static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";
172 // The text used in failure messages to indicate the start of the
174 const char kStackTraceMarker[] = "\nStack trace:\n";
176 // g_help_flag is true if and only if the --help flag or an equivalent form
177 // is specified on the command line.
178 bool g_help_flag = false;
180 // Utilty function to Open File for Writing
181 static 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 << "\"";
195 } // namespace internal
197 // Bazel passes in the argument to '--test_filter' via the TESTBRIDGE_TEST_ONLY
198 // environment variable.
199 static 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;
208 // Bazel passes in the argument to '--test_runner_fail_fast' via the
209 // TESTBRIDGE_TEST_RUNNER_FAIL_FAST environment variable.
210 static 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 "
233 GTEST_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.");
238 GTEST_DEFINE_string_(
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.");
246 GTEST_DEFINE_string_(
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.");
262 GTEST_DEFINE_bool_(list_tests, false,
263 "List all tests without running them.");
265 // The net priority order after flag processing is thus:
266 // --gtest_output command line flag
267 // GTEST_OUTPUT environment variable
268 // XML_OUTPUT_FILE environment variable
270 GTEST_DEFINE_string_(
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.");
287 GTEST_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.");
291 GTEST_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.");
307 GTEST_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.");
312 GTEST_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.");
322 GTEST_DEFINE_string_(
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_
337 GTEST_DEFINE_string_(
339 internal::StringFromGTestEnv("flagfile", ""),
340 "This flag specifies the flagfile to read command-line flags from.");
341 #endif // GTEST_USE_OWN_FLAGFILE_FLAG_
345 // Generates a random number from [0, range), using a Linear
346 // Congruential Generator (LCG). Crashes if 'range' is 0 or greater
348 uint32_t Random::Generate(uint32_t range) {
349 // These constants are the same as are used in glibc's rand(3).
350 // Use wider types than necessary to prevent unsigned overflow diagnostics.
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 << ").";
359 // Converting via modulus introduces a bit of downward bias, but
360 // it's simple, and a linear congruential generator isn't too good
362 return state_ % range;
365 // GTestIsInitialized() returns true if and only if the user has initialized
366 // Google Test. Useful for catching the user mistake of not initializing
367 // Google Test before calling RUN_ALL_TESTS().
368 static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
370 // Iterates over a vector of TestSuites, keeping a running sum of the
371 // results of calling a given int-returning method on each.
373 static 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)();
382 // Returns true if and only if the test suite passed.
383 static bool TestSuitePassed(const TestSuite* test_suite) {
384 return test_suite->should_run() && test_suite->Passed();
387 // Returns true if and only if the test suite failed.
388 static bool TestSuiteFailed(const TestSuite* test_suite) {
389 return test_suite->should_run() && test_suite->Failed();
392 // Returns true if and only if test_suite contains at least one test that
394 static bool ShouldRunTestSuite(const TestSuite* test_suite) {
395 return test_suite->should_run();
398 // AssertHelper constructor.
399 AssertHelper::AssertHelper(TestPartResult::Type type,
403 : data_(new AssertHelperData(type, file, line, message)) {
406 AssertHelper::~AssertHelper() {
410 // Message assignment, for assertion streaming support.
411 void 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)
417 // Skips the stack frame for this function itself.
423 // When TEST_P is found without a matching INSTANTIATE_TEST_SUITE_P
424 // to creates test cases for it, a syntetic test case is
425 // inserted to report ether an error or a log message.
427 // This configuration bit will likely be removed at some point.
428 constexpr bool kErrorOnUninstantiatedParameterizedTest = true;
429 constexpr bool kErrorOnUninstantiatedTypeParameterizedTest = true;
431 // A test that fails at a given file/line location with a given message.
432 class 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_;
458 std::set<std::string>* GetIgnoredParameterizedTestSuites() {
459 return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites();
462 // Add a given test_suit to the list of them allow to go un-instantiated.
463 MarkAsIgnored::MarkAsIgnored(const char* test_suite) {
464 GetIgnoredParameterizedTestSuites()->insert(test_suite);
467 // If this parameterized test suite has no instantiations (and that
468 // has not been marked as okay), emit a test case reporting that.
469 void 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(),
504 nullptr, // No type parameter.
505 nullptr, // No value parameter.
506 location.file.c_str(), location.line, [message, location] {
507 return new FailureTest(location, message,
508 kErrorOnUninstantiatedParameterizedTest);
512 void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
513 CodeLocation code_location) {
514 GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
515 test_suite_name, code_location);
518 void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) {
520 ->type_parameterized_test_registry()
521 .RegisterInstantiation(case_name);
524 void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
525 const char* test_suite_name, CodeLocation code_location) {
526 suites_.emplace(std::string(test_suite_name),
527 TypeParameterizedTestSuiteInfo(code_location));
530 void 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 << "'";
541 void 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(),
567 nullptr, // No type parameter.
568 nullptr, // No value parameter.
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);
577 // A copy of all command line arguments. Set by InitGoogleTest().
578 static ::std::vector<std::string> g_argvs;
580 ::std::vector<std::string> GetArgvs() {
581 #if defined(GTEST_CUSTOM_GET_ARGVS_)
582 // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
583 // ::string. This code converts it to the appropriate type.
584 const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
585 return ::std::vector<std::string>(custom.begin(), custom.end());
586 #else // defined(GTEST_CUSTOM_GET_ARGVS_)
588 #endif // defined(GTEST_CUSTOM_GET_ARGVS_)
591 // Returns the current application's name, removing directory path if that
593 FilePath GetCurrentExecutableName() {
596 #if GTEST_OS_WINDOWS || GTEST_OS_OS2
597 result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
599 result.Set(FilePath(GetArgvs()[0]));
600 #endif // GTEST_OS_WINDOWS
602 return result.RemoveDirectoryName();
605 // Functions for processing the gtest_output flag.
607 // Returns the output format, or "" for normal printed output.
608 std::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));
617 // Returns the name of the requested output file, or the default if none
618 // was explicitly specified.
619 std::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();
649 // Returns true if and only if the wildcard pattern matches the string. Each
650 // pattern consists of regular characters, single-character wildcards (?), and
651 // multi-character wildcards (*).
653 // This function implements a linear-time string globbing algorithm based on
654 // https://research.swtch.com/glob.
655 static 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) {
667 default: // Match an ordinary character.
668 if (name < name_end && *name == *pattern) {
674 case '?': // Match any single character.
675 if (name < name_end) {
682 // Match zero or more characters. Start by skipping over the wildcard
683 // and matching zero characters from name. If that fails, restart and
684 // match one more character than the last attempt.
685 pattern_next = pattern;
686 name_next = name + 1;
691 // Failed to match a character. Restart if possible.
692 if (name_begin < name_next && name_next <= name_end) {
693 pattern = pattern_next;
702 bool UnitTestOptions::MatchesFilter(const std::string& name_str,
703 const char* filter) {
704 // The filter is a list of patterns separated by colons (:).
705 const char* pattern = filter;
707 // Find the bounds of this pattern.
708 const char* const next_sep = strchr(pattern, ':');
709 const char* const pattern_end =
710 next_sep != nullptr ? next_sep : pattern + strlen(pattern);
712 // Check if this pattern matches name_str.
713 if (PatternMatchesString(name_str, pattern, pattern_end)) {
717 // Give up on this pattern. However, if we found a pattern separator (:),
718 // advance to the next pattern (skipping over the separator) and restart.
719 if (next_sep == nullptr) {
722 pattern = next_sep + 1;
727 // Returns true if and only if the user-specified filter matches the test
728 // suite name and the test name.
729 bool 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();
733 // Split --gtest_filter at '-', if there is one, to separate into
734 // positive filter and negative filter portions
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(); // Whole string is a positive filter
743 positive = std::string(p, dash); // Everything up to the dash
744 negative = std::string(dash + 1); // Everything after the dash
745 if (positive.empty()) {
746 // Treat '-test1' as the same as '*-test1'
747 positive = kUniversalFilter;
751 // A filter is a colon-separated list of patterns. It matches a
752 // test if any pattern in it matches the test.
753 return (MatchesFilter(full_name, positive.c_str()) &&
754 !MatchesFilter(full_name, negative.c_str()));
758 // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
759 // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
760 // This function is useful as an __except condition.
761 int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
762 // Google Test should handle a SEH exception if:
763 // 1. the user wants it to, AND
764 // 2. this is not a breakpoint exception, AND
765 // 3. this is not a C++ exception (VC++ implements them via SEH,
768 // SEH exception code for C++ exceptions.
769 // (see http://support.microsoft.com/kb/185294 for more information).
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;
783 #endif // GTEST_HAS_SEH
785 } // namespace internal
787 // The c'tor sets this object as the test part result reporter used by
788 // Google Test. The 'result' parameter specifies where to report the
789 // results. Intercepts only failures from the current thread.
790 ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
791 TestPartResultArray* result)
792 : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
797 // The c'tor sets this object as the test part result reporter used by
798 // Google Test. The 'result' parameter specifies where to report the
800 ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
801 InterceptMode intercept_mode, TestPartResultArray* result)
802 : intercept_mode_(intercept_mode),
807 void 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);
818 // The d'tor restores the test part result reporter used by Google Test
820 ScopedFakeTestPartResultReporter::~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_);
829 // Increments the test part result count and remembers the result.
830 // This method is from the TestPartResultReporterInterface interface.
831 void ScopedFakeTestPartResultReporter::ReportTestPartResult(
832 const TestPartResult& result) {
833 result_->Append(result);
838 // Returns the type ID of ::testing::Test. We should always call this
839 // instead of GetTypeId< ::testing::Test>() to get the type ID of
840 // testing::Test. This is to work around a suspected linker bug when
841 // using Google Test as a framework on Mac OS X. The bug causes
842 // GetTypeId< ::testing::Test>() to return different values depending
843 // on whether the call is from the Google Test framework itself or
844 // from user test code. GetTestTypeId() is guaranteed to always
845 // return the same value, as it always calls GetTypeId<>() from the
846 // gtest.cc, which is within the Google Test framework.
847 TypeId GetTestTypeId() {
848 return GetTypeId<Test>();
851 // The value of GetTestTypeId() as seen from within the Google Test
852 // library. This is solely for testing GetTestTypeId().
853 extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();
855 // This predicate-formatter checks that 'results' contains a test part
856 // failure of the given type and that the failure message contains the
858 static AssertionResult HasOneFailure(const char* /* results_expr */,
859 const char* /* type_expr */,
860 const char* /* substr_expr */,
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();
894 // The constructor of SingleFailureChecker remembers where to look up
895 // test part results, what type of failure we expect, and what
896 // substring the failure message should contain.
897 SingleFailureChecker::SingleFailureChecker(const TestPartResultArray* results,
898 TestPartResult::Type type,
899 const std::string& substr)
900 : results_(results), type_(type), substr_(substr) {}
902 // The destructor of SingleFailureChecker verifies that the given
903 // TestPartResultArray contains exactly one failure that has the given
904 // type and contains the given substring. If that's not the case, a
905 // non-fatal failure will be generated.
906 SingleFailureChecker::~SingleFailureChecker() {
907 EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
910 DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
911 UnitTestImpl* unit_test) : unit_test_(unit_test) {}
913 void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
914 const TestPartResult& result) {
915 unit_test_->current_test_result()->AddTestPartResult(result);
916 unit_test_->listeners()->repeater()->OnTestPartResult(result);
919 DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
920 UnitTestImpl* unit_test) : unit_test_(unit_test) {}
922 void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
923 const TestPartResult& result) {
924 unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
927 // Returns the global test part result reporter.
928 TestPartResultReporterInterface*
929 UnitTestImpl::GetGlobalTestPartResultReporter() {
930 internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
931 return global_test_part_result_repoter_;
934 // Sets the global test part result reporter.
935 void UnitTestImpl::SetGlobalTestPartResultReporter(
936 TestPartResultReporterInterface* reporter) {
937 internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
938 global_test_part_result_repoter_ = reporter;
941 // Returns the test part result reporter for the current thread.
942 TestPartResultReporterInterface*
943 UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
944 return per_thread_test_part_result_reporter_.get();
947 // Sets the test part result reporter for the current thread.
948 void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
949 TestPartResultReporterInterface* reporter) {
950 per_thread_test_part_result_reporter_.set(reporter);
953 // Gets the number of successful test suites.
954 int UnitTestImpl::successful_test_suite_count() const {
955 return CountIf(test_suites_, TestSuitePassed);
958 // Gets the number of failed test suites.
959 int UnitTestImpl::failed_test_suite_count() const {
960 return CountIf(test_suites_, TestSuiteFailed);
963 // Gets the number of all test suites.
964 int UnitTestImpl::total_test_suite_count() const {
965 return static_cast<int>(test_suites_.size());
968 // Gets the number of all test suites that contain at least one test
970 int UnitTestImpl::test_suite_to_run_count() const {
971 return CountIf(test_suites_, ShouldRunTestSuite);
974 // Gets the number of successful tests.
975 int UnitTestImpl::successful_test_count() const {
976 return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count);
979 // Gets the number of skipped tests.
980 int UnitTestImpl::skipped_test_count() const {
981 return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count);
984 // Gets the number of failed tests.
985 int UnitTestImpl::failed_test_count() const {
986 return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count);
989 // Gets the number of disabled tests that will be reported in the XML report.
990 int UnitTestImpl::reportable_disabled_test_count() const {
991 return SumOverTestSuiteList(test_suites_,
992 &TestSuite::reportable_disabled_test_count);
995 // Gets the number of disabled tests.
996 int UnitTestImpl::disabled_test_count() const {
997 return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count);
1000 // Gets the number of tests to be printed in the XML report.
1001 int UnitTestImpl::reportable_test_count() const {
1002 return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count);
1005 // Gets the number of all tests.
1006 int UnitTestImpl::total_test_count() const {
1007 return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count);
1010 // Gets the number of tests that should run.
1011 int UnitTestImpl::test_to_run_count() const {
1012 return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
1015 // Returns the current OS stack trace as an std::string.
1017 // The maximum number of stack frames to be included is specified by
1018 // the gtest_stack_trace_depth flag. The skip_count parameter
1019 // specifies the number of top frames to be skipped, which doesn't
1020 // count against the number of frames to be included.
1022 // For example, if Foo() calls Bar(), which in turn calls
1023 // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
1024 // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
1025 std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
1026 return os_stack_trace_getter()->CurrentStackTrace(
1027 static_cast<int>(GTEST_FLAG(stack_trace_depth)),
1029 // Skips the user-specified number of frames plus this function
1034 // A helper class for measuring elapsed times.
1037 Timer() : start_(std::chrono::steady_clock::now()) {}
1039 // Return time elapsed in milliseconds since the timer was created.
1040 TimeInMillis Elapsed() {
1041 return std::chrono::duration_cast<std::chrono::milliseconds>(
1042 std::chrono::steady_clock::now() - start_)
1047 std::chrono::steady_clock::time_point start_;
1050 // Returns a timestamp as milliseconds since the epoch. Note this time may jump
1051 // around subject to adjustments by the system, to measure elapsed time use
1053 TimeInMillis 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
1065 // Creates a UTF-16 wide string from the given ANSI string, allocating
1066 // memory using new. The caller is responsible for deleting the return
1067 // value using delete[]. Returns the wide string, or NULL if the
1069 LPCWSTR 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;
1081 // Creates an ANSI string from the given wide string, allocating
1082 // memory using new. The caller is responsible for deleting the return
1083 // value using delete[]. Returns the ANSI string, or NULL if the
1085 const 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;
1096 #endif // GTEST_OS_WINDOWS_MOBILE
1098 // Compares two C strings. Returns true if and only if they have the same
1101 // Unlike strcmp(), this function can handle NULL argument(s). A NULL
1102 // C string is considered different to any non-NULL C string,
1103 // including the empty string.
1104 bool 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
1114 // Converts an array of wide chars to a narrow string using the UTF-8
1115 // encoding, and streams the result to the given Message object.
1116 static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
1118 for (size_t i = 0; i != length; ) { // NOLINT
1119 if (wstr[i] != L'\0') {
1120 *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
1121 while (i != length && wstr[i] != L'\0')
1130 #endif // GTEST_HAS_STD_WSTRING
1132 void 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));
1149 } // namespace internal
1151 // Constructs an empty Message.
1152 // We allocate the stringstream separately because otherwise each use of
1153 // ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
1154 // stack frame leading to huge stack frames in some cases; gcc does not reuse
1156 Message::Message() : ss_(new ::std::stringstream) {
1157 // By default, we want there to be enough precision when printing
1158 // a double to a Message.
1159 *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
1162 // These two overloads allow streaming a wide C string to a Message
1163 // using the UTF-8 encoding.
1164 Message& Message::operator <<(const wchar_t* wide_c_str) {
1165 return *this << internal::String::ShowWideCString(wide_c_str);
1167 Message& Message::operator <<(wchar_t* wide_c_str) {
1168 return *this << internal::String::ShowWideCString(wide_c_str);
1171 #if GTEST_HAS_STD_WSTRING
1172 // Converts the given wide string to a narrow string using the UTF-8
1173 // encoding, and streams the result to this Message object.
1174 Message& Message::operator <<(const ::std::wstring& wstr) {
1175 internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
1178 #endif // GTEST_HAS_STD_WSTRING
1180 // Gets the text streamed to this object so far as an std::string.
1181 // Each '\0' character in the buffer is replaced with "\\0".
1182 std::string Message::GetString() const {
1183 return internal::StringStreamToString(ss_.get());
1186 // AssertionResult constructors.
1187 // Used in EXPECT_TRUE/FALSE(assertion_result).
1188 AssertionResult::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)) {}
1194 // Swaps two AssertionResults.
1195 void AssertionResult::swap(AssertionResult& other) {
1197 swap(success_, other.success_);
1198 swap(message_, other.message_);
1201 // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
1202 AssertionResult AssertionResult::operator!() const {
1203 AssertionResult negation(!success_);
1204 if (message_.get() != nullptr) negation << *message_;
1208 // Makes a successful assertion result.
1209 AssertionResult AssertionSuccess() {
1210 return AssertionResult(true);
1213 // Makes a failed assertion result.
1214 AssertionResult AssertionFailure() {
1215 return AssertionResult(false);
1218 // Makes a failed assertion result with the given failure message.
1219 // Deprecated; use AssertionFailure() << message.
1220 AssertionResult AssertionFailure(const Message& message) {
1221 return AssertionFailure() << message;
1224 namespace internal {
1226 namespace edit_distance {
1227 std::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));
1234 // Populate for empty right.
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;
1239 // Populate for empty left.
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]) {
1248 // Found a match. Consume it.
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;
1264 // We make replace a little more expensive than add/remove to lower
1266 costs[l_i + 1][r_i + 1] = replace + 1.00001;
1267 best_move[l_i + 1][r_i + 1] = kReplace;
1272 // Reconstruct the best path. We do it in reverse order.
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());
1286 // Helper class to convert string into ids with deduplication.
1287 class 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;
1303 std::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);
1321 // Helper class that holds the state for one hunk and prints it out to the
1323 // It reorders adds/removes when possible to group all removes before all
1324 // adds. It also adds the hunk header before printint into the stream.
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_);
1370 // Print a unified diff header for one hunk.
1372 // "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@"
1373 // where the left/right parts are omitted if unnecessary.
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_;
1395 // Create a list of diff hunks in Unified diff format.
1396 // Each hunk has a header generated by PrintHeader above plus a body with
1397 // lines prefixed with ' ' for no change, '-' for deletion and '+' for
1399 // 'context' represents the desired unchanged prefix/suffix around the diff.
1400 // If two hunks are close enough that their contexts overlap, then they are
1401 // joined into one hunk.
1402 std::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) {
1417 // Find the first line to include in the hunk.
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());
1424 // Iterate the edits until we found enough suffix for the hunk or the input
1426 size_t n_suffix = 0;
1427 for (; edit_i < edits.size(); ++edit_i) {
1428 if (n_suffix >= context) {
1429 // Continue only if the next hunk is very close.
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) {
1434 // There is no next edit or it is too far away.
1439 EditType edit = edits[edit_i];
1440 // Reset count when a non match is found.
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());
1450 // Advance indices, depending on edit type.
1451 l_i += edit != kAdd;
1452 r_i += edit != kRemove;
1455 if (!hunk.has_edits()) {
1456 // We are done. We don't want this hunk.
1465 } // namespace edit_distance
1469 // The string representation of the values received in EqFailure() are already
1470 // escaped. Split them on escaped '\n' boundaries. Leave all other escaped
1471 // characters the same.
1472 std::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));
1497 // Constructs and returns the message for an equality assertion
1498 // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
1500 // The first four parameters are the expressions used in the assertion
1501 // and their values, as strings. For example, for ASSERT_EQ(foo, bar)
1502 // where foo is 5 and bar is 6, we have:
1504 // lhs_expression: "foo"
1505 // rhs_expression: "bar"
1509 // The ignoring_case parameter is true if and only if the assertion is a
1510 // *_STRCASEEQ*. When it's true, the string "Ignoring case" will
1511 // be inserted into the message.
1512 AssertionResult 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;
1546 // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
1547 std::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();
1562 // Helper function for implementing ASSERT_NEAR.
1563 AssertionResult DoubleNearPredFormat(const char* expr1,
1565 const char* abs_error_expr,
1569 const double diff = fabs(val1 - val2);
1570 if (diff <= abs_error) return AssertionSuccess();
1572 // Find the value which is closest to zero.
1573 const double min_abs = std::min(fabs(val1), fabs(val2));
1574 // Find the distance to the next double from that value.
1575 const double epsilon =
1576 nextafter(min_abs, std::numeric_limits<double>::infinity()) - min_abs;
1577 // Detect the case where abs_error is so small that EXPECT_NEAR is
1578 // effectively the same as EXPECT_EQUAL, and give an informative error
1579 // message so that the situation can be more easily understood without
1580 // requiring exotic floating-point knowledge.
1581 // Don't do an epsilon check if abs_error is zero because that implies
1582 // that an equality check was actually intended.
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 << ".";
1606 // Helper template for implementing FloatLE() and DoubleLE().
1607 template <typename RawType>
1608 AssertionResult FloatingPointLE(const char* expr1,
1612 // Returns success if val1 is less than val2,
1614 return AssertionSuccess();
1617 // or if val1 is almost equal to val2.
1618 const FloatingPoint<RawType> lhs(val1), rhs(val2);
1619 if (lhs.AlmostEquals(rhs)) {
1620 return AssertionSuccess();
1623 // Note that the above two checks will both fail if either val1 or
1624 // val2 is NaN, as the IEEE floating-point standard requires that
1625 // any predicate involving a NaN must return false.
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);
1641 } // namespace internal
1643 // Asserts that val1 is less than, or almost equal to, val2. Fails
1644 // otherwise. In particular, it fails if either val1 or val2 is NaN.
1645 AssertionResult FloatLE(const char* expr1, const char* expr2,
1646 float val1, float val2) {
1647 return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
1650 // Asserts that val1 is less than, or almost equal to, val2. Fails
1651 // otherwise. In particular, it fails if either val1 or val2 is NaN.
1652 AssertionResult DoubleLE(const char* expr1, const char* expr2,
1653 double val1, double val2) {
1654 return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
1657 namespace internal {
1659 // The helper function for {ASSERT|EXPECT}_STREQ.
1660 AssertionResult CmpHelperSTREQ(const char* lhs_expression,
1661 const char* rhs_expression,
1664 if (String::CStringEquals(lhs, rhs)) {
1665 return AssertionSuccess();
1668 return EqFailure(lhs_expression,
1675 // The helper function for {ASSERT|EXPECT}_STRCASEEQ.
1676 AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
1677 const char* rhs_expression,
1680 if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
1681 return AssertionSuccess();
1684 return EqFailure(lhs_expression,
1691 // The helper function for {ASSERT|EXPECT}_STRNE.
1692 AssertionResult 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 << "\"";
1705 // The helper function for {ASSERT|EXPECT}_STRCASENE.
1706 AssertionResult 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 << "\"";
1720 } // namespace internal
1724 // Helper functions for implementing IsSubString() and IsNotSubstring().
1726 // This group of overloaded functions return true if and only if needle
1727 // is a substring of haystack. NULL is considered a substring of
1730 bool IsSubstringPred(const char* needle, const char* haystack) {
1731 if (needle == nullptr || haystack == nullptr) return needle == haystack;
1733 return strstr(haystack, needle) != nullptr;
1736 bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
1737 if (needle == nullptr || haystack == nullptr) return needle == haystack;
1739 return wcsstr(haystack, needle) != nullptr;
1742 // StringType here can be either ::std::string or ::std::wstring.
1743 template <typename StringType>
1744 bool IsSubstringPred(const StringType& needle,
1745 const StringType& haystack) {
1746 return haystack.find(needle) != StringType::npos;
1749 // This function implements either IsSubstring() or IsNotSubstring(),
1750 // depending on the value of the expected_to_be_substring parameter.
1751 // StringType here can be const char*, const wchar_t*, ::std::string,
1752 // or ::std::wstring.
1753 template <typename StringType>
1754 AssertionResult 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 << "\"";
1773 // IsSubstring() and IsNotSubstring() check whether needle is a
1774 // substring of haystack (NULL is considered a substring of itself
1775 // only), and return an appropriate error message when they fail.
1777 AssertionResult 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);
1783 AssertionResult 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);
1789 AssertionResult 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);
1795 AssertionResult 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);
1801 AssertionResult 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);
1807 AssertionResult 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
1814 AssertionResult 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);
1820 AssertionResult 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);
1825 #endif // GTEST_HAS_STD_WSTRING
1827 namespace internal {
1829 #if GTEST_OS_WINDOWS
1833 // Helper function for IsHRESULT{SuccessFailure} predicates
1834 AssertionResult HRESULTFailureHelper(const char* expr,
1835 const char* expected,
1836 long hr) { // NOLINT
1837 # if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE
1839 // Windows CE doesn't support FormatMessage.
1840 const char error_text[] = "";
1844 // Looks up the human-readable system message for the HRESULT code
1845 // and since we're not passing any params to FormatMessage, we don't
1846 // want inserts expanded.
1847 const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
1848 FORMAT_MESSAGE_IGNORE_INSERTS;
1849 const DWORD kBufSize = 4096;
1850 // Gets the system's human readable message string for this HRESULT.
1851 char error_text[kBufSize] = { '\0' };
1852 DWORD message_length = ::FormatMessageA(kFlags,
1853 0, // no source, we're asking system
1854 static_cast<DWORD>(hr), // the error
1855 0, // no line width restrictions
1856 error_text, // output buffer
1857 kBufSize, // buf size
1858 nullptr); // no arguments for inserts
1859 // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
1860 for (; message_length && IsSpace(error_text[message_length - 1]);
1862 error_text[message_length - 1] = '\0';
1865 # endif // GTEST_OS_WINDOWS_MOBILE
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";
1875 AssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT
1876 if (SUCCEEDED(hr)) {
1877 return AssertionSuccess();
1879 return HRESULTFailureHelper(expr, "succeeds", hr);
1882 AssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT
1884 return AssertionSuccess();
1886 return HRESULTFailureHelper(expr, "fails", hr);
1889 #endif // GTEST_OS_WINDOWS
1891 // Utility functions for encoding Unicode text (wide strings) in
1894 // A Unicode code-point can have up to 21 bits, and is encoded in UTF-8
1897 // Code-point length Encoding
1898 // 0 - 7 bits 0xxxxxxx
1899 // 8 - 11 bits 110xxxxx 10xxxxxx
1900 // 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx
1901 // 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
1903 // The maximum code-point a one-byte UTF-8 sequence can represent.
1904 constexpr uint32_t kMaxCodePoint1 = (static_cast<uint32_t>(1) << 7) - 1;
1906 // The maximum code-point a two-byte UTF-8 sequence can represent.
1907 constexpr uint32_t kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1;
1909 // The maximum code-point a three-byte UTF-8 sequence can represent.
1910 constexpr uint32_t kMaxCodePoint3 = (static_cast<uint32_t>(1) << (4 + 2*6)) - 1;
1912 // The maximum code-point a four-byte UTF-8 sequence can represent.
1913 constexpr uint32_t kMaxCodePoint4 = (static_cast<uint32_t>(1) << (3 + 3*6)) - 1;
1915 // Chops off the n lowest bits from a bit pattern. Returns the n
1916 // lowest bits. As a side effect, the original bit pattern will be
1917 // shifted to the right by n bits.
1918 inline uint32_t ChopLowBits(uint32_t* bits, int n) {
1919 const uint32_t low_bits = *bits & ((static_cast<uint32_t>(1) << n) - 1);
1924 // Converts a Unicode code point to a narrow string in UTF-8 encoding.
1925 // code_point parameter is of type uint32_t because wchar_t may not be
1926 // wide enough to contain a code point.
1927 // If the code_point is not a valid Unicode code point
1928 // (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
1929 // to "(Invalid Unicode 0xXXXXXXXX)".
1930 std::string CodePointToUtf8(uint32_t code_point) {
1931 if (code_point > kMaxCodePoint4) {
1932 return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")";
1935 char str[5]; // Big enough for the largest valid code point.
1936 if (code_point <= kMaxCodePoint1) {
1938 str[0] = static_cast<char>(code_point); // 0xxxxxxx
1939 } else if (code_point <= kMaxCodePoint2) {
1941 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1942 str[0] = static_cast<char>(0xC0 | code_point); // 110xxxxx
1943 } else if (code_point <= kMaxCodePoint3) {
1945 str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1946 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1947 str[0] = static_cast<char>(0xE0 | code_point); // 1110xxxx
1948 } else { // code_point <= kMaxCodePoint4
1950 str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1951 str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1952 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1953 str[0] = static_cast<char>(0xF0 | code_point); // 11110xxx
1958 // The following two functions only make sense if the system
1959 // uses UTF-16 for wide string encoding. All supported systems
1960 // with 16 bit wchar_t (Windows, Cygwin) do use UTF-16.
1962 // Determines if the arguments constitute UTF-16 surrogate pair
1963 // and thus should be combined into a single Unicode code point
1964 // using CreateCodePointFromUtf16SurrogatePair.
1965 inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
1966 return sizeof(wchar_t) == 2 &&
1967 (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
1970 // Creates a Unicode code point from UTF16 surrogate pair.
1971 inline 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
1979 // This function should not be called when the condition is
1980 // false, but we provide a sensible default in case it is.
1984 // Converts a wide string to a narrow string in UTF-8 encoding.
1985 // The wide string is assumed to have the following encoding:
1986 // UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
1987 // UTF-32 if sizeof(wchar_t) == 4 (on Linux)
1988 // Parameter str points to a null-terminated wide string.
1989 // Parameter num_chars may additionally limit the number
1990 // of wchar_t characters processed. -1 is used when the entire string
1991 // should be processed.
1992 // If the string contains code points that are not valid Unicode code points
1993 // (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
1994 // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
1995 // and contains invalid UTF-16 surrogate pairs, values in those pairs
1996 // will be encoded as individual Unicode characters from Basic Normal Plane.
1997 std::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);
2020 // Converts a wide C string to an std::string using the UTF-8 encoding.
2021 // NULL will be converted to "(null)".
2022 std::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);
2028 // Compares two wide C strings. Returns true if and only if they have the
2031 // Unlike wcscmp(), this function can handle NULL argument(s). A NULL
2032 // C string is considered different to any non-NULL C string,
2033 // including the empty string.
2034 bool 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;
2042 // Helper function for *_STREQ on wide strings.
2043 AssertionResult 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,
2058 // Helper function for *_STRNE on wide strings.
2059 AssertionResult 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);
2073 // Compares two C strings, ignoring case. Returns true if and only if they have
2074 // the same content.
2076 // Unlike strcasecmp(), this function can handle NULL argument(s). A
2077 // NULL C string is considered different to any non-NULL C string,
2078 // including the empty string.
2079 bool 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;
2085 // Compares two wide C strings, ignoring case. Returns true if and only if they
2086 // have the same content.
2088 // Unlike wcscasecmp(), this function can handle NULL argument(s).
2089 // A NULL C string is considered different to any non-NULL wide C string,
2090 // including the empty string.
2091 // NB: The implementations on different platforms slightly differ.
2092 // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
2093 // environment variable. On GNU platform this method uses wcscasecmp
2094 // which compares according to LC_CTYPE category of the current locale.
2095 // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
2097 bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
2098 const wchar_t* rhs) {
2099 if (lhs == nullptr) return rhs == nullptr;
2101 if (rhs == nullptr) return false;
2103 #if GTEST_OS_WINDOWS
2104 return _wcsicmp(lhs, rhs) == 0;
2105 #elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
2106 return wcscasecmp(lhs, rhs) == 0;
2108 // Android, Mac OS X and Cygwin don't define wcscasecmp.
2109 // Other unknown OSes may not define it either.
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;
2116 #endif // OS selector
2119 // Returns true if and only if str ends with the given suffix, ignoring case.
2120 // Any string is considered to end with an empty suffix.
2121 bool 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,
2130 // Formats an int value as "%02d".
2131 std::string String::FormatIntWidth2(int value) {
2132 return FormatIntWidthN(value, 2);
2135 // Formats an int value to given width with leading zeros.
2136 std::string String::FormatIntWidthN(int value, int width) {
2137 std::stringstream ss;
2138 ss << std::setfill('0') << std::setw(width) << value;
2142 // Formats an int value as "%X".
2143 std::string String::FormatHexUInt32(uint32_t value) {
2144 std::stringstream ss;
2145 ss << std::hex << std::uppercase << value;
2149 // Formats an int value as "%X".
2150 std::string String::FormatHexInt(int value) {
2151 return FormatHexUInt32(static_cast<uint32_t>(value));
2154 // Formats a byte as "%02X".
2155 std::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);
2162 // Converts the buffer in a stringstream to an std::string, converting NUL
2163 // bytes to "\\0" along the way.
2164 std::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) {
2173 result += "\\0"; // Replaces NUL with "\\0";
2182 // Appends the user-supplied message to the Google-Test-generated message.
2183 std::string AppendUserMessage(const std::string& gtest_msg,
2184 const Message& user_msg) {
2185 // Appends the user message if it's non-empty.
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;
2196 } // namespace internal
2200 // Creates an empty TestResult.
2201 TestResult::TestResult()
2202 : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
2205 TestResult::~TestResult() {
2208 // Returns the i-th test part result among all the results. i can
2209 // range from 0 to total_part_count() - 1. If i is not in that range,
2210 // aborts the program.
2211 const 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));
2217 // Returns the i-th test property. i can range from 0 to
2218 // test_property_count() - 1. If i is not in that range, aborts the
2220 const 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));
2226 // Clears the test part results.
2227 void TestResult::ClearTestPartResults() {
2228 test_part_results_.clear();
2231 // Adds a test part result to the list.
2232 void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
2233 test_part_results_.push_back(test_part_result);
2236 // Adds a test property to the list. If a property with the same key as the
2237 // supplied property is already represented, the value of this test_property
2238 // replaces the old value for that key.
2239 void TestResult::RecordProperty(const std::string& xml_element,
2240 const TestProperty& test_property) {
2241 if (!ValidateTestProperty(xml_element, test_property)) {
2244 internal::MutexLock lock(&test_properties_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());
2255 // The list of reserved attributes used in the <testsuites> element of XML
2257 static const char* const kReservedTestSuitesAttributes[] = {
2268 // The list of reserved attributes used in the <testsuite> element of XML
2270 static const char* const kReservedTestSuiteAttributes[] = {
2271 "disabled", "errors", "failures", "name",
2272 "tests", "time", "timestamp", "skipped"};
2274 // The list of reserved attributes used in the <testcase> element of XML output.
2275 static const char* const kReservedTestCaseAttributes[] = {
2276 "classname", "name", "status", "time", "type_param",
2277 "value_param", "file", "line"};
2279 // Use a slightly different set for allowed output to ensure existing tests can
2280 // still RecordProperty("result") or "RecordProperty(timestamp")
2281 static const char* const kReservedOutputTestCaseAttributes[] = {
2282 "classname", "name", "status", "time", "type_param",
2283 "value_param", "file", "line", "result", "timestamp"};
2285 template <size_t kSize>
2286 std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
2287 return std::vector<std::string>(array, array + kSize);
2290 static 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;
2301 // This code is unreachable but some compilers may not realizes that.
2302 return std::vector<std::string>();
2305 // TODO(jdesprez): Merge the two getReserved attributes once skip is improved
2306 static 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;
2317 // This code is unreachable but some compilers may not realizes that.
2318 return std::vector<std::string>();
2321 static 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();
2335 static 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_ << ")";
2348 // Adds a failure if the key is a reserved attribute of the element named
2349 // xml_element. Returns true if the property is valid.
2350 bool TestResult::ValidateTestProperty(const std::string& xml_element,
2351 const TestProperty& test_property) {
2352 return ValidateTestPropertyName(test_property.key(),
2353 GetReservedAttributesForElement(xml_element));
2356 // Clears the object.
2357 void TestResult::Clear() {
2358 test_part_results_.clear();
2359 test_properties_.clear();
2360 death_test_count_ = 0;
2364 // Returns true off the test part was skipped.
2365 static bool TestPartSkipped(const TestPartResult& result) {
2366 return result.skipped();
2369 // Returns true if and only if the test was skipped.
2370 bool TestResult::Skipped() const {
2371 return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
2374 // Returns true if and only if the test failed.
2375 bool TestResult::Failed() const {
2376 for (int i = 0; i < total_part_count(); ++i) {
2377 if (GetTestPartResult(i).failed())
2383 // Returns true if and only if the test part fatally failed.
2384 static bool TestPartFatallyFailed(const TestPartResult& result) {
2385 return result.fatally_failed();
2388 // Returns true if and only if the test fatally failed.
2389 bool TestResult::HasFatalFailure() const {
2390 return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
2393 // Returns true if and only if the test part non-fatally failed.
2394 static bool TestPartNonfatallyFailed(const TestPartResult& result) {
2395 return result.nonfatally_failed();
2398 // Returns true if and only if the test has a non-fatal failure.
2399 bool TestResult::HasNonfatalFailure() const {
2400 return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
2403 // Gets the number of all test parts. This is the sum of the number
2404 // of successful test parts and the number of failed test parts.
2405 int TestResult::total_part_count() const {
2406 return static_cast<int>(test_part_results_.size());
2409 // Returns the number of the test properties.
2410 int TestResult::test_property_count() const {
2411 return static_cast<int>(test_properties_.size());
2416 // Creates a Test object.
2418 // The c'tor saves the states of all flags.
2420 : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
2423 // The d'tor restores the states of all flags. The actual work is
2424 // done by the d'tor of the gtest_flag_saver_ field, and thus not
2429 // Sets up the test fixture.
2431 // A sub-class may override this.
2432 void Test::SetUp() {
2435 // Tears down the test fixture.
2437 // A sub-class may override this.
2438 void Test::TearDown() {
2441 // Allows user supplied key value pairs to be recorded for later output.
2442 void Test::RecordProperty(const std::string& key, const std::string& value) {
2443 UnitTest::GetInstance()->RecordProperty(key, value);
2446 // Allows user supplied key value pairs to be recorded for later output.
2447 void Test::RecordProperty(const std::string& key, int value) {
2448 Message value_message;
2449 value_message << value;
2450 RecordProperty(key, value_message.GetString().c_str());
2453 namespace internal {
2455 void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
2456 const std::string& message) {
2457 // This function is a friend of UnitTest and as such has access to
2458 // AddTestPartResult.
2459 UnitTest::GetInstance()->AddTestPartResult(
2461 nullptr, // No info about the source file where the exception occurred.
2462 -1, // We have no info on which line caused the exception.
2464 ""); // No stack trace, either.
2467 } // namespace internal
2469 // Google Test requires all tests in the same test suite to use the same test
2470 // fixture class. This function checks if the current test has the
2471 // same fixture class as the first test in the current test suite. If
2472 // yes, it returns true; otherwise it generates a Google Test failure and
2474 bool Test::HasSameFixtureClass() {
2475 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
2476 const TestSuite* const test_suite = impl->current_test_suite();
2478 // Info about the first test in the 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();
2483 // Info about the current test.
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) {
2489 // Is the first test defined using TEST?
2490 const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
2491 // Is this test defined using TEST?
2492 const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
2494 if (first_is_TEST || this_is_TEST) {
2495 // Both TEST and TEST_F appear in same test suite, which is incorrect.
2496 // Tell the user how to fix this.
2498 // Gets the name of the TEST and the name of the TEST_F. Note
2499 // that first_is_TEST and this_is_TEST cannot both be true, as
2500 // the fixture IDs are different for the two tests.
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"
2516 // Two fixture classes with the same name appear in two different
2517 // namespaces, which is not allowed. Tell the user how to fix this.
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.";
2537 // Adds an "exception thrown" fatal failure to the current test. This
2538 // function returns its result via an output parameter pointer because VC++
2539 // prohibits creation of objects with destructors on stack in functions
2540 // using __try (see error C2712).
2541 static 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());
2550 #endif // GTEST_HAS_SEH
2552 namespace internal {
2554 #if GTEST_HAS_EXCEPTIONS
2556 // Adds an "exception thrown" fatal failure to the current test.
2557 static 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();
2570 static std::string PrintTestPartResultToString(
2571 const TestPartResult& test_part_result);
2573 GoogleTestFailureException::GoogleTestFailureException(
2574 const TestPartResult& failure)
2575 : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
2577 #endif // GTEST_HAS_EXCEPTIONS
2579 // We put these helper functions in the internal namespace as IBM's xlC
2580 // compiler rejects the code if they were declared static.
2582 // Runs the given method and handles SEH exceptions it throws, when
2583 // SEH is supported; returns the 0-value for type Result in case of an
2584 // SEH exception. (Microsoft compilers cannot handle SEH and C++
2585 // exceptions in the same function. Therefore, we provide a separate
2586 // wrapper function for handling SEH exceptions.)
2587 template <class T, typename Result>
2588 Result HandleSehExceptionsInMethodIfSupported(
2589 T* object, Result (T::*method)(), const char* location) {
2592 return (object->*method)();
2593 } __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT
2594 GetExceptionCode())) {
2595 // We create the exception message on the heap because VC++ prohibits
2596 // creation of objects with destructors on stack in functions using __try
2597 // (see error C2712).
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)();
2608 #endif // GTEST_HAS_SEH
2611 // Runs the given method and catches and reports C++ and/or SEH-style
2612 // exceptions, if they are supported; returns the 0-value for type
2613 // Result in case of an SEH exception.
2614 template <class T, typename Result>
2615 Result HandleExceptionsInMethodIfSupported(
2616 T* object, Result (T::*method)(), const char* location) {
2617 // NOTE: The user code can affect the way in which Google Test handles
2618 // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
2619 // RUN_ALL_TESTS() starts. It is technically possible to check the flag
2620 // after the exception is caught and either report or re-throw the
2621 // exception based on the flag's value:
2624 // // Perform the test method.
2626 // if (GTEST_FLAG(catch_exceptions))
2627 // // Report the exception as failure.
2629 // throw; // Re-throws the original exception.
2632 // However, the purpose of this flag is to allow the program to drop into
2633 // the debugger when the exception is thrown. On most platforms, once the
2634 // control enters the catch block, the exception origin information is
2635 // lost and the debugger will stop the program at the point of the
2636 // re-throw in this function -- instead of at the point of the original
2637 // throw statement in the code under test. For this reason, we perform
2638 // the check early, sacrificing the ability to affect Google Test's
2639 // exception handling in the method where the exception is thrown.
2640 if (internal::GetUnitTestImpl()->catch_exceptions()) {
2641 #if GTEST_HAS_EXCEPTIONS
2643 return HandleSehExceptionsInMethodIfSupported(object, method, location);
2644 } catch (const AssertionException&) { // NOLINT
2645 // This failure was reported already.
2646 } catch (const internal::GoogleTestFailureException&) { // NOLINT
2647 // This exception type can only be thrown by a failed Google
2648 // Test assertion with the intention of letting another testing
2649 // framework catch it. Therefore we just re-throw it.
2651 } catch (const std::exception& e) { // NOLINT
2652 internal::ReportFailureInUnknownLocation(
2653 TestPartResult::kFatalFailure,
2654 FormatCxxExceptionMessage(e.what(), location));
2655 } catch (...) { // NOLINT
2656 internal::ReportFailureInUnknownLocation(
2657 TestPartResult::kFatalFailure,
2658 FormatCxxExceptionMessage(nullptr, location));
2660 return static_cast<Result>(0);
2662 return HandleSehExceptionsInMethodIfSupported(object, method, location);
2663 #endif // GTEST_HAS_EXCEPTIONS
2665 return (object->*method)();
2669 } // namespace internal
2671 // Runs the test and updates the test result.
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()");
2678 // We will run the test only if SetUp() was successful and didn't call
2680 if (!HasFatalFailure() && !IsSkipped()) {
2681 impl->os_stack_trace_getter()->UponLeavingGTest();
2682 internal::HandleExceptionsInMethodIfSupported(
2683 this, &Test::TestBody, "the test body");
2686 // However, we want to clean up as much as possible. Hence we will
2687 // always call TearDown(), even if SetUp() or the test body has
2689 impl->os_stack_trace_getter()->UponLeavingGTest();
2690 internal::HandleExceptionsInMethodIfSupported(
2691 this, &Test::TearDown, "TearDown()");
2694 // Returns true if and only if the current test has a fatal failure.
2695 bool Test::HasFatalFailure() {
2696 return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
2699 // Returns true if and only if the current test has a non-fatal failure.
2700 bool Test::HasNonfatalFailure() {
2701 return internal::GetUnitTestImpl()->current_test_result()->
2702 HasNonfatalFailure();
2705 // Returns true if and only if the current test was skipped.
2706 bool Test::IsSkipped() {
2707 return internal::GetUnitTestImpl()->current_test_result()->Skipped();
2712 // Constructs a TestInfo object. It assumes ownership of the test factory
2714 TestInfo::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),
2733 // Destructs a TestInfo object.
2734 TestInfo::~TestInfo() { delete factory_; }
2736 namespace internal {
2738 // Creates a new TestInfo object and registers it with Google Test;
2739 // returns the created object.
2743 // test_suite_name: name of the test suite
2744 // name: name of the test
2745 // type_param: the name of the test's type parameter, or NULL if
2746 // this is not a typed or a type-parameterized test.
2747 // value_param: text representation of the test's value parameter,
2748 // or NULL if this is not a value-parameterized test.
2749 // code_location: code location where the test is defined
2750 // fixture_class_id: ID of the test fixture class
2751 // set_up_tc: pointer to the function that sets up the test suite
2752 // tear_down_tc: pointer to the function that tears down the test suite
2753 // factory: pointer to the factory that creates a test object.
2754 // The newly created TestInfo instance will assume
2755 // ownership of the factory object.
2756 TestInfo* 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);
2768 void 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();
2785 } // namespace internal
2789 // A predicate that checks the test name of a TestInfo against a known
2792 // This is used for implementation of the TestSuite class only. We put
2793 // it in the anonymous namespace to prevent polluting the outer
2796 // TestNameIs is copyable.
2801 // TestNameIs has NO default constructor.
2802 explicit TestNameIs(const char* name)
2805 // Returns true if and only if the test name of test_info matches name_.
2806 bool operator()(const TestInfo * test_info) const {
2807 return test_info && test_info->name() == name_;
2816 namespace internal {
2818 // This method expands all parameterized tests registered with macros TEST_P
2819 // and INSTANTIATE_TEST_SUITE_P into regular tests and registers those.
2820 // This will be done just once during the program runtime.
2821 void UnitTestImpl::RegisterParameterizedTests() {
2822 if (!parameterized_tests_registered_) {
2823 parameterized_test_registry_.RegisterTests();
2824 type_parameterized_test_registry_.CheckForInstantiations();
2825 parameterized_tests_registered_ = true;
2829 } // namespace internal
2831 // Creates the test object, runs it, records its result, and then
2833 void TestInfo::Run() {
2834 if (!should_run_) return;
2836 // Tells UnitTest where to store test result.
2837 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
2838 impl->set_current_test_info(this);
2840 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
2842 // Notifies the unit test event listeners that a test is about to start.
2843 repeater->OnTestStart(*this);
2845 result_.set_start_timestamp(internal::GetTimeInMillis());
2846 internal::Timer timer;
2848 impl->os_stack_trace_getter()->UponLeavingGTest();
2850 // Creates the test object.
2851 Test* const test = internal::HandleExceptionsInMethodIfSupported(
2852 factory_, &internal::TestFactoryBase::CreateTest,
2853 "the test fixture's constructor");
2855 // Runs the test if the constructor didn't generate a fatal failure or invoke
2857 // Note that the object will not be null
2858 if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
2859 // This doesn't throw as all user code that can throw are wrapped into
2860 // exception handling code.
2864 if (test != nullptr) {
2865 // Deletes the test object.
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());
2873 // Notifies the unit test event listener that a test has just finished.
2874 repeater->OnTestEnd(*this);
2876 // Tells UnitTest to stop associating assertion results to this
2878 impl->set_current_test_info(nullptr);
2881 // Skip and records a skipped test result for this object.
2882 void 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();
2890 // Notifies the unit test event listeners that a test is about to start.
2891 repeater->OnTestStart(*this);
2893 const TestPartResult test_part_result =
2894 TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");
2895 impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
2898 // Notifies the unit test event listener that a test has just finished.
2899 repeater->OnTestEnd(*this);
2900 impl->set_current_test_info(nullptr);
2905 // Gets the number of successful tests in this test suite.
2906 int TestSuite::successful_test_count() const {
2907 return CountIf(test_info_list_, TestPassed);
2910 // Gets the number of successful tests in this test suite.
2911 int TestSuite::skipped_test_count() const {
2912 return CountIf(test_info_list_, TestSkipped);
2915 // Gets the number of failed tests in this test suite.
2916 int TestSuite::failed_test_count() const {
2917 return CountIf(test_info_list_, TestFailed);
2920 // Gets the number of disabled tests that will be reported in the XML report.
2921 int TestSuite::reportable_disabled_test_count() const {
2922 return CountIf(test_info_list_, TestReportableDisabled);
2925 // Gets the number of disabled tests in this test suite.
2926 int TestSuite::disabled_test_count() const {
2927 return CountIf(test_info_list_, TestDisabled);
2930 // Gets the number of tests to be printed in the XML report.
2931 int TestSuite::reportable_test_count() const {
2932 return CountIf(test_info_list_, TestReportable);
2935 // Get the number of tests in this test suite that should run.
2936 int TestSuite::test_to_run_count() const {
2937 return CountIf(test_info_list_, ShouldRunTest);
2940 // Gets the number of all tests.
2941 int TestSuite::total_test_count() const {
2942 return static_cast<int>(test_info_list_.size());
2945 // Creates a TestSuite with the given name.
2949 // a_name: name of the test suite
2950 // a_type_param: the name of the test suite's type parameter, or NULL if
2951 // this is not a typed or a type-parameterized test suite.
2952 // set_up_tc: pointer to the function that sets up the test suite
2953 // tear_down_tc: pointer to the function that tears down the test suite
2954 TestSuite::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),
2965 // Destructor of TestSuite.
2966 TestSuite::~TestSuite() {
2967 // Deletes every Test in the collection.
2968 ForEach(test_info_list_, internal::Delete<TestInfo>);
2971 // Returns the i-th test among all the tests. i can range from 0 to
2972 // total_test_count() - 1. If i is not in that range, returns NULL.
2973 const 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)];
2978 // Returns the i-th test among all the tests. i can range from 0 to
2979 // total_test_count() - 1. If i is not in that range, returns NULL.
2980 TestInfo* 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)];
2985 // Adds a test to this test suite. Will delete the test upon
2986 // destruction of the TestSuite object.
2987 void TestSuite::AddTestInfo(TestInfo* test_info) {
2988 test_info_list_.push_back(test_info);
2989 test_indices_.push_back(static_cast<int>(test_indices_.size()));
2992 // Runs every test in this TestSuite.
2993 void 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();
3001 // Call both legacy and the new API
3002 repeater->OnTestSuiteStart(*this);
3003 // Legacy API is deprecated but still available
3004 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3005 repeater->OnTestCaseStart(*this);
3006 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
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()");
3029 // Call both legacy and the new API
3030 repeater->OnTestSuiteEnd(*this);
3031 // Legacy API is deprecated but still available
3032 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3033 repeater->OnTestCaseEnd(*this);
3034 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3036 impl->set_current_test_suite(nullptr);
3039 // Skips all tests under this TestSuite.
3040 void 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();
3048 // Call both legacy and the new API
3049 repeater->OnTestSuiteStart(*this);
3050 // Legacy API is deprecated but still available
3051 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3052 repeater->OnTestCaseStart(*this);
3053 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3055 for (int i = 0; i < total_test_count(); i++) {
3056 GetMutableTestInfo(i)->Skip();
3059 // Call both legacy and the new API
3060 repeater->OnTestSuiteEnd(*this);
3061 // Legacy API is deprecated but still available
3062 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3063 repeater->OnTestCaseEnd(*this);
3064 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3066 impl->set_current_test_suite(nullptr);
3069 // Clears the results of all tests in this test suite.
3070 void TestSuite::ClearResult() {
3071 ad_hoc_test_result_.Clear();
3072 ForEach(test_info_list_, TestInfo::ClearTestResult);
3075 // Shuffles the tests in this test suite.
3076 void TestSuite::ShuffleTests(internal::Random* random) {
3077 Shuffle(random, &test_indices_);
3080 // Restores the test order to before the first shuffle.
3081 void TestSuite::UnshuffleTests() {
3082 for (size_t i = 0; i < test_indices_.size(); i++) {
3083 test_indices_[i] = static_cast<int>(i);
3087 // Formats a countable noun. Depending on its quantity, either the
3088 // singular form or the plural form is used. e.g.
3090 // FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
3091 // FormatCountableNoun(5, "book", "books") returns "5 books".
3092 static 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);
3099 // Formats the count of tests.
3100 static std::string FormatTestCount(int test_count) {
3101 return FormatCountableNoun(test_count, "test", "tests");
3104 // Formats the count of test suites.
3105 static std::string FormatTestSuiteCount(int test_suite_count) {
3106 return FormatCountableNoun(test_suite_count, "test suite", "test suites");
3109 // Converts a TestPartResult::Type enum to human-friendly string
3110 // representation. Both kNonFatalFailure and kFatalFailure are translated
3111 // to "Failure", as the user usually doesn't care about the difference
3112 // between the two when viewing the test result.
3113 static 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";
3132 namespace internal {
3134 enum class GTestColor { kDefault, kRed, kGreen, kYellow };
3137 // Prints a TestPartResult to an std::string.
3138 static 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();
3147 // Prints a TestPartResult.
3148 static void PrintTestPartResult(const TestPartResult& test_part_result) {
3149 const std::string& result =
3150 PrintTestPartResultToString(test_part_result);
3151 printf("%s\n", result.c_str());
3153 // If the test program runs in Visual Studio or a debugger, the
3154 // following statements add the test part result message to the Output
3155 // window such that the user can double-click on it to jump to the
3156 // corresponding source code location; otherwise they do nothing.
3157 #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
3158 // We don't call OutputDebugString*() on Windows Mobile, as printing
3159 // to stdout is done by OutputDebugString() there already - we don't
3160 // want the same message printed twice.
3161 ::OutputDebugStringA(result.c_str());
3162 ::OutputDebugStringA("\n");
3166 // class PrettyUnitTestResultPrinter
3167 #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
3168 !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
3170 // Returns the character attribute for the given color.
3171 static 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;
3183 static int GetBitOffset(WORD color_mask) {
3184 if (color_mask == 0) return 0;
3187 while ((color_mask & 1) == 0) {
3194 static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
3195 // Let's reuse the BG
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; // invert intensity
3216 // Returns the ANSI color code for the given color. GTestColor::kDefault is
3217 // an invalid input.
3218 static const char* GetAnsiColorCode(GTestColor color) {
3220 case GTestColor::kRed:
3222 case GTestColor::kGreen:
3224 case GTestColor::kYellow:
3231 #endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
3233 // Returns true if and only if Google Test should use colors in the output.
3234 bool 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
3239 // On Windows the TERM variable is usually not set, but the
3240 // console there does support colors.
3241 return stdout_is_tty;
3243 // On non-Windows platforms, we rely on the TERM variable.
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;
3258 #endif // GTEST_OS_WINDOWS
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");
3265 // We take "yes", "true", "t", and "1" as meaning "yes". If the
3266 // value is neither one of these nor "auto", we treat it as "no" to
3270 // Helpers for printing colored strings to stdout. Note that on Windows, we
3271 // cannot simply emit special characters and have the terminal change colors.
3272 // This routine must actually emit the characters rather than return a string
3273 // that would be colored when printed, as can be done on Linux.
3275 GTEST_ATTRIBUTE_PRINTF_(2, 3)
3276 static 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);
3287 #endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS
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);
3299 // Gets the current text color.
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);
3305 // We need to flush the stream buffers into the console before each
3306 // SetConsoleTextAttribute call lest it affect the text that is already
3307 // printed but has not yet reached the console.
3309 SetConsoleTextAttribute(stdout_handle, new_color);
3314 // Restores the text color.
3315 SetConsoleTextAttribute(stdout_handle, old_color_attrs);
3317 printf("\033[0;3%sm", GetAnsiColorCode(color));
3319 printf("\033[m"); // Resets the terminal to default.
3320 #endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
3324 // Text printed in Google Test's text output and --gtest_list_tests
3325 // output to label the type parameter and value parameter for a test.
3326 static const char kTypeParamLabel[] = "TypeParam";
3327 static const char kValueParamLabel[] = "GetParam()";
3329 static 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);
3345 // This class implements the TestEventListener interface.
3347 // Class PrettyUnitTestResultPrinter is copyable.
3348 class PrettyUnitTestResultPrinter : public TestEventListener {
3350 PrettyUnitTestResultPrinter() {}
3351 static void PrintTestName(const char* test_suite, const char* test) {
3352 printf("%s.%s", test_suite, test);
3355 // The following methods override what's in the TestEventListener class.
3356 void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
3357 void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
3358 void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
3359 void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
3360 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3361 void OnTestCaseStart(const TestCase& test_case) override;
3363 void OnTestSuiteStart(const TestSuite& test_suite) override;
3364 #endif // OnTestCaseStart
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;
3374 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3376 void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
3377 void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
3378 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
3379 void OnTestProgramEnd(const UnitTest& /*unit_test*/) 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);
3387 // Fired before each iteration of tests starts.
3388 void 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();
3395 // Prints the filter if it's not *. This reminds the user that some
3396 // tests may be skipped.
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());
3422 void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
3423 const UnitTest& /*unit_test*/) {
3424 ColoredPrintf(GTestColor::kGreen, "[----------] ");
3425 printf("Global test environment set-up.\n");
3429 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3430 void 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());
3443 void 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());
3456 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3458 void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
3459 ColoredPrintf(GTestColor::kGreen, "[ RUN ] ");
3460 PrintTestName(test_info.test_suite_name(), test_info.name());
3465 // Called after an assertion failure.
3466 void PrettyUnitTestResultPrinter::OnTestPartResult(
3467 const TestPartResult& result) {
3468 switch (result.type()) {
3469 // If the test part succeeded, we don't need to do anything.
3470 case TestPartResult::kSuccess:
3473 // Print failure message from the assertion
3474 // (e.g. expected this and got that).
3475 PrintTestPartResult(result);
3480 void 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_
3502 void 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());
3513 void 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());
3523 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3525 void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
3526 const UnitTest& /*unit_test*/) {
3527 ColoredPrintf(GTestColor::kGreen, "[----------] ");
3528 printf("Global test environment tear-down\n");
3532 // Internal helper for printing the list of failed tests.
3533 void 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");
3558 // Internal helper for printing the list of test suite failures not covered by
3559 // PrintFailedTests.
3560 void 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");
3580 // Internal helper for printing the list of skipped tests.
3581 void 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());
3604 void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
3605 int /*iteration*/) {
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()) {
3633 printf("\n"); // Add a spacer if no FAILURE banner is displayed.
3635 ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",
3636 num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
3638 // Ensure that Google Test output is printed before, e.g., heapchecker output.
3642 // End PrettyUnitTestResultPrinter
3644 // This class implements the TestEventListener interface.
3646 // Class BriefUnitTestResultPrinter is copyable.
3647 class BriefUnitTestResultPrinter : public TestEventListener {
3649 BriefUnitTestResultPrinter() {}
3650 static void PrintTestName(const char* test_suite, const char* test) {
3651 printf("%s.%s", test_suite, test);
3654 // The following methods override what's in the TestEventListener class.
3655 void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
3656 void OnTestIterationStart(const UnitTest& /*unit_test*/,
3657 int /*iteration*/) override {}
3658 void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
3659 void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
3660 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3661 void OnTestCaseStart(const TestCase& /*test_case*/) override {}
3663 void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
3664 #endif // OnTestCaseStart
3666 void OnTestStart(const TestInfo& /*test_info*/) 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& /*test_case*/) override {}
3673 void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
3674 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3676 void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
3677 void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
3678 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
3679 void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
3682 // Called after an assertion failure.
3683 void BriefUnitTestResultPrinter::OnTestPartResult(
3684 const TestPartResult& result) {
3685 switch (result.type()) {
3686 // If the test part succeeded, we don't need to do anything.
3687 case TestPartResult::kSuccess:
3690 // Print failure message from the assertion
3691 // (e.g. expected this and got that).
3692 PrintTestPartResult(result);
3697 void 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())
3714 void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
3715 int /*iteration*/) {
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()) {
3737 printf("\n"); // Add a spacer if no FAILURE banner is displayed.
3739 ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",
3740 num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
3742 // Ensure that Google Test output is printed before, e.g., heapchecker output.
3746 // End BriefUnitTestResultPrinter
3748 // class TestEventRepeater
3750 // This class forwards events to other event listeners.
3751 class TestEventRepeater : public TestEventListener {
3753 TestEventRepeater() : forwarding_enabled_(true) {}
3754 ~TestEventRepeater() override;
3755 void Append(TestEventListener *listener);
3756 TestEventListener* Release(TestEventListener* listener);
3758 // Controls whether events will be forwarded to listeners_. Set to false
3759 // in death test child processes.
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;
3767 // Legacy API is deprecated but still available
3768 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3769 void OnTestCaseStart(const TestSuite& parameter) override;
3770 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
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;
3775 // Legacy API is deprecated but still available
3776 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3777 void OnTestCaseEnd(const TestCase& parameter) override;
3778 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
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;
3786 // Controls whether events will be forwarded to listeners_. Set to false
3787 // in death test child processes.
3788 bool forwarding_enabled_;
3789 // The list of listeners that receive events.
3790 std::vector<TestEventListener*> listeners_;
3792 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
3795 TestEventRepeater::~TestEventRepeater() {
3796 ForEach(listeners_, Delete<TestEventListener>);
3799 void TestEventRepeater::Append(TestEventListener *listener) {
3800 listeners_.push_back(listener);
3803 TestEventListener* 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));
3814 // Since most methods are very similar, use macros to reduce boilerplate.
3815 // This defines a member that forwards the call to all listeners.
3816 #define GTEST_REPEATER_METHOD_(Name, Type) \
3817 void TestEventRepeater::Name(const Type& parameter) { \
3818 if (forwarding_enabled_) { \
3819 for (size_t i = 0; i < listeners_.size(); i++) { \
3820 listeners_[i]->Name(parameter); \
3824 // This defines a member that forwards the call to all listeners in reverse
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); \
3835 GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
3836 GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
3837 // Legacy API is deprecated but still available
3838 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3839 GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite)
3840 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3841 GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite)
3842 GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
3843 GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
3844 GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
3845 GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
3846 GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
3847 GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
3848 // Legacy API is deprecated but still available
3849 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3850 GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite)
3851 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3852 GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite)
3853 GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
3855 #undef GTEST_REPEATER_METHOD_
3856 #undef GTEST_REVERSE_REPEATER_METHOD_
3858 void 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);
3867 void 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);
3876 // End TestEventRepeater
3878 // This class generates an XML output file.
3879 class XmlUnitTestResultPrinter : public EmptyTestEventListener {
3881 explicit XmlUnitTestResultPrinter(const char* output_file);
3883 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
3884 void ListTestsMatchingFilter(const std::vector<TestSuite*>& test_suites);
3886 // Prints an XML summary of all unit tests.
3887 static void PrintXmlTestsList(std::ostream* stream,
3888 const std::vector<TestSuite*>& test_suites);
3891 // Is c a whitespace character that is normalized to a space character
3892 // when it appears in an XML attribute value?
3893 static bool IsNormalizableWhitespace(char c) {
3894 return c == 0x9 || c == 0xA || c == 0xD;
3897 // May c appear in a well-formed XML document?
3898 static bool IsValidXmlCharacter(char c) {
3899 return IsNormalizableWhitespace(c) || c >= 0x20;
3902 // Returns an XML-escaped copy of the input string str. If
3903 // is_attribute is true, the text is meant to appear as an attribute
3904 // value, and normalizable whitespace is preserved by replacing it
3905 // with character references.
3906 static std::string EscapeXml(const std::string& str, bool is_attribute);
3908 // Returns the given string with all characters invalid in XML removed.
3909 static std::string RemoveInvalidXmlCharacters(const std::string& str);
3911 // Convenience wrapper around EscapeXml when str is an attribute value.
3912 static std::string EscapeXmlAttribute(const std::string& str) {
3913 return EscapeXml(str, true);
3916 // Convenience wrapper around EscapeXml when str is not an attribute value.
3917 static std::string EscapeXmlText(const char* str) {
3918 return EscapeXml(str, false);
3921 // Verifies that the given attribute belongs to the given element and
3922 // streams the attribute as XML.
3923 static void OutputXmlAttribute(std::ostream* stream,
3924 const std::string& element_name,
3925 const std::string& name,
3926 const std::string& value);
3928 // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
3929 static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
3931 // Streams a test suite XML stanza containing the given test result.
3933 // Requires: result.Failed()
3934 static void OutputXmlTestSuiteForTestResult(::std::ostream* stream,
3935 const TestResult& result);
3937 // Streams an XML representation of a TestResult object.
3938 static void OutputXmlTestResult(::std::ostream* stream,
3939 const TestResult& result);
3941 // Streams an XML representation of a TestInfo object.
3942 static void OutputXmlTestInfo(::std::ostream* stream,
3943 const char* test_suite_name,
3944 const TestInfo& test_info);
3946 // Prints an XML representation of a TestSuite object
3947 static void PrintXmlTestSuite(::std::ostream* stream,
3948 const TestSuite& test_suite);
3950 // Prints an XML summary of unit_test to output stream out.
3951 static void PrintXmlUnitTest(::std::ostream* stream,
3952 const UnitTest& unit_test);
3954 // Produces a string representing the test properties in a result as space
3955 // delimited XML attributes based on the property key="value" pairs.
3956 // When the std::string is not empty, it includes a space at the beginning,
3957 // to delimit this attribute from prior attributes.
3958 static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
3960 // Streams an XML representation of the test properties of a TestResult
3962 static void OutputXmlTestProperties(std::ostream* stream,
3963 const TestResult& result);
3966 const std::string output_file_;
3968 GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
3971 // Creates a new XmlUnitTestResultPrinter.
3972 XmlUnitTestResultPrinter::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";
3979 // Called after the unit test ends.
3980 void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
3981 int /*iteration*/) {
3982 FILE* xmlout = OpenFileForWriting(output_file_);
3983 std::stringstream stream;
3984 PrintXmlUnitTest(&stream, unit_test);
3985 fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
3989 void 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());
3998 // Returns an XML-escaped copy of the input string str. If is_attribute
3999 // is true, the text is meant to appear as an attribute value, and
4000 // normalizable whitespace is preserved by replacing it with character
4003 // Invalid XML characters in str, if any, are stripped from the output.
4004 // It is expected that most, if not all, of the text processed by this
4005 // module will consist of ordinary English text.
4006 // If this module is ever modified to produce version 1.1 XML output,
4007 // most invalid characters can be retained using character references.
4008 std::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();
4051 // Returns the given string with all characters invalid in XML removed.
4052 // Currently invalid characters are dropped from the string. An
4053 // alternative is to replace them with certain characters such as . or ?.
4054 std::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);
4065 // The following routines generate an XML representation of a UnitTest
4067 // GOOGLETEST_CM0009 DO NOT DELETE
4069 // This is how Google Test concepts map to the DTD:
4071 // <testsuites name="AllTests"> <-- corresponds to a UnitTest object
4072 // <testsuite name="testcase-name"> <-- corresponds to a TestSuite object
4073 // <testcase name="test-name"> <-- corresponds to a TestInfo object
4074 // <failure message="...">...</failure>
4075 // <failure message="...">...</failure>
4076 // <failure message="...">...</failure>
4077 // <-- individual assertion failures
4082 // Formats the given time in milliseconds as seconds.
4083 std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
4084 ::std::stringstream ss;
4085 ss << (static_cast<double>(ms) * 1e-3);
4089 static 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__)
4093 // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
4094 // Windows' localtime(), which has a thread-local tm buffer.
4095 struct tm* tm_ptr = localtime(&seconds); // NOLINT
4096 if (tm_ptr == nullptr) return false;
4099 #elif defined(__STDC_LIB_EXT1__)
4100 // Uses localtime_s when available as localtime_r is only available from
4102 return localtime_s(&seconds, out) != nullptr;
4104 return localtime_r(&seconds, out) != nullptr;
4108 // Converts the given epoch time in milliseconds to a date string in the ISO
4109 // 8601 format, without the timezone information.
4110 std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
4111 struct tm time_struct;
4112 if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
4114 // YYYY-MM-DDThh:mm:ss.sss
4115 return StreamableToString(time_struct.tm_year + 1900) + "-" +
4116 String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
4117 String::FormatIntWidth2(time_struct.tm_mday) + "T" +
4118 String::FormatIntWidth2(time_struct.tm_hour) + ":" +
4119 String::FormatIntWidth2(time_struct.tm_min) + ":" +
4120 String::FormatIntWidth2(time_struct.tm_sec) + "." +
4121 String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);
4124 // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
4125 void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
4127 const char* segment = data;
4128 *stream << "<![CDATA[";
4130 const char* const next_segment = strstr(segment, "]]>");
4131 if (next_segment != nullptr) {
4133 segment, static_cast<std::streamsize>(next_segment - segment));
4134 *stream << "]]>]]><![CDATA[";
4135 segment = next_segment + strlen("]]>");
4144 void XmlUnitTestResultPrinter::OutputXmlAttribute(
4145 std::ostream* stream,
4146 const std::string& element_name,
4147 const std::string& name,
4148 const std::string& value) {
4149 const std::vector<std::string>& allowed_names =
4150 GetReservedOutputAttributesForElement(element_name);
4152 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
4153 allowed_names.end())
4154 << "Attribute " << name << " is not allowed for element <" << element_name
4157 *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
4160 // Streams a test suite XML stanza containing the given test result.
4161 void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(
4162 ::std::ostream* stream, const TestResult& result) {
4163 // Output the boilerplate for a minimal test suite with one test.
4164 *stream << " <testsuite";
4165 OutputXmlAttribute(stream, "testsuite", "name", "NonTestSuiteFailure");
4166 OutputXmlAttribute(stream, "testsuite", "tests", "1");
4167 OutputXmlAttribute(stream, "testsuite", "failures", "1");
4168 OutputXmlAttribute(stream, "testsuite", "disabled", "0");
4169 OutputXmlAttribute(stream, "testsuite", "skipped", "0");
4170 OutputXmlAttribute(stream, "testsuite", "errors", "0");
4171 OutputXmlAttribute(stream, "testsuite", "time",
4172 FormatTimeInMillisAsSeconds(result.elapsed_time()));
4174 stream, "testsuite", "timestamp",
4175 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
4178 // Output the boilerplate for a minimal test case with a single test.
4179 *stream << " <testcase";
4180 OutputXmlAttribute(stream, "testcase", "name", "");
4181 OutputXmlAttribute(stream, "testcase", "status", "run");
4182 OutputXmlAttribute(stream, "testcase", "result", "completed");
4183 OutputXmlAttribute(stream, "testcase", "classname", "");
4184 OutputXmlAttribute(stream, "testcase", "time",
4185 FormatTimeInMillisAsSeconds(result.elapsed_time()));
4187 stream, "testcase", "timestamp",
4188 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
4190 // Output the actual test result.
4191 OutputXmlTestResult(stream, result);
4193 // Complete the test suite.
4194 *stream << " </testsuite>\n";
4197 // Prints an XML representation of a TestInfo object.
4198 void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
4199 const char* test_suite_name,
4200 const TestInfo& test_info) {
4201 const TestResult& result = *test_info.result();
4202 const std::string kTestsuite = "testcase";
4204 if (test_info.is_in_another_shard()) {
4208 *stream << " <testcase";
4209 OutputXmlAttribute(stream, kTestsuite, "name", test_info.name());
4211 if (test_info.value_param() != nullptr) {
4212 OutputXmlAttribute(stream, kTestsuite, "value_param",
4213 test_info.value_param());
4215 if (test_info.type_param() != nullptr) {
4216 OutputXmlAttribute(stream, kTestsuite, "type_param",
4217 test_info.type_param());
4219 if (GTEST_FLAG(list_tests)) {
4220 OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
4221 OutputXmlAttribute(stream, kTestsuite, "line",
4222 StreamableToString(test_info.line()));
4227 OutputXmlAttribute(stream, kTestsuite, "status",
4228 test_info.should_run() ? "run" : "notrun");
4229 OutputXmlAttribute(stream, kTestsuite, "result",
4230 test_info.should_run()
4231 ? (result.Skipped() ? "skipped" : "completed")
4233 OutputXmlAttribute(stream, kTestsuite, "time",
4234 FormatTimeInMillisAsSeconds(result.elapsed_time()));
4236 stream, kTestsuite, "timestamp",
4237 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
4238 OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name);
4240 OutputXmlTestResult(stream, result);
4243 void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream,
4244 const TestResult& result) {
4247 for (int i = 0; i < result.total_part_count(); ++i) {
4248 const TestPartResult& part = result.GetTestPartResult(i);
4249 if (part.failed()) {
4250 if (++failures == 1 && skips == 0) {
4253 const std::string location =
4254 internal::FormatCompilerIndependentFileLocation(part.file_name(),
4255 part.line_number());
4256 const std::string summary = location + "\n" + part.summary();
4257 *stream << " <failure message=\""
4258 << EscapeXmlAttribute(summary)
4260 const std::string detail = location + "\n" + part.message();
4261 OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
4262 *stream << "</failure>\n";
4263 } else if (part.skipped()) {
4264 if (++skips == 1 && failures == 0) {
4267 const std::string location =
4268 internal::FormatCompilerIndependentFileLocation(part.file_name(),
4269 part.line_number());
4270 const std::string summary = location + "\n" + part.summary();
4271 *stream << " <skipped message=\""
4272 << EscapeXmlAttribute(summary.c_str()) << "\">";
4273 const std::string detail = location + "\n" + part.message();
4274 OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
4275 *stream << "</skipped>\n";
4279 if (failures == 0 && skips == 0 && result.test_property_count() == 0) {
4282 if (failures == 0 && skips == 0) {
4285 OutputXmlTestProperties(stream, result);
4286 *stream << " </testcase>\n";
4290 // Prints an XML representation of a TestSuite object
4291 void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
4292 const TestSuite& test_suite) {
4293 const std::string kTestsuite = "testsuite";
4294 *stream << " <" << kTestsuite;
4295 OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
4296 OutputXmlAttribute(stream, kTestsuite, "tests",
4297 StreamableToString(test_suite.reportable_test_count()));
4298 if (!GTEST_FLAG(list_tests)) {
4299 OutputXmlAttribute(stream, kTestsuite, "failures",
4300 StreamableToString(test_suite.failed_test_count()));
4302 stream, kTestsuite, "disabled",
4303 StreamableToString(test_suite.reportable_disabled_test_count()));
4304 OutputXmlAttribute(stream, kTestsuite, "skipped",
4305 StreamableToString(test_suite.skipped_test_count()));
4307 OutputXmlAttribute(stream, kTestsuite, "errors", "0");
4309 OutputXmlAttribute(stream, kTestsuite, "time",
4310 FormatTimeInMillisAsSeconds(test_suite.elapsed_time()));
4312 stream, kTestsuite, "timestamp",
4313 FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp()));
4314 *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());
4317 for (int i = 0; i < test_suite.total_test_count(); ++i) {
4318 if (test_suite.GetTestInfo(i)->is_reportable())
4319 OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
4321 *stream << " </" << kTestsuite << ">\n";
4324 // Prints an XML summary of unit_test to output stream out.
4325 void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
4326 const UnitTest& unit_test) {
4327 const std::string kTestsuites = "testsuites";
4329 *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
4330 *stream << "<" << kTestsuites;
4332 OutputXmlAttribute(stream, kTestsuites, "tests",
4333 StreamableToString(unit_test.reportable_test_count()));
4334 OutputXmlAttribute(stream, kTestsuites, "failures",
4335 StreamableToString(unit_test.failed_test_count()));
4337 stream, kTestsuites, "disabled",
4338 StreamableToString(unit_test.reportable_disabled_test_count()));
4339 OutputXmlAttribute(stream, kTestsuites, "errors", "0");
4340 OutputXmlAttribute(stream, kTestsuites, "time",
4341 FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
4343 stream, kTestsuites, "timestamp",
4344 FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
4346 if (GTEST_FLAG(shuffle)) {
4347 OutputXmlAttribute(stream, kTestsuites, "random_seed",
4348 StreamableToString(unit_test.random_seed()));
4350 *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
4352 OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
4355 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
4356 if (unit_test.GetTestSuite(i)->reportable_test_count() > 0)
4357 PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i));
4360 // If there was a test failure outside of one of the test suites (like in a
4361 // test environment) include that in the output.
4362 if (unit_test.ad_hoc_test_result().Failed()) {
4363 OutputXmlTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
4366 *stream << "</" << kTestsuites << ">\n";
4369 void XmlUnitTestResultPrinter::PrintXmlTestsList(
4370 std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
4371 const std::string kTestsuites = "testsuites";
4373 *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
4374 *stream << "<" << kTestsuites;
4376 int total_tests = 0;
4377 for (auto test_suite : test_suites) {
4378 total_tests += test_suite->total_test_count();
4380 OutputXmlAttribute(stream, kTestsuites, "tests",
4381 StreamableToString(total_tests));
4382 OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
4385 for (auto test_suite : test_suites) {
4386 PrintXmlTestSuite(stream, *test_suite);
4388 *stream << "</" << kTestsuites << ">\n";
4391 // Produces a string representing the test properties in a result as space
4392 // delimited XML attributes based on the property key="value" pairs.
4393 std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
4394 const TestResult& result) {
4396 for (int i = 0; i < result.test_property_count(); ++i) {
4397 const TestProperty& property = result.GetTestProperty(i);
4398 attributes << " " << property.key() << "="
4399 << "\"" << EscapeXmlAttribute(property.value()) << "\"";
4401 return attributes.GetString();
4404 void XmlUnitTestResultPrinter::OutputXmlTestProperties(
4405 std::ostream* stream, const TestResult& result) {
4406 const std::string kProperties = "properties";
4407 const std::string kProperty = "property";
4409 if (result.test_property_count() <= 0) {
4413 *stream << "<" << kProperties << ">\n";
4414 for (int i = 0; i < result.test_property_count(); ++i) {
4415 const TestProperty& property = result.GetTestProperty(i);
4416 *stream << "<" << kProperty;
4417 *stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
4418 *stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
4421 *stream << "</" << kProperties << ">\n";
4424 // End XmlUnitTestResultPrinter
4426 // This class generates an JSON output file.
4427 class JsonUnitTestResultPrinter : public EmptyTestEventListener {
4429 explicit JsonUnitTestResultPrinter(const char* output_file);
4431 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
4433 // Prints an JSON summary of all unit tests.
4434 static void PrintJsonTestList(::std::ostream* stream,
4435 const std::vector<TestSuite*>& test_suites);
4438 // Returns an JSON-escaped copy of the input string str.
4439 static std::string EscapeJson(const std::string& str);
4441 //// Verifies that the given attribute belongs to the given element and
4442 //// streams the attribute as JSON.
4443 static void OutputJsonKey(std::ostream* stream,
4444 const std::string& element_name,
4445 const std::string& name,
4446 const std::string& value,
4447 const std::string& indent,
4449 static void OutputJsonKey(std::ostream* stream,
4450 const std::string& element_name,
4451 const std::string& name,
4453 const std::string& indent,
4456 // Streams a test suite JSON stanza containing the given test result.
4458 // Requires: result.Failed()
4459 static void OutputJsonTestSuiteForTestResult(::std::ostream* stream,
4460 const TestResult& result);
4462 // Streams a JSON representation of a TestResult object.
4463 static void OutputJsonTestResult(::std::ostream* stream,
4464 const TestResult& result);
4466 // Streams a JSON representation of a TestInfo object.
4467 static void OutputJsonTestInfo(::std::ostream* stream,
4468 const char* test_suite_name,
4469 const TestInfo& test_info);
4471 // Prints a JSON representation of a TestSuite object
4472 static void PrintJsonTestSuite(::std::ostream* stream,
4473 const TestSuite& test_suite);
4475 // Prints a JSON summary of unit_test to output stream out.
4476 static void PrintJsonUnitTest(::std::ostream* stream,
4477 const UnitTest& unit_test);
4479 // Produces a string representing the test properties in a result as
4480 // a JSON dictionary.
4481 static std::string TestPropertiesAsJson(const TestResult& result,
4482 const std::string& indent);
4485 const std::string output_file_;
4487 GTEST_DISALLOW_COPY_AND_ASSIGN_(JsonUnitTestResultPrinter);
4490 // Creates a new JsonUnitTestResultPrinter.
4491 JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file)
4492 : output_file_(output_file) {
4493 if (output_file_.empty()) {
4494 GTEST_LOG_(FATAL) << "JSON output file may not be null";
4498 void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
4499 int /*iteration*/) {
4500 FILE* jsonout = OpenFileForWriting(output_file_);
4501 std::stringstream stream;
4502 PrintJsonUnitTest(&stream, unit_test);
4503 fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
4507 // Returns an JSON-escaped copy of the input string str.
4508 std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
4511 for (size_t i = 0; i < str.size(); ++i) {
4512 const char ch = str[i];
4536 m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch));
4544 return m.GetString();
4547 // The following routines generate an JSON representation of a UnitTest
4550 // Formats the given time in milliseconds as seconds.
4551 static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
4552 ::std::stringstream ss;
4553 ss << (static_cast<double>(ms) * 1e-3) << "s";
4557 // Converts the given epoch time in milliseconds to a date string in the
4558 // RFC3339 format, without the timezone information.
4559 static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
4560 struct tm time_struct;
4561 if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
4563 // YYYY-MM-DDThh:mm:ss
4564 return StreamableToString(time_struct.tm_year + 1900) + "-" +
4565 String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
4566 String::FormatIntWidth2(time_struct.tm_mday) + "T" +
4567 String::FormatIntWidth2(time_struct.tm_hour) + ":" +
4568 String::FormatIntWidth2(time_struct.tm_min) + ":" +
4569 String::FormatIntWidth2(time_struct.tm_sec) + "Z";
4572 static inline std::string Indent(size_t width) {
4573 return std::string(width, ' ');
4576 void JsonUnitTestResultPrinter::OutputJsonKey(
4577 std::ostream* stream,
4578 const std::string& element_name,
4579 const std::string& name,
4580 const std::string& value,
4581 const std::string& indent,
4583 const std::vector<std::string>& allowed_names =
4584 GetReservedOutputAttributesForElement(element_name);
4586 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
4587 allowed_names.end())
4588 << "Key \"" << name << "\" is not allowed for value \"" << element_name
4591 *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\"";
4596 void JsonUnitTestResultPrinter::OutputJsonKey(
4597 std::ostream* stream,
4598 const std::string& element_name,
4599 const std::string& name,
4601 const std::string& indent,
4603 const std::vector<std::string>& allowed_names =
4604 GetReservedOutputAttributesForElement(element_name);
4606 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
4607 allowed_names.end())
4608 << "Key \"" << name << "\" is not allowed for value \"" << element_name
4611 *stream << indent << "\"" << name << "\": " << StreamableToString(value);
4616 // Streams a test suite JSON stanza containing the given test result.
4617 void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(
4618 ::std::ostream* stream, const TestResult& result) {
4619 // Output the boilerplate for a new test suite.
4620 *stream << Indent(4) << "{\n";
4621 OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6));
4622 OutputJsonKey(stream, "testsuite", "tests", 1, Indent(6));
4623 if (!GTEST_FLAG(list_tests)) {
4624 OutputJsonKey(stream, "testsuite", "failures", 1, Indent(6));
4625 OutputJsonKey(stream, "testsuite", "disabled", 0, Indent(6));
4626 OutputJsonKey(stream, "testsuite", "skipped", 0, Indent(6));
4627 OutputJsonKey(stream, "testsuite", "errors", 0, Indent(6));
4628 OutputJsonKey(stream, "testsuite", "time",
4629 FormatTimeInMillisAsDuration(result.elapsed_time()),
4631 OutputJsonKey(stream, "testsuite", "timestamp",
4632 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
4635 *stream << Indent(6) << "\"testsuite\": [\n";
4637 // Output the boilerplate for a new test case.
4638 *stream << Indent(8) << "{\n";
4639 OutputJsonKey(stream, "testcase", "name", "", Indent(10));
4640 OutputJsonKey(stream, "testcase", "status", "RUN", Indent(10));
4641 OutputJsonKey(stream, "testcase", "result", "COMPLETED", Indent(10));
4642 OutputJsonKey(stream, "testcase", "timestamp",
4643 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
4645 OutputJsonKey(stream, "testcase", "time",
4646 FormatTimeInMillisAsDuration(result.elapsed_time()),
4648 OutputJsonKey(stream, "testcase", "classname", "", Indent(10), false);
4649 *stream << TestPropertiesAsJson(result, Indent(10));
4651 // Output the actual test result.
4652 OutputJsonTestResult(stream, result);
4654 // Finish the test suite.
4655 *stream << "\n" << Indent(6) << "]\n" << Indent(4) << "}";
4658 // Prints a JSON representation of a TestInfo object.
4659 void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
4660 const char* test_suite_name,
4661 const TestInfo& test_info) {
4662 const TestResult& result = *test_info.result();
4663 const std::string kTestsuite = "testcase";
4664 const std::string kIndent = Indent(10);
4666 *stream << Indent(8) << "{\n";
4667 OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent);
4669 if (test_info.value_param() != nullptr) {
4670 OutputJsonKey(stream, kTestsuite, "value_param", test_info.value_param(),
4673 if (test_info.type_param() != nullptr) {
4674 OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(),
4677 if (GTEST_FLAG(list_tests)) {
4678 OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);
4679 OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false);
4680 *stream << "\n" << Indent(8) << "}";
4684 OutputJsonKey(stream, kTestsuite, "status",
4685 test_info.should_run() ? "RUN" : "NOTRUN", kIndent);
4686 OutputJsonKey(stream, kTestsuite, "result",
4687 test_info.should_run()
4688 ? (result.Skipped() ? "SKIPPED" : "COMPLETED")
4691 OutputJsonKey(stream, kTestsuite, "timestamp",
4692 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
4694 OutputJsonKey(stream, kTestsuite, "time",
4695 FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent);
4696 OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent,
4698 *stream << TestPropertiesAsJson(result, kIndent);
4700 OutputJsonTestResult(stream, result);
4703 void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
4704 const TestResult& result) {
4705 const std::string kIndent = Indent(10);
4708 for (int i = 0; i < result.total_part_count(); ++i) {
4709 const TestPartResult& part = result.GetTestPartResult(i);
4710 if (part.failed()) {
4712 if (++failures == 1) {
4713 *stream << kIndent << "\"" << "failures" << "\": [\n";
4715 const std::string location =
4716 internal::FormatCompilerIndependentFileLocation(part.file_name(),
4717 part.line_number());
4718 const std::string message = EscapeJson(location + "\n" + part.message());
4719 *stream << kIndent << " {\n"
4720 << kIndent << " \"failure\": \"" << message << "\",\n"
4721 << kIndent << " \"type\": \"\"\n"
4727 *stream << "\n" << kIndent << "]";
4728 *stream << "\n" << Indent(8) << "}";
4731 // Prints an JSON representation of a TestSuite object
4732 void JsonUnitTestResultPrinter::PrintJsonTestSuite(
4733 std::ostream* stream, const TestSuite& test_suite) {
4734 const std::string kTestsuite = "testsuite";
4735 const std::string kIndent = Indent(6);
4737 *stream << Indent(4) << "{\n";
4738 OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
4739 OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(),
4741 if (!GTEST_FLAG(list_tests)) {
4742 OutputJsonKey(stream, kTestsuite, "failures",
4743 test_suite.failed_test_count(), kIndent);
4744 OutputJsonKey(stream, kTestsuite, "disabled",
4745 test_suite.reportable_disabled_test_count(), kIndent);
4746 OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);
4748 stream, kTestsuite, "timestamp",
4749 FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()),
4751 OutputJsonKey(stream, kTestsuite, "time",
4752 FormatTimeInMillisAsDuration(test_suite.elapsed_time()),
4754 *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent)
4758 *stream << kIndent << "\"" << kTestsuite << "\": [\n";
4761 for (int i = 0; i < test_suite.total_test_count(); ++i) {
4762 if (test_suite.GetTestInfo(i)->is_reportable()) {
4768 OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
4771 *stream << "\n" << kIndent << "]\n" << Indent(4) << "}";
4774 // Prints a JSON summary of unit_test to output stream out.
4775 void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
4776 const UnitTest& unit_test) {
4777 const std::string kTestsuites = "testsuites";
4778 const std::string kIndent = Indent(2);
4781 OutputJsonKey(stream, kTestsuites, "tests", unit_test.reportable_test_count(),
4783 OutputJsonKey(stream, kTestsuites, "failures", unit_test.failed_test_count(),
4785 OutputJsonKey(stream, kTestsuites, "disabled",
4786 unit_test.reportable_disabled_test_count(), kIndent);
4787 OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent);
4788 if (GTEST_FLAG(shuffle)) {
4789 OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(),
4792 OutputJsonKey(stream, kTestsuites, "timestamp",
4793 FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()),
4795 OutputJsonKey(stream, kTestsuites, "time",
4796 FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent,
4799 *stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent)
4802 OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
4803 *stream << kIndent << "\"" << kTestsuites << "\": [\n";
4806 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
4807 if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) {
4813 PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i));
4817 // If there was a test failure outside of one of the test suites (like in a
4818 // test environment) include that in the output.
4819 if (unit_test.ad_hoc_test_result().Failed()) {
4820 OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
4823 *stream << "\n" << kIndent << "]\n" << "}\n";
4826 void JsonUnitTestResultPrinter::PrintJsonTestList(
4827 std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
4828 const std::string kTestsuites = "testsuites";
4829 const std::string kIndent = Indent(2);
4831 int total_tests = 0;
4832 for (auto test_suite : test_suites) {
4833 total_tests += test_suite->total_test_count();
4835 OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent);
4837 OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
4838 *stream << kIndent << "\"" << kTestsuites << "\": [\n";
4840 for (size_t i = 0; i < test_suites.size(); ++i) {
4844 PrintJsonTestSuite(stream, *test_suites[i]);
4851 // Produces a string representing the test properties in a result as
4852 // a JSON dictionary.
4853 std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
4854 const TestResult& result, const std::string& indent) {
4856 for (int i = 0; i < result.test_property_count(); ++i) {
4857 const TestProperty& property = result.GetTestProperty(i);
4858 attributes << ",\n" << indent << "\"" << property.key() << "\": "
4859 << "\"" << EscapeJson(property.value()) << "\"";
4861 return attributes.GetString();
4864 // End JsonUnitTestResultPrinter
4866 #if GTEST_CAN_STREAM_RESULTS_
4868 // Checks if str contains '=', '&', '%' or '\n' characters. If yes,
4869 // replaces them by "%xx" where xx is their hexadecimal value. For
4870 // example, replaces "=" with "%3D". This algorithm is O(strlen(str))
4871 // in both time and space -- important as the input str may contain an
4872 // arbitrarily long test failure message and stack trace.
4873 std::string StreamingListener::UrlEncode(const char* str) {
4875 result.reserve(strlen(str) + 1);
4876 for (char ch = *str; ch != '\0'; ch = *++str) {
4882 result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
4885 result.push_back(ch);
4892 void StreamingListener::SocketWriter::MakeConnection() {
4893 GTEST_CHECK_(sockfd_ == -1)
4894 << "MakeConnection() can't be called when there is already a connection.";
4897 memset(&hints, 0, sizeof(hints));
4898 hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses.
4899 hints.ai_socktype = SOCK_STREAM;
4900 addrinfo* servinfo = nullptr;
4902 // Use the getaddrinfo() to get a linked list of IP addresses for
4903 // the given host name.
4904 const int error_num = getaddrinfo(
4905 host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
4906 if (error_num != 0) {
4907 GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
4908 << gai_strerror(error_num);
4911 // Loop through all the results and connect to the first we can.
4912 for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;
4913 cur_addr = cur_addr->ai_next) {
4915 cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
4916 if (sockfd_ != -1) {
4917 // Connect the client socket to the server socket.
4918 if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
4925 freeaddrinfo(servinfo); // all done with this structure
4927 if (sockfd_ == -1) {
4928 GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
4929 << host_name_ << ":" << port_num_;
4933 // End of class Streaming Listener
4934 #endif // GTEST_CAN_STREAM_RESULTS__
4936 // class OsStackTraceGetter
4938 const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
4939 "... " GTEST_NAME_ " internal frames ...";
4941 std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
4942 GTEST_LOCK_EXCLUDED_(mutex_) {
4946 if (max_depth <= 0) {
4950 max_depth = std::min(max_depth, kMaxStackTraceDepth);
4952 std::vector<void*> raw_stack(max_depth);
4953 // Skips the frames requested by the caller, plus this function.
4954 const int raw_stack_size =
4955 absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1);
4957 void* caller_frame = nullptr;
4959 MutexLock lock(&mutex_);
4960 caller_frame = caller_frame_;
4963 for (int i = 0; i < raw_stack_size; ++i) {
4964 if (raw_stack[i] == caller_frame &&
4965 !GTEST_FLAG(show_internal_stack_frames)) {
4966 // Add a marker to the trace and stop adding frames.
4967 absl::StrAppend(&result, kElidedFramesMarker, "\n");
4972 const char* symbol = "(unknown)";
4973 if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) {
4978 snprintf(line, sizeof(line), " %p: %s\n", raw_stack[i], symbol);
4984 #else // !GTEST_HAS_ABSL
4985 static_cast<void>(max_depth);
4986 static_cast<void>(skip_count);
4988 #endif // GTEST_HAS_ABSL
4991 void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
4993 void* caller_frame = nullptr;
4994 if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
4995 caller_frame = nullptr;
4998 MutexLock lock(&mutex_);
4999 caller_frame_ = caller_frame;
5000 #endif // GTEST_HAS_ABSL
5003 // A helper class that creates the premature-exit file in its
5004 // constructor and deletes the file in its destructor.
5005 class ScopedPrematureExitFile {
5007 explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
5008 : premature_exit_filepath_(premature_exit_filepath ?
5009 premature_exit_filepath : "") {
5010 // If a path to the premature-exit file is specified...
5011 if (!premature_exit_filepath_.empty()) {
5012 // create the file with a single "0" character in it. I/O
5013 // errors are ignored as there's nothing better we can do and we
5014 // don't want to fail the test because of this.
5015 FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
5016 fwrite("0", 1, 1, pfile);
5021 ~ScopedPrematureExitFile() {
5022 #if !defined GTEST_OS_ESP8266
5023 if (!premature_exit_filepath_.empty()) {
5024 int retval = remove(premature_exit_filepath_.c_str());
5026 GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
5027 << premature_exit_filepath_ << "\" with error "
5035 const std::string premature_exit_filepath_;
5037 GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
5040 } // namespace internal
5042 // class TestEventListeners
5044 TestEventListeners::TestEventListeners()
5045 : repeater_(new internal::TestEventRepeater()),
5046 default_result_printer_(nullptr),
5047 default_xml_generator_(nullptr) {}
5049 TestEventListeners::~TestEventListeners() { delete repeater_; }
5051 // Returns the standard listener responsible for the default console
5052 // output. Can be removed from the listeners list to shut down default
5053 // console output. Note that removing this object from the listener list
5054 // with Release transfers its ownership to the user.
5055 void TestEventListeners::Append(TestEventListener* listener) {
5056 repeater_->Append(listener);
5059 // Removes the given event listener from the list and returns it. It then
5060 // becomes the caller's responsibility to delete the listener. Returns
5061 // NULL if the listener is not found in the list.
5062 TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
5063 if (listener == default_result_printer_)
5064 default_result_printer_ = nullptr;
5065 else if (listener == default_xml_generator_)
5066 default_xml_generator_ = nullptr;
5067 return repeater_->Release(listener);
5070 // Returns repeater that broadcasts the TestEventListener events to all
5072 TestEventListener* TestEventListeners::repeater() { return repeater_; }
5074 // Sets the default_result_printer attribute to the provided listener.
5075 // The listener is also added to the listener list and previous
5076 // default_result_printer is removed from it and deleted. The listener can
5077 // also be NULL in which case it will not be added to the list. Does
5078 // nothing if the previous and the current listener objects are the same.
5079 void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
5080 if (default_result_printer_ != listener) {
5081 // It is an error to pass this method a listener that is already in the
5083 delete Release(default_result_printer_);
5084 default_result_printer_ = listener;
5085 if (listener != nullptr) Append(listener);
5089 // Sets the default_xml_generator attribute to the provided listener. The
5090 // listener is also added to the listener list and previous
5091 // default_xml_generator is removed from it and deleted. The listener can
5092 // also be NULL in which case it will not be added to the list. Does
5093 // nothing if the previous and the current listener objects are the same.
5094 void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
5095 if (default_xml_generator_ != listener) {
5096 // It is an error to pass this method a listener that is already in the
5098 delete Release(default_xml_generator_);
5099 default_xml_generator_ = listener;
5100 if (listener != nullptr) Append(listener);
5104 // Controls whether events will be forwarded by the repeater to the
5105 // listeners in the list.
5106 bool TestEventListeners::EventForwardingEnabled() const {
5107 return repeater_->forwarding_enabled();
5110 void TestEventListeners::SuppressEventForwarding() {
5111 repeater_->set_forwarding_enabled(false);
5116 // Gets the singleton UnitTest object. The first time this method is
5117 // called, a UnitTest object is constructed and returned. Consecutive
5118 // calls will return the same object.
5120 // We don't protect this under mutex_ as a user is not supposed to
5121 // call this before main() starts, from which point on the return
5122 // value will never change.
5123 UnitTest* UnitTest::GetInstance() {
5124 // CodeGear C++Builder insists on a public destructor for the
5125 // default implementation. Use this implementation to keep good OO
5126 // design with private destructor.
5128 #if defined(__BORLANDC__)
5129 static UnitTest* const instance = new UnitTest;
5132 static UnitTest instance;
5134 #endif // defined(__BORLANDC__)
5137 // Gets the number of successful test suites.
5138 int UnitTest::successful_test_suite_count() const {
5139 return impl()->successful_test_suite_count();
5142 // Gets the number of failed test suites.
5143 int UnitTest::failed_test_suite_count() const {
5144 return impl()->failed_test_suite_count();
5147 // Gets the number of all test suites.
5148 int UnitTest::total_test_suite_count() const {
5149 return impl()->total_test_suite_count();
5152 // Gets the number of all test suites that contain at least one test
5154 int UnitTest::test_suite_to_run_count() const {
5155 return impl()->test_suite_to_run_count();
5158 // Legacy API is deprecated but still available
5159 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5160 int UnitTest::successful_test_case_count() const {
5161 return impl()->successful_test_suite_count();
5163 int UnitTest::failed_test_case_count() const {
5164 return impl()->failed_test_suite_count();
5166 int UnitTest::total_test_case_count() const {
5167 return impl()->total_test_suite_count();
5169 int UnitTest::test_case_to_run_count() const {
5170 return impl()->test_suite_to_run_count();
5172 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5174 // Gets the number of successful tests.
5175 int UnitTest::successful_test_count() const {
5176 return impl()->successful_test_count();
5179 // Gets the number of skipped tests.
5180 int UnitTest::skipped_test_count() const {
5181 return impl()->skipped_test_count();
5184 // Gets the number of failed tests.
5185 int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
5187 // Gets the number of disabled tests that will be reported in the XML report.
5188 int UnitTest::reportable_disabled_test_count() const {
5189 return impl()->reportable_disabled_test_count();
5192 // Gets the number of disabled tests.
5193 int UnitTest::disabled_test_count() const {
5194 return impl()->disabled_test_count();
5197 // Gets the number of tests to be printed in the XML report.
5198 int UnitTest::reportable_test_count() const {
5199 return impl()->reportable_test_count();
5202 // Gets the number of all tests.
5203 int UnitTest::total_test_count() const { return impl()->total_test_count(); }
5205 // Gets the number of tests that should run.
5206 int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
5208 // Gets the time of the test program start, in ms from the start of the
5210 internal::TimeInMillis UnitTest::start_timestamp() const {
5211 return impl()->start_timestamp();
5214 // Gets the elapsed time, in milliseconds.
5215 internal::TimeInMillis UnitTest::elapsed_time() const {
5216 return impl()->elapsed_time();
5219 // Returns true if and only if the unit test passed (i.e. all test suites
5221 bool UnitTest::Passed() const { return impl()->Passed(); }
5223 // Returns true if and only if the unit test failed (i.e. some test suite
5224 // failed or something outside of all tests failed).
5225 bool UnitTest::Failed() const { return impl()->Failed(); }
5227 // Gets the i-th test suite among all the test suites. i can range from 0 to
5228 // total_test_suite_count() - 1. If i is not in that range, returns NULL.
5229 const TestSuite* UnitTest::GetTestSuite(int i) const {
5230 return impl()->GetTestSuite(i);
5233 // Legacy API is deprecated but still available
5234 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5235 const TestCase* UnitTest::GetTestCase(int i) const {
5236 return impl()->GetTestCase(i);
5238 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5240 // Returns the TestResult containing information on test failures and
5241 // properties logged outside of individual test suites.
5242 const TestResult& UnitTest::ad_hoc_test_result() const {
5243 return *impl()->ad_hoc_test_result();
5246 // Gets the i-th test suite among all the test suites. i can range from 0 to
5247 // total_test_suite_count() - 1. If i is not in that range, returns NULL.
5248 TestSuite* UnitTest::GetMutableTestSuite(int i) {
5249 return impl()->GetMutableSuiteCase(i);
5252 // Returns the list of event listeners that can be used to track events
5253 // inside Google Test.
5254 TestEventListeners& UnitTest::listeners() {
5255 return *impl()->listeners();
5258 // Registers and returns a global test environment. When a test
5259 // program is run, all global test environments will be set-up in the
5260 // order they were registered. After all tests in the program have
5261 // finished, all global test environments will be torn-down in the
5262 // *reverse* order they were registered.
5264 // The UnitTest object takes ownership of the given environment.
5266 // We don't protect this under mutex_, as we only support calling it
5267 // from the main thread.
5268 Environment* UnitTest::AddEnvironment(Environment* env) {
5269 if (env == nullptr) {
5273 impl_->environments().push_back(env);
5277 // Adds a TestPartResult to the current TestResult object. All Google Test
5278 // assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
5279 // this to report their results. The user code should use the
5280 // assertion macros instead of calling this directly.
5281 void UnitTest::AddTestPartResult(
5282 TestPartResult::Type result_type,
5283 const char* file_name,
5285 const std::string& message,
5286 const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
5290 internal::MutexLock lock(&mutex_);
5291 if (impl_->gtest_trace_stack().size() > 0) {
5292 msg << "\n" << GTEST_NAME_ << " trace:";
5294 for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) {
5295 const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
5296 msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
5297 << " " << trace.message;
5301 if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) {
5302 msg << internal::kStackTraceMarker << os_stack_trace;
5305 const TestPartResult result = TestPartResult(
5306 result_type, file_name, line_number, msg.GetString().c_str());
5307 impl_->GetTestPartResultReporterForCurrentThread()->
5308 ReportTestPartResult(result);
5310 if (result_type != TestPartResult::kSuccess &&
5311 result_type != TestPartResult::kSkip) {
5312 // gtest_break_on_failure takes precedence over
5313 // gtest_throw_on_failure. This allows a user to set the latter
5314 // in the code (perhaps in order to use Google Test assertions
5315 // with another testing framework) and specify the former on the
5316 // command line for debugging.
5317 if (GTEST_FLAG(break_on_failure)) {
5318 #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
5319 // Using DebugBreak on Windows allows gtest to still break into a debugger
5320 // when a failure happens and both the --gtest_break_on_failure and
5321 // the --gtest_catch_exceptions flags are specified.
5323 #elif (!defined(__native_client__)) && \
5324 ((defined(__clang__) || defined(__GNUC__)) && \
5325 (defined(__x86_64__) || defined(__i386__)))
5326 // with clang/gcc we can achieve the same effect on x86 by invoking int3
5329 // Dereference nullptr through a volatile pointer to prevent the compiler
5330 // from removing. We use this rather than abort() or __builtin_trap() for
5331 // portability: some debuggers don't correctly trap abort().
5332 *static_cast<volatile int*>(nullptr) = 1;
5333 #endif // GTEST_OS_WINDOWS
5334 } else if (GTEST_FLAG(throw_on_failure)) {
5335 #if GTEST_HAS_EXCEPTIONS
5336 throw internal::GoogleTestFailureException(result);
5338 // We cannot call abort() as it generates a pop-up in debug mode
5339 // that cannot be suppressed in VC 7.1 or below.
5346 // Adds a TestProperty to the current TestResult object when invoked from
5347 // inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
5348 // from SetUpTestSuite or TearDownTestSuite, or to the global property set
5349 // when invoked elsewhere. If the result already contains a property with
5350 // the same key, the value will be updated.
5351 void UnitTest::RecordProperty(const std::string& key,
5352 const std::string& value) {
5353 impl_->RecordProperty(TestProperty(key, value));
5356 // Runs all tests in this UnitTest object and prints the result.
5357 // Returns 0 if successful, or 1 otherwise.
5359 // We don't protect this under mutex_, as we only support calling it
5360 // from the main thread.
5361 int UnitTest::Run() {
5362 const bool in_death_test_child_process =
5363 internal::GTEST_FLAG(internal_run_death_test).length() > 0;
5365 // Google Test implements this protocol for catching that a test
5366 // program exits before returning control to Google Test:
5368 // 1. Upon start, Google Test creates a file whose absolute path
5369 // is specified by the environment variable
5370 // TEST_PREMATURE_EXIT_FILE.
5371 // 2. When Google Test has finished its work, it deletes the file.
5373 // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
5374 // running a Google-Test-based test program and check the existence
5375 // of the file at the end of the test execution to see if it has
5376 // exited prematurely.
5378 // If we are in the child process of a death test, don't
5379 // create/delete the premature exit file, as doing so is unnecessary
5380 // and will confuse the parent process. Otherwise, create/delete
5381 // the file upon entering/leaving this function. If the program
5382 // somehow exits before this function has a chance to return, the
5383 // premature-exit file will be left undeleted, causing a test runner
5384 // that understands the premature-exit-file protocol to report the
5385 // test as having failed.
5386 const internal::ScopedPrematureExitFile premature_exit_file(
5387 in_death_test_child_process
5389 : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
5391 // Captures the value of GTEST_FLAG(catch_exceptions). This value will be
5392 // used for the duration of the program.
5393 impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
5395 #if GTEST_OS_WINDOWS
5396 // Either the user wants Google Test to catch exceptions thrown by the
5397 // tests or this is executing in the context of death test child
5398 // process. In either case the user does not want to see pop-up dialogs
5399 // about crashes - they are expected.
5400 if (impl()->catch_exceptions() || in_death_test_child_process) {
5401 # if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
5402 // SetErrorMode doesn't exist on CE.
5403 SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
5404 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
5405 # endif // !GTEST_OS_WINDOWS_MOBILE
5407 # if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
5408 // Death test children can be terminated with _abort(). On Windows,
5409 // _abort() can show a dialog with a warning message. This forces the
5410 // abort message to go to stderr instead.
5411 _set_error_mode(_OUT_TO_STDERR);
5414 # if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
5415 // In the debug version, Visual Studio pops up a separate dialog
5416 // offering a choice to debug the aborted program. We need to suppress
5417 // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
5418 // executed. Google Test will notify the user of any unexpected
5419 // failure via stderr.
5420 if (!GTEST_FLAG(break_on_failure))
5421 _set_abort_behavior(
5422 0x0, // Clear the following flags:
5423 _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump.
5425 // In debug mode, the Windows CRT can crash with an assertion over invalid
5426 // input (e.g. passing an invalid file descriptor). The default handling
5427 // for these assertions is to pop up a dialog and wait for user input.
5428 // Instead ask the CRT to dump such assertions to stderr non-interactively.
5429 if (!IsDebuggerPresent()) {
5430 (void)_CrtSetReportMode(_CRT_ASSERT,
5431 _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
5432 (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
5436 #endif // GTEST_OS_WINDOWS
5438 return internal::HandleExceptionsInMethodIfSupported(
5440 &internal::UnitTestImpl::RunAllTests,
5441 "auxiliary test code (environments or event listeners)") ? 0 : 1;
5444 // Returns the working directory when the first TEST() or TEST_F() was
5446 const char* UnitTest::original_working_dir() const {
5447 return impl_->original_working_dir_.c_str();
5450 // Returns the TestSuite object for the test that's currently running,
5451 // or NULL if no test is running.
5452 const TestSuite* UnitTest::current_test_suite() const
5453 GTEST_LOCK_EXCLUDED_(mutex_) {
5454 internal::MutexLock lock(&mutex_);
5455 return impl_->current_test_suite();
5458 // Legacy API is still available but deprecated
5459 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5460 const TestCase* UnitTest::current_test_case() const
5461 GTEST_LOCK_EXCLUDED_(mutex_) {
5462 internal::MutexLock lock(&mutex_);
5463 return impl_->current_test_suite();
5467 // Returns the TestInfo object for the test that's currently running,
5468 // or NULL if no test is running.
5469 const TestInfo* UnitTest::current_test_info() const
5470 GTEST_LOCK_EXCLUDED_(mutex_) {
5471 internal::MutexLock lock(&mutex_);
5472 return impl_->current_test_info();
5475 // Returns the random seed used at the start of the current test run.
5476 int UnitTest::random_seed() const { return impl_->random_seed(); }
5478 // Returns ParameterizedTestSuiteRegistry object used to keep track of
5479 // value-parameterized tests and instantiate and register them.
5480 internal::ParameterizedTestSuiteRegistry&
5481 UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {
5482 return impl_->parameterized_test_registry();
5485 // Creates an empty UnitTest.
5486 UnitTest::UnitTest() {
5487 impl_ = new internal::UnitTestImpl(this);
5490 // Destructor of UnitTest.
5491 UnitTest::~UnitTest() {
5495 // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
5496 // Google Test trace stack.
5497 void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
5498 GTEST_LOCK_EXCLUDED_(mutex_) {
5499 internal::MutexLock lock(&mutex_);
5500 impl_->gtest_trace_stack().push_back(trace);
5503 // Pops a trace from the per-thread Google Test trace stack.
5504 void UnitTest::PopGTestTrace()
5505 GTEST_LOCK_EXCLUDED_(mutex_) {
5506 internal::MutexLock lock(&mutex_);
5507 impl_->gtest_trace_stack().pop_back();
5510 namespace internal {
5512 UnitTestImpl::UnitTestImpl(UnitTest* parent)
5514 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
5515 default_global_test_part_result_reporter_(this),
5516 default_per_thread_test_part_result_reporter_(this),
5517 GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_(
5518 &default_global_test_part_result_reporter_),
5519 per_thread_test_part_result_reporter_(
5520 &default_per_thread_test_part_result_reporter_),
5521 parameterized_test_registry_(),
5522 parameterized_tests_registered_(false),
5523 last_death_test_suite_(-1),
5524 current_test_suite_(nullptr),
5525 current_test_info_(nullptr),
5526 ad_hoc_test_result_(),
5527 os_stack_trace_getter_(nullptr),
5528 post_flag_parse_init_performed_(false),
5529 random_seed_(0), // Will be overridden by the flag before first use.
5530 random_(0), // Will be reseeded before first use.
5531 start_timestamp_(0),
5533 #if GTEST_HAS_DEATH_TEST
5534 death_test_factory_(new DefaultDeathTestFactory),
5536 // Will be overridden by the flag before first use.
5537 catch_exceptions_(false) {
5538 listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
5541 UnitTestImpl::~UnitTestImpl() {
5542 // Deletes every TestSuite.
5543 ForEach(test_suites_, internal::Delete<TestSuite>);
5545 // Deletes every Environment.
5546 ForEach(environments_, internal::Delete<Environment>);
5548 delete os_stack_trace_getter_;
5551 // Adds a TestProperty to the current TestResult object when invoked in a
5552 // context of a test, to current test suite's ad_hoc_test_result when invoke
5553 // from SetUpTestSuite/TearDownTestSuite, or to the global property set
5554 // otherwise. If the result already contains a property with the same key,
5555 // the value will be updated.
5556 void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
5557 std::string xml_element;
5558 TestResult* test_result; // TestResult appropriate for property recording.
5560 if (current_test_info_ != nullptr) {
5561 xml_element = "testcase";
5562 test_result = &(current_test_info_->result_);
5563 } else if (current_test_suite_ != nullptr) {
5564 xml_element = "testsuite";
5565 test_result = &(current_test_suite_->ad_hoc_test_result_);
5567 xml_element = "testsuites";
5568 test_result = &ad_hoc_test_result_;
5570 test_result->RecordProperty(xml_element, test_property);
5573 #if GTEST_HAS_DEATH_TEST
5574 // Disables event forwarding if the control is currently in a death test
5575 // subprocess. Must not be called before InitGoogleTest.
5576 void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
5577 if (internal_run_death_test_flag_.get() != nullptr)
5578 listeners()->SuppressEventForwarding();
5580 #endif // GTEST_HAS_DEATH_TEST
5582 // Initializes event listeners performing XML output as specified by
5583 // UnitTestOptions. Must not be called before InitGoogleTest.
5584 void UnitTestImpl::ConfigureXmlOutput() {
5585 const std::string& output_format = UnitTestOptions::GetOutputFormat();
5586 if (output_format == "xml") {
5587 listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
5588 UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
5589 } else if (output_format == "json") {
5590 listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
5591 UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
5592 } else if (output_format != "") {
5593 GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
5594 << output_format << "\" ignored.";
5598 #if GTEST_CAN_STREAM_RESULTS_
5599 // Initializes event listeners for streaming test results in string form.
5600 // Must not be called before InitGoogleTest.
5601 void UnitTestImpl::ConfigureStreamingOutput() {
5602 const std::string& target = GTEST_FLAG(stream_result_to);
5603 if (!target.empty()) {
5604 const size_t pos = target.find(':');
5605 if (pos != std::string::npos) {
5606 listeners()->Append(new StreamingListener(target.substr(0, pos),
5607 target.substr(pos+1)));
5609 GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
5614 #endif // GTEST_CAN_STREAM_RESULTS_
5616 // Performs initialization dependent upon flag values obtained in
5617 // ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to
5618 // ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest
5619 // this function is also called from RunAllTests. Since this function can be
5620 // called more than once, it has to be idempotent.
5621 void UnitTestImpl::PostFlagParsingInit() {
5622 // Ensures that this function does not execute more than once.
5623 if (!post_flag_parse_init_performed_) {
5624 post_flag_parse_init_performed_ = true;
5626 #if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
5627 // Register to send notifications about key process state changes.
5628 listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
5629 #endif // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
5631 #if GTEST_HAS_DEATH_TEST
5632 InitDeathTestSubprocessControlInfo();
5633 SuppressTestEventsIfInSubprocess();
5634 #endif // GTEST_HAS_DEATH_TEST
5636 // Registers parameterized tests. This makes parameterized tests
5637 // available to the UnitTest reflection API without running
5639 RegisterParameterizedTests();
5641 // Configures listeners for XML output. This makes it possible for users
5642 // to shut down the default XML output before invoking RUN_ALL_TESTS.
5643 ConfigureXmlOutput();
5645 if (GTEST_FLAG(brief)) {
5646 listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
5649 #if GTEST_CAN_STREAM_RESULTS_
5650 // Configures listeners for streaming test results to the specified server.
5651 ConfigureStreamingOutput();
5652 #endif // GTEST_CAN_STREAM_RESULTS_
5655 if (GTEST_FLAG(install_failure_signal_handler)) {
5656 absl::FailureSignalHandlerOptions options;
5657 absl::InstallFailureSignalHandler(options);
5659 #endif // GTEST_HAS_ABSL
5663 // A predicate that checks the name of a TestSuite against a known
5666 // This is used for implementation of the UnitTest class only. We put
5667 // it in the anonymous namespace to prevent polluting the outer
5670 // TestSuiteNameIs is copyable.
5671 class TestSuiteNameIs {
5674 explicit TestSuiteNameIs(const std::string& name) : name_(name) {}
5676 // Returns true if and only if the name of test_suite matches name_.
5677 bool operator()(const TestSuite* test_suite) const {
5678 return test_suite != nullptr &&
5679 strcmp(test_suite->name(), name_.c_str()) == 0;
5686 // Finds and returns a TestSuite with the given name. If one doesn't
5687 // exist, creates one and returns it. It's the CALLER'S
5688 // RESPONSIBILITY to ensure that this function is only called WHEN THE
5689 // TESTS ARE NOT SHUFFLED.
5693 // test_suite_name: name of the test suite
5694 // type_param: the name of the test suite's type parameter, or NULL if
5695 // this is not a typed or a type-parameterized test suite.
5696 // set_up_tc: pointer to the function that sets up the test suite
5697 // tear_down_tc: pointer to the function that tears down the test suite
5698 TestSuite* UnitTestImpl::GetTestSuite(
5699 const char* test_suite_name, const char* type_param,
5700 internal::SetUpTestSuiteFunc set_up_tc,
5701 internal::TearDownTestSuiteFunc tear_down_tc) {
5702 // Can we find a TestSuite with the given name?
5703 const auto test_suite =
5704 std::find_if(test_suites_.rbegin(), test_suites_.rend(),
5705 TestSuiteNameIs(test_suite_name));
5707 if (test_suite != test_suites_.rend()) return *test_suite;
5709 // No. Let's create one.
5710 auto* const new_test_suite =
5711 new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
5713 // Is this a death test suite?
5714 if (internal::UnitTestOptions::MatchesFilter(test_suite_name,
5715 kDeathTestSuiteFilter)) {
5716 // Yes. Inserts the test suite after the last death test suite
5717 // defined so far. This only works when the test suites haven't
5718 // been shuffled. Otherwise we may end up running a death test
5719 // after a non-death test.
5720 ++last_death_test_suite_;
5721 test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
5724 // No. Appends to the end of the list.
5725 test_suites_.push_back(new_test_suite);
5728 test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));
5729 return new_test_suite;
5732 // Helpers for setting up / tearing down the given environment. They
5733 // are for use in the ForEach() function.
5734 static void SetUpEnvironment(Environment* env) { env->SetUp(); }
5735 static void TearDownEnvironment(Environment* env) { env->TearDown(); }
5737 // Runs all tests in this UnitTest object, prints the result, and
5738 // returns true if all tests are successful. If any exception is
5739 // thrown during a test, the test is considered to be failed, but the
5740 // rest of the tests will still be run.
5742 // When parameterized tests are enabled, it expands and registers
5743 // parameterized tests first in RegisterParameterizedTests().
5744 // All other functions called from RunAllTests() may safely assume that
5745 // parameterized tests are ready to be counted and run.
5746 bool UnitTestImpl::RunAllTests() {
5747 // True if and only if Google Test is initialized before RUN_ALL_TESTS() is
5749 const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
5751 // Do not run any test if the --help flag was specified.
5755 // Repeats the call to the post-flag parsing initialization in case the
5756 // user didn't call InitGoogleTest.
5757 PostFlagParsingInit();
5759 // Even if sharding is not on, test runners may want to use the
5760 // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
5762 internal::WriteToShardStatusFileIfNeeded();
5764 // True if and only if we are in a subprocess for running a thread-safe-style
5766 bool in_subprocess_for_death_test = false;
5768 #if GTEST_HAS_DEATH_TEST
5769 in_subprocess_for_death_test =
5770 (internal_run_death_test_flag_.get() != nullptr);
5771 # if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
5772 if (in_subprocess_for_death_test) {
5773 GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
5775 # endif // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
5776 #endif // GTEST_HAS_DEATH_TEST
5778 const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
5779 in_subprocess_for_death_test);
5781 // Compares the full test names with the filter to decide which
5783 const bool has_tests_to_run = FilterTests(should_shard
5784 ? HONOR_SHARDING_PROTOCOL
5785 : IGNORE_SHARDING_PROTOCOL) > 0;
5787 // Lists the tests and exits if the --gtest_list_tests flag was specified.
5788 if (GTEST_FLAG(list_tests)) {
5789 // This must be called *after* FilterTests() has been called.
5790 ListTestsMatchingFilter();
5794 random_seed_ = GTEST_FLAG(shuffle) ?
5795 GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
5797 // True if and only if at least one test has failed.
5798 bool failed = false;
5800 TestEventListener* repeater = listeners()->repeater();
5802 start_timestamp_ = GetTimeInMillis();
5803 repeater->OnTestProgramStart(*parent_);
5805 // How many times to repeat the tests? We don't want to repeat them
5806 // when we are inside the subprocess of a death test.
5807 const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
5808 // Repeats forever if the repeat count is negative.
5809 const bool gtest_repeat_forever = repeat < 0;
5810 for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
5811 // We want to preserve failures generated by ad-hoc test
5812 // assertions executed before RUN_ALL_TESTS().
5813 ClearNonAdHocTestResult();
5817 // Shuffles test suites and tests if requested.
5818 if (has_tests_to_run && GTEST_FLAG(shuffle)) {
5819 random()->Reseed(static_cast<uint32_t>(random_seed_));
5820 // This should be done before calling OnTestIterationStart(),
5821 // such that a test event listener can see the actual test order
5826 // Tells the unit test event listeners that the tests are about to start.
5827 repeater->OnTestIterationStart(*parent_, i);
5829 // Runs each test suite if there is at least one test to run.
5830 if (has_tests_to_run) {
5831 // Sets up all environments beforehand.
5832 repeater->OnEnvironmentsSetUpStart(*parent_);
5833 ForEach(environments_, SetUpEnvironment);
5834 repeater->OnEnvironmentsSetUpEnd(*parent_);
5836 // Runs the tests only if there was no fatal failure or skip triggered
5837 // during global set-up.
5838 if (Test::IsSkipped()) {
5839 // Emit diagnostics when global set-up calls skip, as it will not be
5840 // emitted by default.
5841 TestResult& test_result =
5842 *internal::GetUnitTestImpl()->current_test_result();
5843 for (int j = 0; j < test_result.total_part_count(); ++j) {
5844 const TestPartResult& test_part_result =
5845 test_result.GetTestPartResult(j);
5846 if (test_part_result.type() == TestPartResult::kSkip) {
5847 const std::string& result = test_part_result.message();
5848 printf("%s\n", result.c_str());
5852 } else if (!Test::HasFatalFailure()) {
5853 for (int test_index = 0; test_index < total_test_suite_count();
5855 GetMutableSuiteCase(test_index)->Run();
5856 if (GTEST_FLAG(fail_fast) &&
5857 GetMutableSuiteCase(test_index)->Failed()) {
5858 for (int j = test_index + 1; j < total_test_suite_count(); j++) {
5859 GetMutableSuiteCase(j)->Skip();
5864 } else if (Test::HasFatalFailure()) {
5865 // If there was a fatal failure during the global setup then we know we
5866 // aren't going to run any tests. Explicitly mark all of the tests as
5867 // skipped to make this obvious in the output.
5868 for (int test_index = 0; test_index < total_test_suite_count();
5870 GetMutableSuiteCase(test_index)->Skip();
5874 // Tears down all environments in reverse order afterwards.
5875 repeater->OnEnvironmentsTearDownStart(*parent_);
5876 std::for_each(environments_.rbegin(), environments_.rend(),
5877 TearDownEnvironment);
5878 repeater->OnEnvironmentsTearDownEnd(*parent_);
5881 elapsed_time_ = timer.Elapsed();
5883 // Tells the unit test event listener that the tests have just finished.
5884 repeater->OnTestIterationEnd(*parent_, i);
5886 // Gets the result and clears it.
5891 // Restores the original test order after the iteration. This
5892 // allows the user to quickly repro a failure that happens in the
5893 // N-th iteration without repeating the first (N - 1) iterations.
5894 // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
5895 // case the user somehow changes the value of the flag somewhere
5896 // (it's always safe to unshuffle the tests).
5899 if (GTEST_FLAG(shuffle)) {
5900 // Picks a new random seed for each iteration.
5901 random_seed_ = GetNextRandomSeed(random_seed_);
5905 repeater->OnTestProgramEnd(*parent_);
5907 if (!gtest_is_initialized_before_run_all_tests) {
5910 "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
5911 "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
5912 "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
5913 " will start to enforce the valid usage. "
5914 "Please fix it ASAP, or IT WILL START TO FAIL.\n"); // NOLINT
5915 #if GTEST_FOR_GOOGLE_
5916 ColoredPrintf(GTestColor::kRed,
5917 "For more details, see http://wiki/Main/ValidGUnitMain.\n");
5918 #endif // GTEST_FOR_GOOGLE_
5924 // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
5925 // if the variable is present. If a file already exists at this location, this
5926 // function will write over it. If the variable is present, but the file cannot
5927 // be created, prints an error and exits.
5928 void WriteToShardStatusFileIfNeeded() {
5929 const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
5930 if (test_shard_file != nullptr) {
5931 FILE* const file = posix::FOpen(test_shard_file, "w");
5932 if (file == nullptr) {
5933 ColoredPrintf(GTestColor::kRed,
5934 "Could not write to the test shard status file \"%s\" "
5935 "specified by the %s environment variable.\n",
5936 test_shard_file, kTestShardStatusFile);
5944 // Checks whether sharding is enabled by examining the relevant
5945 // environment variable values. If the variables are present,
5946 // but inconsistent (i.e., shard_index >= total_shards), prints
5947 // an error and exits. If in_subprocess_for_death_test, sharding is
5948 // disabled because it must only be applied to the original test
5949 // process. Otherwise, we could filter out death tests we intended to execute.
5950 bool ShouldShard(const char* total_shards_env,
5951 const char* shard_index_env,
5952 bool in_subprocess_for_death_test) {
5953 if (in_subprocess_for_death_test) {
5957 const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
5958 const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);
5960 if (total_shards == -1 && shard_index == -1) {
5962 } else if (total_shards == -1 && shard_index != -1) {
5963 const Message msg = Message()
5964 << "Invalid environment variables: you have "
5965 << kTestShardIndex << " = " << shard_index
5966 << ", but have left " << kTestTotalShards << " unset.\n";
5967 ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
5970 } else if (total_shards != -1 && shard_index == -1) {
5971 const Message msg = Message()
5972 << "Invalid environment variables: you have "
5973 << kTestTotalShards << " = " << total_shards
5974 << ", but have left " << kTestShardIndex << " unset.\n";
5975 ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
5978 } else if (shard_index < 0 || shard_index >= total_shards) {
5979 const Message msg = Message()
5980 << "Invalid environment variables: we require 0 <= "
5981 << kTestShardIndex << " < " << kTestTotalShards
5982 << ", but you have " << kTestShardIndex << "=" << shard_index
5983 << ", " << kTestTotalShards << "=" << total_shards << ".\n";
5984 ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
5989 return total_shards > 1;
5992 // Parses the environment variable var as an Int32. If it is unset,
5993 // returns default_val. If it is not an Int32, prints an error
5995 int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
5996 const char* str_val = posix::GetEnv(var);
5997 if (str_val == nullptr) {
6002 if (!ParseInt32(Message() << "The value of environment variable " << var,
6003 str_val, &result)) {
6009 // Given the total number of shards, the shard index, and the test id,
6010 // returns true if and only if the test should be run on this shard. The test id
6011 // is some arbitrary but unique non-negative integer assigned to each test
6012 // method. Assumes that 0 <= shard_index < total_shards.
6013 bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
6014 return (test_id % total_shards) == shard_index;
6017 // Compares the name of each test with the user-specified filter to
6018 // decide whether the test should be run, then records the result in
6019 // each TestSuite and TestInfo object.
6020 // If shard_tests == true, further filters tests based on sharding
6021 // variables in the environment - see
6022 // https://github.com/google/googletest/blob/master/googletest/docs/advanced.md
6023 // . Returns the number of tests that should run.
6024 int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
6025 const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
6026 Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
6027 const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
6028 Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
6030 // num_runnable_tests are the number of tests that will
6031 // run across all shards (i.e., match filter and are not disabled).
6032 // num_selected_tests are the number of tests to be run on
6034 int num_runnable_tests = 0;
6035 int num_selected_tests = 0;
6036 for (auto* test_suite : test_suites_) {
6037 const std::string& test_suite_name = test_suite->name();
6038 test_suite->set_should_run(false);
6040 for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
6041 TestInfo* const test_info = test_suite->test_info_list()[j];
6042 const std::string test_name(test_info->name());
6043 // A test is disabled if test suite name or test name matches
6044 // kDisableTestFilter.
6045 const bool is_disabled = internal::UnitTestOptions::MatchesFilter(
6046 test_suite_name, kDisableTestFilter) ||
6047 internal::UnitTestOptions::MatchesFilter(
6048 test_name, kDisableTestFilter);
6049 test_info->is_disabled_ = is_disabled;
6051 const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest(
6052 test_suite_name, test_name);
6053 test_info->matches_filter_ = matches_filter;
6055 const bool is_runnable =
6056 (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
6059 const bool is_in_another_shard =
6060 shard_tests != IGNORE_SHARDING_PROTOCOL &&
6061 !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
6062 test_info->is_in_another_shard_ = is_in_another_shard;
6063 const bool is_selected = is_runnable && !is_in_another_shard;
6065 num_runnable_tests += is_runnable;
6066 num_selected_tests += is_selected;
6068 test_info->should_run_ = is_selected;
6069 test_suite->set_should_run(test_suite->should_run() || is_selected);
6072 return num_selected_tests;
6075 // Prints the given C-string on a single line by replacing all '\n'
6076 // characters with string "\\n". If the output takes more than
6077 // max_length characters, only prints the first max_length characters
6079 static void PrintOnOneLine(const char* str, int max_length) {
6080 if (str != nullptr) {
6081 for (int i = 0; *str != '\0'; ++str) {
6082 if (i >= max_length) {
6097 // Prints the names of the tests matching the user-specified filter flag.
6098 void UnitTestImpl::ListTestsMatchingFilter() {
6099 // Print at most this many characters for each type/value parameter.
6100 const int kMaxParamLength = 250;
6102 for (auto* test_suite : test_suites_) {
6103 bool printed_test_suite_name = false;
6105 for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
6106 const TestInfo* const test_info = test_suite->test_info_list()[j];
6107 if (test_info->matches_filter_) {
6108 if (!printed_test_suite_name) {
6109 printed_test_suite_name = true;
6110 printf("%s.", test_suite->name());
6111 if (test_suite->type_param() != nullptr) {
6112 printf(" # %s = ", kTypeParamLabel);
6113 // We print the type parameter on a single line to make
6114 // the output easy to parse by a program.
6115 PrintOnOneLine(test_suite->type_param(), kMaxParamLength);
6119 printf(" %s", test_info->name());
6120 if (test_info->value_param() != nullptr) {
6121 printf(" # %s = ", kValueParamLabel);
6122 // We print the value parameter on a single line to make the
6123 // output easy to parse by a program.
6124 PrintOnOneLine(test_info->value_param(), kMaxParamLength);
6131 const std::string& output_format = UnitTestOptions::GetOutputFormat();
6132 if (output_format == "xml" || output_format == "json") {
6133 FILE* fileout = OpenFileForWriting(
6134 UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
6135 std::stringstream stream;
6136 if (output_format == "xml") {
6137 XmlUnitTestResultPrinter(
6138 UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
6139 .PrintXmlTestsList(&stream, test_suites_);
6140 } else if (output_format == "json") {
6141 JsonUnitTestResultPrinter(
6142 UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
6143 .PrintJsonTestList(&stream, test_suites_);
6145 fprintf(fileout, "%s", StringStreamToString(&stream).c_str());
6150 // Sets the OS stack trace getter.
6152 // Does nothing if the input and the current OS stack trace getter are
6153 // the same; otherwise, deletes the old getter and makes the input the
6155 void UnitTestImpl::set_os_stack_trace_getter(
6156 OsStackTraceGetterInterface* getter) {
6157 if (os_stack_trace_getter_ != getter) {
6158 delete os_stack_trace_getter_;
6159 os_stack_trace_getter_ = getter;
6163 // Returns the current OS stack trace getter if it is not NULL;
6164 // otherwise, creates an OsStackTraceGetter, makes it the current
6165 // getter, and returns it.
6166 OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
6167 if (os_stack_trace_getter_ == nullptr) {
6168 #ifdef GTEST_OS_STACK_TRACE_GETTER_
6169 os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
6171 os_stack_trace_getter_ = new OsStackTraceGetter;
6172 #endif // GTEST_OS_STACK_TRACE_GETTER_
6175 return os_stack_trace_getter_;
6178 // Returns the most specific TestResult currently running.
6179 TestResult* UnitTestImpl::current_test_result() {
6180 if (current_test_info_ != nullptr) {
6181 return ¤t_test_info_->result_;
6183 if (current_test_suite_ != nullptr) {
6184 return ¤t_test_suite_->ad_hoc_test_result_;
6186 return &ad_hoc_test_result_;
6189 // Shuffles all test suites, and the tests within each test suite,
6190 // making sure that death tests are still run first.
6191 void UnitTestImpl::ShuffleTests() {
6192 // Shuffles the death test suites.
6193 ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
6195 // Shuffles the non-death test suites.
6196 ShuffleRange(random(), last_death_test_suite_ + 1,
6197 static_cast<int>(test_suites_.size()), &test_suite_indices_);
6199 // Shuffles the tests inside each test suite.
6200 for (auto& test_suite : test_suites_) {
6201 test_suite->ShuffleTests(random());
6205 // Restores the test suites and tests to their order before the first shuffle.
6206 void UnitTestImpl::UnshuffleTests() {
6207 for (size_t i = 0; i < test_suites_.size(); i++) {
6208 // Unshuffles the tests in each test suite.
6209 test_suites_[i]->UnshuffleTests();
6210 // Resets the index of each test suite.
6211 test_suite_indices_[i] = static_cast<int>(i);
6215 // Returns the current OS stack trace as an std::string.
6217 // The maximum number of stack frames to be included is specified by
6218 // the gtest_stack_trace_depth flag. The skip_count parameter
6219 // specifies the number of top frames to be skipped, which doesn't
6220 // count against the number of frames to be included.
6222 // For example, if Foo() calls Bar(), which in turn calls
6223 // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
6224 // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
6225 std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
6227 // We pass skip_count + 1 to skip this wrapper function in addition
6228 // to what the user really wants to skip.
6229 return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
6232 // Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to
6233 // suppress unreachable code warnings.
6235 class ClassUniqueToAlwaysTrue {};
6238 bool IsTrue(bool condition) { return condition; }
6241 #if GTEST_HAS_EXCEPTIONS
6242 // This condition is always false so AlwaysTrue() never actually throws,
6243 // but it makes the compiler think that it may throw.
6245 throw ClassUniqueToAlwaysTrue();
6246 #endif // GTEST_HAS_EXCEPTIONS
6250 // If *pstr starts with the given prefix, modifies *pstr to be right
6251 // past the prefix and returns true; otherwise leaves *pstr unchanged
6252 // and returns false. None of pstr, *pstr, and prefix can be NULL.
6253 bool SkipPrefix(const char* prefix, const char** pstr) {
6254 const size_t prefix_len = strlen(prefix);
6255 if (strncmp(*pstr, prefix, prefix_len) == 0) {
6256 *pstr += prefix_len;
6262 // Parses a string as a command line flag. The string should have
6263 // the format "--flag=value". When def_optional is true, the "=value"
6264 // part can be omitted.
6266 // Returns the value of the flag, or NULL if the parsing failed.
6267 static const char* ParseFlagValue(const char* str, const char* flag,
6268 bool def_optional) {
6269 // str and flag must not be NULL.
6270 if (str == nullptr || flag == nullptr) return nullptr;
6272 // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
6273 const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
6274 const size_t flag_len = flag_str.length();
6275 if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
6277 // Skips the flag name.
6278 const char* flag_end = str + flag_len;
6280 // When def_optional is true, it's OK to not have a "=value" part.
6281 if (def_optional && (flag_end[0] == '\0')) {
6285 // If def_optional is true and there are more characters after the
6286 // flag name, or if def_optional is false, there must be a '=' after
6288 if (flag_end[0] != '=') return nullptr;
6290 // Returns the string after "=".
6291 return flag_end + 1;
6294 // Parses a string for a bool flag, in the form of either
6295 // "--flag=value" or "--flag".
6297 // In the former case, the value is taken as true as long as it does
6298 // not start with '0', 'f', or 'F'.
6300 // In the latter case, the value is taken as true.
6302 // On success, stores the value of the flag in *value, and returns
6303 // true. On failure, returns false without changing *value.
6304 static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
6305 // Gets the value of the flag as a string.
6306 const char* const value_str = ParseFlagValue(str, flag, true);
6308 // Aborts if the parsing failed.
6309 if (value_str == nullptr) return false;
6311 // Converts the string value to a bool.
6312 *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
6316 // Parses a string for an int32_t flag, in the form of "--flag=value".
6318 // On success, stores the value of the flag in *value, and returns
6319 // true. On failure, returns false without changing *value.
6320 bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
6321 // Gets the value of the flag as a string.
6322 const char* const value_str = ParseFlagValue(str, flag, false);
6324 // Aborts if the parsing failed.
6325 if (value_str == nullptr) return false;
6327 // Sets *value to the value of the flag.
6328 return ParseInt32(Message() << "The value of flag --" << flag,
6332 // Parses a string for a string flag, in the form of "--flag=value".
6334 // On success, stores the value of the flag in *value, and returns
6335 // true. On failure, returns false without changing *value.
6336 template <typename String>
6337 static bool ParseStringFlag(const char* str, const char* flag, String* value) {
6338 // Gets the value of the flag as a string.
6339 const char* const value_str = ParseFlagValue(str, flag, false);
6341 // Aborts if the parsing failed.
6342 if (value_str == nullptr) return false;
6344 // Sets *value to the value of the flag.
6349 // Determines whether a string has a prefix that Google Test uses for its
6350 // flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.
6351 // If Google Test detects that a command line flag has its prefix but is not
6352 // recognized, it will print its help message. Flags starting with
6353 // GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
6354 // internal flags and do not trigger the help message.
6355 static bool HasGoogleTestFlagPrefix(const char* str) {
6356 return (SkipPrefix("--", &str) ||
6357 SkipPrefix("-", &str) ||
6358 SkipPrefix("/", &str)) &&
6359 !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
6360 (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
6361 SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
6364 // Prints a string containing code-encoded text. The following escape
6365 // sequences can be used in the string to control the text color:
6367 // @@ prints a single '@' character.
6368 // @R changes the color to red.
6369 // @G changes the color to green.
6370 // @Y changes the color to yellow.
6371 // @D changes to the default terminal text color.
6373 static void PrintColorEncoded(const char* str) {
6374 GTestColor color = GTestColor::kDefault; // The current color.
6376 // Conceptually, we split the string into segments divided by escape
6377 // sequences. Then we print one segment at a time. At the end of
6378 // each iteration, the str pointer advances to the beginning of the
6381 const char* p = strchr(str, '@');
6383 ColoredPrintf(color, "%s", str);
6387 ColoredPrintf(color, "%s", std::string(str, p).c_str());
6389 const char ch = p[1];
6392 ColoredPrintf(color, "@");
6393 } else if (ch == 'D') {
6394 color = GTestColor::kDefault;
6395 } else if (ch == 'R') {
6396 color = GTestColor::kRed;
6397 } else if (ch == 'G') {
6398 color = GTestColor::kGreen;
6399 } else if (ch == 'Y') {
6400 color = GTestColor::kYellow;
6407 static const char kColorEncodedHelpMessage[] =
6408 "This program contains tests written using " GTEST_NAME_
6409 ". You can use the\n"
6410 "following command line flags to control its behavior:\n"
6413 " @G--" GTEST_FLAG_PREFIX_
6415 " List the names of all tests instead of running them. The name of\n"
6416 " TEST(Foo, Bar) is \"Foo.Bar\".\n"
6417 " @G--" GTEST_FLAG_PREFIX_
6418 "filter=@YPOSITIVE_PATTERNS"
6419 "[@G-@YNEGATIVE_PATTERNS]@D\n"
6420 " Run only the tests whose name matches one of the positive patterns "
6422 " none of the negative patterns. '?' matches any single character; "
6424 " matches any substring; ':' separates two patterns.\n"
6425 " @G--" GTEST_FLAG_PREFIX_
6426 "also_run_disabled_tests@D\n"
6427 " Run all disabled tests too.\n"
6430 " @G--" GTEST_FLAG_PREFIX_
6431 "repeat=@Y[COUNT]@D\n"
6432 " Run the tests repeatedly; use a negative count to repeat forever.\n"
6433 " @G--" GTEST_FLAG_PREFIX_
6435 " Randomize tests' orders on every iteration.\n"
6436 " @G--" GTEST_FLAG_PREFIX_
6437 "random_seed=@Y[NUMBER]@D\n"
6438 " Random number seed to use for shuffling test orders (between 1 and\n"
6439 " 99999, or 0 to use a seed based on the current time).\n"
6442 " @G--" GTEST_FLAG_PREFIX_
6443 "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
6444 " Enable/disable colored output. The default is @Gauto@D.\n"
6445 " @G--" GTEST_FLAG_PREFIX_
6447 " Only print test failures.\n"
6448 " @G--" GTEST_FLAG_PREFIX_
6450 " Don't print the elapsed time of each test.\n"
6451 " @G--" GTEST_FLAG_PREFIX_
6452 "output=@Y(@Gjson@Y|@Gxml@Y)[@G:@YDIRECTORY_PATH@G" GTEST_PATH_SEP_
6453 "@Y|@G:@YFILE_PATH]@D\n"
6454 " Generate a JSON or XML report in the given directory or with the "
6456 " file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n"
6457 # if GTEST_CAN_STREAM_RESULTS_
6458 " @G--" GTEST_FLAG_PREFIX_
6459 "stream_result_to=@YHOST@G:@YPORT@D\n"
6460 " Stream test results to the given server.\n"
6461 # endif // GTEST_CAN_STREAM_RESULTS_
6463 "Assertion Behavior:\n"
6464 # if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
6465 " @G--" GTEST_FLAG_PREFIX_
6466 "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
6467 " Set the default death test style.\n"
6468 # endif // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
6469 " @G--" GTEST_FLAG_PREFIX_
6470 "break_on_failure@D\n"
6471 " Turn assertion failures into debugger break-points.\n"
6472 " @G--" GTEST_FLAG_PREFIX_
6473 "throw_on_failure@D\n"
6474 " Turn assertion failures into C++ exceptions for use by an external\n"
6475 " test framework.\n"
6476 " @G--" GTEST_FLAG_PREFIX_
6477 "catch_exceptions=0@D\n"
6478 " Do not report exceptions as test failures. Instead, allow them\n"
6479 " to crash the program or throw a pop-up (on Windows).\n"
6481 "Except for @G--" GTEST_FLAG_PREFIX_
6482 "list_tests@D, you can alternatively set "
6483 "the corresponding\n"
6484 "environment variable of a flag (all letters in upper-case). For example, "
6486 "disable colored text output, you can either specify "
6487 "@G--" GTEST_FLAG_PREFIX_
6488 "color=no@D or set\n"
6489 "the @G" GTEST_FLAG_PREFIX_UPPER_
6490 "COLOR@D environment variable to @Gno@D.\n"
6492 "For more information, please read the " GTEST_NAME_
6493 " documentation at\n"
6494 "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_
6496 "(not one in your own code or tests), please report it to\n"
6497 "@G<" GTEST_DEV_EMAIL_ ">@D.\n";
6499 static bool ParseGoogleTestFlag(const char* const arg) {
6500 return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
6501 >EST_FLAG(also_run_disabled_tests)) ||
6502 ParseBoolFlag(arg, kBreakOnFailureFlag,
6503 >EST_FLAG(break_on_failure)) ||
6504 ParseBoolFlag(arg, kCatchExceptionsFlag,
6505 >EST_FLAG(catch_exceptions)) ||
6506 ParseStringFlag(arg, kColorFlag, >EST_FLAG(color)) ||
6507 ParseStringFlag(arg, kDeathTestStyleFlag,
6508 >EST_FLAG(death_test_style)) ||
6509 ParseBoolFlag(arg, kDeathTestUseFork,
6510 >EST_FLAG(death_test_use_fork)) ||
6511 ParseBoolFlag(arg, kFailFast, >EST_FLAG(fail_fast)) ||
6512 ParseStringFlag(arg, kFilterFlag, >EST_FLAG(filter)) ||
6513 ParseStringFlag(arg, kInternalRunDeathTestFlag,
6514 >EST_FLAG(internal_run_death_test)) ||
6515 ParseBoolFlag(arg, kListTestsFlag, >EST_FLAG(list_tests)) ||
6516 ParseStringFlag(arg, kOutputFlag, >EST_FLAG(output)) ||
6517 ParseBoolFlag(arg, kBriefFlag, >EST_FLAG(brief)) ||
6518 ParseBoolFlag(arg, kPrintTimeFlag, >EST_FLAG(print_time)) ||
6519 ParseBoolFlag(arg, kPrintUTF8Flag, >EST_FLAG(print_utf8)) ||
6520 ParseInt32Flag(arg, kRandomSeedFlag, >EST_FLAG(random_seed)) ||
6521 ParseInt32Flag(arg, kRepeatFlag, >EST_FLAG(repeat)) ||
6522 ParseBoolFlag(arg, kShuffleFlag, >EST_FLAG(shuffle)) ||
6523 ParseInt32Flag(arg, kStackTraceDepthFlag,
6524 >EST_FLAG(stack_trace_depth)) ||
6525 ParseStringFlag(arg, kStreamResultToFlag,
6526 >EST_FLAG(stream_result_to)) ||
6527 ParseBoolFlag(arg, kThrowOnFailureFlag, >EST_FLAG(throw_on_failure));
6530 #if GTEST_USE_OWN_FLAGFILE_FLAG_
6531 static void LoadFlagsFromFile(const std::string& path) {
6532 FILE* flagfile = posix::FOpen(path.c_str(), "r");
6534 GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG(flagfile)
6537 std::string contents(ReadEntireFile(flagfile));
6538 posix::FClose(flagfile);
6539 std::vector<std::string> lines;
6540 SplitString(contents, '\n', &lines);
6541 for (size_t i = 0; i < lines.size(); ++i) {
6542 if (lines[i].empty())
6544 if (!ParseGoogleTestFlag(lines[i].c_str()))
6548 #endif // GTEST_USE_OWN_FLAGFILE_FLAG_
6550 // Parses the command line for Google Test flags, without initializing
6551 // other parts of Google Test. The type parameter CharType can be
6552 // instantiated to either char or wchar_t.
6553 template <typename CharType>
6554 void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
6555 for (int i = 1; i < *argc; i++) {
6556 const std::string arg_string = StreamableToString(argv[i]);
6557 const char* const arg = arg_string.c_str();
6559 using internal::ParseBoolFlag;
6560 using internal::ParseInt32Flag;
6561 using internal::ParseStringFlag;
6563 bool remove_flag = false;
6564 if (ParseGoogleTestFlag(arg)) {
6566 #if GTEST_USE_OWN_FLAGFILE_FLAG_
6567 } else if (ParseStringFlag(arg, kFlagfileFlag, >EST_FLAG(flagfile))) {
6568 LoadFlagsFromFile(GTEST_FLAG(flagfile));
6570 #endif // GTEST_USE_OWN_FLAGFILE_FLAG_
6571 } else if (arg_string == "--help" || arg_string == "-h" ||
6572 arg_string == "-?" || arg_string == "/?" ||
6573 HasGoogleTestFlagPrefix(arg)) {
6574 // Both help flag and unrecognized Google Test flags (excluding
6575 // internal ones) trigger help display.
6580 // Shift the remainder of the argv list left by one. Note
6581 // that argv has (*argc + 1) elements, the last one always being
6582 // NULL. The following loop moves the trailing NULL element as
6584 for (int j = i; j != *argc; j++) {
6585 argv[j] = argv[j + 1];
6588 // Decrements the argument count.
6591 // We also need to decrement the iterator as we just removed
6598 // We print the help here instead of in RUN_ALL_TESTS(), as the
6599 // latter may not be called at all if the user is using Google
6600 // Test with another testing framework.
6601 PrintColorEncoded(kColorEncodedHelpMessage);
6605 // Parses the command line for Google Test flags, without initializing
6606 // other parts of Google Test.
6607 void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
6608 ParseGoogleTestFlagsOnlyImpl(argc, argv);
6610 // Fix the value of *_NSGetArgc() on macOS, but if and only if
6611 // *_NSGetArgv() == argv
6612 // Only applicable to char** version of argv
6614 #ifndef GTEST_OS_IOS
6615 if (*_NSGetArgv() == argv) {
6616 *_NSGetArgc() = *argc;
6621 void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
6622 ParseGoogleTestFlagsOnlyImpl(argc, argv);
6625 // The internal implementation of InitGoogleTest().
6627 // The type parameter CharType can be instantiated to either char or
6629 template <typename CharType>
6630 void InitGoogleTestImpl(int* argc, CharType** argv) {
6631 // We don't want to run the initialization code twice.
6632 if (GTestIsInitialized()) return;
6634 if (*argc <= 0) return;
6637 for (int i = 0; i != *argc; i++) {
6638 g_argvs.push_back(StreamableToString(argv[i]));
6642 absl::InitializeSymbolizer(g_argvs[0].c_str());
6643 #endif // GTEST_HAS_ABSL
6645 ParseGoogleTestFlagsOnly(argc, argv);
6646 GetUnitTestImpl()->PostFlagParsingInit();
6649 } // namespace internal
6651 // Initializes Google Test. This must be called before calling
6652 // RUN_ALL_TESTS(). In particular, it parses a command line for the
6653 // flags that Google Test recognizes. Whenever a Google Test flag is
6654 // seen, it is removed from argv, and *argc is decremented.
6656 // No value is returned. Instead, the Google Test flag variables are
6659 // Calling the function for the second time has no user-visible effect.
6660 void InitGoogleTest(int* argc, char** argv) {
6661 #if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6662 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
6663 #else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6664 internal::InitGoogleTestImpl(argc, argv);
6665 #endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6668 // This overloaded version can be used in Windows programs compiled in
6670 void InitGoogleTest(int* argc, wchar_t** argv) {
6671 #if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6672 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
6673 #else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6674 internal::InitGoogleTestImpl(argc, argv);
6675 #endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6678 // This overloaded version can be used on Arduino/embedded platforms where
6679 // there is no argc/argv.
6680 void InitGoogleTest() {
6681 // Since Arduino doesn't have a command line, fake out the argc/argv arguments
6683 const auto arg0 = "dummy";
6684 char* argv0 = const_cast<char*>(arg0);
6685 char** argv = &argv0;
6687 #if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6688 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
6689 #else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6690 internal::InitGoogleTestImpl(&argc, argv);
6691 #endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6694 std::string TempDir() {
6695 #if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
6696 return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
6697 #elif GTEST_OS_WINDOWS_MOBILE
6699 #elif GTEST_OS_WINDOWS
6700 const char* temp_dir = internal::posix::GetEnv("TEMP");
6701 if (temp_dir == nullptr || temp_dir[0] == '\0') {
6703 } else if (temp_dir[strlen(temp_dir) - 1] == '\\') {
6706 return std::string(temp_dir) + "\\";
6708 #elif GTEST_OS_LINUX_ANDROID
6709 const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
6710 if (temp_dir == nullptr || temp_dir[0] == '\0') {
6711 return "/data/local/tmp/";
6715 #elif GTEST_OS_LINUX
6716 const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
6717 if (temp_dir == nullptr || temp_dir[0] == '\0') {
6724 #endif // GTEST_OS_WINDOWS_MOBILE
6727 // Class ScopedTrace
6729 // Pushes the given source file location and message onto a per-thread
6730 // trace stack maintained by Google Test.
6731 void ScopedTrace::PushTrace(const char* file, int line, std::string message) {
6732 internal::TraceInfo trace;
6735 trace.message.swap(message);
6737 UnitTest::GetInstance()->PushGTestTrace(trace);
6740 // Pops the info pushed by the c'tor.
6741 ScopedTrace::~ScopedTrace()
6742 GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
6743 UnitTest::GetInstance()->PopGTestTrace();
6746 } // namespace testing