6908 lines · plain
1// Copyright 2005, Google Inc.2// All rights reserved.3//4// Redistribution and use in source and binary forms, with or without5// modification, are permitted provided that the following conditions are6// met:7//8// * Redistributions of source code must retain the above copyright9// notice, this list of conditions and the following disclaimer.10// * Redistributions in binary form must reproduce the above11// copyright notice, this list of conditions and the following disclaimer12// in the documentation and/or other materials provided with the13// distribution.14// * Neither the name of Google Inc. nor the names of its15// contributors may be used to endorse or promote products derived from16// this software without specific prior written permission.17//18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.29 30//31// The Google C++ Testing and Mocking Framework (Google Test)32 33#include "gtest/gtest.h"34 35#include <ctype.h>36#include <stdarg.h>37#include <stdio.h>38#include <stdlib.h>39#include <time.h>40#include <wchar.h>41#include <wctype.h>42 43#include <algorithm>44#include <chrono> // NOLINT45#include <cmath>46#include <csignal>47#include <cstdint>48#include <cstdlib>49#include <cstring>50#include <initializer_list>51#include <iomanip>52#include <ios>53#include <iostream>54#include <iterator>55#include <limits>56#include <list>57#include <map>58#include <ostream> // NOLINT59#include <set>60#include <sstream>61#include <unordered_set>62#include <utility>63#include <vector>64 65#include "gtest/gtest-assertion-result.h"66#include "gtest/gtest-spi.h"67#include "gtest/internal/custom/gtest.h"68#include "gtest/internal/gtest-port.h"69 70#ifdef GTEST_OS_LINUX71 72#include <fcntl.h> // NOLINT73#include <limits.h> // NOLINT74#include <sched.h> // NOLINT75// Declares vsnprintf(). This header is not available on Windows.76#include <strings.h> // NOLINT77#include <sys/mman.h> // NOLINT78#include <sys/time.h> // NOLINT79#include <unistd.h> // NOLINT80 81#include <string>82 83#elif defined(GTEST_OS_ZOS)84#include <sys/time.h> // NOLINT85 86// On z/OS we additionally need strings.h for strcasecmp.87#include <strings.h> // NOLINT88 89#elif defined(GTEST_OS_WINDOWS_MOBILE) // We are on Windows CE.90 91#include <windows.h> // NOLINT92#undef min93 94#elif defined(GTEST_OS_WINDOWS) // We are on Windows proper.95 96#include <windows.h> // NOLINT97#undef min98 99#ifdef _MSC_VER100#include <crtdbg.h> // NOLINT101#endif102 103#include <io.h> // NOLINT104#include <sys/stat.h> // NOLINT105#include <sys/timeb.h> // NOLINT106#include <sys/types.h> // NOLINT107 108#ifdef GTEST_OS_WINDOWS_MINGW109#include <sys/time.h> // NOLINT110#endif // GTEST_OS_WINDOWS_MINGW111 112#else113 114// cpplint thinks that the header is already included, so we want to115// silence it.116#include <sys/time.h> // NOLINT117#include <unistd.h> // NOLINT118 119#endif // GTEST_OS_LINUX120 121#if GTEST_HAS_EXCEPTIONS122#include <stdexcept>123#endif124 125#if GTEST_CAN_STREAM_RESULTS_126#include <arpa/inet.h> // NOLINT127#include <netdb.h> // NOLINT128#include <sys/socket.h> // NOLINT129#include <sys/types.h> // NOLINT130#endif131 132#include "src/gtest-internal-inl.h"133 134#ifdef GTEST_OS_WINDOWS135#define vsnprintf _vsnprintf136#endif // GTEST_OS_WINDOWS137 138#ifdef GTEST_OS_MAC139#ifndef GTEST_OS_IOS140#include <crt_externs.h>141#endif142#endif143 144#ifdef GTEST_HAS_ABSL145#include "absl/container/flat_hash_set.h"146#include "absl/debugging/failure_signal_handler.h"147#include "absl/debugging/stacktrace.h"148#include "absl/debugging/symbolize.h"149#include "absl/flags/parse.h"150#include "absl/flags/usage.h"151#include "absl/strings/str_cat.h"152#include "absl/strings/str_replace.h"153#include "absl/strings/string_view.h"154#include "absl/strings/strip.h"155#endif // GTEST_HAS_ABSL156 157// Checks builtin compiler feature |x| while avoiding an extra layer of #ifdefs158// at the callsite.159#if defined(__has_builtin)160#define GTEST_HAS_BUILTIN(x) __has_builtin(x)161#else162#define GTEST_HAS_BUILTIN(x) 0163#endif // defined(__has_builtin)164 165namespace testing {166 167using internal::CountIf;168using internal::ForEach;169using internal::GetElementOr;170using internal::Shuffle;171 172// Constants.173 174// A test whose test suite name or test name matches this filter is175// disabled and not run.176static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";177 178// A test suite whose name matches this filter is considered a death179// test suite and will be run before test suites whose name doesn't180// match this filter.181static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*";182 183// A test filter that matches everything.184static const char kUniversalFilter[] = "*";185 186// The default output format.187static const char kDefaultOutputFormat[] = "xml";188// The default output file.189static const char kDefaultOutputFile[] = "test_detail";190 191// The environment variable name for the test shard index.192static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";193// The environment variable name for the total number of test shards.194static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";195// The environment variable name for the test shard status file.196static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";197 198namespace internal {199 200// The text used in failure messages to indicate the start of the201// stack trace.202const char kStackTraceMarker[] = "\nStack trace:\n";203 204// g_help_flag is true if and only if the --help flag or an equivalent form205// is specified on the command line.206bool g_help_flag = false;207 208#if GTEST_HAS_FILE_SYSTEM209// Utility function to Open File for Writing210static FILE* OpenFileForWriting(const std::string& output_file) {211 FILE* fileout = nullptr;212 FilePath output_file_path(output_file);213 FilePath output_dir(output_file_path.RemoveFileName());214 215 if (output_dir.CreateDirectoriesRecursively()) {216 fileout = posix::FOpen(output_file.c_str(), "w");217 }218 if (fileout == nullptr) {219 GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";220 }221 return fileout;222}223#endif // GTEST_HAS_FILE_SYSTEM224 225} // namespace internal226 227// Bazel passes in the argument to '--test_filter' via the TESTBRIDGE_TEST_ONLY228// environment variable.229static const char* GetDefaultFilter() {230 const char* const testbridge_test_only =231 internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");232 if (testbridge_test_only != nullptr) {233 return testbridge_test_only;234 }235 return kUniversalFilter;236}237 238// Bazel passes in the argument to '--test_runner_fail_fast' via the239// TESTBRIDGE_TEST_RUNNER_FAIL_FAST environment variable.240static bool GetDefaultFailFast() {241 const char* const testbridge_test_runner_fail_fast =242 internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST");243 if (testbridge_test_runner_fail_fast != nullptr) {244 return strcmp(testbridge_test_runner_fail_fast, "1") == 0;245 }246 return false;247}248 249} // namespace testing250 251GTEST_DEFINE_bool_(252 fail_fast,253 testing::internal::BoolFromGTestEnv("fail_fast",254 testing::GetDefaultFailFast()),255 "True if and only if a test failure should stop further test execution.");256 257GTEST_DEFINE_bool_(258 also_run_disabled_tests,259 testing::internal::BoolFromGTestEnv("also_run_disabled_tests", false),260 "Run disabled tests too, in addition to the tests normally being run.");261 262GTEST_DEFINE_bool_(263 break_on_failure,264 testing::internal::BoolFromGTestEnv("break_on_failure", false),265 "True if and only if a failed assertion should be a debugger "266 "break-point.");267 268GTEST_DEFINE_bool_(catch_exceptions,269 testing::internal::BoolFromGTestEnv("catch_exceptions",270 true),271 "True if and only if " GTEST_NAME_272 " should catch exceptions and treat them as test failures.");273 274GTEST_DEFINE_string_(275 color, testing::internal::StringFromGTestEnv("color", "auto"),276 "Whether to use colors in the output. Valid values: yes, no, "277 "and auto. 'auto' means to use colors if the output is "278 "being sent to a terminal and the TERM environment variable "279 "is set to a terminal type that supports colors.");280 281GTEST_DEFINE_string_(282 filter,283 testing::internal::StringFromGTestEnv("filter",284 testing::GetDefaultFilter()),285 "A colon-separated list of glob (not regex) patterns "286 "for filtering the tests to run, optionally followed by a "287 "'-' and a : separated list of negative patterns (tests to "288 "exclude). A test is run if it matches one of the positive "289 "patterns and does not match any of the negative patterns.");290 291GTEST_DEFINE_bool_(292 install_failure_signal_handler,293 testing::internal::BoolFromGTestEnv("install_failure_signal_handler",294 false),295 "If true and supported on the current platform, " GTEST_NAME_296 " should "297 "install a signal handler that dumps debugging information when fatal "298 "signals are raised.");299 300GTEST_DEFINE_bool_(list_tests, false, "List all tests without running them.");301 302// The net priority order after flag processing is thus:303// --gtest_output command line flag304// GTEST_OUTPUT environment variable305// XML_OUTPUT_FILE environment variable306// ''307GTEST_DEFINE_string_(308 output,309 testing::internal::StringFromGTestEnv(310 "output", testing::internal::OutputFlagAlsoCheckEnvVar().c_str()),311 "A format (defaults to \"xml\" but can be specified to be \"json\"), "312 "optionally followed by a colon and an output file name or directory. "313 "A directory is indicated by a trailing pathname separator. "314 "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "315 "If a directory is specified, output files will be created "316 "within that directory, with file-names based on the test "317 "executable's name and, if necessary, made unique by adding "318 "digits.");319 320GTEST_DEFINE_bool_(321 brief, testing::internal::BoolFromGTestEnv("brief", false),322 "True if only test failures should be displayed in text output.");323 324GTEST_DEFINE_bool_(print_time,325 testing::internal::BoolFromGTestEnv("print_time", true),326 "True if and only if " GTEST_NAME_327 " should display elapsed time in text output.");328 329GTEST_DEFINE_bool_(print_utf8,330 testing::internal::BoolFromGTestEnv("print_utf8", true),331 "True if and only if " GTEST_NAME_332 " prints UTF8 characters as text.");333 334GTEST_DEFINE_int32_(335 random_seed, testing::internal::Int32FromGTestEnv("random_seed", 0),336 "Random number seed to use when shuffling test orders. Must be in range "337 "[1, 99999], or 0 to use a seed based on the current time.");338 339GTEST_DEFINE_int32_(340 repeat, testing::internal::Int32FromGTestEnv("repeat", 1),341 "How many times to repeat each test. Specify a negative number "342 "for repeating forever. Useful for shaking out flaky tests.");343 344GTEST_DEFINE_bool_(345 recreate_environments_when_repeating,346 testing::internal::BoolFromGTestEnv("recreate_environments_when_repeating",347 false),348 "Controls whether global test environments are recreated for each repeat "349 "of the tests. If set to false the global test environments are only set "350 "up once, for the first iteration, and only torn down once, for the last. "351 "Useful for shaking out flaky tests with stable, expensive test "352 "environments. If --gtest_repeat is set to a negative number, meaning "353 "there is no last run, the environments will always be recreated to avoid "354 "leaks.");355 356GTEST_DEFINE_bool_(show_internal_stack_frames, false,357 "True if and only if " GTEST_NAME_358 " should include internal stack frames when "359 "printing test failure stack traces.");360 361GTEST_DEFINE_bool_(shuffle,362 testing::internal::BoolFromGTestEnv("shuffle", false),363 "True if and only if " GTEST_NAME_364 " should randomize tests' order on every run.");365 366GTEST_DEFINE_int32_(367 stack_trace_depth,368 testing::internal::Int32FromGTestEnv("stack_trace_depth",369 testing::kMaxStackTraceDepth),370 "The maximum number of stack frames to print when an "371 "assertion fails. The valid range is 0 through 100, inclusive.");372 373GTEST_DEFINE_string_(374 stream_result_to,375 testing::internal::StringFromGTestEnv("stream_result_to", ""),376 "This flag specifies the host name and the port number on which to stream "377 "test results. Example: \"localhost:555\". The flag is effective only on "378 "Linux.");379 380GTEST_DEFINE_bool_(381 throw_on_failure,382 testing::internal::BoolFromGTestEnv("throw_on_failure", false),383 "When this flag is specified, a failed assertion will throw an exception "384 "if exceptions are enabled or exit the program with a non-zero code "385 "otherwise. For use with an external test framework.");386 387#if GTEST_USE_OWN_FLAGFILE_FLAG_388GTEST_DEFINE_string_(389 flagfile, testing::internal::StringFromGTestEnv("flagfile", ""),390 "This flag specifies the flagfile to read command-line flags from.");391#endif // GTEST_USE_OWN_FLAGFILE_FLAG_392 393namespace testing {394namespace internal {395 396const uint32_t Random::kMaxRange;397 398// Generates a random number from [0, range), using a Linear399// Congruential Generator (LCG). Crashes if 'range' is 0 or greater400// than kMaxRange.401uint32_t Random::Generate(uint32_t range) {402 // These constants are the same as are used in glibc's rand(3).403 // Use wider types than necessary to prevent unsigned overflow diagnostics.404 state_ = static_cast<uint32_t>(1103515245ULL * state_ + 12345U) % kMaxRange;405 406 GTEST_CHECK_(range > 0) << "Cannot generate a number in the range [0, 0).";407 GTEST_CHECK_(range <= kMaxRange)408 << "Generation of a number in [0, " << range << ") was requested, "409 << "but this can only generate numbers in [0, " << kMaxRange << ").";410 411 // Converting via modulus introduces a bit of downward bias, but412 // it's simple, and a linear congruential generator isn't too good413 // to begin with.414 return state_ % range;415}416 417// GTestIsInitialized() returns true if and only if the user has initialized418// Google Test. Useful for catching the user mistake of not initializing419// Google Test before calling RUN_ALL_TESTS().420static bool GTestIsInitialized() { return !GetArgvs().empty(); }421 422// Iterates over a vector of TestSuites, keeping a running sum of the423// results of calling a given int-returning method on each.424// Returns the sum.425static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list,426 int (TestSuite::*method)() const) {427 int sum = 0;428 for (size_t i = 0; i < case_list.size(); i++) {429 sum += (case_list[i]->*method)();430 }431 return sum;432}433 434// Returns true if and only if the test suite passed.435static bool TestSuitePassed(const TestSuite* test_suite) {436 return test_suite->should_run() && test_suite->Passed();437}438 439// Returns true if and only if the test suite failed.440static bool TestSuiteFailed(const TestSuite* test_suite) {441 return test_suite->should_run() && test_suite->Failed();442}443 444// Returns true if and only if test_suite contains at least one test that445// should run.446static bool ShouldRunTestSuite(const TestSuite* test_suite) {447 return test_suite->should_run();448}449 450// AssertHelper constructor.451AssertHelper::AssertHelper(TestPartResult::Type type, const char* file,452 int line, const char* message)453 : data_(new AssertHelperData(type, file, line, message)) {}454 455AssertHelper::~AssertHelper() { delete data_; }456 457// Message assignment, for assertion streaming support.458void AssertHelper::operator=(const Message& message) const {459 UnitTest::GetInstance()->AddTestPartResult(460 data_->type, data_->file, data_->line,461 AppendUserMessage(data_->message, message),462 UnitTest::GetInstance()->impl()->CurrentOsStackTraceExceptTop(1)463 // Skips the stack frame for this function itself.464 ); // NOLINT465}466 467namespace {468 469// When TEST_P is found without a matching INSTANTIATE_TEST_SUITE_P470// to creates test cases for it, a synthetic test case is471// inserted to report ether an error or a log message.472//473// This configuration bit will likely be removed at some point.474constexpr bool kErrorOnUninstantiatedParameterizedTest = true;475constexpr bool kErrorOnUninstantiatedTypeParameterizedTest = true;476 477// A test that fails at a given file/line location with a given message.478class FailureTest : public Test {479 public:480 explicit FailureTest(const CodeLocation& loc, std::string error_message,481 bool as_error)482 : loc_(loc),483 error_message_(std::move(error_message)),484 as_error_(as_error) {}485 486 void TestBody() override {487 if (as_error_) {488 AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),489 loc_.line, "") = Message() << error_message_;490 } else {491 std::cout << error_message_ << std::endl;492 }493 }494 495 private:496 const CodeLocation loc_;497 const std::string error_message_;498 const bool as_error_;499};500 501} // namespace502 503std::set<std::string>* GetIgnoredParameterizedTestSuites() {504 return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites();505}506 507// Add a given test_suit to the list of them allow to go un-instantiated.508MarkAsIgnored::MarkAsIgnored(const char* test_suite) {509 GetIgnoredParameterizedTestSuites()->insert(test_suite);510}511 512// If this parameterized test suite has no instantiations (and that513// has not been marked as okay), emit a test case reporting that.514void InsertSyntheticTestCase(const std::string& name, CodeLocation location,515 bool has_test_p) {516 const auto& ignored = *GetIgnoredParameterizedTestSuites();517 if (ignored.find(name) != ignored.end()) return;518 519 const char kMissingInstantiation[] = //520 " is defined via TEST_P, but never instantiated. None of the test cases "521 "will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only "522 "ones provided expand to nothing."523 "\n\n"524 "Ideally, TEST_P definitions should only ever be included as part of "525 "binaries that intend to use them. (As opposed to, for example, being "526 "placed in a library that may be linked in to get other utilities.)";527 528 const char kMissingTestCase[] = //529 " is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are "530 "defined via TEST_P . No test cases will run."531 "\n\n"532 "Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from "533 "code that always depend on code that provides TEST_P. Failing to do "534 "so is often an indication of dead code, e.g. the last TEST_P was "535 "removed but the rest got left behind.";536 537 std::string message =538 "Parameterized test suite " + name +539 (has_test_p ? kMissingInstantiation : kMissingTestCase) +540 "\n\n"541 "To suppress this error for this test suite, insert the following line "542 "(in a non-header) in the namespace it is defined in:"543 "\n\n"544 "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +545 name + ");";546 547 std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">";548 RegisterTest( //549 "GoogleTestVerification", full_name.c_str(),550 nullptr, // No type parameter.551 nullptr, // No value parameter.552 location.file.c_str(), location.line, [message, location] {553 return new FailureTest(location, message,554 kErrorOnUninstantiatedParameterizedTest);555 });556}557 558void RegisterTypeParameterizedTestSuite(const char* test_suite_name,559 CodeLocation code_location) {560 GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(561 test_suite_name, code_location);562}563 564void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) {565 GetUnitTestImpl()->type_parameterized_test_registry().RegisterInstantiation(566 case_name);567}568 569void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(570 const char* test_suite_name, CodeLocation code_location) {571 suites_.emplace(std::string(test_suite_name),572 TypeParameterizedTestSuiteInfo(code_location));573}574 575void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(576 const char* test_suite_name) {577 auto it = suites_.find(std::string(test_suite_name));578 if (it != suites_.end()) {579 it->second.instantiated = true;580 } else {581 GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"582 << test_suite_name << "'";583 }584}585 586void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {587 const auto& ignored = *GetIgnoredParameterizedTestSuites();588 for (const auto& testcase : suites_) {589 if (testcase.second.instantiated) continue;590 if (ignored.find(testcase.first) != ignored.end()) continue;591 592 std::string message =593 "Type parameterized test suite " + testcase.first +594 " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "595 "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."596 "\n\n"597 "Ideally, TYPED_TEST_P definitions should only ever be included as "598 "part of binaries that intend to use them. (As opposed to, for "599 "example, being placed in a library that may be linked in to get other "600 "utilities.)"601 "\n\n"602 "To suppress this error for this test suite, insert the following line "603 "(in a non-header) in the namespace it is defined in:"604 "\n\n"605 "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +606 testcase.first + ");";607 608 std::string full_name =609 "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">";610 RegisterTest( //611 "GoogleTestVerification", full_name.c_str(),612 nullptr, // No type parameter.613 nullptr, // No value parameter.614 testcase.second.code_location.file.c_str(),615 testcase.second.code_location.line, [message, testcase] {616 return new FailureTest(testcase.second.code_location, message,617 kErrorOnUninstantiatedTypeParameterizedTest);618 });619 }620}621 622// A copy of all command line arguments. Set by InitGoogleTest().623static ::std::vector<std::string> g_argvs;624 625::std::vector<std::string> GetArgvs() {626#if defined(GTEST_CUSTOM_GET_ARGVS_)627 // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or628 // ::string. This code converts it to the appropriate type.629 const auto& custom = GTEST_CUSTOM_GET_ARGVS_();630 return ::std::vector<std::string>(custom.begin(), custom.end());631#else // defined(GTEST_CUSTOM_GET_ARGVS_)632 return g_argvs;633#endif // defined(GTEST_CUSTOM_GET_ARGVS_)634}635 636#if GTEST_HAS_FILE_SYSTEM637// Returns the current application's name, removing directory path if that638// is present.639FilePath GetCurrentExecutableName() {640 FilePath result;641 642#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_OS2)643 result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));644#else645 result.Set(FilePath(GetArgvs()[0]));646#endif // GTEST_OS_WINDOWS647 648 return result.RemoveDirectoryName();649}650#endif // GTEST_HAS_FILE_SYSTEM651 652// Functions for processing the gtest_output flag.653 654// Returns the output format, or "" for normal printed output.655std::string UnitTestOptions::GetOutputFormat() {656 std::string s = GTEST_FLAG_GET(output);657 const char* const gtest_output_flag = s.c_str();658 const char* const colon = strchr(gtest_output_flag, ':');659 return (colon == nullptr)660 ? std::string(gtest_output_flag)661 : std::string(gtest_output_flag,662 static_cast<size_t>(colon - gtest_output_flag));663}664 665#if GTEST_HAS_FILE_SYSTEM666// Returns the name of the requested output file, or the default if none667// was explicitly specified.668std::string UnitTestOptions::GetAbsolutePathToOutputFile() {669 std::string s = GTEST_FLAG_GET(output);670 const char* const gtest_output_flag = s.c_str();671 672 std::string format = GetOutputFormat();673 if (format.empty()) format = std::string(kDefaultOutputFormat);674 675 const char* const colon = strchr(gtest_output_flag, ':');676 if (colon == nullptr)677 return internal::FilePath::MakeFileName(678 internal::FilePath(679 UnitTest::GetInstance()->original_working_dir()),680 internal::FilePath(kDefaultOutputFile), 0, format.c_str())681 .string();682 683 internal::FilePath output_name(colon + 1);684 if (!output_name.IsAbsolutePath())685 output_name = internal::FilePath::ConcatPaths(686 internal::FilePath(UnitTest::GetInstance()->original_working_dir()),687 internal::FilePath(colon + 1));688 689 if (!output_name.IsDirectory()) return output_name.string();690 691 internal::FilePath result(internal::FilePath::GenerateUniqueFileName(692 output_name, internal::GetCurrentExecutableName(),693 GetOutputFormat().c_str()));694 return result.string();695}696#endif // GTEST_HAS_FILE_SYSTEM697 698// Returns true if and only if the wildcard pattern matches the string. Each699// pattern consists of regular characters, single-character wildcards (?), and700// multi-character wildcards (*).701//702// This function implements a linear-time string globbing algorithm based on703// https://research.swtch.com/glob.704static bool PatternMatchesString(const std::string& name_str,705 const char* pattern, const char* pattern_end) {706 const char* name = name_str.c_str();707 const char* const name_begin = name;708 const char* const name_end = name + name_str.size();709 710 const char* pattern_next = pattern;711 const char* name_next = name;712 713 while (pattern < pattern_end || name < name_end) {714 if (pattern < pattern_end) {715 switch (*pattern) {716 default: // Match an ordinary character.717 if (name < name_end && *name == *pattern) {718 ++pattern;719 ++name;720 continue;721 }722 break;723 case '?': // Match any single character.724 if (name < name_end) {725 ++pattern;726 ++name;727 continue;728 }729 break;730 case '*':731 // Match zero or more characters. Start by skipping over the wildcard732 // and matching zero characters from name. If that fails, restart and733 // match one more character than the last attempt.734 pattern_next = pattern;735 name_next = name + 1;736 ++pattern;737 continue;738 }739 }740 // Failed to match a character. Restart if possible.741 if (name_begin < name_next && name_next <= name_end) {742 pattern = pattern_next;743 name = name_next;744 continue;745 }746 return false;747 }748 return true;749}750 751namespace {752 753bool IsGlobPattern(const std::string& pattern) {754 return std::any_of(pattern.begin(), pattern.end(),755 [](const char c) { return c == '?' || c == '*'; });756}757 758class UnitTestFilter {759 public:760 UnitTestFilter() = default;761 762 // Constructs a filter from a string of patterns separated by `:`.763 explicit UnitTestFilter(const std::string& filter) {764 // By design "" filter matches "" string.765 std::vector<std::string> all_patterns;766 SplitString(filter, ':', &all_patterns);767 const auto exact_match_patterns_begin = std::partition(768 all_patterns.begin(), all_patterns.end(), &IsGlobPattern);769 770 glob_patterns_.reserve(static_cast<size_t>(771 std::distance(all_patterns.begin(), exact_match_patterns_begin)));772 std::move(all_patterns.begin(), exact_match_patterns_begin,773 std::inserter(glob_patterns_, glob_patterns_.begin()));774 std::move(775 exact_match_patterns_begin, all_patterns.end(),776 std::inserter(exact_match_patterns_, exact_match_patterns_.begin()));777 }778 779 // Returns true if and only if name matches at least one of the patterns in780 // the filter.781 bool MatchesName(const std::string& name) const {782 return exact_match_patterns_.count(name) > 0 ||783 std::any_of(glob_patterns_.begin(), glob_patterns_.end(),784 [&name](const std::string& pattern) {785 return PatternMatchesString(786 name, pattern.c_str(),787 pattern.c_str() + pattern.size());788 });789 }790 791 private:792 std::vector<std::string> glob_patterns_;793 std::unordered_set<std::string> exact_match_patterns_;794};795 796class PositiveAndNegativeUnitTestFilter {797 public:798 // Constructs a positive and a negative filter from a string. The string799 // contains a positive filter optionally followed by a '-' character and a800 // negative filter. In case only a negative filter is provided the positive801 // filter will be assumed "*".802 // A filter is a list of patterns separated by ':'.803 explicit PositiveAndNegativeUnitTestFilter(const std::string& filter) {804 std::vector<std::string> positive_and_negative_filters;805 806 // NOTE: `SplitString` always returns a non-empty container.807 SplitString(filter, '-', &positive_and_negative_filters);808 const auto& positive_filter = positive_and_negative_filters.front();809 810 if (positive_and_negative_filters.size() > 1) {811 positive_filter_ = UnitTestFilter(812 positive_filter.empty() ? kUniversalFilter : positive_filter);813 814 // TODO(b/214626361): Fail on multiple '-' characters815 // For the moment to preserve old behavior we concatenate the rest of the816 // string parts with `-` as separator to generate the negative filter.817 auto negative_filter_string = positive_and_negative_filters[1];818 for (std::size_t i = 2; i < positive_and_negative_filters.size(); i++)819 negative_filter_string =820 negative_filter_string + '-' + positive_and_negative_filters[i];821 negative_filter_ = UnitTestFilter(negative_filter_string);822 } else {823 // In case we don't have a negative filter and positive filter is ""824 // we do not use kUniversalFilter by design as opposed to when we have a825 // negative filter.826 positive_filter_ = UnitTestFilter(positive_filter);827 }828 }829 830 // Returns true if and only if test name (this is generated by appending test831 // suit name and test name via a '.' character) matches the positive filter832 // and does not match the negative filter.833 bool MatchesTest(const std::string& test_suite_name,834 const std::string& test_name) const {835 return MatchesName(test_suite_name + "." + test_name);836 }837 838 // Returns true if and only if name matches the positive filter and does not839 // match the negative filter.840 bool MatchesName(const std::string& name) const {841 return positive_filter_.MatchesName(name) &&842 !negative_filter_.MatchesName(name);843 }844 845 private:846 UnitTestFilter positive_filter_;847 UnitTestFilter negative_filter_;848};849} // namespace850 851bool UnitTestOptions::MatchesFilter(const std::string& name_str,852 const char* filter) {853 return UnitTestFilter(filter).MatchesName(name_str);854}855 856// Returns true if and only if the user-specified filter matches the test857// suite name and the test name.858bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,859 const std::string& test_name) {860 // Split --gtest_filter at '-', if there is one, to separate into861 // positive filter and negative filter portions862 return PositiveAndNegativeUnitTestFilter(GTEST_FLAG_GET(filter))863 .MatchesTest(test_suite_name, test_name);864}865 866#if GTEST_HAS_SEH867static std::string FormatSehExceptionMessage(DWORD exception_code,868 const char* location) {869 Message message;870 message << "SEH exception with code 0x" << std::setbase(16) << exception_code871 << std::setbase(10) << " thrown in " << location << ".";872 return message.GetString();873}874 875int UnitTestOptions::GTestProcessSEH(DWORD seh_code, const char* location) {876 // Google Test should handle a SEH exception if:877 // 1. the user wants it to, AND878 // 2. this is not a breakpoint exception or stack overflow, AND879 // 3. this is not a C++ exception (VC++ implements them via SEH,880 // apparently).881 //882 // SEH exception code for C++ exceptions.883 // (see http://support.microsoft.com/kb/185294 for more information).884 const DWORD kCxxExceptionCode = 0xe06d7363;885 886 if (!GTEST_FLAG_GET(catch_exceptions) || seh_code == kCxxExceptionCode ||887 seh_code == EXCEPTION_BREAKPOINT ||888 seh_code == EXCEPTION_STACK_OVERFLOW) {889 return EXCEPTION_CONTINUE_SEARCH; // Don't handle these exceptions890 }891 892 internal::ReportFailureInUnknownLocation(893 TestPartResult::kFatalFailure,894 FormatSehExceptionMessage(seh_code, location) +895 "\n"896 "Stack trace:\n" +897 ::testing::internal::GetCurrentOsStackTraceExceptTop(1));898 899 return EXCEPTION_EXECUTE_HANDLER;900}901#endif // GTEST_HAS_SEH902 903} // namespace internal904 905// The c'tor sets this object as the test part result reporter used by906// Google Test. The 'result' parameter specifies where to report the907// results. Intercepts only failures from the current thread.908ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(909 TestPartResultArray* result)910 : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD), result_(result) {911 Init();912}913 914// The c'tor sets this object as the test part result reporter used by915// Google Test. The 'result' parameter specifies where to report the916// results.917ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(918 InterceptMode intercept_mode, TestPartResultArray* result)919 : intercept_mode_(intercept_mode), result_(result) {920 Init();921}922 923void ScopedFakeTestPartResultReporter::Init() {924 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();925 if (intercept_mode_ == INTERCEPT_ALL_THREADS) {926 old_reporter_ = impl->GetGlobalTestPartResultReporter();927 impl->SetGlobalTestPartResultReporter(this);928 } else {929 old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();930 impl->SetTestPartResultReporterForCurrentThread(this);931 }932}933 934// The d'tor restores the test part result reporter used by Google Test935// before.936ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {937 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();938 if (intercept_mode_ == INTERCEPT_ALL_THREADS) {939 impl->SetGlobalTestPartResultReporter(old_reporter_);940 } else {941 impl->SetTestPartResultReporterForCurrentThread(old_reporter_);942 }943}944 945// Increments the test part result count and remembers the result.946// This method is from the TestPartResultReporterInterface interface.947void ScopedFakeTestPartResultReporter::ReportTestPartResult(948 const TestPartResult& result) {949 result_->Append(result);950}951 952namespace internal {953 954// Returns the type ID of ::testing::Test. We should always call this955// instead of GetTypeId< ::testing::Test>() to get the type ID of956// testing::Test. This is to work around a suspected linker bug when957// using Google Test as a framework on Mac OS X. The bug causes958// GetTypeId< ::testing::Test>() to return different values depending959// on whether the call is from the Google Test framework itself or960// from user test code. GetTestTypeId() is guaranteed to always961// return the same value, as it always calls GetTypeId<>() from the962// gtest.cc, which is within the Google Test framework.963TypeId GetTestTypeId() { return GetTypeId<Test>(); }964 965// The value of GetTestTypeId() as seen from within the Google Test966// library. This is solely for testing GetTestTypeId().967extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();968 969// This predicate-formatter checks that 'results' contains a test part970// failure of the given type and that the failure message contains the971// given substring.972static AssertionResult HasOneFailure(const char* /* results_expr */,973 const char* /* type_expr */,974 const char* /* substr_expr */,975 const TestPartResultArray& results,976 TestPartResult::Type type,977 const std::string& substr) {978 const std::string expected(type == TestPartResult::kFatalFailure979 ? "1 fatal failure"980 : "1 non-fatal failure");981 Message msg;982 if (results.size() != 1) {983 msg << "Expected: " << expected << "\n"984 << " Actual: " << results.size() << " failures";985 for (int i = 0; i < results.size(); i++) {986 msg << "\n" << results.GetTestPartResult(i);987 }988 return AssertionFailure() << msg;989 }990 991 const TestPartResult& r = results.GetTestPartResult(0);992 if (r.type() != type) {993 return AssertionFailure() << "Expected: " << expected << "\n"994 << " Actual:\n"995 << r;996 }997 998 if (strstr(r.message(), substr.c_str()) == nullptr) {999 return AssertionFailure()1000 << "Expected: " << expected << " containing \"" << substr << "\"\n"1001 << " Actual:\n"1002 << r;1003 }1004 1005 return AssertionSuccess();1006}1007 1008// The constructor of SingleFailureChecker remembers where to look up1009// test part results, what type of failure we expect, and what1010// substring the failure message should contain.1011SingleFailureChecker::SingleFailureChecker(const TestPartResultArray* results,1012 TestPartResult::Type type,1013 const std::string& substr)1014 : results_(results), type_(type), substr_(substr) {}1015 1016// The destructor of SingleFailureChecker verifies that the given1017// TestPartResultArray contains exactly one failure that has the given1018// type and contains the given substring. If that's not the case, a1019// non-fatal failure will be generated.1020SingleFailureChecker::~SingleFailureChecker() {1021 EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);1022}1023 1024DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(1025 UnitTestImpl* unit_test)1026 : unit_test_(unit_test) {}1027 1028void DefaultGlobalTestPartResultReporter::ReportTestPartResult(1029 const TestPartResult& result) {1030 unit_test_->current_test_result()->AddTestPartResult(result);1031 unit_test_->listeners()->repeater()->OnTestPartResult(result);1032}1033 1034DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(1035 UnitTestImpl* unit_test)1036 : unit_test_(unit_test) {}1037 1038void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(1039 const TestPartResult& result) {1040 unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);1041}1042 1043// Returns the global test part result reporter.1044TestPartResultReporterInterface*1045UnitTestImpl::GetGlobalTestPartResultReporter() {1046 internal::MutexLock lock(&global_test_part_result_reporter_mutex_);1047 return global_test_part_result_reporter_;1048}1049 1050// Sets the global test part result reporter.1051void UnitTestImpl::SetGlobalTestPartResultReporter(1052 TestPartResultReporterInterface* reporter) {1053 internal::MutexLock lock(&global_test_part_result_reporter_mutex_);1054 global_test_part_result_reporter_ = reporter;1055}1056 1057// Returns the test part result reporter for the current thread.1058TestPartResultReporterInterface*1059UnitTestImpl::GetTestPartResultReporterForCurrentThread() {1060 return per_thread_test_part_result_reporter_.get();1061}1062 1063// Sets the test part result reporter for the current thread.1064void UnitTestImpl::SetTestPartResultReporterForCurrentThread(1065 TestPartResultReporterInterface* reporter) {1066 per_thread_test_part_result_reporter_.set(reporter);1067}1068 1069// Gets the number of successful test suites.1070int UnitTestImpl::successful_test_suite_count() const {1071 return CountIf(test_suites_, TestSuitePassed);1072}1073 1074// Gets the number of failed test suites.1075int UnitTestImpl::failed_test_suite_count() const {1076 return CountIf(test_suites_, TestSuiteFailed);1077}1078 1079// Gets the number of all test suites.1080int UnitTestImpl::total_test_suite_count() const {1081 return static_cast<int>(test_suites_.size());1082}1083 1084// Gets the number of all test suites that contain at least one test1085// that should run.1086int UnitTestImpl::test_suite_to_run_count() const {1087 return CountIf(test_suites_, ShouldRunTestSuite);1088}1089 1090// Gets the number of successful tests.1091int UnitTestImpl::successful_test_count() const {1092 return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count);1093}1094 1095// Gets the number of skipped tests.1096int UnitTestImpl::skipped_test_count() const {1097 return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count);1098}1099 1100// Gets the number of failed tests.1101int UnitTestImpl::failed_test_count() const {1102 return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count);1103}1104 1105// Gets the number of disabled tests that will be reported in the XML report.1106int UnitTestImpl::reportable_disabled_test_count() const {1107 return SumOverTestSuiteList(test_suites_,1108 &TestSuite::reportable_disabled_test_count);1109}1110 1111// Gets the number of disabled tests.1112int UnitTestImpl::disabled_test_count() const {1113 return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count);1114}1115 1116// Gets the number of tests to be printed in the XML report.1117int UnitTestImpl::reportable_test_count() const {1118 return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count);1119}1120 1121// Gets the number of all tests.1122int UnitTestImpl::total_test_count() const {1123 return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count);1124}1125 1126// Gets the number of tests that should run.1127int UnitTestImpl::test_to_run_count() const {1128 return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);1129}1130 1131// Returns the current OS stack trace as an std::string.1132//1133// The maximum number of stack frames to be included is specified by1134// the gtest_stack_trace_depth flag. The skip_count parameter1135// specifies the number of top frames to be skipped, which doesn't1136// count against the number of frames to be included.1137//1138// For example, if Foo() calls Bar(), which in turn calls1139// CurrentOsStackTraceExceptTop(1), Foo() will be included in the1140// trace but Bar() and CurrentOsStackTraceExceptTop() won't.1141std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {1142 return os_stack_trace_getter()->CurrentStackTrace(1143 static_cast<int>(GTEST_FLAG_GET(stack_trace_depth)), skip_count + 11144 // Skips the user-specified number of frames plus this function1145 // itself.1146 ); // NOLINT1147}1148 1149// A helper class for measuring elapsed times.1150class Timer {1151 public:1152 Timer() : start_(clock::now()) {}1153 1154 // Return time elapsed in milliseconds since the timer was created.1155 TimeInMillis Elapsed() {1156 return std::chrono::duration_cast<std::chrono::milliseconds>(clock::now() -1157 start_)1158 .count();1159 }1160 1161 private:1162 // Fall back to the system_clock when building with newlib on a system1163 // without a monotonic clock.1164#if defined(_NEWLIB_VERSION) && !defined(CLOCK_MONOTONIC)1165 using clock = std::chrono::system_clock;1166#else1167 using clock = std::chrono::steady_clock;1168#endif1169 clock::time_point start_;1170};1171 1172// Returns a timestamp as milliseconds since the epoch. Note this time may jump1173// around subject to adjustments by the system, to measure elapsed time use1174// Timer instead.1175TimeInMillis GetTimeInMillis() {1176 return std::chrono::duration_cast<std::chrono::milliseconds>(1177 std::chrono::system_clock::now() -1178 std::chrono::system_clock::from_time_t(0))1179 .count();1180}1181 1182// Utilities1183 1184// class String.1185 1186#ifdef GTEST_OS_WINDOWS_MOBILE1187// Creates a UTF-16 wide string from the given ANSI string, allocating1188// memory using new. The caller is responsible for deleting the return1189// value using delete[]. Returns the wide string, or NULL if the1190// input is NULL.1191LPCWSTR String::AnsiToUtf16(const char* ansi) {1192 if (!ansi) return nullptr;1193 const int length = strlen(ansi);1194 const int unicode_length =1195 MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 0);1196 WCHAR* unicode = new WCHAR[unicode_length + 1];1197 MultiByteToWideChar(CP_ACP, 0, ansi, length, unicode, unicode_length);1198 unicode[unicode_length] = 0;1199 return unicode;1200}1201 1202// Creates an ANSI string from the given wide string, allocating1203// memory using new. The caller is responsible for deleting the return1204// value using delete[]. Returns the ANSI string, or NULL if the1205// input is NULL.1206const char* String::Utf16ToAnsi(LPCWSTR utf16_str) {1207 if (!utf16_str) return nullptr;1208 const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, nullptr,1209 0, nullptr, nullptr);1210 char* ansi = new char[ansi_length + 1];1211 WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length, nullptr,1212 nullptr);1213 ansi[ansi_length] = 0;1214 return ansi;1215}1216 1217#endif // GTEST_OS_WINDOWS_MOBILE1218 1219// Compares two C strings. Returns true if and only if they have the same1220// content.1221//1222// Unlike strcmp(), this function can handle NULL argument(s). A NULL1223// C string is considered different to any non-NULL C string,1224// including the empty string.1225bool String::CStringEquals(const char* lhs, const char* rhs) {1226 if (lhs == nullptr) return rhs == nullptr;1227 1228 if (rhs == nullptr) return false;1229 1230 return strcmp(lhs, rhs) == 0;1231}1232 1233#if GTEST_HAS_STD_WSTRING1234 1235// Converts an array of wide chars to a narrow string using the UTF-81236// encoding, and streams the result to the given Message object.1237static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,1238 Message* msg) {1239 for (size_t i = 0; i != length;) { // NOLINT1240 if (wstr[i] != L'\0') {1241 *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));1242 while (i != length && wstr[i] != L'\0') i++;1243 } else {1244 *msg << '\0';1245 i++;1246 }1247 }1248}1249 1250#endif // GTEST_HAS_STD_WSTRING1251 1252void SplitString(const ::std::string& str, char delimiter,1253 ::std::vector< ::std::string>* dest) {1254 ::std::vector< ::std::string> parsed;1255 ::std::string::size_type pos = 0;1256 while (::testing::internal::AlwaysTrue()) {1257 const ::std::string::size_type colon = str.find(delimiter, pos);1258 if (colon == ::std::string::npos) {1259 parsed.push_back(str.substr(pos));1260 break;1261 } else {1262 parsed.push_back(str.substr(pos, colon - pos));1263 pos = colon + 1;1264 }1265 }1266 dest->swap(parsed);1267}1268 1269} // namespace internal1270 1271// Constructs an empty Message.1272// We allocate the stringstream separately because otherwise each use of1273// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's1274// stack frame leading to huge stack frames in some cases; gcc does not reuse1275// the stack space.1276Message::Message() : ss_(new ::std::stringstream) {1277 // By default, we want there to be enough precision when printing1278 // a double to a Message.1279 *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);1280}1281 1282// These two overloads allow streaming a wide C string to a Message1283// using the UTF-8 encoding.1284Message& Message::operator<<(const wchar_t* wide_c_str) {1285 return *this << internal::String::ShowWideCString(wide_c_str);1286}1287Message& Message::operator<<(wchar_t* wide_c_str) {1288 return *this << internal::String::ShowWideCString(wide_c_str);1289}1290 1291#if GTEST_HAS_STD_WSTRING1292// Converts the given wide string to a narrow string using the UTF-81293// encoding, and streams the result to this Message object.1294Message& Message::operator<<(const ::std::wstring& wstr) {1295 internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);1296 return *this;1297}1298#endif // GTEST_HAS_STD_WSTRING1299 1300// Gets the text streamed to this object so far as an std::string.1301// Each '\0' character in the buffer is replaced with "\\0".1302std::string Message::GetString() const {1303 return internal::StringStreamToString(ss_.get());1304}1305 1306namespace internal {1307 1308namespace edit_distance {1309std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,1310 const std::vector<size_t>& right) {1311 std::vector<std::vector<double> > costs(1312 left.size() + 1, std::vector<double>(right.size() + 1));1313 std::vector<std::vector<EditType> > best_move(1314 left.size() + 1, std::vector<EditType>(right.size() + 1));1315 1316 // Populate for empty right.1317 for (size_t l_i = 0; l_i < costs.size(); ++l_i) {1318 costs[l_i][0] = static_cast<double>(l_i);1319 best_move[l_i][0] = kRemove;1320 }1321 // Populate for empty left.1322 for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) {1323 costs[0][r_i] = static_cast<double>(r_i);1324 best_move[0][r_i] = kAdd;1325 }1326 1327 for (size_t l_i = 0; l_i < left.size(); ++l_i) {1328 for (size_t r_i = 0; r_i < right.size(); ++r_i) {1329 if (left[l_i] == right[r_i]) {1330 // Found a match. Consume it.1331 costs[l_i + 1][r_i + 1] = costs[l_i][r_i];1332 best_move[l_i + 1][r_i + 1] = kMatch;1333 continue;1334 }1335 1336 const double add = costs[l_i + 1][r_i];1337 const double remove = costs[l_i][r_i + 1];1338 const double replace = costs[l_i][r_i];1339 if (add < remove && add < replace) {1340 costs[l_i + 1][r_i + 1] = add + 1;1341 best_move[l_i + 1][r_i + 1] = kAdd;1342 } else if (remove < add && remove < replace) {1343 costs[l_i + 1][r_i + 1] = remove + 1;1344 best_move[l_i + 1][r_i + 1] = kRemove;1345 } else {1346 // We make replace a little more expensive than add/remove to lower1347 // their priority.1348 costs[l_i + 1][r_i + 1] = replace + 1.00001;1349 best_move[l_i + 1][r_i + 1] = kReplace;1350 }1351 }1352 }1353 1354 // Reconstruct the best path. We do it in reverse order.1355 std::vector<EditType> best_path;1356 for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {1357 EditType move = best_move[l_i][r_i];1358 best_path.push_back(move);1359 l_i -= move != kAdd;1360 r_i -= move != kRemove;1361 }1362 std::reverse(best_path.begin(), best_path.end());1363 return best_path;1364}1365 1366namespace {1367 1368// Helper class to convert string into ids with deduplication.1369class InternalStrings {1370 public:1371 size_t GetId(const std::string& str) {1372 IdMap::iterator it = ids_.find(str);1373 if (it != ids_.end()) return it->second;1374 size_t id = ids_.size();1375 return ids_[str] = id;1376 }1377 1378 private:1379 typedef std::map<std::string, size_t> IdMap;1380 IdMap ids_;1381};1382 1383} // namespace1384 1385std::vector<EditType> CalculateOptimalEdits(1386 const std::vector<std::string>& left,1387 const std::vector<std::string>& right) {1388 std::vector<size_t> left_ids, right_ids;1389 {1390 InternalStrings intern_table;1391 for (size_t i = 0; i < left.size(); ++i) {1392 left_ids.push_back(intern_table.GetId(left[i]));1393 }1394 for (size_t i = 0; i < right.size(); ++i) {1395 right_ids.push_back(intern_table.GetId(right[i]));1396 }1397 }1398 return CalculateOptimalEdits(left_ids, right_ids);1399}1400 1401namespace {1402 1403// Helper class that holds the state for one hunk and prints it out to the1404// stream.1405// It reorders adds/removes when possible to group all removes before all1406// adds. It also adds the hunk header before printint into the stream.1407class Hunk {1408 public:1409 Hunk(size_t left_start, size_t right_start)1410 : left_start_(left_start),1411 right_start_(right_start),1412 adds_(),1413 removes_(),1414 common_() {}1415 1416 void PushLine(char edit, const char* line) {1417 switch (edit) {1418 case ' ':1419 ++common_;1420 FlushEdits();1421 hunk_.push_back(std::make_pair(' ', line));1422 break;1423 case '-':1424 ++removes_;1425 hunk_removes_.push_back(std::make_pair('-', line));1426 break;1427 case '+':1428 ++adds_;1429 hunk_adds_.push_back(std::make_pair('+', line));1430 break;1431 }1432 }1433 1434 void PrintTo(std::ostream* os) {1435 PrintHeader(os);1436 FlushEdits();1437 for (std::list<std::pair<char, const char*> >::const_iterator it =1438 hunk_.begin();1439 it != hunk_.end(); ++it) {1440 *os << it->first << it->second << "\n";1441 }1442 }1443 1444 bool has_edits() const { return adds_ || removes_; }1445 1446 private:1447 void FlushEdits() {1448 hunk_.splice(hunk_.end(), hunk_removes_);1449 hunk_.splice(hunk_.end(), hunk_adds_);1450 }1451 1452 // Print a unified diff header for one hunk.1453 // The format is1454 // "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@"1455 // where the left/right parts are omitted if unnecessary.1456 void PrintHeader(std::ostream* ss) const {1457 *ss << "@@ ";1458 if (removes_) {1459 *ss << "-" << left_start_ << "," << (removes_ + common_);1460 }1461 if (removes_ && adds_) {1462 *ss << " ";1463 }1464 if (adds_) {1465 *ss << "+" << right_start_ << "," << (adds_ + common_);1466 }1467 *ss << " @@\n";1468 }1469 1470 size_t left_start_, right_start_;1471 size_t adds_, removes_, common_;1472 std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_;1473};1474 1475} // namespace1476 1477// Create a list of diff hunks in Unified diff format.1478// Each hunk has a header generated by PrintHeader above plus a body with1479// lines prefixed with ' ' for no change, '-' for deletion and '+' for1480// addition.1481// 'context' represents the desired unchanged prefix/suffix around the diff.1482// If two hunks are close enough that their contexts overlap, then they are1483// joined into one hunk.1484std::string CreateUnifiedDiff(const std::vector<std::string>& left,1485 const std::vector<std::string>& right,1486 size_t context) {1487 const std::vector<EditType> edits = CalculateOptimalEdits(left, right);1488 1489 size_t l_i = 0, r_i = 0, edit_i = 0;1490 std::stringstream ss;1491 while (edit_i < edits.size()) {1492 // Find first edit.1493 while (edit_i < edits.size() && edits[edit_i] == kMatch) {1494 ++l_i;1495 ++r_i;1496 ++edit_i;1497 }1498 1499 // Find the first line to include in the hunk.1500 const size_t prefix_context = std::min(l_i, context);1501 Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);1502 for (size_t i = prefix_context; i > 0; --i) {1503 hunk.PushLine(' ', left[l_i - i].c_str());1504 }1505 1506 // Iterate the edits until we found enough suffix for the hunk or the input1507 // is over.1508 size_t n_suffix = 0;1509 for (; edit_i < edits.size(); ++edit_i) {1510 if (n_suffix >= context) {1511 // Continue only if the next hunk is very close.1512 auto it = edits.begin() + static_cast<int>(edit_i);1513 while (it != edits.end() && *it == kMatch) ++it;1514 if (it == edits.end() ||1515 static_cast<size_t>(it - edits.begin()) - edit_i >= context) {1516 // There is no next edit or it is too far away.1517 break;1518 }1519 }1520 1521 EditType edit = edits[edit_i];1522 // Reset count when a non match is found.1523 n_suffix = edit == kMatch ? n_suffix + 1 : 0;1524 1525 if (edit == kMatch || edit == kRemove || edit == kReplace) {1526 hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());1527 }1528 if (edit == kAdd || edit == kReplace) {1529 hunk.PushLine('+', right[r_i].c_str());1530 }1531 1532 // Advance indices, depending on edit type.1533 l_i += edit != kAdd;1534 r_i += edit != kRemove;1535 }1536 1537 if (!hunk.has_edits()) {1538 // We are done. We don't want this hunk.1539 break;1540 }1541 1542 hunk.PrintTo(&ss);1543 }1544 return ss.str();1545}1546 1547} // namespace edit_distance1548 1549namespace {1550 1551// The string representation of the values received in EqFailure() are already1552// escaped. Split them on escaped '\n' boundaries. Leave all other escaped1553// characters the same.1554std::vector<std::string> SplitEscapedString(const std::string& str) {1555 std::vector<std::string> lines;1556 size_t start = 0, end = str.size();1557 if (end > 2 && str[0] == '"' && str[end - 1] == '"') {1558 ++start;1559 --end;1560 }1561 bool escaped = false;1562 for (size_t i = start; i + 1 < end; ++i) {1563 if (escaped) {1564 escaped = false;1565 if (str[i] == 'n') {1566 lines.push_back(str.substr(start, i - start - 1));1567 start = i + 1;1568 }1569 } else {1570 escaped = str[i] == '\\';1571 }1572 }1573 lines.push_back(str.substr(start, end - start));1574 return lines;1575}1576 1577} // namespace1578 1579// Constructs and returns the message for an equality assertion1580// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.1581//1582// The first four parameters are the expressions used in the assertion1583// and their values, as strings. For example, for ASSERT_EQ(foo, bar)1584// where foo is 5 and bar is 6, we have:1585//1586// lhs_expression: "foo"1587// rhs_expression: "bar"1588// lhs_value: "5"1589// rhs_value: "6"1590//1591// The ignoring_case parameter is true if and only if the assertion is a1592// *_STRCASEEQ*. When it's true, the string "Ignoring case" will1593// be inserted into the message.1594AssertionResult EqFailure(const char* lhs_expression,1595 const char* rhs_expression,1596 const std::string& lhs_value,1597 const std::string& rhs_value, bool ignoring_case) {1598 Message msg;1599 msg << "Expected equality of these values:";1600 msg << "\n " << lhs_expression;1601 if (lhs_value != lhs_expression) {1602 msg << "\n Which is: " << lhs_value;1603 }1604 msg << "\n " << rhs_expression;1605 if (rhs_value != rhs_expression) {1606 msg << "\n Which is: " << rhs_value;1607 }1608 1609 if (ignoring_case) {1610 msg << "\nIgnoring case";1611 }1612 1613 if (!lhs_value.empty() && !rhs_value.empty()) {1614 const std::vector<std::string> lhs_lines = SplitEscapedString(lhs_value);1615 const std::vector<std::string> rhs_lines = SplitEscapedString(rhs_value);1616 if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {1617 msg << "\nWith diff:\n"1618 << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);1619 }1620 }1621 1622 return AssertionFailure() << msg;1623}1624 1625// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.1626std::string GetBoolAssertionFailureMessage(1627 const AssertionResult& assertion_result, const char* expression_text,1628 const char* actual_predicate_value, const char* expected_predicate_value) {1629 const char* actual_message = assertion_result.message();1630 Message msg;1631 msg << "Value of: " << expression_text1632 << "\n Actual: " << actual_predicate_value;1633 if (actual_message[0] != '\0') msg << " (" << actual_message << ")";1634 msg << "\nExpected: " << expected_predicate_value;1635 return msg.GetString();1636}1637 1638// Helper function for implementing ASSERT_NEAR.1639AssertionResult DoubleNearPredFormat(const char* expr1, const char* expr2,1640 const char* abs_error_expr, double val1,1641 double val2, double abs_error) {1642 const double diff = fabs(val1 - val2);1643 if (diff <= abs_error) return AssertionSuccess();1644 1645 // Find the value which is closest to zero.1646 const double min_abs = std::min(fabs(val1), fabs(val2));1647 // Find the distance to the next double from that value.1648 const double epsilon =1649 nextafter(min_abs, std::numeric_limits<double>::infinity()) - min_abs;1650 // Detect the case where abs_error is so small that EXPECT_NEAR is1651 // effectively the same as EXPECT_EQUAL, and give an informative error1652 // message so that the situation can be more easily understood without1653 // requiring exotic floating-point knowledge.1654 // Don't do an epsilon check if abs_error is zero because that implies1655 // that an equality check was actually intended.1656 if (!(std::isnan)(val1) && !(std::isnan)(val2) && abs_error > 0 &&1657 abs_error < epsilon) {1658 return AssertionFailure()1659 << "The difference between " << expr1 << " and " << expr2 << " is "1660 << diff << ", where\n"1661 << expr1 << " evaluates to " << val1 << ",\n"1662 << expr2 << " evaluates to " << val2 << ".\nThe abs_error parameter "1663 << abs_error_expr << " evaluates to " << abs_error1664 << " which is smaller than the minimum distance between doubles for "1665 "numbers of this magnitude which is "1666 << epsilon1667 << ", thus making this EXPECT_NEAR check equivalent to "1668 "EXPECT_EQUAL. Consider using EXPECT_DOUBLE_EQ instead.";1669 }1670 return AssertionFailure()1671 << "The difference between " << expr1 << " and " << expr2 << " is "1672 << diff << ", which exceeds " << abs_error_expr << ", where\n"1673 << expr1 << " evaluates to " << val1 << ",\n"1674 << expr2 << " evaluates to " << val2 << ", and\n"1675 << abs_error_expr << " evaluates to " << abs_error << ".";1676}1677 1678// Helper template for implementing FloatLE() and DoubleLE().1679template <typename RawType>1680AssertionResult FloatingPointLE(const char* expr1, const char* expr2,1681 RawType val1, RawType val2) {1682 // Returns success if val1 is less than val2,1683 if (val1 < val2) {1684 return AssertionSuccess();1685 }1686 1687 // or if val1 is almost equal to val2.1688 const FloatingPoint<RawType> lhs(val1), rhs(val2);1689 if (lhs.AlmostEquals(rhs)) {1690 return AssertionSuccess();1691 }1692 1693 // Note that the above two checks will both fail if either val1 or1694 // val2 is NaN, as the IEEE floating-point standard requires that1695 // any predicate involving a NaN must return false.1696 1697 ::std::stringstream val1_ss;1698 val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)1699 << val1;1700 1701 ::std::stringstream val2_ss;1702 val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)1703 << val2;1704 1705 return AssertionFailure()1706 << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"1707 << " Actual: " << StringStreamToString(&val1_ss) << " vs "1708 << StringStreamToString(&val2_ss);1709}1710 1711} // namespace internal1712 1713// Asserts that val1 is less than, or almost equal to, val2. Fails1714// otherwise. In particular, it fails if either val1 or val2 is NaN.1715AssertionResult FloatLE(const char* expr1, const char* expr2, float val1,1716 float val2) {1717 return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);1718}1719 1720// Asserts that val1 is less than, or almost equal to, val2. Fails1721// otherwise. In particular, it fails if either val1 or val2 is NaN.1722AssertionResult DoubleLE(const char* expr1, const char* expr2, double val1,1723 double val2) {1724 return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);1725}1726 1727namespace internal {1728 1729// The helper function for {ASSERT|EXPECT}_STREQ.1730AssertionResult CmpHelperSTREQ(const char* lhs_expression,1731 const char* rhs_expression, const char* lhs,1732 const char* rhs) {1733 if (String::CStringEquals(lhs, rhs)) {1734 return AssertionSuccess();1735 }1736 1737 return EqFailure(lhs_expression, rhs_expression, PrintToString(lhs),1738 PrintToString(rhs), false);1739}1740 1741// The helper function for {ASSERT|EXPECT}_STRCASEEQ.1742AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,1743 const char* rhs_expression, const char* lhs,1744 const char* rhs) {1745 if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {1746 return AssertionSuccess();1747 }1748 1749 return EqFailure(lhs_expression, rhs_expression, PrintToString(lhs),1750 PrintToString(rhs), true);1751}1752 1753// The helper function for {ASSERT|EXPECT}_STRNE.1754AssertionResult CmpHelperSTRNE(const char* s1_expression,1755 const char* s2_expression, const char* s1,1756 const char* s2) {1757 if (!String::CStringEquals(s1, s2)) {1758 return AssertionSuccess();1759 } else {1760 return AssertionFailure()1761 << "Expected: (" << s1_expression << ") != (" << s2_expression1762 << "), actual: \"" << s1 << "\" vs \"" << s2 << "\"";1763 }1764}1765 1766// The helper function for {ASSERT|EXPECT}_STRCASENE.1767AssertionResult CmpHelperSTRCASENE(const char* s1_expression,1768 const char* s2_expression, const char* s1,1769 const char* s2) {1770 if (!String::CaseInsensitiveCStringEquals(s1, s2)) {1771 return AssertionSuccess();1772 } else {1773 return AssertionFailure()1774 << "Expected: (" << s1_expression << ") != (" << s2_expression1775 << ") (ignoring case), actual: \"" << s1 << "\" vs \"" << s2 << "\"";1776 }1777}1778 1779} // namespace internal1780 1781namespace {1782 1783// Helper functions for implementing IsSubString() and IsNotSubstring().1784 1785// This group of overloaded functions return true if and only if needle1786// is a substring of haystack. NULL is considered a substring of1787// itself only.1788 1789bool IsSubstringPred(const char* needle, const char* haystack) {1790 if (needle == nullptr || haystack == nullptr) return needle == haystack;1791 1792 return strstr(haystack, needle) != nullptr;1793}1794 1795bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {1796 if (needle == nullptr || haystack == nullptr) return needle == haystack;1797 1798 return wcsstr(haystack, needle) != nullptr;1799}1800 1801// StringType here can be either ::std::string or ::std::wstring.1802template <typename StringType>1803bool IsSubstringPred(const StringType& needle, const StringType& haystack) {1804 return haystack.find(needle) != StringType::npos;1805}1806 1807// This function implements either IsSubstring() or IsNotSubstring(),1808// depending on the value of the expected_to_be_substring parameter.1809// StringType here can be const char*, const wchar_t*, ::std::string,1810// or ::std::wstring.1811template <typename StringType>1812AssertionResult IsSubstringImpl(bool expected_to_be_substring,1813 const char* needle_expr,1814 const char* haystack_expr,1815 const StringType& needle,1816 const StringType& haystack) {1817 if (IsSubstringPred(needle, haystack) == expected_to_be_substring)1818 return AssertionSuccess();1819 1820 const bool is_wide_string = sizeof(needle[0]) > 1;1821 const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";1822 return AssertionFailure()1823 << "Value of: " << needle_expr << "\n"1824 << " Actual: " << begin_string_quote << needle << "\"\n"1825 << "Expected: " << (expected_to_be_substring ? "" : "not ")1826 << "a substring of " << haystack_expr << "\n"1827 << "Which is: " << begin_string_quote << haystack << "\"";1828}1829 1830} // namespace1831 1832// IsSubstring() and IsNotSubstring() check whether needle is a1833// substring of haystack (NULL is considered a substring of itself1834// only), and return an appropriate error message when they fail.1835 1836AssertionResult IsSubstring(const char* needle_expr, const char* haystack_expr,1837 const char* needle, const char* haystack) {1838 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);1839}1840 1841AssertionResult IsSubstring(const char* needle_expr, const char* haystack_expr,1842 const wchar_t* needle, const wchar_t* haystack) {1843 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);1844}1845 1846AssertionResult IsNotSubstring(const char* needle_expr,1847 const char* haystack_expr, const char* needle,1848 const char* haystack) {1849 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);1850}1851 1852AssertionResult IsNotSubstring(const char* needle_expr,1853 const char* haystack_expr, const wchar_t* needle,1854 const wchar_t* haystack) {1855 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);1856}1857 1858AssertionResult IsSubstring(const char* needle_expr, const char* haystack_expr,1859 const ::std::string& needle,1860 const ::std::string& haystack) {1861 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);1862}1863 1864AssertionResult IsNotSubstring(const char* needle_expr,1865 const char* haystack_expr,1866 const ::std::string& needle,1867 const ::std::string& haystack) {1868 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);1869}1870 1871#if GTEST_HAS_STD_WSTRING1872AssertionResult IsSubstring(const char* needle_expr, const char* haystack_expr,1873 const ::std::wstring& needle,1874 const ::std::wstring& haystack) {1875 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);1876}1877 1878AssertionResult IsNotSubstring(const char* needle_expr,1879 const char* haystack_expr,1880 const ::std::wstring& needle,1881 const ::std::wstring& haystack) {1882 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);1883}1884#endif // GTEST_HAS_STD_WSTRING1885 1886namespace internal {1887 1888#ifdef GTEST_OS_WINDOWS1889 1890namespace {1891 1892// Helper function for IsHRESULT{SuccessFailure} predicates1893AssertionResult HRESULTFailureHelper(const char* expr, const char* expected,1894 long hr) { // NOLINT1895#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_TV_TITLE)1896 1897 // Windows CE doesn't support FormatMessage.1898 const char error_text[] = "";1899 1900#else1901 1902 // Looks up the human-readable system message for the HRESULT code1903 // and since we're not passing any params to FormatMessage, we don't1904 // want inserts expanded.1905 const DWORD kFlags =1906 FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;1907 const DWORD kBufSize = 4096;1908 // Gets the system's human readable message string for this HRESULT.1909 char error_text[kBufSize] = {'\0'};1910 DWORD message_length = ::FormatMessageA(kFlags,1911 0, // no source, we're asking system1912 static_cast<DWORD>(hr), // the error1913 0, // no line width restrictions1914 error_text, // output buffer1915 kBufSize, // buf size1916 nullptr); // no arguments for inserts1917 // Trims tailing white space (FormatMessage leaves a trailing CR-LF)1918 for (; message_length && IsSpace(error_text[message_length - 1]);1919 --message_length) {1920 error_text[message_length - 1] = '\0';1921 }1922 1923#endif // GTEST_OS_WINDOWS_MOBILE1924 1925 const std::string error_hex("0x" + String::FormatHexInt(hr));1926 return ::testing::AssertionFailure()1927 << "Expected: " << expr << " " << expected << ".\n"1928 << " Actual: " << error_hex << " " << error_text << "\n";1929}1930 1931} // namespace1932 1933AssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT1934 if (SUCCEEDED(hr)) {1935 return AssertionSuccess();1936 }1937 return HRESULTFailureHelper(expr, "succeeds", hr);1938}1939 1940AssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT1941 if (FAILED(hr)) {1942 return AssertionSuccess();1943 }1944 return HRESULTFailureHelper(expr, "fails", hr);1945}1946 1947#endif // GTEST_OS_WINDOWS1948 1949// Utility functions for encoding Unicode text (wide strings) in1950// UTF-8.1951 1952// A Unicode code-point can have up to 21 bits, and is encoded in UTF-81953// like this:1954//1955// Code-point length Encoding1956// 0 - 7 bits 0xxxxxxx1957// 8 - 11 bits 110xxxxx 10xxxxxx1958// 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx1959// 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx1960 1961// The maximum code-point a one-byte UTF-8 sequence can represent.1962constexpr uint32_t kMaxCodePoint1 = (static_cast<uint32_t>(1) << 7) - 1;1963 1964// The maximum code-point a two-byte UTF-8 sequence can represent.1965constexpr uint32_t kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1;1966 1967// The maximum code-point a three-byte UTF-8 sequence can represent.1968constexpr uint32_t kMaxCodePoint3 =1969 (static_cast<uint32_t>(1) << (4 + 2 * 6)) - 1;1970 1971// The maximum code-point a four-byte UTF-8 sequence can represent.1972constexpr uint32_t kMaxCodePoint4 =1973 (static_cast<uint32_t>(1) << (3 + 3 * 6)) - 1;1974 1975// Chops off the n lowest bits from a bit pattern. Returns the n1976// lowest bits. As a side effect, the original bit pattern will be1977// shifted to the right by n bits.1978inline uint32_t ChopLowBits(uint32_t* bits, int n) {1979 const uint32_t low_bits = *bits & ((static_cast<uint32_t>(1) << n) - 1);1980 *bits >>= n;1981 return low_bits;1982}1983 1984// Converts a Unicode code point to a narrow string in UTF-8 encoding.1985// code_point parameter is of type uint32_t because wchar_t may not be1986// wide enough to contain a code point.1987// If the code_point is not a valid Unicode code point1988// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted1989// to "(Invalid Unicode 0xXXXXXXXX)".1990std::string CodePointToUtf8(uint32_t code_point) {1991 if (code_point > kMaxCodePoint4) {1992 return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")";1993 }1994 1995 char str[5]; // Big enough for the largest valid code point.1996 if (code_point <= kMaxCodePoint1) {1997 str[1] = '\0';1998 str[0] = static_cast<char>(code_point); // 0xxxxxxx1999 } else if (code_point <= kMaxCodePoint2) {2000 str[2] = '\0';2001 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx2002 str[0] = static_cast<char>(0xC0 | code_point); // 110xxxxx2003 } else if (code_point <= kMaxCodePoint3) {2004 str[3] = '\0';2005 str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx2006 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx2007 str[0] = static_cast<char>(0xE0 | code_point); // 1110xxxx2008 } else { // code_point <= kMaxCodePoint42009 str[4] = '\0';2010 str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx2011 str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx2012 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx2013 str[0] = static_cast<char>(0xF0 | code_point); // 11110xxx2014 }2015 return str;2016}2017 2018// The following two functions only make sense if the system2019// uses UTF-16 for wide string encoding. All supported systems2020// with 16 bit wchar_t (Windows, Cygwin) do use UTF-16.2021 2022// Determines if the arguments constitute UTF-16 surrogate pair2023// and thus should be combined into a single Unicode code point2024// using CreateCodePointFromUtf16SurrogatePair.2025inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {2026 return sizeof(wchar_t) == 2 && (first & 0xFC00) == 0xD800 &&2027 (second & 0xFC00) == 0xDC00;2028}2029 2030// Creates a Unicode code point from UTF16 surrogate pair.2031inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,2032 wchar_t second) {2033 const auto first_u = static_cast<uint32_t>(first);2034 const auto second_u = static_cast<uint32_t>(second);2035 const uint32_t mask = (1 << 10) - 1;2036 return (sizeof(wchar_t) == 2)2037 ? (((first_u & mask) << 10) | (second_u & mask)) + 0x100002038 :2039 // This function should not be called when the condition is2040 // false, but we provide a sensible default in case it is.2041 first_u;2042}2043 2044// Converts a wide string to a narrow string in UTF-8 encoding.2045// The wide string is assumed to have the following encoding:2046// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)2047// UTF-32 if sizeof(wchar_t) == 4 (on Linux)2048// Parameter str points to a null-terminated wide string.2049// Parameter num_chars may additionally limit the number2050// of wchar_t characters processed. -1 is used when the entire string2051// should be processed.2052// If the string contains code points that are not valid Unicode code points2053// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output2054// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding2055// and contains invalid UTF-16 surrogate pairs, values in those pairs2056// will be encoded as individual Unicode characters from Basic Normal Plane.2057std::string WideStringToUtf8(const wchar_t* str, int num_chars) {2058 if (num_chars == -1) num_chars = static_cast<int>(wcslen(str));2059 2060 ::std::stringstream stream;2061 for (int i = 0; i < num_chars; ++i) {2062 uint32_t unicode_code_point;2063 2064 if (str[i] == L'\0') {2065 break;2066 } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {2067 unicode_code_point =2068 CreateCodePointFromUtf16SurrogatePair(str[i], str[i + 1]);2069 i++;2070 } else {2071 unicode_code_point = static_cast<uint32_t>(str[i]);2072 }2073 2074 stream << CodePointToUtf8(unicode_code_point);2075 }2076 return StringStreamToString(&stream);2077}2078 2079// Converts a wide C string to an std::string using the UTF-8 encoding.2080// NULL will be converted to "(null)".2081std::string String::ShowWideCString(const wchar_t* wide_c_str) {2082 if (wide_c_str == nullptr) return "(null)";2083 2084 return internal::WideStringToUtf8(wide_c_str, -1);2085}2086 2087// Compares two wide C strings. Returns true if and only if they have the2088// same content.2089//2090// Unlike wcscmp(), this function can handle NULL argument(s). A NULL2091// C string is considered different to any non-NULL C string,2092// including the empty string.2093bool String::WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs) {2094 if (lhs == nullptr) return rhs == nullptr;2095 2096 if (rhs == nullptr) return false;2097 2098 return wcscmp(lhs, rhs) == 0;2099}2100 2101// Helper function for *_STREQ on wide strings.2102AssertionResult CmpHelperSTREQ(const char* lhs_expression,2103 const char* rhs_expression, const wchar_t* lhs,2104 const wchar_t* rhs) {2105 if (String::WideCStringEquals(lhs, rhs)) {2106 return AssertionSuccess();2107 }2108 2109 return EqFailure(lhs_expression, rhs_expression, PrintToString(lhs),2110 PrintToString(rhs), false);2111}2112 2113// Helper function for *_STRNE on wide strings.2114AssertionResult CmpHelperSTRNE(const char* s1_expression,2115 const char* s2_expression, const wchar_t* s1,2116 const wchar_t* s2) {2117 if (!String::WideCStringEquals(s1, s2)) {2118 return AssertionSuccess();2119 }2120 2121 return AssertionFailure()2122 << "Expected: (" << s1_expression << ") != (" << s2_expression2123 << "), actual: " << PrintToString(s1) << " vs " << PrintToString(s2);2124}2125 2126// Compares two C strings, ignoring case. Returns true if and only if they have2127// the same content.2128//2129// Unlike strcasecmp(), this function can handle NULL argument(s). A2130// NULL C string is considered different to any non-NULL C string,2131// including the empty string.2132bool String::CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {2133 if (lhs == nullptr) return rhs == nullptr;2134 if (rhs == nullptr) return false;2135 return posix::StrCaseCmp(lhs, rhs) == 0;2136}2137 2138// Compares two wide C strings, ignoring case. Returns true if and only if they2139// have the same content.2140//2141// Unlike wcscasecmp(), this function can handle NULL argument(s).2142// A NULL C string is considered different to any non-NULL wide C string,2143// including the empty string.2144// NB: The implementations on different platforms slightly differ.2145// On windows, this method uses _wcsicmp which compares according to LC_CTYPE2146// environment variable. On GNU platform this method uses wcscasecmp2147// which compares according to LC_CTYPE category of the current locale.2148// On MacOS X, it uses towlower, which also uses LC_CTYPE category of the2149// current locale.2150bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,2151 const wchar_t* rhs) {2152 if (lhs == nullptr) return rhs == nullptr;2153 2154 if (rhs == nullptr) return false;2155 2156#ifdef GTEST_OS_WINDOWS2157 return _wcsicmp(lhs, rhs) == 0;2158#elif defined(GTEST_OS_LINUX) && !defined(GTEST_OS_LINUX_ANDROID)2159 return wcscasecmp(lhs, rhs) == 0;2160#else2161 // Android, Mac OS X and Cygwin don't define wcscasecmp.2162 // Other unknown OSes may not define it either.2163 wint_t left, right;2164 do {2165 left = towlower(static_cast<wint_t>(*lhs++));2166 right = towlower(static_cast<wint_t>(*rhs++));2167 } while (left && left == right);2168 return left == right;2169#endif // OS selector2170}2171 2172// Returns true if and only if str ends with the given suffix, ignoring case.2173// Any string is considered to end with an empty suffix.2174bool String::EndsWithCaseInsensitive(const std::string& str,2175 const std::string& suffix) {2176 const size_t str_len = str.length();2177 const size_t suffix_len = suffix.length();2178 return (str_len >= suffix_len) &&2179 CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,2180 suffix.c_str());2181}2182 2183// Formats an int value as "%02d".2184std::string String::FormatIntWidth2(int value) {2185 return FormatIntWidthN(value, 2);2186}2187 2188// Formats an int value to given width with leading zeros.2189std::string String::FormatIntWidthN(int value, int width) {2190 std::stringstream ss;2191 ss << std::setfill('0') << std::setw(width) << value;2192 return ss.str();2193}2194 2195// Formats an int value as "%X".2196std::string String::FormatHexUInt32(uint32_t value) {2197 std::stringstream ss;2198 ss << std::hex << std::uppercase << value;2199 return ss.str();2200}2201 2202// Formats an int value as "%X".2203std::string String::FormatHexInt(int value) {2204 return FormatHexUInt32(static_cast<uint32_t>(value));2205}2206 2207// Formats a byte as "%02X".2208std::string String::FormatByte(unsigned char value) {2209 std::stringstream ss;2210 ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase2211 << static_cast<unsigned int>(value);2212 return ss.str();2213}2214 2215// Converts the buffer in a stringstream to an std::string, converting NUL2216// bytes to "\\0" along the way.2217std::string StringStreamToString(::std::stringstream* ss) {2218 const ::std::string& str = ss->str();2219 const char* const start = str.c_str();2220 const char* const end = start + str.length();2221 2222 std::string result;2223 result.reserve(static_cast<size_t>(2 * (end - start)));2224 for (const char* ch = start; ch != end; ++ch) {2225 if (*ch == '\0') {2226 result += "\\0"; // Replaces NUL with "\\0";2227 } else {2228 result += *ch;2229 }2230 }2231 2232 return result;2233}2234 2235// Appends the user-supplied message to the Google-Test-generated message.2236std::string AppendUserMessage(const std::string& gtest_msg,2237 const Message& user_msg) {2238 // Appends the user message if it's non-empty.2239 const std::string user_msg_string = user_msg.GetString();2240 if (user_msg_string.empty()) {2241 return gtest_msg;2242 }2243 if (gtest_msg.empty()) {2244 return user_msg_string;2245 }2246 return gtest_msg + "\n" + user_msg_string;2247}2248 2249} // namespace internal2250 2251// class TestResult2252 2253// Creates an empty TestResult.2254TestResult::TestResult()2255 : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}2256 2257// D'tor.2258TestResult::~TestResult() = default;2259 2260// Returns the i-th test part result among all the results. i can2261// range from 0 to total_part_count() - 1. If i is not in that range,2262// aborts the program.2263const TestPartResult& TestResult::GetTestPartResult(int i) const {2264 if (i < 0 || i >= total_part_count()) internal::posix::Abort();2265 return test_part_results_.at(static_cast<size_t>(i));2266}2267 2268// Returns the i-th test property. i can range from 0 to2269// test_property_count() - 1. If i is not in that range, aborts the2270// program.2271const TestProperty& TestResult::GetTestProperty(int i) const {2272 if (i < 0 || i >= test_property_count()) internal::posix::Abort();2273 return test_properties_.at(static_cast<size_t>(i));2274}2275 2276// Clears the test part results.2277void TestResult::ClearTestPartResults() { test_part_results_.clear(); }2278 2279// Adds a test part result to the list.2280void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {2281 test_part_results_.push_back(test_part_result);2282}2283 2284// Adds a test property to the list. If a property with the same key as the2285// supplied property is already represented, the value of this test_property2286// replaces the old value for that key.2287void TestResult::RecordProperty(const std::string& xml_element,2288 const TestProperty& test_property) {2289 if (!ValidateTestProperty(xml_element, test_property)) {2290 return;2291 }2292 internal::MutexLock lock(&test_properties_mutex_);2293 const std::vector<TestProperty>::iterator property_with_matching_key =2294 std::find_if(test_properties_.begin(), test_properties_.end(),2295 internal::TestPropertyKeyIs(test_property.key()));2296 if (property_with_matching_key == test_properties_.end()) {2297 test_properties_.push_back(test_property);2298 return;2299 }2300 property_with_matching_key->SetValue(test_property.value());2301}2302 2303// The list of reserved attributes used in the <testsuites> element of XML2304// output.2305static const char* const kReservedTestSuitesAttributes[] = {2306 "disabled", "errors", "failures", "name",2307 "random_seed", "tests", "time", "timestamp"};2308 2309// The list of reserved attributes used in the <testsuite> element of XML2310// output.2311static const char* const kReservedTestSuiteAttributes[] = {2312 "disabled", "errors", "failures", "name",2313 "tests", "time", "timestamp", "skipped"};2314 2315// The list of reserved attributes used in the <testcase> element of XML output.2316static const char* const kReservedTestCaseAttributes[] = {2317 "classname", "name", "status", "time",2318 "type_param", "value_param", "file", "line"};2319 2320// Use a slightly different set for allowed output to ensure existing tests can2321// still RecordProperty("result") or "RecordProperty(timestamp")2322static const char* const kReservedOutputTestCaseAttributes[] = {2323 "classname", "name", "status", "time", "type_param",2324 "value_param", "file", "line", "result", "timestamp"};2325 2326template <size_t kSize>2327std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {2328 return std::vector<std::string>(array, array + kSize);2329}2330 2331static std::vector<std::string> GetReservedAttributesForElement(2332 const std::string& xml_element) {2333 if (xml_element == "testsuites") {2334 return ArrayAsVector(kReservedTestSuitesAttributes);2335 } else if (xml_element == "testsuite") {2336 return ArrayAsVector(kReservedTestSuiteAttributes);2337 } else if (xml_element == "testcase") {2338 return ArrayAsVector(kReservedTestCaseAttributes);2339 } else {2340 GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;2341 }2342 // This code is unreachable but some compilers may not realizes that.2343 return std::vector<std::string>();2344}2345 2346#if GTEST_HAS_FILE_SYSTEM2347// TODO(jdesprez): Merge the two getReserved attributes once skip is improved2348// This function is only used when file systems are enabled.2349static std::vector<std::string> GetReservedOutputAttributesForElement(2350 const std::string& xml_element) {2351 if (xml_element == "testsuites") {2352 return ArrayAsVector(kReservedTestSuitesAttributes);2353 } else if (xml_element == "testsuite") {2354 return ArrayAsVector(kReservedTestSuiteAttributes);2355 } else if (xml_element == "testcase") {2356 return ArrayAsVector(kReservedOutputTestCaseAttributes);2357 } else {2358 GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;2359 }2360 // This code is unreachable but some compilers may not realizes that.2361 return std::vector<std::string>();2362}2363#endif2364 2365static std::string FormatWordList(const std::vector<std::string>& words) {2366 Message word_list;2367 for (size_t i = 0; i < words.size(); ++i) {2368 if (i > 0 && words.size() > 2) {2369 word_list << ", ";2370 }2371 if (i == words.size() - 1) {2372 word_list << "and ";2373 }2374 word_list << "'" << words[i] << "'";2375 }2376 return word_list.GetString();2377}2378 2379static bool ValidateTestPropertyName(2380 const std::string& property_name,2381 const std::vector<std::string>& reserved_names) {2382 if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=2383 reserved_names.end()) {2384 ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name2385 << " (" << FormatWordList(reserved_names)2386 << " are reserved by " << GTEST_NAME_ << ")";2387 return false;2388 }2389 return true;2390}2391 2392// Adds a failure if the key is a reserved attribute of the element named2393// xml_element. Returns true if the property is valid.2394bool TestResult::ValidateTestProperty(const std::string& xml_element,2395 const TestProperty& test_property) {2396 return ValidateTestPropertyName(test_property.key(),2397 GetReservedAttributesForElement(xml_element));2398}2399 2400// Clears the object.2401void TestResult::Clear() {2402 test_part_results_.clear();2403 test_properties_.clear();2404 death_test_count_ = 0;2405 elapsed_time_ = 0;2406}2407 2408// Returns true off the test part was skipped.2409static bool TestPartSkipped(const TestPartResult& result) {2410 return result.skipped();2411}2412 2413// Returns true if and only if the test was skipped.2414bool TestResult::Skipped() const {2415 return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;2416}2417 2418// Returns true if and only if the test failed.2419bool TestResult::Failed() const {2420 for (int i = 0; i < total_part_count(); ++i) {2421 if (GetTestPartResult(i).failed()) return true;2422 }2423 return false;2424}2425 2426// Returns true if and only if the test part fatally failed.2427static bool TestPartFatallyFailed(const TestPartResult& result) {2428 return result.fatally_failed();2429}2430 2431// Returns true if and only if the test fatally failed.2432bool TestResult::HasFatalFailure() const {2433 return CountIf(test_part_results_, TestPartFatallyFailed) > 0;2434}2435 2436// Returns true if and only if the test part non-fatally failed.2437static bool TestPartNonfatallyFailed(const TestPartResult& result) {2438 return result.nonfatally_failed();2439}2440 2441// Returns true if and only if the test has a non-fatal failure.2442bool TestResult::HasNonfatalFailure() const {2443 return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;2444}2445 2446// Gets the number of all test parts. This is the sum of the number2447// of successful test parts and the number of failed test parts.2448int TestResult::total_part_count() const {2449 return static_cast<int>(test_part_results_.size());2450}2451 2452// Returns the number of the test properties.2453int TestResult::test_property_count() const {2454 return static_cast<int>(test_properties_.size());2455}2456 2457// class Test2458 2459// Creates a Test object.2460 2461// The c'tor saves the states of all flags.2462Test::Test() : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {}2463 2464// The d'tor restores the states of all flags. The actual work is2465// done by the d'tor of the gtest_flag_saver_ field, and thus not2466// visible here.2467Test::~Test() = default;2468 2469// Sets up the test fixture.2470//2471// A sub-class may override this.2472void Test::SetUp() {}2473 2474// Tears down the test fixture.2475//2476// A sub-class may override this.2477void Test::TearDown() {}2478 2479// Allows user supplied key value pairs to be recorded for later output.2480void Test::RecordProperty(const std::string& key, const std::string& value) {2481 UnitTest::GetInstance()->RecordProperty(key, value);2482}2483 2484namespace internal {2485 2486void ReportFailureInUnknownLocation(TestPartResult::Type result_type,2487 const std::string& message) {2488 // This function is a friend of UnitTest and as such has access to2489 // AddTestPartResult.2490 UnitTest::GetInstance()->AddTestPartResult(2491 result_type,2492 nullptr, // No info about the source file where the exception occurred.2493 -1, // We have no info on which line caused the exception.2494 message,2495 ""); // No stack trace, either.2496}2497 2498} // namespace internal2499 2500// Google Test requires all tests in the same test suite to use the same test2501// fixture class. This function checks if the current test has the2502// same fixture class as the first test in the current test suite. If2503// yes, it returns true; otherwise it generates a Google Test failure and2504// returns false.2505bool Test::HasSameFixtureClass() {2506 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();2507 const TestSuite* const test_suite = impl->current_test_suite();2508 2509 // Info about the first test in the current test suite.2510 const TestInfo* const first_test_info = test_suite->test_info_list()[0];2511 const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;2512 const char* const first_test_name = first_test_info->name();2513 2514 // Info about the current test.2515 const TestInfo* const this_test_info = impl->current_test_info();2516 const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;2517 const char* const this_test_name = this_test_info->name();2518 2519 if (this_fixture_id != first_fixture_id) {2520 // Is the first test defined using TEST?2521 const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();2522 // Is this test defined using TEST?2523 const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();2524 2525 if (first_is_TEST || this_is_TEST) {2526 // Both TEST and TEST_F appear in same test suite, which is incorrect.2527 // Tell the user how to fix this.2528 2529 // Gets the name of the TEST and the name of the TEST_F. Note2530 // that first_is_TEST and this_is_TEST cannot both be true, as2531 // the fixture IDs are different for the two tests.2532 const char* const TEST_name =2533 first_is_TEST ? first_test_name : this_test_name;2534 const char* const TEST_F_name =2535 first_is_TEST ? this_test_name : first_test_name;2536 2537 ADD_FAILURE()2538 << "All tests in the same test suite must use the same test fixture\n"2539 << "class, so mixing TEST_F and TEST in the same test suite is\n"2540 << "illegal. In test suite " << this_test_info->test_suite_name()2541 << ",\n"2542 << "test " << TEST_F_name << " is defined using TEST_F but\n"2543 << "test " << TEST_name << " is defined using TEST. You probably\n"2544 << "want to change the TEST to TEST_F or move it to another test\n"2545 << "case.";2546 } else {2547 // Two fixture classes with the same name appear in two different2548 // namespaces, which is not allowed. Tell the user how to fix this.2549 ADD_FAILURE()2550 << "All tests in the same test suite must use the same test fixture\n"2551 << "class. However, in test suite "2552 << this_test_info->test_suite_name() << ",\n"2553 << "you defined test " << first_test_name << " and test "2554 << this_test_name << "\n"2555 << "using two different test fixture classes. This can happen if\n"2556 << "the two classes are from different namespaces or translation\n"2557 << "units and have the same name. You should probably rename one\n"2558 << "of the classes to put the tests into different test suites.";2559 }2560 return false;2561 }2562 2563 return true;2564}2565 2566namespace internal {2567 2568#if GTEST_HAS_EXCEPTIONS2569 2570// Adds an "exception thrown" fatal failure to the current test.2571static std::string FormatCxxExceptionMessage(const char* description,2572 const char* location) {2573 Message message;2574 if (description != nullptr) {2575 message << "C++ exception with description \"" << description << "\"";2576 } else {2577 message << "Unknown C++ exception";2578 }2579 message << " thrown in " << location << ".";2580 2581 return message.GetString();2582}2583 2584static std::string PrintTestPartResultToString(2585 const TestPartResult& test_part_result);2586 2587GoogleTestFailureException::GoogleTestFailureException(2588 const TestPartResult& failure)2589 : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}2590 2591#endif // GTEST_HAS_EXCEPTIONS2592 2593// We put these helper functions in the internal namespace as IBM's xlC2594// compiler rejects the code if they were declared static.2595 2596// Runs the given method and handles SEH exceptions it throws, when2597// SEH is supported; returns the 0-value for type Result in case of an2598// SEH exception. (Microsoft compilers cannot handle SEH and C++2599// exceptions in the same function. Therefore, we provide a separate2600// wrapper function for handling SEH exceptions.)2601template <class T, typename Result>2602Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::*method)(),2603 const char* location) {2604#if GTEST_HAS_SEH2605 __try {2606 return (object->*method)();2607 } __except (internal::UnitTestOptions::GTestProcessSEH( // NOLINT2608 GetExceptionCode(), location)) {2609 return static_cast<Result>(0);2610 }2611#else2612 (void)location;2613 return (object->*method)();2614#endif // GTEST_HAS_SEH2615}2616 2617// Runs the given method and catches and reports C++ and/or SEH-style2618// exceptions, if they are supported; returns the 0-value for type2619// Result in case of an SEH exception.2620template <class T, typename Result>2621Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*method)(),2622 const char* location) {2623 // NOTE: The user code can affect the way in which Google Test handles2624 // exceptions by setting GTEST_FLAG(catch_exceptions), but only before2625 // RUN_ALL_TESTS() starts. It is technically possible to check the flag2626 // after the exception is caught and either report or re-throw the2627 // exception based on the flag's value:2628 //2629 // try {2630 // // Perform the test method.2631 // } catch (...) {2632 // if (GTEST_FLAG_GET(catch_exceptions))2633 // // Report the exception as failure.2634 // else2635 // throw; // Re-throws the original exception.2636 // }2637 //2638 // However, the purpose of this flag is to allow the program to drop into2639 // the debugger when the exception is thrown. On most platforms, once the2640 // control enters the catch block, the exception origin information is2641 // lost and the debugger will stop the program at the point of the2642 // re-throw in this function -- instead of at the point of the original2643 // throw statement in the code under test. For this reason, we perform2644 // the check early, sacrificing the ability to affect Google Test's2645 // exception handling in the method where the exception is thrown.2646 if (internal::GetUnitTestImpl()->catch_exceptions()) {2647#if GTEST_HAS_EXCEPTIONS2648 try {2649 return HandleSehExceptionsInMethodIfSupported(object, method, location);2650 } catch (const AssertionException&) { // NOLINT2651 // This failure was reported already.2652 } catch (const internal::GoogleTestFailureException&) { // NOLINT2653 // This exception type can only be thrown by a failed Google2654 // Test assertion with the intention of letting another testing2655 // framework catch it. Therefore we just re-throw it.2656 throw;2657 } catch (const std::exception& e) { // NOLINT2658 internal::ReportFailureInUnknownLocation(2659 TestPartResult::kFatalFailure,2660 FormatCxxExceptionMessage(e.what(), location));2661 } catch (...) { // NOLINT2662 internal::ReportFailureInUnknownLocation(2663 TestPartResult::kFatalFailure,2664 FormatCxxExceptionMessage(nullptr, location));2665 }2666 return static_cast<Result>(0);2667#else2668 return HandleSehExceptionsInMethodIfSupported(object, method, location);2669#endif // GTEST_HAS_EXCEPTIONS2670 } else {2671 return (object->*method)();2672 }2673}2674 2675} // namespace internal2676 2677// Runs the test and updates the test result.2678void Test::Run() {2679 if (!HasSameFixtureClass()) return;2680 2681 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();2682 impl->os_stack_trace_getter()->UponLeavingGTest();2683 internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");2684 // We will run the test only if SetUp() was successful and didn't call2685 // GTEST_SKIP().2686 if (!HasFatalFailure() && !IsSkipped()) {2687 impl->os_stack_trace_getter()->UponLeavingGTest();2688 internal::HandleExceptionsInMethodIfSupported(this, &Test::TestBody,2689 "the test body");2690 }2691 2692 // However, we want to clean up as much as possible. Hence we will2693 // always call TearDown(), even if SetUp() or the test body has2694 // failed.2695 impl->os_stack_trace_getter()->UponLeavingGTest();2696 internal::HandleExceptionsInMethodIfSupported(this, &Test::TearDown,2697 "TearDown()");2698}2699 2700// Returns true if and only if the current test has a fatal failure.2701bool Test::HasFatalFailure() {2702 return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();2703}2704 2705// Returns true if and only if the current test has a non-fatal failure.2706bool Test::HasNonfatalFailure() {2707 return internal::GetUnitTestImpl()2708 ->current_test_result()2709 ->HasNonfatalFailure();2710}2711 2712// Returns true if and only if the current test was skipped.2713bool Test::IsSkipped() {2714 return internal::GetUnitTestImpl()->current_test_result()->Skipped();2715}2716 2717// class TestInfo2718 2719// Constructs a TestInfo object. It assumes ownership of the test factory2720// object.2721TestInfo::TestInfo(const std::string& a_test_suite_name,2722 const std::string& a_name, const char* a_type_param,2723 const char* a_value_param,2724 internal::CodeLocation a_code_location,2725 internal::TypeId fixture_class_id,2726 internal::TestFactoryBase* factory)2727 : test_suite_name_(a_test_suite_name),2728 // begin()/end() is MSVC 17.3.3 ASAN crash workaround (GitHub issue #3997)2729 name_(a_name.begin(), a_name.end()),2730 type_param_(a_type_param ? new std::string(a_type_param) : nullptr),2731 value_param_(a_value_param ? new std::string(a_value_param) : nullptr),2732 location_(a_code_location),2733 fixture_class_id_(fixture_class_id),2734 should_run_(false),2735 is_disabled_(false),2736 matches_filter_(false),2737 is_in_another_shard_(false),2738 factory_(factory),2739 result_() {}2740 2741// Destructs a TestInfo object.2742TestInfo::~TestInfo() { delete factory_; }2743 2744namespace internal {2745 2746// Creates a new TestInfo object and registers it with Google Test;2747// returns the created object.2748//2749// Arguments:2750//2751// test_suite_name: name of the test suite2752// name: name of the test2753// type_param: the name of the test's type parameter, or NULL if2754// this is not a typed or a type-parameterized test.2755// value_param: text representation of the test's value parameter,2756// or NULL if this is not a value-parameterized test.2757// code_location: code location where the test is defined2758// fixture_class_id: ID of the test fixture class2759// set_up_tc: pointer to the function that sets up the test suite2760// tear_down_tc: pointer to the function that tears down the test suite2761// factory: pointer to the factory that creates a test object.2762// The newly created TestInfo instance will assume2763// ownership of the factory object.2764TestInfo* MakeAndRegisterTestInfo(2765 const char* test_suite_name, const char* name, const char* type_param,2766 const char* value_param, CodeLocation code_location,2767 TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,2768 TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {2769 TestInfo* const test_info =2770 new TestInfo(test_suite_name, name, type_param, value_param,2771 code_location, fixture_class_id, factory);2772 GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);2773 return test_info;2774}2775 2776void ReportInvalidTestSuiteType(const char* test_suite_name,2777 CodeLocation code_location) {2778 Message errors;2779 errors2780 << "Attempted redefinition of test suite " << test_suite_name << ".\n"2781 << "All tests in the same test suite must use the same test fixture\n"2782 << "class. However, in test suite " << test_suite_name << ", you tried\n"2783 << "to define a test using a fixture class different from the one\n"2784 << "used earlier. This can happen if the two fixture classes are\n"2785 << "from different namespaces and have the same name. You should\n"2786 << "probably rename one of the classes to put the tests into different\n"2787 << "test suites.";2788 2789 GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),2790 code_location.line)2791 << " " << errors.GetString();2792}2793 2794// This method expands all parameterized tests registered with macros TEST_P2795// and INSTANTIATE_TEST_SUITE_P into regular tests and registers those.2796// This will be done just once during the program runtime.2797void UnitTestImpl::RegisterParameterizedTests() {2798 if (!parameterized_tests_registered_) {2799 parameterized_test_registry_.RegisterTests();2800 type_parameterized_test_registry_.CheckForInstantiations();2801 parameterized_tests_registered_ = true;2802 }2803}2804 2805} // namespace internal2806 2807// Creates the test object, runs it, records its result, and then2808// deletes it.2809void TestInfo::Run() {2810 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();2811 if (!should_run_) {2812 if (is_disabled_ && matches_filter_) repeater->OnTestDisabled(*this);2813 return;2814 }2815 2816 // Tells UnitTest where to store test result.2817 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();2818 impl->set_current_test_info(this);2819 2820 // Notifies the unit test event listeners that a test is about to start.2821 repeater->OnTestStart(*this);2822 result_.set_start_timestamp(internal::GetTimeInMillis());2823 internal::Timer timer;2824 impl->os_stack_trace_getter()->UponLeavingGTest();2825 2826 // Creates the test object.2827 Test* const test = internal::HandleExceptionsInMethodIfSupported(2828 factory_, &internal::TestFactoryBase::CreateTest,2829 "the test fixture's constructor");2830 2831 // Runs the test if the constructor didn't generate a fatal failure or invoke2832 // GTEST_SKIP().2833 // Note that the object will not be null2834 if (!Test::HasFatalFailure() && !Test::IsSkipped()) {2835 // This doesn't throw as all user code that can throw are wrapped into2836 // exception handling code.2837 test->Run();2838 }2839 2840 if (test != nullptr) {2841 // Deletes the test object.2842 impl->os_stack_trace_getter()->UponLeavingGTest();2843 internal::HandleExceptionsInMethodIfSupported(2844 test, &Test::DeleteSelf_, "the test fixture's destructor");2845 }2846 2847 result_.set_elapsed_time(timer.Elapsed());2848 2849 // Notifies the unit test event listener that a test has just finished.2850 repeater->OnTestEnd(*this);2851 2852 // Tells UnitTest to stop associating assertion results to this2853 // test.2854 impl->set_current_test_info(nullptr);2855}2856 2857// Skip and records a skipped test result for this object.2858void TestInfo::Skip() {2859 if (!should_run_) return;2860 2861 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();2862 impl->set_current_test_info(this);2863 2864 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();2865 2866 // Notifies the unit test event listeners that a test is about to start.2867 repeater->OnTestStart(*this);2868 2869 const TestPartResult test_part_result =2870 TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");2871 impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(2872 test_part_result);2873 2874 // Notifies the unit test event listener that a test has just finished.2875 repeater->OnTestEnd(*this);2876 impl->set_current_test_info(nullptr);2877}2878 2879// class TestSuite2880 2881// Gets the number of successful tests in this test suite.2882int TestSuite::successful_test_count() const {2883 return CountIf(test_info_list_, TestPassed);2884}2885 2886// Gets the number of successful tests in this test suite.2887int TestSuite::skipped_test_count() const {2888 return CountIf(test_info_list_, TestSkipped);2889}2890 2891// Gets the number of failed tests in this test suite.2892int TestSuite::failed_test_count() const {2893 return CountIf(test_info_list_, TestFailed);2894}2895 2896// Gets the number of disabled tests that will be reported in the XML report.2897int TestSuite::reportable_disabled_test_count() const {2898 return CountIf(test_info_list_, TestReportableDisabled);2899}2900 2901// Gets the number of disabled tests in this test suite.2902int TestSuite::disabled_test_count() const {2903 return CountIf(test_info_list_, TestDisabled);2904}2905 2906// Gets the number of tests to be printed in the XML report.2907int TestSuite::reportable_test_count() const {2908 return CountIf(test_info_list_, TestReportable);2909}2910 2911// Get the number of tests in this test suite that should run.2912int TestSuite::test_to_run_count() const {2913 return CountIf(test_info_list_, ShouldRunTest);2914}2915 2916// Gets the number of all tests.2917int TestSuite::total_test_count() const {2918 return static_cast<int>(test_info_list_.size());2919}2920 2921// Creates a TestSuite with the given name.2922//2923// Arguments:2924//2925// a_name: name of the test suite2926// a_type_param: the name of the test suite's type parameter, or NULL if2927// this is not a typed or a type-parameterized test suite.2928// set_up_tc: pointer to the function that sets up the test suite2929// tear_down_tc: pointer to the function that tears down the test suite2930TestSuite::TestSuite(const char* a_name, const char* a_type_param,2931 internal::SetUpTestSuiteFunc set_up_tc,2932 internal::TearDownTestSuiteFunc tear_down_tc)2933 : name_(a_name),2934 type_param_(a_type_param ? new std::string(a_type_param) : nullptr),2935 set_up_tc_(set_up_tc),2936 tear_down_tc_(tear_down_tc),2937 should_run_(false),2938 start_timestamp_(0),2939 elapsed_time_(0) {}2940 2941// Destructor of TestSuite.2942TestSuite::~TestSuite() {2943 // Deletes every Test in the collection.2944 ForEach(test_info_list_, internal::Delete<TestInfo>);2945}2946 2947// Returns the i-th test among all the tests. i can range from 0 to2948// total_test_count() - 1. If i is not in that range, returns NULL.2949const TestInfo* TestSuite::GetTestInfo(int i) const {2950 const int index = GetElementOr(test_indices_, i, -1);2951 return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];2952}2953 2954// Returns the i-th test among all the tests. i can range from 0 to2955// total_test_count() - 1. If i is not in that range, returns NULL.2956TestInfo* TestSuite::GetMutableTestInfo(int i) {2957 const int index = GetElementOr(test_indices_, i, -1);2958 return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];2959}2960 2961// Adds a test to this test suite. Will delete the test upon2962// destruction of the TestSuite object.2963void TestSuite::AddTestInfo(TestInfo* test_info) {2964 test_info_list_.push_back(test_info);2965 test_indices_.push_back(static_cast<int>(test_indices_.size()));2966}2967 2968// Runs every test in this TestSuite.2969void TestSuite::Run() {2970 if (!should_run_) return;2971 2972 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();2973 impl->set_current_test_suite(this);2974 2975 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();2976 2977 // Ensure our tests are in a deterministic order.2978 //2979 // We do this by sorting lexicographically on (file, line number), providing2980 // an order matching what the user can see in the source code.2981 //2982 // In the common case the line number comparison shouldn't be necessary,2983 // because the registrations made by the TEST macro are executed in order2984 // within a translation unit. But this is not true of the manual registration2985 // API, and in more exotic scenarios a single file may be part of multiple2986 // translation units.2987 std::stable_sort(test_info_list_.begin(), test_info_list_.end(),2988 [](const TestInfo* const a, const TestInfo* const b) {2989 if (const int result = std::strcmp(a->file(), b->file())) {2990 return result < 0;2991 }2992 2993 return a->line() < b->line();2994 });2995 2996 // Call both legacy and the new API2997 repeater->OnTestSuiteStart(*this);2998// Legacy API is deprecated but still available2999#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3000 repeater->OnTestCaseStart(*this);3001#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3002 3003 impl->os_stack_trace_getter()->UponLeavingGTest();3004 internal::HandleExceptionsInMethodIfSupported(3005 this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");3006 3007 const bool skip_all =3008 ad_hoc_test_result().Failed() || ad_hoc_test_result().Skipped();3009 3010 start_timestamp_ = internal::GetTimeInMillis();3011 internal::Timer timer;3012 for (int i = 0; i < total_test_count(); i++) {3013 if (skip_all) {3014 GetMutableTestInfo(i)->Skip();3015 } else {3016 GetMutableTestInfo(i)->Run();3017 }3018 if (GTEST_FLAG_GET(fail_fast) &&3019 GetMutableTestInfo(i)->result()->Failed()) {3020 for (int j = i + 1; j < total_test_count(); j++) {3021 GetMutableTestInfo(j)->Skip();3022 }3023 break;3024 }3025 }3026 elapsed_time_ = timer.Elapsed();3027 3028 impl->os_stack_trace_getter()->UponLeavingGTest();3029 internal::HandleExceptionsInMethodIfSupported(3030 this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");3031 3032 // Call both legacy and the new API3033 repeater->OnTestSuiteEnd(*this);3034// Legacy API is deprecated but still available3035#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3036 repeater->OnTestCaseEnd(*this);3037#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3038 3039 impl->set_current_test_suite(nullptr);3040}3041 3042// Skips all tests under this TestSuite.3043void TestSuite::Skip() {3044 if (!should_run_) return;3045 3046 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();3047 impl->set_current_test_suite(this);3048 3049 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();3050 3051 // Call both legacy and the new API3052 repeater->OnTestSuiteStart(*this);3053// Legacy API is deprecated but still available3054#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3055 repeater->OnTestCaseStart(*this);3056#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3057 3058 for (int i = 0; i < total_test_count(); i++) {3059 GetMutableTestInfo(i)->Skip();3060 }3061 3062 // Call both legacy and the new API3063 repeater->OnTestSuiteEnd(*this);3064 // Legacy API is deprecated but still available3065#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3066 repeater->OnTestCaseEnd(*this);3067#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3068 3069 impl->set_current_test_suite(nullptr);3070}3071 3072// Clears the results of all tests in this test suite.3073void TestSuite::ClearResult() {3074 ad_hoc_test_result_.Clear();3075 ForEach(test_info_list_, TestInfo::ClearTestResult);3076}3077 3078// Shuffles the tests in this test suite.3079void TestSuite::ShuffleTests(internal::Random* random) {3080 Shuffle(random, &test_indices_);3081}3082 3083// Restores the test order to before the first shuffle.3084void TestSuite::UnshuffleTests() {3085 for (size_t i = 0; i < test_indices_.size(); i++) {3086 test_indices_[i] = static_cast<int>(i);3087 }3088}3089 3090// Formats a countable noun. Depending on its quantity, either the3091// singular form or the plural form is used. e.g.3092//3093// FormatCountableNoun(1, "formula", "formuli") returns "1 formula".3094// FormatCountableNoun(5, "book", "books") returns "5 books".3095static std::string FormatCountableNoun(int count, const char* singular_form,3096 const char* plural_form) {3097 return internal::StreamableToString(count) + " " +3098 (count == 1 ? singular_form : plural_form);3099}3100 3101// Formats the count of tests.3102static std::string FormatTestCount(int test_count) {3103 return FormatCountableNoun(test_count, "test", "tests");3104}3105 3106// Formats the count of test suites.3107static std::string FormatTestSuiteCount(int test_suite_count) {3108 return FormatCountableNoun(test_suite_count, "test suite", "test suites");3109}3110 3111// Converts a TestPartResult::Type enum to human-friendly string3112// representation. Both kNonFatalFailure and kFatalFailure are translated3113// to "Failure", as the user usually doesn't care about the difference3114// between the two when viewing the test result.3115static const char* TestPartResultTypeToString(TestPartResult::Type type) {3116 switch (type) {3117 case TestPartResult::kSkip:3118 return "Skipped\n";3119 case TestPartResult::kSuccess:3120 return "Success";3121 3122 case TestPartResult::kNonFatalFailure:3123 case TestPartResult::kFatalFailure:3124#ifdef _MSC_VER3125 return "error: ";3126#else3127 return "Failure\n";3128#endif3129 default:3130 return "Unknown result type";3131 }3132}3133 3134namespace internal {3135namespace {3136enum class GTestColor { kDefault, kRed, kGreen, kYellow };3137} // namespace3138 3139// Prints a TestPartResult to an std::string.3140static std::string PrintTestPartResultToString(3141 const TestPartResult& test_part_result) {3142 return (Message() << internal::FormatFileLocation(3143 test_part_result.file_name(),3144 test_part_result.line_number())3145 << " "3146 << TestPartResultTypeToString(test_part_result.type())3147 << test_part_result.message())3148 .GetString();3149}3150 3151// Prints a TestPartResult.3152static void PrintTestPartResult(const TestPartResult& test_part_result) {3153 const std::string& result = PrintTestPartResultToString(test_part_result);3154 printf("%s\n", result.c_str());3155 fflush(stdout);3156 // If the test program runs in Visual Studio or a debugger, the3157 // following statements add the test part result message to the Output3158 // window such that the user can double-click on it to jump to the3159 // corresponding source code location; otherwise they do nothing.3160#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE)3161 // We don't call OutputDebugString*() on Windows Mobile, as printing3162 // to stdout is done by OutputDebugString() there already - we don't3163 // want the same message printed twice.3164 ::OutputDebugStringA(result.c_str());3165 ::OutputDebugStringA("\n");3166#endif3167}3168 3169// class PrettyUnitTestResultPrinter3170#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) && \3171 !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \3172 !defined(GTEST_OS_WINDOWS_MINGW)3173 3174// Returns the character attribute for the given color.3175static WORD GetColorAttribute(GTestColor color) {3176 switch (color) {3177 case GTestColor::kRed:3178 return FOREGROUND_RED;3179 case GTestColor::kGreen:3180 return FOREGROUND_GREEN;3181 case GTestColor::kYellow:3182 return FOREGROUND_RED | FOREGROUND_GREEN;3183 default:3184 return 0;3185 }3186}3187 3188static int GetBitOffset(WORD color_mask) {3189 if (color_mask == 0) return 0;3190 3191 int bitOffset = 0;3192 while ((color_mask & 1) == 0) {3193 color_mask >>= 1;3194 ++bitOffset;3195 }3196 return bitOffset;3197}3198 3199static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {3200 // Let's reuse the BG3201 static const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN |3202 BACKGROUND_RED | BACKGROUND_INTENSITY;3203 static const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN |3204 FOREGROUND_RED | FOREGROUND_INTENSITY;3205 const WORD existing_bg = old_color_attrs & background_mask;3206 3207 WORD new_color =3208 GetColorAttribute(color) | existing_bg | FOREGROUND_INTENSITY;3209 static const int bg_bitOffset = GetBitOffset(background_mask);3210 static const int fg_bitOffset = GetBitOffset(foreground_mask);3211 3212 if (((new_color & background_mask) >> bg_bitOffset) ==3213 ((new_color & foreground_mask) >> fg_bitOffset)) {3214 new_color ^= FOREGROUND_INTENSITY; // invert intensity3215 }3216 return new_color;3217}3218 3219#else3220 3221// Returns the ANSI color code for the given color. GTestColor::kDefault is3222// an invalid input.3223static const char* GetAnsiColorCode(GTestColor color) {3224 switch (color) {3225 case GTestColor::kRed:3226 return "1";3227 case GTestColor::kGreen:3228 return "2";3229 case GTestColor::kYellow:3230 return "3";3231 default:3232 return nullptr;3233 }3234}3235 3236#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE3237 3238// Returns true if and only if Google Test should use colors in the output.3239bool ShouldUseColor(bool stdout_is_tty) {3240 std::string c = GTEST_FLAG_GET(color);3241 const char* const gtest_color = c.c_str();3242 3243 if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {3244#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW)3245 // On Windows the TERM variable is usually not set, but the3246 // console there does support colors.3247 return stdout_is_tty;3248#else3249 // On non-Windows platforms, we rely on the TERM variable.3250 const char* const term = posix::GetEnv("TERM");3251 const bool term_supports_color =3252 term != nullptr && (String::CStringEquals(term, "xterm") ||3253 String::CStringEquals(term, "xterm-color") ||3254 String::CStringEquals(term, "xterm-kitty") ||3255 String::CStringEquals(term, "screen") ||3256 String::CStringEquals(term, "tmux") ||3257 String::CStringEquals(term, "rxvt-unicode") ||3258 String::CStringEquals(term, "linux") ||3259 String::CStringEquals(term, "cygwin") ||3260 String::EndsWithCaseInsensitive(term, "-256color"));3261 return stdout_is_tty && term_supports_color;3262#endif // GTEST_OS_WINDOWS3263 }3264 3265 return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||3266 String::CaseInsensitiveCStringEquals(gtest_color, "true") ||3267 String::CaseInsensitiveCStringEquals(gtest_color, "t") ||3268 String::CStringEquals(gtest_color, "1");3269 // We take "yes", "true", "t", and "1" as meaning "yes". If the3270 // value is neither one of these nor "auto", we treat it as "no" to3271 // be conservative.3272}3273 3274// Helpers for printing colored strings to stdout. Note that on Windows, we3275// cannot simply emit special characters and have the terminal change colors.3276// This routine must actually emit the characters rather than return a string3277// that would be colored when printed, as can be done on Linux.3278 3279GTEST_ATTRIBUTE_PRINTF_(2, 3)3280static void ColoredPrintf(GTestColor color, const char* fmt, ...) {3281 va_list args;3282 va_start(args, fmt);3283 3284 static const bool in_color_mode =3285#if GTEST_HAS_FILE_SYSTEM3286 ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);3287#else3288 false;3289#endif // GTEST_HAS_FILE_SYSTEM3290 3291 const bool use_color = in_color_mode && (color != GTestColor::kDefault);3292 3293 if (!use_color) {3294 vprintf(fmt, args);3295 va_end(args);3296 return;3297 }3298 3299#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) && \3300 !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \3301 !defined(GTEST_OS_WINDOWS_MINGW)3302 const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);3303 3304 // Gets the current text color.3305 CONSOLE_SCREEN_BUFFER_INFO buffer_info;3306 GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);3307 const WORD old_color_attrs = buffer_info.wAttributes;3308 const WORD new_color = GetNewColor(color, old_color_attrs);3309 3310 // We need to flush the stream buffers into the console before each3311 // SetConsoleTextAttribute call lest it affect the text that is already3312 // printed but has not yet reached the console.3313 fflush(stdout);3314 SetConsoleTextAttribute(stdout_handle, new_color);3315 3316 vprintf(fmt, args);3317 3318 fflush(stdout);3319 // Restores the text color.3320 SetConsoleTextAttribute(stdout_handle, old_color_attrs);3321#else3322 printf("\033[0;3%sm", GetAnsiColorCode(color));3323 vprintf(fmt, args);3324 printf("\033[m"); // Resets the terminal to default.3325#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE3326 va_end(args);3327}3328 3329// Text printed in Google Test's text output and --gtest_list_tests3330// output to label the type parameter and value parameter for a test.3331static const char kTypeParamLabel[] = "TypeParam";3332static const char kValueParamLabel[] = "GetParam()";3333 3334static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {3335 const char* const type_param = test_info.type_param();3336 const char* const value_param = test_info.value_param();3337 3338 if (type_param != nullptr || value_param != nullptr) {3339 printf(", where ");3340 if (type_param != nullptr) {3341 printf("%s = %s", kTypeParamLabel, type_param);3342 if (value_param != nullptr) printf(" and ");3343 }3344 if (value_param != nullptr) {3345 printf("%s = %s", kValueParamLabel, value_param);3346 }3347 }3348}3349 3350// This class implements the TestEventListener interface.3351//3352// Class PrettyUnitTestResultPrinter is copyable.3353class PrettyUnitTestResultPrinter : public TestEventListener {3354 public:3355 PrettyUnitTestResultPrinter() = default;3356 static void PrintTestName(const char* test_suite, const char* test) {3357 printf("%s.%s", test_suite, test);3358 }3359 3360 // The following methods override what's in the TestEventListener class.3361 void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}3362 void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;3363 void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;3364 void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}3365#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3366 void OnTestCaseStart(const TestCase& test_case) override;3367#else3368 void OnTestSuiteStart(const TestSuite& test_suite) override;3369#endif // OnTestCaseStart3370 3371 void OnTestStart(const TestInfo& test_info) override;3372 void OnTestDisabled(const TestInfo& test_info) override;3373 3374 void OnTestPartResult(const TestPartResult& result) override;3375 void OnTestEnd(const TestInfo& test_info) override;3376#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3377 void OnTestCaseEnd(const TestCase& test_case) override;3378#else3379 void OnTestSuiteEnd(const TestSuite& test_suite) override;3380#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3381 3382 void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;3383 void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}3384 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;3385 void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}3386 3387 private:3388 static void PrintFailedTests(const UnitTest& unit_test);3389 static void PrintFailedTestSuites(const UnitTest& unit_test);3390 static void PrintSkippedTests(const UnitTest& unit_test);3391};3392 3393// Fired before each iteration of tests starts.3394void PrettyUnitTestResultPrinter::OnTestIterationStart(3395 const UnitTest& unit_test, int iteration) {3396 if (GTEST_FLAG_GET(repeat) != 1)3397 printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);3398 3399 std::string f = GTEST_FLAG_GET(filter);3400 const char* const filter = f.c_str();3401 3402 // Prints the filter if it's not *. This reminds the user that some3403 // tests may be skipped.3404 if (!String::CStringEquals(filter, kUniversalFilter)) {3405 ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,3406 filter);3407 }3408 3409 if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {3410 const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);3411 ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",3412 static_cast<int>(shard_index) + 1,3413 internal::posix::GetEnv(kTestTotalShards));3414 }3415 3416 if (GTEST_FLAG_GET(shuffle)) {3417 ColoredPrintf(GTestColor::kYellow,3418 "Note: Randomizing tests' orders with a seed of %d .\n",3419 unit_test.random_seed());3420 }3421 3422 ColoredPrintf(GTestColor::kGreen, "[==========] ");3423 printf("Running %s from %s.\n",3424 FormatTestCount(unit_test.test_to_run_count()).c_str(),3425 FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());3426 fflush(stdout);3427}3428 3429void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(3430 const UnitTest& /*unit_test*/) {3431 ColoredPrintf(GTestColor::kGreen, "[----------] ");3432 printf("Global test environment set-up.\n");3433 fflush(stdout);3434}3435 3436#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3437void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {3438 const std::string counts =3439 FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");3440 ColoredPrintf(GTestColor::kGreen, "[----------] ");3441 printf("%s from %s", counts.c_str(), test_case.name());3442 if (test_case.type_param() == nullptr) {3443 printf("\n");3444 } else {3445 printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());3446 }3447 fflush(stdout);3448}3449#else3450void PrettyUnitTestResultPrinter::OnTestSuiteStart(3451 const TestSuite& test_suite) {3452 const std::string counts =3453 FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");3454 ColoredPrintf(GTestColor::kGreen, "[----------] ");3455 printf("%s from %s", counts.c_str(), test_suite.name());3456 if (test_suite.type_param() == nullptr) {3457 printf("\n");3458 } else {3459 printf(", where %s = %s\n", kTypeParamLabel, test_suite.type_param());3460 }3461 fflush(stdout);3462}3463#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3464 3465void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {3466 ColoredPrintf(GTestColor::kGreen, "[ RUN ] ");3467 PrintTestName(test_info.test_suite_name(), test_info.name());3468 printf("\n");3469 fflush(stdout);3470}3471 3472void PrettyUnitTestResultPrinter::OnTestDisabled(const TestInfo& test_info) {3473 ColoredPrintf(GTestColor::kYellow, "[ DISABLED ] ");3474 PrintTestName(test_info.test_suite_name(), test_info.name());3475 printf("\n");3476 fflush(stdout);3477}3478 3479// Called after an assertion failure.3480void PrettyUnitTestResultPrinter::OnTestPartResult(3481 const TestPartResult& result) {3482 switch (result.type()) {3483 // If the test part succeeded, we don't need to do anything.3484 case TestPartResult::kSuccess:3485 return;3486 default:3487 // Print failure message from the assertion3488 // (e.g. expected this and got that).3489 PrintTestPartResult(result);3490 fflush(stdout);3491 }3492}3493 3494void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {3495 if (test_info.result()->Passed()) {3496 ColoredPrintf(GTestColor::kGreen, "[ OK ] ");3497 } else if (test_info.result()->Skipped()) {3498 ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");3499 } else {3500 ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");3501 }3502 PrintTestName(test_info.test_suite_name(), test_info.name());3503 if (test_info.result()->Failed()) PrintFullTestCommentIfPresent(test_info);3504 3505 if (GTEST_FLAG_GET(print_time)) {3506 printf(" (%s ms)\n",3507 internal::StreamableToString(test_info.result()->elapsed_time())3508 .c_str());3509 } else {3510 printf("\n");3511 }3512 fflush(stdout);3513}3514 3515#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3516void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {3517 if (!GTEST_FLAG_GET(print_time)) return;3518 3519 const std::string counts =3520 FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");3521 ColoredPrintf(GTestColor::kGreen, "[----------] ");3522 printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(),3523 internal::StreamableToString(test_case.elapsed_time()).c_str());3524 fflush(stdout);3525}3526#else3527void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite& test_suite) {3528 if (!GTEST_FLAG_GET(print_time)) return;3529 3530 const std::string counts =3531 FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");3532 ColoredPrintf(GTestColor::kGreen, "[----------] ");3533 printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name(),3534 internal::StreamableToString(test_suite.elapsed_time()).c_str());3535 fflush(stdout);3536}3537#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3538 3539void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(3540 const UnitTest& /*unit_test*/) {3541 ColoredPrintf(GTestColor::kGreen, "[----------] ");3542 printf("Global test environment tear-down\n");3543 fflush(stdout);3544}3545 3546// Internal helper for printing the list of failed tests.3547void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {3548 const int failed_test_count = unit_test.failed_test_count();3549 ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");3550 printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());3551 3552 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {3553 const TestSuite& test_suite = *unit_test.GetTestSuite(i);3554 if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) {3555 continue;3556 }3557 for (int j = 0; j < test_suite.total_test_count(); ++j) {3558 const TestInfo& test_info = *test_suite.GetTestInfo(j);3559 if (!test_info.should_run() || !test_info.result()->Failed()) {3560 continue;3561 }3562 ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");3563 printf("%s.%s", test_suite.name(), test_info.name());3564 PrintFullTestCommentIfPresent(test_info);3565 printf("\n");3566 }3567 }3568 printf("\n%2d FAILED %s\n", failed_test_count,3569 failed_test_count == 1 ? "TEST" : "TESTS");3570}3571 3572// Internal helper for printing the list of test suite failures not covered by3573// PrintFailedTests.3574void PrettyUnitTestResultPrinter::PrintFailedTestSuites(3575 const UnitTest& unit_test) {3576 int suite_failure_count = 0;3577 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {3578 const TestSuite& test_suite = *unit_test.GetTestSuite(i);3579 if (!test_suite.should_run()) {3580 continue;3581 }3582 if (test_suite.ad_hoc_test_result().Failed()) {3583 ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");3584 printf("%s: SetUpTestSuite or TearDownTestSuite\n", test_suite.name());3585 ++suite_failure_count;3586 }3587 }3588 if (suite_failure_count > 0) {3589 printf("\n%2d FAILED TEST %s\n", suite_failure_count,3590 suite_failure_count == 1 ? "SUITE" : "SUITES");3591 }3592}3593 3594// Internal helper for printing the list of skipped tests.3595void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {3596 const int skipped_test_count = unit_test.skipped_test_count();3597 if (skipped_test_count == 0) {3598 return;3599 }3600 3601 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {3602 const TestSuite& test_suite = *unit_test.GetTestSuite(i);3603 if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) {3604 continue;3605 }3606 for (int j = 0; j < test_suite.total_test_count(); ++j) {3607 const TestInfo& test_info = *test_suite.GetTestInfo(j);3608 if (!test_info.should_run() || !test_info.result()->Skipped()) {3609 continue;3610 }3611 ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");3612 printf("%s.%s", test_suite.name(), test_info.name());3613 printf("\n");3614 }3615 }3616}3617 3618void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,3619 int /*iteration*/) {3620 ColoredPrintf(GTestColor::kGreen, "[==========] ");3621 printf("%s from %s ran.",3622 FormatTestCount(unit_test.test_to_run_count()).c_str(),3623 FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());3624 if (GTEST_FLAG_GET(print_time)) {3625 printf(" (%s ms total)",3626 internal::StreamableToString(unit_test.elapsed_time()).c_str());3627 }3628 printf("\n");3629 ColoredPrintf(GTestColor::kGreen, "[ PASSED ] ");3630 printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());3631 3632 const int skipped_test_count = unit_test.skipped_test_count();3633 if (skipped_test_count > 0) {3634 ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");3635 printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());3636 PrintSkippedTests(unit_test);3637 }3638 3639 if (!unit_test.Passed()) {3640 PrintFailedTests(unit_test);3641 PrintFailedTestSuites(unit_test);3642 }3643 3644 int num_disabled = unit_test.reportable_disabled_test_count();3645 if (num_disabled && !GTEST_FLAG_GET(also_run_disabled_tests)) {3646 if (unit_test.Passed()) {3647 printf("\n"); // Add a spacer if no FAILURE banner is displayed.3648 }3649 ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",3650 num_disabled, num_disabled == 1 ? "TEST" : "TESTS");3651 }3652 // Ensure that Google Test output is printed before, e.g., heapchecker output.3653 fflush(stdout);3654}3655 3656// End PrettyUnitTestResultPrinter3657 3658// This class implements the TestEventListener interface.3659//3660// Class BriefUnitTestResultPrinter is copyable.3661class BriefUnitTestResultPrinter : public TestEventListener {3662 public:3663 BriefUnitTestResultPrinter() = default;3664 static void PrintTestName(const char* test_suite, const char* test) {3665 printf("%s.%s", test_suite, test);3666 }3667 3668 // The following methods override what's in the TestEventListener class.3669 void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}3670 void OnTestIterationStart(const UnitTest& /*unit_test*/,3671 int /*iteration*/) override {}3672 void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}3673 void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}3674#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3675 void OnTestCaseStart(const TestCase& /*test_case*/) override {}3676#else3677 void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}3678#endif // OnTestCaseStart3679 3680 void OnTestStart(const TestInfo& /*test_info*/) override {}3681 void OnTestDisabled(const TestInfo& /*test_info*/) override {}3682 3683 void OnTestPartResult(const TestPartResult& result) override;3684 void OnTestEnd(const TestInfo& test_info) override;3685#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3686 void OnTestCaseEnd(const TestCase& /*test_case*/) override {}3687#else3688 void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}3689#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3690 3691 void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}3692 void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}3693 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;3694 void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}3695};3696 3697// Called after an assertion failure.3698void BriefUnitTestResultPrinter::OnTestPartResult(3699 const TestPartResult& result) {3700 switch (result.type()) {3701 // If the test part succeeded, we don't need to do anything.3702 case TestPartResult::kSuccess:3703 return;3704 default:3705 // Print failure message from the assertion3706 // (e.g. expected this and got that).3707 PrintTestPartResult(result);3708 fflush(stdout);3709 }3710}3711 3712void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {3713 if (test_info.result()->Failed()) {3714 ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");3715 PrintTestName(test_info.test_suite_name(), test_info.name());3716 PrintFullTestCommentIfPresent(test_info);3717 3718 if (GTEST_FLAG_GET(print_time)) {3719 printf(" (%s ms)\n",3720 internal::StreamableToString(test_info.result()->elapsed_time())3721 .c_str());3722 } else {3723 printf("\n");3724 }3725 fflush(stdout);3726 }3727}3728 3729void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,3730 int /*iteration*/) {3731 ColoredPrintf(GTestColor::kGreen, "[==========] ");3732 printf("%s from %s ran.",3733 FormatTestCount(unit_test.test_to_run_count()).c_str(),3734 FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());3735 if (GTEST_FLAG_GET(print_time)) {3736 printf(" (%s ms total)",3737 internal::StreamableToString(unit_test.elapsed_time()).c_str());3738 }3739 printf("\n");3740 ColoredPrintf(GTestColor::kGreen, "[ PASSED ] ");3741 printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());3742 3743 const int skipped_test_count = unit_test.skipped_test_count();3744 if (skipped_test_count > 0) {3745 ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");3746 printf("%s.\n", FormatTestCount(skipped_test_count).c_str());3747 }3748 3749 int num_disabled = unit_test.reportable_disabled_test_count();3750 if (num_disabled && !GTEST_FLAG_GET(also_run_disabled_tests)) {3751 if (unit_test.Passed()) {3752 printf("\n"); // Add a spacer if no FAILURE banner is displayed.3753 }3754 ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",3755 num_disabled, num_disabled == 1 ? "TEST" : "TESTS");3756 }3757 // Ensure that Google Test output is printed before, e.g., heapchecker output.3758 fflush(stdout);3759}3760 3761// End BriefUnitTestResultPrinter3762 3763// class TestEventRepeater3764//3765// This class forwards events to other event listeners.3766class TestEventRepeater : public TestEventListener {3767 public:3768 TestEventRepeater() : forwarding_enabled_(true) {}3769 ~TestEventRepeater() override;3770 void Append(TestEventListener* listener);3771 TestEventListener* Release(TestEventListener* listener);3772 3773 // Controls whether events will be forwarded to listeners_. Set to false3774 // in death test child processes.3775 bool forwarding_enabled() const { return forwarding_enabled_; }3776 void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }3777 3778 void OnTestProgramStart(const UnitTest& parameter) override;3779 void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;3780 void OnEnvironmentsSetUpStart(const UnitTest& parameter) override;3781 void OnEnvironmentsSetUpEnd(const UnitTest& parameter) override;3782// Legacy API is deprecated but still available3783#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3784 void OnTestCaseStart(const TestSuite& parameter) override;3785#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3786 void OnTestSuiteStart(const TestSuite& parameter) override;3787 void OnTestStart(const TestInfo& parameter) override;3788 void OnTestDisabled(const TestInfo& parameter) override;3789 void OnTestPartResult(const TestPartResult& parameter) override;3790 void OnTestEnd(const TestInfo& parameter) override;3791// Legacy API is deprecated but still available3792#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3793 void OnTestCaseEnd(const TestCase& parameter) override;3794#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3795 void OnTestSuiteEnd(const TestSuite& parameter) override;3796 void OnEnvironmentsTearDownStart(const UnitTest& parameter) override;3797 void OnEnvironmentsTearDownEnd(const UnitTest& parameter) override;3798 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;3799 void OnTestProgramEnd(const UnitTest& parameter) override;3800 3801 private:3802 // Controls whether events will be forwarded to listeners_. Set to false3803 // in death test child processes.3804 bool forwarding_enabled_;3805 // The list of listeners that receive events.3806 std::vector<TestEventListener*> listeners_;3807 3808 TestEventRepeater(const TestEventRepeater&) = delete;3809 TestEventRepeater& operator=(const TestEventRepeater&) = delete;3810};3811 3812TestEventRepeater::~TestEventRepeater() {3813 ForEach(listeners_, Delete<TestEventListener>);3814}3815 3816void TestEventRepeater::Append(TestEventListener* listener) {3817 listeners_.push_back(listener);3818}3819 3820TestEventListener* TestEventRepeater::Release(TestEventListener* listener) {3821 for (size_t i = 0; i < listeners_.size(); ++i) {3822 if (listeners_[i] == listener) {3823 listeners_.erase(listeners_.begin() + static_cast<int>(i));3824 return listener;3825 }3826 }3827 3828 return nullptr;3829}3830 3831// Since most methods are very similar, use macros to reduce boilerplate.3832// This defines a member that forwards the call to all listeners.3833#define GTEST_REPEATER_METHOD_(Name, Type) \3834 void TestEventRepeater::Name(const Type& parameter) { \3835 if (forwarding_enabled_) { \3836 for (size_t i = 0; i < listeners_.size(); i++) { \3837 listeners_[i]->Name(parameter); \3838 } \3839 } \3840 }3841// This defines a member that forwards the call to all listeners in reverse3842// order.3843#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \3844 void TestEventRepeater::Name(const Type& parameter) { \3845 if (forwarding_enabled_) { \3846 for (size_t i = listeners_.size(); i != 0; i--) { \3847 listeners_[i - 1]->Name(parameter); \3848 } \3849 } \3850 }3851 3852GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)3853GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)3854// Legacy API is deprecated but still available3855#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3856GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite)3857#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3858GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite)3859GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)3860GTEST_REPEATER_METHOD_(OnTestDisabled, TestInfo)3861GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)3862GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)3863GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)3864GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)3865GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)3866// Legacy API is deprecated but still available3867#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_3868GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite)3869#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_3870GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite)3871GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)3872 3873#undef GTEST_REPEATER_METHOD_3874#undef GTEST_REVERSE_REPEATER_METHOD_3875 3876void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,3877 int iteration) {3878 if (forwarding_enabled_) {3879 for (size_t i = 0; i < listeners_.size(); i++) {3880 listeners_[i]->OnTestIterationStart(unit_test, iteration);3881 }3882 }3883}3884 3885void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,3886 int iteration) {3887 if (forwarding_enabled_) {3888 for (size_t i = listeners_.size(); i > 0; i--) {3889 listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);3890 }3891 }3892}3893 3894// End TestEventRepeater3895 3896#if GTEST_HAS_FILE_SYSTEM3897// This class generates an XML output file.3898class XmlUnitTestResultPrinter : public EmptyTestEventListener {3899 public:3900 explicit XmlUnitTestResultPrinter(const char* output_file);3901 3902 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;3903 void ListTestsMatchingFilter(const std::vector<TestSuite*>& test_suites);3904 3905 // Prints an XML summary of all unit tests.3906 static void PrintXmlTestsList(std::ostream* stream,3907 const std::vector<TestSuite*>& test_suites);3908 3909 private:3910 // Is c a whitespace character that is normalized to a space character3911 // when it appears in an XML attribute value?3912 static bool IsNormalizableWhitespace(unsigned char c) {3913 return c == '\t' || c == '\n' || c == '\r';3914 }3915 3916 // May c appear in a well-formed XML document?3917 // https://www.w3.org/TR/REC-xml/#charsets3918 static bool IsValidXmlCharacter(unsigned char c) {3919 return IsNormalizableWhitespace(c) || c >= 0x20;3920 }3921 3922 // Returns an XML-escaped copy of the input string str. If3923 // is_attribute is true, the text is meant to appear as an attribute3924 // value, and normalizable whitespace is preserved by replacing it3925 // with character references.3926 static std::string EscapeXml(const std::string& str, bool is_attribute);3927 3928 // Returns the given string with all characters invalid in XML removed.3929 static std::string RemoveInvalidXmlCharacters(const std::string& str);3930 3931 // Convenience wrapper around EscapeXml when str is an attribute value.3932 static std::string EscapeXmlAttribute(const std::string& str) {3933 return EscapeXml(str, true);3934 }3935 3936 // Convenience wrapper around EscapeXml when str is not an attribute value.3937 static std::string EscapeXmlText(const char* str) {3938 return EscapeXml(str, false);3939 }3940 3941 // Verifies that the given attribute belongs to the given element and3942 // streams the attribute as XML.3943 static void OutputXmlAttribute(std::ostream* stream,3944 const std::string& element_name,3945 const std::string& name,3946 const std::string& value);3947 3948 // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.3949 static void OutputXmlCDataSection(::std::ostream* stream, const char* data);3950 3951 // Streams a test suite XML stanza containing the given test result.3952 //3953 // Requires: result.Failed()3954 static void OutputXmlTestSuiteForTestResult(::std::ostream* stream,3955 const TestResult& result);3956 3957 // Streams an XML representation of a TestResult object.3958 static void OutputXmlTestResult(::std::ostream* stream,3959 const TestResult& result);3960 3961 // Streams an XML representation of a TestInfo object.3962 static void OutputXmlTestInfo(::std::ostream* stream,3963 const char* test_suite_name,3964 const TestInfo& test_info);3965 3966 // Prints an XML representation of a TestSuite object3967 static void PrintXmlTestSuite(::std::ostream* stream,3968 const TestSuite& test_suite);3969 3970 // Prints an XML summary of unit_test to output stream out.3971 static void PrintXmlUnitTest(::std::ostream* stream,3972 const UnitTest& unit_test);3973 3974 // Produces a string representing the test properties in a result as space3975 // delimited XML attributes based on the property key="value" pairs.3976 // When the std::string is not empty, it includes a space at the beginning,3977 // to delimit this attribute from prior attributes.3978 static std::string TestPropertiesAsXmlAttributes(const TestResult& result);3979 3980 // Streams an XML representation of the test properties of a TestResult3981 // object.3982 static void OutputXmlTestProperties(std::ostream* stream,3983 const TestResult& result);3984 3985 // The output file.3986 const std::string output_file_;3987 3988 XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;3989 XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter&) = delete;3990};3991 3992// Creates a new XmlUnitTestResultPrinter.3993XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)3994 : output_file_(output_file) {3995 if (output_file_.empty()) {3996 GTEST_LOG_(FATAL) << "XML output file may not be null";3997 }3998}3999 4000// Called after the unit test ends.4001void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,4002 int /*iteration*/) {4003 FILE* xmlout = OpenFileForWriting(output_file_);4004 std::stringstream stream;4005 PrintXmlUnitTest(&stream, unit_test);4006 fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());4007 fclose(xmlout);4008}4009 4010void XmlUnitTestResultPrinter::ListTestsMatchingFilter(4011 const std::vector<TestSuite*>& test_suites) {4012 FILE* xmlout = OpenFileForWriting(output_file_);4013 std::stringstream stream;4014 PrintXmlTestsList(&stream, test_suites);4015 fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());4016 fclose(xmlout);4017}4018 4019// Returns an XML-escaped copy of the input string str. If is_attribute4020// is true, the text is meant to appear as an attribute value, and4021// normalizable whitespace is preserved by replacing it with character4022// references.4023//4024// Invalid XML characters in str, if any, are stripped from the output.4025// It is expected that most, if not all, of the text processed by this4026// module will consist of ordinary English text.4027// If this module is ever modified to produce version 1.1 XML output,4028// most invalid characters can be retained using character references.4029std::string XmlUnitTestResultPrinter::EscapeXml(const std::string& str,4030 bool is_attribute) {4031 Message m;4032 4033 for (size_t i = 0; i < str.size(); ++i) {4034 const char ch = str[i];4035 switch (ch) {4036 case '<':4037 m << "<";4038 break;4039 case '>':4040 m << ">";4041 break;4042 case '&':4043 m << "&";4044 break;4045 case '\'':4046 if (is_attribute)4047 m << "'";4048 else4049 m << '\'';4050 break;4051 case '"':4052 if (is_attribute)4053 m << """;4054 else4055 m << '"';4056 break;4057 default:4058 if (IsValidXmlCharacter(static_cast<unsigned char>(ch))) {4059 if (is_attribute &&4060 IsNormalizableWhitespace(static_cast<unsigned char>(ch)))4061 m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))4062 << ";";4063 else4064 m << ch;4065 }4066 break;4067 }4068 }4069 4070 return m.GetString();4071}4072 4073// Returns the given string with all characters invalid in XML removed.4074// Currently invalid characters are dropped from the string. An4075// alternative is to replace them with certain characters such as . or ?.4076std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(4077 const std::string& str) {4078 std::string output;4079 output.reserve(str.size());4080 for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)4081 if (IsValidXmlCharacter(static_cast<unsigned char>(*it)))4082 output.push_back(*it);4083 4084 return output;4085}4086 4087// The following routines generate an XML representation of a UnitTest4088// object.4089//4090// This is how Google Test concepts map to the DTD:4091//4092// <testsuites name="AllTests"> <-- corresponds to a UnitTest object4093// <testsuite name="testcase-name"> <-- corresponds to a TestSuite object4094// <testcase name="test-name"> <-- corresponds to a TestInfo object4095// <failure message="...">...</failure>4096// <failure message="...">...</failure>4097// <failure message="...">...</failure>4098// <-- individual assertion failures4099// </testcase>4100// </testsuite>4101// </testsuites>4102 4103// Formats the given time in milliseconds as seconds.4104std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {4105 ::std::stringstream ss;4106 // For the exact N seconds, makes sure output has a trailing decimal point.4107 // Sets precision so that we won't have many trailing zeros (e.g., 300 ms4108 // will be just 0.3, 410 ms 0.41, and so on)4109 ss << std::fixed4110 << std::setprecision(4111 ms % 1000 == 0 ? 0 : (ms % 100 == 0 ? 1 : (ms % 10 == 0 ? 2 : 3)))4112 << std::showpoint;4113 ss << (static_cast<double>(ms) * 1e-3);4114 return ss.str();4115}4116 4117static bool PortableLocaltime(time_t seconds, struct tm* out) {4118#if defined(_MSC_VER)4119 return localtime_s(out, &seconds) == 0;4120#elif defined(__MINGW32__) || defined(__MINGW64__)4121 // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses4122 // Windows' localtime(), which has a thread-local tm buffer.4123 struct tm* tm_ptr = localtime(&seconds); // NOLINT4124 if (tm_ptr == nullptr) return false;4125 *out = *tm_ptr;4126 return true;4127#elif defined(__STDC_LIB_EXT1__)4128 // Uses localtime_s when available as localtime_r is only available from4129 // C23 standard.4130 return localtime_s(&seconds, out) != nullptr;4131#else4132 return localtime_r(&seconds, out) != nullptr;4133#endif4134}4135 4136// Converts the given epoch time in milliseconds to a date string in the ISO4137// 8601 format, without the timezone information.4138std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {4139 struct tm time_struct;4140 if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))4141 return "";4142 // YYYY-MM-DDThh:mm:ss.sss4143 return StreamableToString(time_struct.tm_year + 1900) + "-" +4144 String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +4145 String::FormatIntWidth2(time_struct.tm_mday) + "T" +4146 String::FormatIntWidth2(time_struct.tm_hour) + ":" +4147 String::FormatIntWidth2(time_struct.tm_min) + ":" +4148 String::FormatIntWidth2(time_struct.tm_sec) + "." +4149 String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);4150}4151 4152// Streams an XML CDATA section, escaping invalid CDATA sequences as needed.4153void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,4154 const char* data) {4155 const char* segment = data;4156 *stream << "<![CDATA[";4157 for (;;) {4158 const char* const next_segment = strstr(segment, "]]>");4159 if (next_segment != nullptr) {4160 stream->write(segment,4161 static_cast<std::streamsize>(next_segment - segment));4162 *stream << "]]>]]><![CDATA[";4163 segment = next_segment + strlen("]]>");4164 } else {4165 *stream << segment;4166 break;4167 }4168 }4169 *stream << "]]>";4170}4171 4172void XmlUnitTestResultPrinter::OutputXmlAttribute(4173 std::ostream* stream, const std::string& element_name,4174 const std::string& name, const std::string& value) {4175 const std::vector<std::string>& allowed_names =4176 GetReservedOutputAttributesForElement(element_name);4177 4178 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=4179 allowed_names.end())4180 << "Attribute " << name << " is not allowed for element <" << element_name4181 << ">.";4182 4183 *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";4184}4185 4186// Streams a test suite XML stanza containing the given test result.4187void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(4188 ::std::ostream* stream, const TestResult& result) {4189 // Output the boilerplate for a minimal test suite with one test.4190 *stream << " <testsuite";4191 OutputXmlAttribute(stream, "testsuite", "name", "NonTestSuiteFailure");4192 OutputXmlAttribute(stream, "testsuite", "tests", "1");4193 OutputXmlAttribute(stream, "testsuite", "failures", "1");4194 OutputXmlAttribute(stream, "testsuite", "disabled", "0");4195 OutputXmlAttribute(stream, "testsuite", "skipped", "0");4196 OutputXmlAttribute(stream, "testsuite", "errors", "0");4197 OutputXmlAttribute(stream, "testsuite", "time",4198 FormatTimeInMillisAsSeconds(result.elapsed_time()));4199 OutputXmlAttribute(4200 stream, "testsuite", "timestamp",4201 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));4202 *stream << ">";4203 4204 // Output the boilerplate for a minimal test case with a single test.4205 *stream << " <testcase";4206 OutputXmlAttribute(stream, "testcase", "name", "");4207 OutputXmlAttribute(stream, "testcase", "status", "run");4208 OutputXmlAttribute(stream, "testcase", "result", "completed");4209 OutputXmlAttribute(stream, "testcase", "classname", "");4210 OutputXmlAttribute(stream, "testcase", "time",4211 FormatTimeInMillisAsSeconds(result.elapsed_time()));4212 OutputXmlAttribute(4213 stream, "testcase", "timestamp",4214 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));4215 4216 // Output the actual test result.4217 OutputXmlTestResult(stream, result);4218 4219 // Complete the test suite.4220 *stream << " </testsuite>\n";4221}4222 4223// Prints an XML representation of a TestInfo object.4224void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,4225 const char* test_suite_name,4226 const TestInfo& test_info) {4227 const TestResult& result = *test_info.result();4228 const std::string kTestsuite = "testcase";4229 4230 if (test_info.is_in_another_shard()) {4231 return;4232 }4233 4234 *stream << " <testcase";4235 OutputXmlAttribute(stream, kTestsuite, "name", test_info.name());4236 4237 if (test_info.value_param() != nullptr) {4238 OutputXmlAttribute(stream, kTestsuite, "value_param",4239 test_info.value_param());4240 }4241 if (test_info.type_param() != nullptr) {4242 OutputXmlAttribute(stream, kTestsuite, "type_param",4243 test_info.type_param());4244 }4245 4246 OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());4247 OutputXmlAttribute(stream, kTestsuite, "line",4248 StreamableToString(test_info.line()));4249 if (GTEST_FLAG_GET(list_tests)) {4250 *stream << " />\n";4251 return;4252 }4253 4254 OutputXmlAttribute(stream, kTestsuite, "status",4255 test_info.should_run() ? "run" : "notrun");4256 OutputXmlAttribute(stream, kTestsuite, "result",4257 test_info.should_run()4258 ? (result.Skipped() ? "skipped" : "completed")4259 : "suppressed");4260 OutputXmlAttribute(stream, kTestsuite, "time",4261 FormatTimeInMillisAsSeconds(result.elapsed_time()));4262 OutputXmlAttribute(4263 stream, kTestsuite, "timestamp",4264 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));4265 OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name);4266 4267 OutputXmlTestResult(stream, result);4268}4269 4270void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream,4271 const TestResult& result) {4272 int failures = 0;4273 int skips = 0;4274 for (int i = 0; i < result.total_part_count(); ++i) {4275 const TestPartResult& part = result.GetTestPartResult(i);4276 if (part.failed()) {4277 if (++failures == 1 && skips == 0) {4278 *stream << ">\n";4279 }4280 const std::string location =4281 internal::FormatCompilerIndependentFileLocation(part.file_name(),4282 part.line_number());4283 const std::string summary = location + "\n" + part.summary();4284 *stream << " <failure message=\"" << EscapeXmlAttribute(summary)4285 << "\" type=\"\">";4286 const std::string detail = location + "\n" + part.message();4287 OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());4288 *stream << "</failure>\n";4289 } else if (part.skipped()) {4290 if (++skips == 1 && failures == 0) {4291 *stream << ">\n";4292 }4293 const std::string location =4294 internal::FormatCompilerIndependentFileLocation(part.file_name(),4295 part.line_number());4296 const std::string summary = location + "\n" + part.summary();4297 *stream << " <skipped message=\""4298 << EscapeXmlAttribute(summary.c_str()) << "\">";4299 const std::string detail = location + "\n" + part.message();4300 OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());4301 *stream << "</skipped>\n";4302 }4303 }4304 4305 if (failures == 0 && skips == 0 && result.test_property_count() == 0) {4306 *stream << " />\n";4307 } else {4308 if (failures == 0 && skips == 0) {4309 *stream << ">\n";4310 }4311 OutputXmlTestProperties(stream, result);4312 *stream << " </testcase>\n";4313 }4314}4315 4316// Prints an XML representation of a TestSuite object4317void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,4318 const TestSuite& test_suite) {4319 const std::string kTestsuite = "testsuite";4320 *stream << " <" << kTestsuite;4321 OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());4322 OutputXmlAttribute(stream, kTestsuite, "tests",4323 StreamableToString(test_suite.reportable_test_count()));4324 if (!GTEST_FLAG_GET(list_tests)) {4325 OutputXmlAttribute(stream, kTestsuite, "failures",4326 StreamableToString(test_suite.failed_test_count()));4327 OutputXmlAttribute(4328 stream, kTestsuite, "disabled",4329 StreamableToString(test_suite.reportable_disabled_test_count()));4330 OutputXmlAttribute(stream, kTestsuite, "skipped",4331 StreamableToString(test_suite.skipped_test_count()));4332 4333 OutputXmlAttribute(stream, kTestsuite, "errors", "0");4334 4335 OutputXmlAttribute(stream, kTestsuite, "time",4336 FormatTimeInMillisAsSeconds(test_suite.elapsed_time()));4337 OutputXmlAttribute(4338 stream, kTestsuite, "timestamp",4339 FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp()));4340 *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());4341 }4342 *stream << ">\n";4343 for (int i = 0; i < test_suite.total_test_count(); ++i) {4344 if (test_suite.GetTestInfo(i)->is_reportable())4345 OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));4346 }4347 *stream << " </" << kTestsuite << ">\n";4348}4349 4350// Prints an XML summary of unit_test to output stream out.4351void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,4352 const UnitTest& unit_test) {4353 const std::string kTestsuites = "testsuites";4354 4355 *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";4356 *stream << "<" << kTestsuites;4357 4358 OutputXmlAttribute(stream, kTestsuites, "tests",4359 StreamableToString(unit_test.reportable_test_count()));4360 OutputXmlAttribute(stream, kTestsuites, "failures",4361 StreamableToString(unit_test.failed_test_count()));4362 OutputXmlAttribute(4363 stream, kTestsuites, "disabled",4364 StreamableToString(unit_test.reportable_disabled_test_count()));4365 OutputXmlAttribute(stream, kTestsuites, "errors", "0");4366 OutputXmlAttribute(stream, kTestsuites, "time",4367 FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));4368 OutputXmlAttribute(4369 stream, kTestsuites, "timestamp",4370 FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));4371 4372 if (GTEST_FLAG_GET(shuffle)) {4373 OutputXmlAttribute(stream, kTestsuites, "random_seed",4374 StreamableToString(unit_test.random_seed()));4375 }4376 *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());4377 4378 OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");4379 *stream << ">\n";4380 4381 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {4382 if (unit_test.GetTestSuite(i)->reportable_test_count() > 0)4383 PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i));4384 }4385 4386 // If there was a test failure outside of one of the test suites (like in a4387 // test environment) include that in the output.4388 if (unit_test.ad_hoc_test_result().Failed()) {4389 OutputXmlTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());4390 }4391 4392 *stream << "</" << kTestsuites << ">\n";4393}4394 4395void XmlUnitTestResultPrinter::PrintXmlTestsList(4396 std::ostream* stream, const std::vector<TestSuite*>& test_suites) {4397 const std::string kTestsuites = "testsuites";4398 4399 *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";4400 *stream << "<" << kTestsuites;4401 4402 int total_tests = 0;4403 for (auto test_suite : test_suites) {4404 total_tests += test_suite->total_test_count();4405 }4406 OutputXmlAttribute(stream, kTestsuites, "tests",4407 StreamableToString(total_tests));4408 OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");4409 *stream << ">\n";4410 4411 for (auto test_suite : test_suites) {4412 PrintXmlTestSuite(stream, *test_suite);4413 }4414 *stream << "</" << kTestsuites << ">\n";4415}4416 4417// Produces a string representing the test properties in a result as space4418// delimited XML attributes based on the property key="value" pairs.4419std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(4420 const TestResult& result) {4421 Message attributes;4422 for (int i = 0; i < result.test_property_count(); ++i) {4423 const TestProperty& property = result.GetTestProperty(i);4424 attributes << " " << property.key() << "="4425 << "\"" << EscapeXmlAttribute(property.value()) << "\"";4426 }4427 return attributes.GetString();4428}4429 4430void XmlUnitTestResultPrinter::OutputXmlTestProperties(4431 std::ostream* stream, const TestResult& result) {4432 const std::string kProperties = "properties";4433 const std::string kProperty = "property";4434 4435 if (result.test_property_count() <= 0) {4436 return;4437 }4438 4439 *stream << " <" << kProperties << ">\n";4440 for (int i = 0; i < result.test_property_count(); ++i) {4441 const TestProperty& property = result.GetTestProperty(i);4442 *stream << " <" << kProperty;4443 *stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";4444 *stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";4445 *stream << "/>\n";4446 }4447 *stream << " </" << kProperties << ">\n";4448}4449 4450// End XmlUnitTestResultPrinter4451#endif // GTEST_HAS_FILE_SYSTEM4452 4453#if GTEST_HAS_FILE_SYSTEM4454// This class generates an JSON output file.4455class JsonUnitTestResultPrinter : public EmptyTestEventListener {4456 public:4457 explicit JsonUnitTestResultPrinter(const char* output_file);4458 4459 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;4460 4461 // Prints an JSON summary of all unit tests.4462 static void PrintJsonTestList(::std::ostream* stream,4463 const std::vector<TestSuite*>& test_suites);4464 4465 private:4466 // Returns an JSON-escaped copy of the input string str.4467 static std::string EscapeJson(const std::string& str);4468 4469 //// Verifies that the given attribute belongs to the given element and4470 //// streams the attribute as JSON.4471 static void OutputJsonKey(std::ostream* stream,4472 const std::string& element_name,4473 const std::string& name, const std::string& value,4474 const std::string& indent, bool comma = true);4475 static void OutputJsonKey(std::ostream* stream,4476 const std::string& element_name,4477 const std::string& name, int value,4478 const std::string& indent, bool comma = true);4479 4480 // Streams a test suite JSON stanza containing the given test result.4481 //4482 // Requires: result.Failed()4483 static void OutputJsonTestSuiteForTestResult(::std::ostream* stream,4484 const TestResult& result);4485 4486 // Streams a JSON representation of a TestResult object.4487 static void OutputJsonTestResult(::std::ostream* stream,4488 const TestResult& result);4489 4490 // Streams a JSON representation of a TestInfo object.4491 static void OutputJsonTestInfo(::std::ostream* stream,4492 const char* test_suite_name,4493 const TestInfo& test_info);4494 4495 // Prints a JSON representation of a TestSuite object4496 static void PrintJsonTestSuite(::std::ostream* stream,4497 const TestSuite& test_suite);4498 4499 // Prints a JSON summary of unit_test to output stream out.4500 static void PrintJsonUnitTest(::std::ostream* stream,4501 const UnitTest& unit_test);4502 4503 // Produces a string representing the test properties in a result as4504 // a JSON dictionary.4505 static std::string TestPropertiesAsJson(const TestResult& result,4506 const std::string& indent);4507 4508 // The output file.4509 const std::string output_file_;4510 4511 JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;4512 JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrinter&) =4513 delete;4514};4515 4516// Creates a new JsonUnitTestResultPrinter.4517JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file)4518 : output_file_(output_file) {4519 if (output_file_.empty()) {4520 GTEST_LOG_(FATAL) << "JSON output file may not be null";4521 }4522}4523 4524void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,4525 int /*iteration*/) {4526 FILE* jsonout = OpenFileForWriting(output_file_);4527 std::stringstream stream;4528 PrintJsonUnitTest(&stream, unit_test);4529 fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());4530 fclose(jsonout);4531}4532 4533// Returns an JSON-escaped copy of the input string str.4534std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {4535 Message m;4536 4537 for (size_t i = 0; i < str.size(); ++i) {4538 const char ch = str[i];4539 switch (ch) {4540 case '\\':4541 case '"':4542 case '/':4543 m << '\\' << ch;4544 break;4545 case '\b':4546 m << "\\b";4547 break;4548 case '\t':4549 m << "\\t";4550 break;4551 case '\n':4552 m << "\\n";4553 break;4554 case '\f':4555 m << "\\f";4556 break;4557 case '\r':4558 m << "\\r";4559 break;4560 default:4561 if (ch < ' ') {4562 m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch));4563 } else {4564 m << ch;4565 }4566 break;4567 }4568 }4569 4570 return m.GetString();4571}4572 4573// The following routines generate an JSON representation of a UnitTest4574// object.4575 4576// Formats the given time in milliseconds as seconds.4577static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {4578 ::std::stringstream ss;4579 ss << (static_cast<double>(ms) * 1e-3) << "s";4580 return ss.str();4581}4582 4583// Converts the given epoch time in milliseconds to a date string in the4584// RFC3339 format, without the timezone information.4585static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {4586 struct tm time_struct;4587 if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))4588 return "";4589 // YYYY-MM-DDThh:mm:ss4590 return StreamableToString(time_struct.tm_year + 1900) + "-" +4591 String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +4592 String::FormatIntWidth2(time_struct.tm_mday) + "T" +4593 String::FormatIntWidth2(time_struct.tm_hour) + ":" +4594 String::FormatIntWidth2(time_struct.tm_min) + ":" +4595 String::FormatIntWidth2(time_struct.tm_sec) + "Z";4596}4597 4598static inline std::string Indent(size_t width) {4599 return std::string(width, ' ');4600}4601 4602void JsonUnitTestResultPrinter::OutputJsonKey(std::ostream* stream,4603 const std::string& element_name,4604 const std::string& name,4605 const std::string& value,4606 const std::string& indent,4607 bool comma) {4608 const std::vector<std::string>& allowed_names =4609 GetReservedOutputAttributesForElement(element_name);4610 4611 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=4612 allowed_names.end())4613 << "Key \"" << name << "\" is not allowed for value \"" << element_name4614 << "\".";4615 4616 *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\"";4617 if (comma) *stream << ",\n";4618}4619 4620void JsonUnitTestResultPrinter::OutputJsonKey(4621 std::ostream* stream, const std::string& element_name,4622 const std::string& name, int value, const std::string& indent, bool comma) {4623 const std::vector<std::string>& allowed_names =4624 GetReservedOutputAttributesForElement(element_name);4625 4626 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=4627 allowed_names.end())4628 << "Key \"" << name << "\" is not allowed for value \"" << element_name4629 << "\".";4630 4631 *stream << indent << "\"" << name << "\": " << StreamableToString(value);4632 if (comma) *stream << ",\n";4633}4634 4635// Streams a test suite JSON stanza containing the given test result.4636void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(4637 ::std::ostream* stream, const TestResult& result) {4638 // Output the boilerplate for a new test suite.4639 *stream << Indent(4) << "{\n";4640 OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6));4641 OutputJsonKey(stream, "testsuite", "tests", 1, Indent(6));4642 if (!GTEST_FLAG_GET(list_tests)) {4643 OutputJsonKey(stream, "testsuite", "failures", 1, Indent(6));4644 OutputJsonKey(stream, "testsuite", "disabled", 0, Indent(6));4645 OutputJsonKey(stream, "testsuite", "skipped", 0, Indent(6));4646 OutputJsonKey(stream, "testsuite", "errors", 0, Indent(6));4647 OutputJsonKey(stream, "testsuite", "time",4648 FormatTimeInMillisAsDuration(result.elapsed_time()),4649 Indent(6));4650 OutputJsonKey(stream, "testsuite", "timestamp",4651 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),4652 Indent(6));4653 }4654 *stream << Indent(6) << "\"testsuite\": [\n";4655 4656 // Output the boilerplate for a new test case.4657 *stream << Indent(8) << "{\n";4658 OutputJsonKey(stream, "testcase", "name", "", Indent(10));4659 OutputJsonKey(stream, "testcase", "status", "RUN", Indent(10));4660 OutputJsonKey(stream, "testcase", "result", "COMPLETED", Indent(10));4661 OutputJsonKey(stream, "testcase", "timestamp",4662 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),4663 Indent(10));4664 OutputJsonKey(stream, "testcase", "time",4665 FormatTimeInMillisAsDuration(result.elapsed_time()),4666 Indent(10));4667 OutputJsonKey(stream, "testcase", "classname", "", Indent(10), false);4668 *stream << TestPropertiesAsJson(result, Indent(10));4669 4670 // Output the actual test result.4671 OutputJsonTestResult(stream, result);4672 4673 // Finish the test suite.4674 *stream << "\n" << Indent(6) << "]\n" << Indent(4) << "}";4675}4676 4677// Prints a JSON representation of a TestInfo object.4678void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,4679 const char* test_suite_name,4680 const TestInfo& test_info) {4681 const TestResult& result = *test_info.result();4682 const std::string kTestsuite = "testcase";4683 const std::string kIndent = Indent(10);4684 4685 *stream << Indent(8) << "{\n";4686 OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent);4687 4688 if (test_info.value_param() != nullptr) {4689 OutputJsonKey(stream, kTestsuite, "value_param", test_info.value_param(),4690 kIndent);4691 }4692 if (test_info.type_param() != nullptr) {4693 OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(),4694 kIndent);4695 }4696 4697 OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);4698 OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false);4699 if (GTEST_FLAG_GET(list_tests)) {4700 *stream << "\n" << Indent(8) << "}";4701 return;4702 } else {4703 *stream << ",\n";4704 }4705 4706 OutputJsonKey(stream, kTestsuite, "status",4707 test_info.should_run() ? "RUN" : "NOTRUN", kIndent);4708 OutputJsonKey(stream, kTestsuite, "result",4709 test_info.should_run()4710 ? (result.Skipped() ? "SKIPPED" : "COMPLETED")4711 : "SUPPRESSED",4712 kIndent);4713 OutputJsonKey(stream, kTestsuite, "timestamp",4714 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),4715 kIndent);4716 OutputJsonKey(stream, kTestsuite, "time",4717 FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent);4718 OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent,4719 false);4720 *stream << TestPropertiesAsJson(result, kIndent);4721 4722 OutputJsonTestResult(stream, result);4723}4724 4725void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,4726 const TestResult& result) {4727 const std::string kIndent = Indent(10);4728 4729 int failures = 0;4730 for (int i = 0; i < result.total_part_count(); ++i) {4731 const TestPartResult& part = result.GetTestPartResult(i);4732 if (part.failed()) {4733 *stream << ",\n";4734 if (++failures == 1) {4735 *stream << kIndent << "\""4736 << "failures"4737 << "\": [\n";4738 }4739 const std::string location =4740 internal::FormatCompilerIndependentFileLocation(part.file_name(),4741 part.line_number());4742 const std::string message = EscapeJson(location + "\n" + part.message());4743 *stream << kIndent << " {\n"4744 << kIndent << " \"failure\": \"" << message << "\",\n"4745 << kIndent << " \"type\": \"\"\n"4746 << kIndent << " }";4747 }4748 }4749 4750 if (failures > 0) *stream << "\n" << kIndent << "]";4751 *stream << "\n" << Indent(8) << "}";4752}4753 4754// Prints an JSON representation of a TestSuite object4755void JsonUnitTestResultPrinter::PrintJsonTestSuite(4756 std::ostream* stream, const TestSuite& test_suite) {4757 const std::string kTestsuite = "testsuite";4758 const std::string kIndent = Indent(6);4759 4760 *stream << Indent(4) << "{\n";4761 OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);4762 OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(),4763 kIndent);4764 if (!GTEST_FLAG_GET(list_tests)) {4765 OutputJsonKey(stream, kTestsuite, "failures",4766 test_suite.failed_test_count(), kIndent);4767 OutputJsonKey(stream, kTestsuite, "disabled",4768 test_suite.reportable_disabled_test_count(), kIndent);4769 OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);4770 OutputJsonKey(4771 stream, kTestsuite, "timestamp",4772 FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()),4773 kIndent);4774 OutputJsonKey(stream, kTestsuite, "time",4775 FormatTimeInMillisAsDuration(test_suite.elapsed_time()),4776 kIndent, false);4777 *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent)4778 << ",\n";4779 }4780 4781 *stream << kIndent << "\"" << kTestsuite << "\": [\n";4782 4783 bool comma = false;4784 for (int i = 0; i < test_suite.total_test_count(); ++i) {4785 if (test_suite.GetTestInfo(i)->is_reportable()) {4786 if (comma) {4787 *stream << ",\n";4788 } else {4789 comma = true;4790 }4791 OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));4792 }4793 }4794 *stream << "\n" << kIndent << "]\n" << Indent(4) << "}";4795}4796 4797// Prints a JSON summary of unit_test to output stream out.4798void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,4799 const UnitTest& unit_test) {4800 const std::string kTestsuites = "testsuites";4801 const std::string kIndent = Indent(2);4802 *stream << "{\n";4803 4804 OutputJsonKey(stream, kTestsuites, "tests", unit_test.reportable_test_count(),4805 kIndent);4806 OutputJsonKey(stream, kTestsuites, "failures", unit_test.failed_test_count(),4807 kIndent);4808 OutputJsonKey(stream, kTestsuites, "disabled",4809 unit_test.reportable_disabled_test_count(), kIndent);4810 OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent);4811 if (GTEST_FLAG_GET(shuffle)) {4812 OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(),4813 kIndent);4814 }4815 OutputJsonKey(stream, kTestsuites, "timestamp",4816 FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()),4817 kIndent);4818 OutputJsonKey(stream, kTestsuites, "time",4819 FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent,4820 false);4821 4822 *stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent)4823 << ",\n";4824 4825 OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);4826 *stream << kIndent << "\"" << kTestsuites << "\": [\n";4827 4828 bool comma = false;4829 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {4830 if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) {4831 if (comma) {4832 *stream << ",\n";4833 } else {4834 comma = true;4835 }4836 PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i));4837 }4838 }4839 4840 // If there was a test failure outside of one of the test suites (like in a4841 // test environment) include that in the output.4842 if (unit_test.ad_hoc_test_result().Failed()) {4843 if (comma) {4844 *stream << ",\n";4845 }4846 OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());4847 }4848 4849 *stream << "\n"4850 << kIndent << "]\n"4851 << "}\n";4852}4853 4854void JsonUnitTestResultPrinter::PrintJsonTestList(4855 std::ostream* stream, const std::vector<TestSuite*>& test_suites) {4856 const std::string kTestsuites = "testsuites";4857 const std::string kIndent = Indent(2);4858 *stream << "{\n";4859 int total_tests = 0;4860 for (auto test_suite : test_suites) {4861 total_tests += test_suite->total_test_count();4862 }4863 OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent);4864 4865 OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);4866 *stream << kIndent << "\"" << kTestsuites << "\": [\n";4867 4868 for (size_t i = 0; i < test_suites.size(); ++i) {4869 if (i != 0) {4870 *stream << ",\n";4871 }4872 PrintJsonTestSuite(stream, *test_suites[i]);4873 }4874 4875 *stream << "\n"4876 << kIndent << "]\n"4877 << "}\n";4878}4879// Produces a string representing the test properties in a result as4880// a JSON dictionary.4881std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(4882 const TestResult& result, const std::string& indent) {4883 Message attributes;4884 for (int i = 0; i < result.test_property_count(); ++i) {4885 const TestProperty& property = result.GetTestProperty(i);4886 attributes << ",\n"4887 << indent << "\"" << property.key() << "\": "4888 << "\"" << EscapeJson(property.value()) << "\"";4889 }4890 return attributes.GetString();4891}4892 4893// End JsonUnitTestResultPrinter4894#endif // GTEST_HAS_FILE_SYSTEM4895 4896#if GTEST_CAN_STREAM_RESULTS_4897 4898// Checks if str contains '=', '&', '%' or '\n' characters. If yes,4899// replaces them by "%xx" where xx is their hexadecimal value. For4900// example, replaces "=" with "%3D". This algorithm is O(strlen(str))4901// in both time and space -- important as the input str may contain an4902// arbitrarily long test failure message and stack trace.4903std::string StreamingListener::UrlEncode(const char* str) {4904 std::string result;4905 result.reserve(strlen(str) + 1);4906 for (char ch = *str; ch != '\0'; ch = *++str) {4907 switch (ch) {4908 case '%':4909 case '=':4910 case '&':4911 case '\n':4912 result.push_back('%');4913 result.append(String::FormatByte(static_cast<unsigned char>(ch)));4914 break;4915 default:4916 result.push_back(ch);4917 break;4918 }4919 }4920 return result;4921}4922 4923void StreamingListener::SocketWriter::MakeConnection() {4924 GTEST_CHECK_(sockfd_ == -1)4925 << "MakeConnection() can't be called when there is already a connection.";4926 4927 addrinfo hints;4928 memset(&hints, 0, sizeof(hints));4929 hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses.4930 hints.ai_socktype = SOCK_STREAM;4931 addrinfo* servinfo = nullptr;4932 4933 // Use the getaddrinfo() to get a linked list of IP addresses for4934 // the given host name.4935 const int error_num =4936 getaddrinfo(host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);4937 if (error_num != 0) {4938 GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "4939 << gai_strerror(error_num);4940 }4941 4942 // Loop through all the results and connect to the first we can.4943 for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;4944 cur_addr = cur_addr->ai_next) {4945 sockfd_ = socket(cur_addr->ai_family, cur_addr->ai_socktype,4946 cur_addr->ai_protocol);4947 if (sockfd_ != -1) {4948 // Connect the client socket to the server socket.4949 if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {4950 close(sockfd_);4951 sockfd_ = -1;4952 }4953 }4954 }4955 4956 freeaddrinfo(servinfo); // all done with this structure4957 4958 if (sockfd_ == -1) {4959 GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "4960 << host_name_ << ":" << port_num_;4961 }4962}4963 4964// End of class Streaming Listener4965#endif // GTEST_CAN_STREAM_RESULTS__4966 4967// class OsStackTraceGetter4968 4969const char* const OsStackTraceGetterInterface::kElidedFramesMarker =4970 "... " GTEST_NAME_ " internal frames ...";4971 4972std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)4973 GTEST_LOCK_EXCLUDED_(mutex_) {4974#ifdef GTEST_HAS_ABSL4975 std::string result;4976 4977 if (max_depth <= 0) {4978 return result;4979 }4980 4981 max_depth = std::min(max_depth, kMaxStackTraceDepth);4982 4983 std::vector<void*> raw_stack(max_depth);4984 // Skips the frames requested by the caller, plus this function.4985 const int raw_stack_size =4986 absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1);4987 4988 void* caller_frame = nullptr;4989 {4990 MutexLock lock(&mutex_);4991 caller_frame = caller_frame_;4992 }4993 4994 for (int i = 0; i < raw_stack_size; ++i) {4995 if (raw_stack[i] == caller_frame &&4996 !GTEST_FLAG_GET(show_internal_stack_frames)) {4997 // Add a marker to the trace and stop adding frames.4998 absl::StrAppend(&result, kElidedFramesMarker, "\n");4999 break;5000 }5001 5002 char tmp[1024];5003 const char* symbol = "(unknown)";5004 if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) {5005 symbol = tmp;5006 }5007 5008 char line[1024];5009 snprintf(line, sizeof(line), " %p: %s\n", raw_stack[i], symbol);5010 result += line;5011 }5012 5013 return result;5014 5015#else // !GTEST_HAS_ABSL5016 static_cast<void>(max_depth);5017 static_cast<void>(skip_count);5018 return "";5019#endif // GTEST_HAS_ABSL5020}5021 5022void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {5023#ifdef GTEST_HAS_ABSL5024 void* caller_frame = nullptr;5025 if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {5026 caller_frame = nullptr;5027 }5028 5029 MutexLock lock(&mutex_);5030 caller_frame_ = caller_frame;5031#endif // GTEST_HAS_ABSL5032}5033 5034#ifdef GTEST_HAS_DEATH_TEST5035// A helper class that creates the premature-exit file in its5036// constructor and deletes the file in its destructor.5037class ScopedPrematureExitFile {5038 public:5039 explicit ScopedPrematureExitFile(const char* premature_exit_filepath)5040 : premature_exit_filepath_(5041 premature_exit_filepath ? premature_exit_filepath : "") {5042 // If a path to the premature-exit file is specified...5043 if (!premature_exit_filepath_.empty()) {5044 // create the file with a single "0" character in it. I/O5045 // errors are ignored as there's nothing better we can do and we5046 // don't want to fail the test because of this.5047 FILE* pfile = posix::FOpen(premature_exit_filepath_.c_str(), "w");5048 fwrite("0", 1, 1, pfile);5049 fclose(pfile);5050 }5051 }5052 5053 ~ScopedPrematureExitFile() {5054#ifndef GTEST_OS_ESP82665055 if (!premature_exit_filepath_.empty()) {5056 int retval = remove(premature_exit_filepath_.c_str());5057 if (retval) {5058 GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""5059 << premature_exit_filepath_ << "\" with error "5060 << retval;5061 }5062 }5063#endif5064 }5065 5066 private:5067 const std::string premature_exit_filepath_;5068 5069 ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;5070 ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&) = delete;5071};5072#endif // GTEST_HAS_DEATH_TEST5073 5074} // namespace internal5075 5076// class TestEventListeners5077 5078TestEventListeners::TestEventListeners()5079 : repeater_(new internal::TestEventRepeater()),5080 default_result_printer_(nullptr),5081 default_xml_generator_(nullptr) {}5082 5083TestEventListeners::~TestEventListeners() { delete repeater_; }5084 5085// Returns the standard listener responsible for the default console5086// output. Can be removed from the listeners list to shut down default5087// console output. Note that removing this object from the listener list5088// with Release transfers its ownership to the user.5089void TestEventListeners::Append(TestEventListener* listener) {5090 repeater_->Append(listener);5091}5092 5093// Removes the given event listener from the list and returns it. It then5094// becomes the caller's responsibility to delete the listener. Returns5095// NULL if the listener is not found in the list.5096TestEventListener* TestEventListeners::Release(TestEventListener* listener) {5097 if (listener == default_result_printer_)5098 default_result_printer_ = nullptr;5099 else if (listener == default_xml_generator_)5100 default_xml_generator_ = nullptr;5101 return repeater_->Release(listener);5102}5103 5104// Returns repeater that broadcasts the TestEventListener events to all5105// subscribers.5106TestEventListener* TestEventListeners::repeater() { return repeater_; }5107 5108// Sets the default_result_printer attribute to the provided listener.5109// The listener is also added to the listener list and previous5110// default_result_printer is removed from it and deleted. The listener can5111// also be NULL in which case it will not be added to the list. Does5112// nothing if the previous and the current listener objects are the same.5113void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {5114 if (default_result_printer_ != listener) {5115 // It is an error to pass this method a listener that is already in the5116 // list.5117 delete Release(default_result_printer_);5118 default_result_printer_ = listener;5119 if (listener != nullptr) Append(listener);5120 }5121}5122 5123// Sets the default_xml_generator attribute to the provided listener. The5124// listener is also added to the listener list and previous5125// default_xml_generator is removed from it and deleted. The listener can5126// also be NULL in which case it will not be added to the list. Does5127// nothing if the previous and the current listener objects are the same.5128void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {5129 if (default_xml_generator_ != listener) {5130 // It is an error to pass this method a listener that is already in the5131 // list.5132 delete Release(default_xml_generator_);5133 default_xml_generator_ = listener;5134 if (listener != nullptr) Append(listener);5135 }5136}5137 5138// Controls whether events will be forwarded by the repeater to the5139// listeners in the list.5140bool TestEventListeners::EventForwardingEnabled() const {5141 return repeater_->forwarding_enabled();5142}5143 5144void TestEventListeners::SuppressEventForwarding(bool suppress) {5145 repeater_->set_forwarding_enabled(!suppress);5146}5147 5148// class UnitTest5149 5150// Gets the singleton UnitTest object. The first time this method is5151// called, a UnitTest object is constructed and returned. Consecutive5152// calls will return the same object.5153//5154// We don't protect this under mutex_ as a user is not supposed to5155// call this before main() starts, from which point on the return5156// value will never change.5157UnitTest* UnitTest::GetInstance() {5158 // CodeGear C++Builder insists on a public destructor for the5159 // default implementation. Use this implementation to keep good OO5160 // design with private destructor.5161 5162#if defined(__BORLANDC__)5163 static UnitTest* const instance = new UnitTest;5164 return instance;5165#else5166 static UnitTest instance;5167 return &instance;5168#endif // defined(__BORLANDC__)5169}5170 5171// Gets the number of successful test suites.5172int UnitTest::successful_test_suite_count() const {5173 return impl()->successful_test_suite_count();5174}5175 5176// Gets the number of failed test suites.5177int UnitTest::failed_test_suite_count() const {5178 return impl()->failed_test_suite_count();5179}5180 5181// Gets the number of all test suites.5182int UnitTest::total_test_suite_count() const {5183 return impl()->total_test_suite_count();5184}5185 5186// Gets the number of all test suites that contain at least one test5187// that should run.5188int UnitTest::test_suite_to_run_count() const {5189 return impl()->test_suite_to_run_count();5190}5191 5192// Legacy API is deprecated but still available5193#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_5194int UnitTest::successful_test_case_count() const {5195 return impl()->successful_test_suite_count();5196}5197int UnitTest::failed_test_case_count() const {5198 return impl()->failed_test_suite_count();5199}5200int UnitTest::total_test_case_count() const {5201 return impl()->total_test_suite_count();5202}5203int UnitTest::test_case_to_run_count() const {5204 return impl()->test_suite_to_run_count();5205}5206#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_5207 5208// Gets the number of successful tests.5209int UnitTest::successful_test_count() const {5210 return impl()->successful_test_count();5211}5212 5213// Gets the number of skipped tests.5214int UnitTest::skipped_test_count() const {5215 return impl()->skipped_test_count();5216}5217 5218// Gets the number of failed tests.5219int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }5220 5221// Gets the number of disabled tests that will be reported in the XML report.5222int UnitTest::reportable_disabled_test_count() const {5223 return impl()->reportable_disabled_test_count();5224}5225 5226// Gets the number of disabled tests.5227int UnitTest::disabled_test_count() const {5228 return impl()->disabled_test_count();5229}5230 5231// Gets the number of tests to be printed in the XML report.5232int UnitTest::reportable_test_count() const {5233 return impl()->reportable_test_count();5234}5235 5236// Gets the number of all tests.5237int UnitTest::total_test_count() const { return impl()->total_test_count(); }5238 5239// Gets the number of tests that should run.5240int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }5241 5242// Gets the time of the test program start, in ms from the start of the5243// UNIX epoch.5244internal::TimeInMillis UnitTest::start_timestamp() const {5245 return impl()->start_timestamp();5246}5247 5248// Gets the elapsed time, in milliseconds.5249internal::TimeInMillis UnitTest::elapsed_time() const {5250 return impl()->elapsed_time();5251}5252 5253// Returns true if and only if the unit test passed (i.e. all test suites5254// passed).5255bool UnitTest::Passed() const { return impl()->Passed(); }5256 5257// Returns true if and only if the unit test failed (i.e. some test suite5258// failed or something outside of all tests failed).5259bool UnitTest::Failed() const { return impl()->Failed(); }5260 5261// Gets the i-th test suite among all the test suites. i can range from 0 to5262// total_test_suite_count() - 1. If i is not in that range, returns NULL.5263const TestSuite* UnitTest::GetTestSuite(int i) const {5264 return impl()->GetTestSuite(i);5265}5266 5267// Legacy API is deprecated but still available5268#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_5269const TestCase* UnitTest::GetTestCase(int i) const {5270 return impl()->GetTestCase(i);5271}5272#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_5273 5274// Returns the TestResult containing information on test failures and5275// properties logged outside of individual test suites.5276const TestResult& UnitTest::ad_hoc_test_result() const {5277 return *impl()->ad_hoc_test_result();5278}5279 5280// Gets the i-th test suite among all the test suites. i can range from 0 to5281// total_test_suite_count() - 1. If i is not in that range, returns NULL.5282TestSuite* UnitTest::GetMutableTestSuite(int i) {5283 return impl()->GetMutableSuiteCase(i);5284}5285 5286// Returns the list of event listeners that can be used to track events5287// inside Google Test.5288TestEventListeners& UnitTest::listeners() { return *impl()->listeners(); }5289 5290// Registers and returns a global test environment. When a test5291// program is run, all global test environments will be set-up in the5292// order they were registered. After all tests in the program have5293// finished, all global test environments will be torn-down in the5294// *reverse* order they were registered.5295//5296// The UnitTest object takes ownership of the given environment.5297//5298// We don't protect this under mutex_, as we only support calling it5299// from the main thread.5300Environment* UnitTest::AddEnvironment(Environment* env) {5301 if (env == nullptr) {5302 return nullptr;5303 }5304 5305 impl_->environments().push_back(env);5306 return env;5307}5308 5309// Adds a TestPartResult to the current TestResult object. All Google Test5310// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call5311// this to report their results. The user code should use the5312// assertion macros instead of calling this directly.5313void UnitTest::AddTestPartResult(TestPartResult::Type result_type,5314 const char* file_name, int line_number,5315 const std::string& message,5316 const std::string& os_stack_trace)5317 GTEST_LOCK_EXCLUDED_(mutex_) {5318 Message msg;5319 msg << message;5320 5321 internal::MutexLock lock(&mutex_);5322 if (!impl_->gtest_trace_stack().empty()) {5323 msg << "\n" << GTEST_NAME_ << " trace:";5324 5325 for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) {5326 const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];5327 msg << "\n"5328 << internal::FormatFileLocation(trace.file, trace.line) << " "5329 << trace.message;5330 }5331 }5332 5333 if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) {5334 msg << internal::kStackTraceMarker << os_stack_trace;5335 } else {5336 msg << "\n";5337 }5338 5339 const TestPartResult result = TestPartResult(5340 result_type, file_name, line_number, msg.GetString().c_str());5341 impl_->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(5342 result);5343 5344 if (result_type != TestPartResult::kSuccess &&5345 result_type != TestPartResult::kSkip) {5346 // gtest_break_on_failure takes precedence over5347 // gtest_throw_on_failure. This allows a user to set the latter5348 // in the code (perhaps in order to use Google Test assertions5349 // with another testing framework) and specify the former on the5350 // command line for debugging.5351 if (GTEST_FLAG_GET(break_on_failure)) {5352#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_PHONE) && \5353 !defined(GTEST_OS_WINDOWS_RT)5354 // Using DebugBreak on Windows allows gtest to still break into a debugger5355 // when a failure happens and both the --gtest_break_on_failure and5356 // the --gtest_catch_exceptions flags are specified.5357 DebugBreak();5358#elif (!defined(__native_client__)) && \5359 ((defined(__clang__) || defined(__GNUC__)) && \5360 (defined(__x86_64__) || defined(__i386__)))5361 // with clang/gcc we can achieve the same effect on x86 by invoking int35362 asm("int3");5363#elif GTEST_HAS_BUILTIN(__builtin_trap)5364 __builtin_trap();5365#elif defined(SIGTRAP)5366 raise(SIGTRAP);5367#else5368 // Dereference nullptr through a volatile pointer to prevent the compiler5369 // from removing. We use this rather than abort() or __builtin_trap() for5370 // portability: some debuggers don't correctly trap abort().5371 *static_cast<volatile int*>(nullptr) = 1;5372#endif // GTEST_OS_WINDOWS5373 } else if (GTEST_FLAG_GET(throw_on_failure)) {5374#if GTEST_HAS_EXCEPTIONS5375 throw internal::GoogleTestFailureException(result);5376#else5377 // We cannot call abort() as it generates a pop-up in debug mode5378 // that cannot be suppressed in VC 7.1 or below.5379 exit(1);5380#endif5381 }5382 }5383}5384 5385// Adds a TestProperty to the current TestResult object when invoked from5386// inside a test, to current TestSuite's ad_hoc_test_result_ when invoked5387// from SetUpTestSuite or TearDownTestSuite, or to the global property set5388// when invoked elsewhere. If the result already contains a property with5389// the same key, the value will be updated.5390void UnitTest::RecordProperty(const std::string& key,5391 const std::string& value) {5392 impl_->RecordProperty(TestProperty(key, value));5393}5394 5395// Runs all tests in this UnitTest object and prints the result.5396// Returns 0 if successful, or 1 otherwise.5397//5398// We don't protect this under mutex_, as we only support calling it5399// from the main thread.5400int UnitTest::Run() {5401#ifdef GTEST_HAS_DEATH_TEST5402 const bool in_death_test_child_process =5403 GTEST_FLAG_GET(internal_run_death_test).length() > 0;5404 5405 // Google Test implements this protocol for catching that a test5406 // program exits before returning control to Google Test:5407 //5408 // 1. Upon start, Google Test creates a file whose absolute path5409 // is specified by the environment variable5410 // TEST_PREMATURE_EXIT_FILE.5411 // 2. When Google Test has finished its work, it deletes the file.5412 //5413 // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before5414 // running a Google-Test-based test program and check the existence5415 // of the file at the end of the test execution to see if it has5416 // exited prematurely.5417 5418 // If we are in the child process of a death test, don't5419 // create/delete the premature exit file, as doing so is unnecessary5420 // and will confuse the parent process. Otherwise, create/delete5421 // the file upon entering/leaving this function. If the program5422 // somehow exits before this function has a chance to return, the5423 // premature-exit file will be left undeleted, causing a test runner5424 // that understands the premature-exit-file protocol to report the5425 // test as having failed.5426 const internal::ScopedPrematureExitFile premature_exit_file(5427 in_death_test_child_process5428 ? nullptr5429 : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));5430#else5431 const bool in_death_test_child_process = false;5432#endif // GTEST_HAS_DEATH_TEST5433 5434 // Captures the value of GTEST_FLAG(catch_exceptions). This value will be5435 // used for the duration of the program.5436 impl()->set_catch_exceptions(GTEST_FLAG_GET(catch_exceptions));5437 5438#ifdef GTEST_OS_WINDOWS5439 // Either the user wants Google Test to catch exceptions thrown by the5440 // tests or this is executing in the context of death test child5441 // process. In either case the user does not want to see pop-up dialogs5442 // about crashes - they are expected.5443 if (impl()->catch_exceptions() || in_death_test_child_process) {5444#if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \5445 !defined(GTEST_OS_WINDOWS_RT)5446 // SetErrorMode doesn't exist on CE.5447 SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |5448 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);5449#endif // !GTEST_OS_WINDOWS_MOBILE5450 5451#if (defined(_MSC_VER) || defined(GTEST_OS_WINDOWS_MINGW)) && \5452 !defined(GTEST_OS_WINDOWS_MOBILE)5453 // Death test children can be terminated with _abort(). On Windows,5454 // _abort() can show a dialog with a warning message. This forces the5455 // abort message to go to stderr instead.5456 _set_error_mode(_OUT_TO_STDERR);5457#endif5458 5459#if defined(_MSC_VER) && !defined(GTEST_OS_WINDOWS_MOBILE)5460 // In the debug version, Visual Studio pops up a separate dialog5461 // offering a choice to debug the aborted program. We need to suppress5462 // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement5463 // executed. Google Test will notify the user of any unexpected5464 // failure via stderr.5465 if (!GTEST_FLAG_GET(break_on_failure))5466 _set_abort_behavior(5467 0x0, // Clear the following flags:5468 _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump.5469 5470 // In debug mode, the Windows CRT can crash with an assertion over invalid5471 // input (e.g. passing an invalid file descriptor). The default handling5472 // for these assertions is to pop up a dialog and wait for user input.5473 // Instead ask the CRT to dump such assertions to stderr non-interactively.5474 if (!IsDebuggerPresent()) {5475 (void)_CrtSetReportMode(_CRT_ASSERT,5476 _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);5477 (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);5478 }5479#endif5480 }5481#else5482 (void)in_death_test_child_process; // Needed inside the #if block above5483#endif // GTEST_OS_WINDOWS5484 5485 return internal::HandleExceptionsInMethodIfSupported(5486 impl(), &internal::UnitTestImpl::RunAllTests,5487 "auxiliary test code (environments or event listeners)")5488 ? 05489 : 1;5490}5491 5492#if GTEST_HAS_FILE_SYSTEM5493// Returns the working directory when the first TEST() or TEST_F() was5494// executed.5495const char* UnitTest::original_working_dir() const {5496 return impl_->original_working_dir_.c_str();5497}5498#endif // GTEST_HAS_FILE_SYSTEM5499 5500// Returns the TestSuite object for the test that's currently running,5501// or NULL if no test is running.5502const TestSuite* UnitTest::current_test_suite() const5503 GTEST_LOCK_EXCLUDED_(mutex_) {5504 internal::MutexLock lock(&mutex_);5505 return impl_->current_test_suite();5506}5507 5508// Legacy API is still available but deprecated5509#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_5510const TestCase* UnitTest::current_test_case() const5511 GTEST_LOCK_EXCLUDED_(mutex_) {5512 internal::MutexLock lock(&mutex_);5513 return impl_->current_test_suite();5514}5515#endif5516 5517// Returns the TestInfo object for the test that's currently running,5518// or NULL if no test is running.5519const TestInfo* UnitTest::current_test_info() const5520 GTEST_LOCK_EXCLUDED_(mutex_) {5521 internal::MutexLock lock(&mutex_);5522 return impl_->current_test_info();5523}5524 5525// Returns the random seed used at the start of the current test run.5526int UnitTest::random_seed() const { return impl_->random_seed(); }5527 5528// Returns ParameterizedTestSuiteRegistry object used to keep track of5529// value-parameterized tests and instantiate and register them.5530internal::ParameterizedTestSuiteRegistry&5531UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {5532 return impl_->parameterized_test_registry();5533}5534 5535// Creates an empty UnitTest.5536UnitTest::UnitTest() { impl_ = new internal::UnitTestImpl(this); }5537 5538// Destructor of UnitTest.5539UnitTest::~UnitTest() { delete impl_; }5540 5541// Pushes a trace defined by SCOPED_TRACE() on to the per-thread5542// Google Test trace stack.5543void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)5544 GTEST_LOCK_EXCLUDED_(mutex_) {5545 internal::MutexLock lock(&mutex_);5546 impl_->gtest_trace_stack().push_back(trace);5547}5548 5549// Pops a trace from the per-thread Google Test trace stack.5550void UnitTest::PopGTestTrace() GTEST_LOCK_EXCLUDED_(mutex_) {5551 internal::MutexLock lock(&mutex_);5552 impl_->gtest_trace_stack().pop_back();5553}5554 5555namespace internal {5556 5557UnitTestImpl::UnitTestImpl(UnitTest* parent)5558 : parent_(parent),5559 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)5560 default_global_test_part_result_reporter_(this),5561 default_per_thread_test_part_result_reporter_(this),5562 GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_reporter_(5563 &default_global_test_part_result_reporter_),5564 per_thread_test_part_result_reporter_(5565 &default_per_thread_test_part_result_reporter_),5566 parameterized_test_registry_(),5567 parameterized_tests_registered_(false),5568 last_death_test_suite_(-1),5569 current_test_suite_(nullptr),5570 current_test_info_(nullptr),5571 ad_hoc_test_result_(),5572 os_stack_trace_getter_(nullptr),5573 post_flag_parse_init_performed_(false),5574 random_seed_(0), // Will be overridden by the flag before first use.5575 random_(0), // Will be reseeded before first use.5576 start_timestamp_(0),5577 elapsed_time_(0),5578#ifdef GTEST_HAS_DEATH_TEST5579 death_test_factory_(new DefaultDeathTestFactory),5580#endif5581 // Will be overridden by the flag before first use.5582 catch_exceptions_(false) {5583 listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);5584}5585 5586UnitTestImpl::~UnitTestImpl() {5587 // Deletes every TestSuite.5588 ForEach(test_suites_, internal::Delete<TestSuite>);5589 5590 // Deletes every Environment.5591 ForEach(environments_, internal::Delete<Environment>);5592 5593 delete os_stack_trace_getter_;5594}5595 5596// Adds a TestProperty to the current TestResult object when invoked in a5597// context of a test, to current test suite's ad_hoc_test_result when invoke5598// from SetUpTestSuite/TearDownTestSuite, or to the global property set5599// otherwise. If the result already contains a property with the same key,5600// the value will be updated.5601void UnitTestImpl::RecordProperty(const TestProperty& test_property) {5602 std::string xml_element;5603 TestResult* test_result; // TestResult appropriate for property recording.5604 5605 if (current_test_info_ != nullptr) {5606 xml_element = "testcase";5607 test_result = &(current_test_info_->result_);5608 } else if (current_test_suite_ != nullptr) {5609 xml_element = "testsuite";5610 test_result = &(current_test_suite_->ad_hoc_test_result_);5611 } else {5612 xml_element = "testsuites";5613 test_result = &ad_hoc_test_result_;5614 }5615 test_result->RecordProperty(xml_element, test_property);5616}5617 5618#ifdef GTEST_HAS_DEATH_TEST5619// Disables event forwarding if the control is currently in a death test5620// subprocess. Must not be called before InitGoogleTest.5621void UnitTestImpl::SuppressTestEventsIfInSubprocess() {5622 if (internal_run_death_test_flag_ != nullptr)5623 listeners()->SuppressEventForwarding(true);5624}5625#endif // GTEST_HAS_DEATH_TEST5626 5627// Initializes event listeners performing XML output as specified by5628// UnitTestOptions. Must not be called before InitGoogleTest.5629void UnitTestImpl::ConfigureXmlOutput() {5630 const std::string& output_format = UnitTestOptions::GetOutputFormat();5631#if GTEST_HAS_FILE_SYSTEM5632 if (output_format == "xml") {5633 listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(5634 UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));5635 } else if (output_format == "json") {5636 listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(5637 UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));5638 } else if (!output_format.empty()) {5639 GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""5640 << output_format << "\" ignored.";5641 }5642#else5643 if (!output_format.empty()) {5644 GTEST_LOG_(ERROR) << "ERROR: alternative output formats require "5645 << "GTEST_HAS_FILE_SYSTEM to be enabled";5646 }5647#endif // GTEST_HAS_FILE_SYSTEM5648}5649 5650#if GTEST_CAN_STREAM_RESULTS_5651// Initializes event listeners for streaming test results in string form.5652// Must not be called before InitGoogleTest.5653void UnitTestImpl::ConfigureStreamingOutput() {5654 const std::string& target = GTEST_FLAG_GET(stream_result_to);5655 if (!target.empty()) {5656 const size_t pos = target.find(':');5657 if (pos != std::string::npos) {5658 listeners()->Append(5659 new StreamingListener(target.substr(0, pos), target.substr(pos + 1)));5660 } else {5661 GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target5662 << "\" ignored.";5663 }5664 }5665}5666#endif // GTEST_CAN_STREAM_RESULTS_5667 5668// Performs initialization dependent upon flag values obtained in5669// ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to5670// ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest5671// this function is also called from RunAllTests. Since this function can be5672// called more than once, it has to be idempotent.5673void UnitTestImpl::PostFlagParsingInit() {5674 // Ensures that this function does not execute more than once.5675 if (!post_flag_parse_init_performed_) {5676 post_flag_parse_init_performed_ = true;5677 5678#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)5679 // Register to send notifications about key process state changes.5680 listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());5681#endif // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)5682 5683#ifdef GTEST_HAS_DEATH_TEST5684 InitDeathTestSubprocessControlInfo();5685 SuppressTestEventsIfInSubprocess();5686#endif // GTEST_HAS_DEATH_TEST5687 5688 // Registers parameterized tests. This makes parameterized tests5689 // available to the UnitTest reflection API without running5690 // RUN_ALL_TESTS.5691 RegisterParameterizedTests();5692 5693 // Configures listeners for XML output. This makes it possible for users5694 // to shut down the default XML output before invoking RUN_ALL_TESTS.5695 ConfigureXmlOutput();5696 5697 if (GTEST_FLAG_GET(brief)) {5698 listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);5699 }5700 5701#if GTEST_CAN_STREAM_RESULTS_5702 // Configures listeners for streaming test results to the specified server.5703 ConfigureStreamingOutput();5704#endif // GTEST_CAN_STREAM_RESULTS_5705 5706#ifdef GTEST_HAS_ABSL5707 if (GTEST_FLAG_GET(install_failure_signal_handler)) {5708 absl::FailureSignalHandlerOptions options;5709 absl::InstallFailureSignalHandler(options);5710 }5711#endif // GTEST_HAS_ABSL5712 }5713}5714 5715// A predicate that checks the name of a TestSuite against a known5716// value.5717//5718// This is used for implementation of the UnitTest class only. We put5719// it in the anonymous namespace to prevent polluting the outer5720// namespace.5721//5722// TestSuiteNameIs is copyable.5723class TestSuiteNameIs {5724 public:5725 // Constructor.5726 explicit TestSuiteNameIs(const std::string& name) : name_(name) {}5727 5728 // Returns true if and only if the name of test_suite matches name_.5729 bool operator()(const TestSuite* test_suite) const {5730 return test_suite != nullptr &&5731 strcmp(test_suite->name(), name_.c_str()) == 0;5732 }5733 5734 private:5735 std::string name_;5736};5737 5738// Finds and returns a TestSuite with the given name. If one doesn't5739// exist, creates one and returns it. It's the CALLER'S5740// RESPONSIBILITY to ensure that this function is only called WHEN THE5741// TESTS ARE NOT SHUFFLED.5742//5743// Arguments:5744//5745// test_suite_name: name of the test suite5746// type_param: the name of the test suite's type parameter, or NULL if5747// this is not a typed or a type-parameterized test suite.5748// set_up_tc: pointer to the function that sets up the test suite5749// tear_down_tc: pointer to the function that tears down the test suite5750TestSuite* UnitTestImpl::GetTestSuite(5751 const char* test_suite_name, const char* type_param,5752 internal::SetUpTestSuiteFunc set_up_tc,5753 internal::TearDownTestSuiteFunc tear_down_tc) {5754 // Can we find a TestSuite with the given name?5755 const auto test_suite =5756 std::find_if(test_suites_.rbegin(), test_suites_.rend(),5757 TestSuiteNameIs(test_suite_name));5758 5759 if (test_suite != test_suites_.rend()) return *test_suite;5760 5761 // No. Let's create one.5762 auto* const new_test_suite =5763 new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);5764 5765 const UnitTestFilter death_test_suite_filter(kDeathTestSuiteFilter);5766 // Is this a death test suite?5767 if (death_test_suite_filter.MatchesName(test_suite_name)) {5768 // Yes. Inserts the test suite after the last death test suite5769 // defined so far. This only works when the test suites haven't5770 // been shuffled. Otherwise we may end up running a death test5771 // after a non-death test.5772 ++last_death_test_suite_;5773 test_suites_.insert(test_suites_.begin() + last_death_test_suite_,5774 new_test_suite);5775 } else {5776 // No. Appends to the end of the list.5777 test_suites_.push_back(new_test_suite);5778 }5779 5780 test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));5781 return new_test_suite;5782}5783 5784// Helpers for setting up / tearing down the given environment. They5785// are for use in the ForEach() function.5786static void SetUpEnvironment(Environment* env) { env->SetUp(); }5787static void TearDownEnvironment(Environment* env) { env->TearDown(); }5788 5789// Runs all tests in this UnitTest object, prints the result, and5790// returns true if all tests are successful. If any exception is5791// thrown during a test, the test is considered to be failed, but the5792// rest of the tests will still be run.5793//5794// When parameterized tests are enabled, it expands and registers5795// parameterized tests first in RegisterParameterizedTests().5796// All other functions called from RunAllTests() may safely assume that5797// parameterized tests are ready to be counted and run.5798bool UnitTestImpl::RunAllTests() {5799 // True if and only if Google Test is initialized before RUN_ALL_TESTS() is5800 // called.5801 const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();5802 5803 // Do not run any test if the --help flag was specified.5804 if (g_help_flag) return true;5805 5806 // Repeats the call to the post-flag parsing initialization in case the5807 // user didn't call InitGoogleTest.5808 PostFlagParsingInit();5809 5810#if GTEST_HAS_FILE_SYSTEM5811 // Even if sharding is not on, test runners may want to use the5812 // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding5813 // protocol.5814 internal::WriteToShardStatusFileIfNeeded();5815#endif // GTEST_HAS_FILE_SYSTEM5816 5817 // True if and only if we are in a subprocess for running a thread-safe-style5818 // death test.5819 bool in_subprocess_for_death_test = false;5820 5821#ifdef GTEST_HAS_DEATH_TEST5822 in_subprocess_for_death_test = (internal_run_death_test_flag_ != nullptr);5823#if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)5824 if (in_subprocess_for_death_test) {5825 GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();5826 }5827#endif // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)5828#endif // GTEST_HAS_DEATH_TEST5829 5830 const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,5831 in_subprocess_for_death_test);5832 5833 // Compares the full test names with the filter to decide which5834 // tests to run.5835 const bool has_tests_to_run =5836 FilterTests(should_shard ? HONOR_SHARDING_PROTOCOL5837 : IGNORE_SHARDING_PROTOCOL) > 0;5838 5839 // Lists the tests and exits if the --gtest_list_tests flag was specified.5840 if (GTEST_FLAG_GET(list_tests)) {5841 // This must be called *after* FilterTests() has been called.5842 ListTestsMatchingFilter();5843 return true;5844 }5845 5846 random_seed_ = GetRandomSeedFromFlag(GTEST_FLAG_GET(random_seed));5847 5848 // True if and only if at least one test has failed.5849 bool failed = false;5850 5851 TestEventListener* repeater = listeners()->repeater();5852 5853 start_timestamp_ = GetTimeInMillis();5854 repeater->OnTestProgramStart(*parent_);5855 5856 // How many times to repeat the tests? We don't want to repeat them5857 // when we are inside the subprocess of a death test.5858 const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG_GET(repeat);5859 5860 // Repeats forever if the repeat count is negative.5861 const bool gtest_repeat_forever = repeat < 0;5862 5863 // Should test environments be set up and torn down for each repeat, or only5864 // set up on the first and torn down on the last iteration? If there is no5865 // "last" iteration because the tests will repeat forever, always recreate the5866 // environments to avoid leaks in case one of the environments is using5867 // resources that are external to this process. Without this check there would5868 // be no way to clean up those external resources automatically.5869 const bool recreate_environments_when_repeating =5870 GTEST_FLAG_GET(recreate_environments_when_repeating) ||5871 gtest_repeat_forever;5872 5873 for (int i = 0; gtest_repeat_forever || i != repeat; i++) {5874 // We want to preserve failures generated by ad-hoc test5875 // assertions executed before RUN_ALL_TESTS().5876 ClearNonAdHocTestResult();5877 5878 Timer timer;5879 5880 // Shuffles test suites and tests if requested.5881 if (has_tests_to_run && GTEST_FLAG_GET(shuffle)) {5882 random()->Reseed(static_cast<uint32_t>(random_seed_));5883 // This should be done before calling OnTestIterationStart(),5884 // such that a test event listener can see the actual test order5885 // in the event.5886 ShuffleTests();5887 }5888 5889 // Tells the unit test event listeners that the tests are about to start.5890 repeater->OnTestIterationStart(*parent_, i);5891 5892 // Runs each test suite if there is at least one test to run.5893 if (has_tests_to_run) {5894 // Sets up all environments beforehand. If test environments aren't5895 // recreated for each iteration, only do so on the first iteration.5896 if (i == 0 || recreate_environments_when_repeating) {5897 repeater->OnEnvironmentsSetUpStart(*parent_);5898 ForEach(environments_, SetUpEnvironment);5899 repeater->OnEnvironmentsSetUpEnd(*parent_);5900 }5901 5902 // Runs the tests only if there was no fatal failure or skip triggered5903 // during global set-up.5904 if (Test::IsSkipped()) {5905 // Emit diagnostics when global set-up calls skip, as it will not be5906 // emitted by default.5907 TestResult& test_result =5908 *internal::GetUnitTestImpl()->current_test_result();5909 for (int j = 0; j < test_result.total_part_count(); ++j) {5910 const TestPartResult& test_part_result =5911 test_result.GetTestPartResult(j);5912 if (test_part_result.type() == TestPartResult::kSkip) {5913 const std::string& result = test_part_result.message();5914 printf("%s\n", result.c_str());5915 }5916 }5917 fflush(stdout);5918 } else if (!Test::HasFatalFailure()) {5919 for (int test_index = 0; test_index < total_test_suite_count();5920 test_index++) {5921 GetMutableSuiteCase(test_index)->Run();5922 if (GTEST_FLAG_GET(fail_fast) &&5923 GetMutableSuiteCase(test_index)->Failed()) {5924 for (int j = test_index + 1; j < total_test_suite_count(); j++) {5925 GetMutableSuiteCase(j)->Skip();5926 }5927 break;5928 }5929 }5930 } else if (Test::HasFatalFailure()) {5931 // If there was a fatal failure during the global setup then we know we5932 // aren't going to run any tests. Explicitly mark all of the tests as5933 // skipped to make this obvious in the output.5934 for (int test_index = 0; test_index < total_test_suite_count();5935 test_index++) {5936 GetMutableSuiteCase(test_index)->Skip();5937 }5938 }5939 5940 // Tears down all environments in reverse order afterwards. If test5941 // environments aren't recreated for each iteration, only do so on the5942 // last iteration.5943 if (i == repeat - 1 || recreate_environments_when_repeating) {5944 repeater->OnEnvironmentsTearDownStart(*parent_);5945 std::for_each(environments_.rbegin(), environments_.rend(),5946 TearDownEnvironment);5947 repeater->OnEnvironmentsTearDownEnd(*parent_);5948 }5949 }5950 5951 elapsed_time_ = timer.Elapsed();5952 5953 // Tells the unit test event listener that the tests have just finished.5954 repeater->OnTestIterationEnd(*parent_, i);5955 5956 // Gets the result and clears it.5957 if (!Passed()) {5958 failed = true;5959 }5960 5961 // Restores the original test order after the iteration. This5962 // allows the user to quickly repro a failure that happens in the5963 // N-th iteration without repeating the first (N - 1) iterations.5964 // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in5965 // case the user somehow changes the value of the flag somewhere5966 // (it's always safe to unshuffle the tests).5967 UnshuffleTests();5968 5969 if (GTEST_FLAG_GET(shuffle)) {5970 // Picks a new random seed for each iteration.5971 random_seed_ = GetNextRandomSeed(random_seed_);5972 }5973 }5974 5975 repeater->OnTestProgramEnd(*parent_);5976 5977 if (!gtest_is_initialized_before_run_all_tests) {5978 ColoredPrintf(5979 GTestColor::kRed,5980 "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"5981 "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_5982 "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_5983 " will start to enforce the valid usage. "5984 "Please fix it ASAP, or IT WILL START TO FAIL.\n"); // NOLINT5985 }5986 5987 return !failed;5988}5989 5990#if GTEST_HAS_FILE_SYSTEM5991// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file5992// if the variable is present. If a file already exists at this location, this5993// function will write over it. If the variable is present, but the file cannot5994// be created, prints an error and exits.5995void WriteToShardStatusFileIfNeeded() {5996 const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);5997 if (test_shard_file != nullptr) {5998 FILE* const file = posix::FOpen(test_shard_file, "w");5999 if (file == nullptr) {6000 ColoredPrintf(GTestColor::kRed,6001 "Could not write to the test shard status file \"%s\" "6002 "specified by the %s environment variable.\n",6003 test_shard_file, kTestShardStatusFile);6004 fflush(stdout);6005 exit(EXIT_FAILURE);6006 }6007 fclose(file);6008 }6009}6010#endif // GTEST_HAS_FILE_SYSTEM6011 6012// Checks whether sharding is enabled by examining the relevant6013// environment variable values. If the variables are present,6014// but inconsistent (i.e., shard_index >= total_shards), prints6015// an error and exits. If in_subprocess_for_death_test, sharding is6016// disabled because it must only be applied to the original test6017// process. Otherwise, we could filter out death tests we intended to execute.6018bool ShouldShard(const char* total_shards_env, const char* shard_index_env,6019 bool in_subprocess_for_death_test) {6020 if (in_subprocess_for_death_test) {6021 return false;6022 }6023 6024 const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);6025 const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);6026 6027 if (total_shards == -1 && shard_index == -1) {6028 return false;6029 } else if (total_shards == -1 && shard_index != -1) {6030 const Message msg = Message() << "Invalid environment variables: you have "6031 << kTestShardIndex << " = " << shard_index6032 << ", but have left " << kTestTotalShards6033 << " unset.\n";6034 ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());6035 fflush(stdout);6036 exit(EXIT_FAILURE);6037 } else if (total_shards != -1 && shard_index == -1) {6038 const Message msg = Message()6039 << "Invalid environment variables: you have "6040 << kTestTotalShards << " = " << total_shards6041 << ", but have left " << kTestShardIndex << " unset.\n";6042 ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());6043 fflush(stdout);6044 exit(EXIT_FAILURE);6045 } else if (shard_index < 0 || shard_index >= total_shards) {6046 const Message msg =6047 Message() << "Invalid environment variables: we require 0 <= "6048 << kTestShardIndex << " < " << kTestTotalShards6049 << ", but you have " << kTestShardIndex << "=" << shard_index6050 << ", " << kTestTotalShards << "=" << total_shards << ".\n";6051 ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());6052 fflush(stdout);6053 exit(EXIT_FAILURE);6054 }6055 6056 return total_shards > 1;6057}6058 6059// Parses the environment variable var as an Int32. If it is unset,6060// returns default_val. If it is not an Int32, prints an error6061// and aborts.6062int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {6063 const char* str_val = posix::GetEnv(var);6064 if (str_val == nullptr) {6065 return default_val;6066 }6067 6068 int32_t result;6069 if (!ParseInt32(Message() << "The value of environment variable " << var,6070 str_val, &result)) {6071 exit(EXIT_FAILURE);6072 }6073 return result;6074}6075 6076// Given the total number of shards, the shard index, and the test id,6077// returns true if and only if the test should be run on this shard. The test id6078// is some arbitrary but unique non-negative integer assigned to each test6079// method. Assumes that 0 <= shard_index < total_shards.6080bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {6081 return (test_id % total_shards) == shard_index;6082}6083 6084// Compares the name of each test with the user-specified filter to6085// decide whether the test should be run, then records the result in6086// each TestSuite and TestInfo object.6087// If shard_tests == true, further filters tests based on sharding6088// variables in the environment - see6089// https://github.com/google/googletest/blob/main/docs/advanced.md6090// . Returns the number of tests that should run.6091int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {6092 const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL6093 ? Int32FromEnvOrDie(kTestTotalShards, -1)6094 : -1;6095 const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL6096 ? Int32FromEnvOrDie(kTestShardIndex, -1)6097 : -1;6098 6099 const PositiveAndNegativeUnitTestFilter gtest_flag_filter(6100 GTEST_FLAG_GET(filter));6101 const UnitTestFilter disable_test_filter(kDisableTestFilter);6102 // num_runnable_tests are the number of tests that will6103 // run across all shards (i.e., match filter and are not disabled).6104 // num_selected_tests are the number of tests to be run on6105 // this shard.6106 int num_runnable_tests = 0;6107 int num_selected_tests = 0;6108 for (auto* test_suite : test_suites_) {6109 const std::string& test_suite_name = test_suite->name();6110 test_suite->set_should_run(false);6111 6112 for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {6113 TestInfo* const test_info = test_suite->test_info_list()[j];6114 const std::string test_name(test_info->name());6115 // A test is disabled if test suite name or test name matches6116 // kDisableTestFilter.6117 const bool is_disabled =6118 disable_test_filter.MatchesName(test_suite_name) ||6119 disable_test_filter.MatchesName(test_name);6120 test_info->is_disabled_ = is_disabled;6121 6122 const bool matches_filter =6123 gtest_flag_filter.MatchesTest(test_suite_name, test_name);6124 test_info->matches_filter_ = matches_filter;6125 6126 const bool is_runnable =6127 (GTEST_FLAG_GET(also_run_disabled_tests) || !is_disabled) &&6128 matches_filter;6129 6130 const bool is_in_another_shard =6131 shard_tests != IGNORE_SHARDING_PROTOCOL &&6132 !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);6133 test_info->is_in_another_shard_ = is_in_another_shard;6134 const bool is_selected = is_runnable && !is_in_another_shard;6135 6136 num_runnable_tests += is_runnable;6137 num_selected_tests += is_selected;6138 6139 test_info->should_run_ = is_selected;6140 test_suite->set_should_run(test_suite->should_run() || is_selected);6141 }6142 }6143 return num_selected_tests;6144}6145 6146// Prints the given C-string on a single line by replacing all '\n'6147// characters with string "\\n". If the output takes more than6148// max_length characters, only prints the first max_length characters6149// and "...".6150static void PrintOnOneLine(const char* str, int max_length) {6151 if (str != nullptr) {6152 for (int i = 0; *str != '\0'; ++str) {6153 if (i >= max_length) {6154 printf("...");6155 break;6156 }6157 if (*str == '\n') {6158 printf("\\n");6159 i += 2;6160 } else {6161 printf("%c", *str);6162 ++i;6163 }6164 }6165 }6166}6167 6168// Prints the names of the tests matching the user-specified filter flag.6169void UnitTestImpl::ListTestsMatchingFilter() {6170 // Print at most this many characters for each type/value parameter.6171 const int kMaxParamLength = 250;6172 6173 for (auto* test_suite : test_suites_) {6174 bool printed_test_suite_name = false;6175 6176 for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {6177 const TestInfo* const test_info = test_suite->test_info_list()[j];6178 if (test_info->matches_filter_) {6179 if (!printed_test_suite_name) {6180 printed_test_suite_name = true;6181 printf("%s.", test_suite->name());6182 if (test_suite->type_param() != nullptr) {6183 printf(" # %s = ", kTypeParamLabel);6184 // We print the type parameter on a single line to make6185 // the output easy to parse by a program.6186 PrintOnOneLine(test_suite->type_param(), kMaxParamLength);6187 }6188 printf("\n");6189 }6190 printf(" %s", test_info->name());6191 if (test_info->value_param() != nullptr) {6192 printf(" # %s = ", kValueParamLabel);6193 // We print the value parameter on a single line to make the6194 // output easy to parse by a program.6195 PrintOnOneLine(test_info->value_param(), kMaxParamLength);6196 }6197 printf("\n");6198 }6199 }6200 }6201 fflush(stdout);6202#if GTEST_HAS_FILE_SYSTEM6203 const std::string& output_format = UnitTestOptions::GetOutputFormat();6204 if (output_format == "xml" || output_format == "json") {6205 FILE* fileout = OpenFileForWriting(6206 UnitTestOptions::GetAbsolutePathToOutputFile().c_str());6207 std::stringstream stream;6208 if (output_format == "xml") {6209 XmlUnitTestResultPrinter(6210 UnitTestOptions::GetAbsolutePathToOutputFile().c_str())6211 .PrintXmlTestsList(&stream, test_suites_);6212 } else if (output_format == "json") {6213 JsonUnitTestResultPrinter(6214 UnitTestOptions::GetAbsolutePathToOutputFile().c_str())6215 .PrintJsonTestList(&stream, test_suites_);6216 }6217 fprintf(fileout, "%s", StringStreamToString(&stream).c_str());6218 fclose(fileout);6219 }6220#endif // GTEST_HAS_FILE_SYSTEM6221}6222 6223// Sets the OS stack trace getter.6224//6225// Does nothing if the input and the current OS stack trace getter are6226// the same; otherwise, deletes the old getter and makes the input the6227// current getter.6228void UnitTestImpl::set_os_stack_trace_getter(6229 OsStackTraceGetterInterface* getter) {6230 if (os_stack_trace_getter_ != getter) {6231 delete os_stack_trace_getter_;6232 os_stack_trace_getter_ = getter;6233 }6234}6235 6236// Returns the current OS stack trace getter if it is not NULL;6237// otherwise, creates an OsStackTraceGetter, makes it the current6238// getter, and returns it.6239OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {6240 if (os_stack_trace_getter_ == nullptr) {6241#ifdef GTEST_OS_STACK_TRACE_GETTER_6242 os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;6243#else6244 os_stack_trace_getter_ = new OsStackTraceGetter;6245#endif // GTEST_OS_STACK_TRACE_GETTER_6246 }6247 6248 return os_stack_trace_getter_;6249}6250 6251// Returns the most specific TestResult currently running.6252TestResult* UnitTestImpl::current_test_result() {6253 if (current_test_info_ != nullptr) {6254 return ¤t_test_info_->result_;6255 }6256 if (current_test_suite_ != nullptr) {6257 return ¤t_test_suite_->ad_hoc_test_result_;6258 }6259 return &ad_hoc_test_result_;6260}6261 6262// Shuffles all test suites, and the tests within each test suite,6263// making sure that death tests are still run first.6264void UnitTestImpl::ShuffleTests() {6265 // Shuffles the death test suites.6266 ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);6267 6268 // Shuffles the non-death test suites.6269 ShuffleRange(random(), last_death_test_suite_ + 1,6270 static_cast<int>(test_suites_.size()), &test_suite_indices_);6271 6272 // Shuffles the tests inside each test suite.6273 for (auto& test_suite : test_suites_) {6274 test_suite->ShuffleTests(random());6275 }6276}6277 6278// Restores the test suites and tests to their order before the first shuffle.6279void UnitTestImpl::UnshuffleTests() {6280 for (size_t i = 0; i < test_suites_.size(); i++) {6281 // Unshuffles the tests in each test suite.6282 test_suites_[i]->UnshuffleTests();6283 // Resets the index of each test suite.6284 test_suite_indices_[i] = static_cast<int>(i);6285 }6286}6287 6288// Returns the current OS stack trace as an std::string.6289//6290// The maximum number of stack frames to be included is specified by6291// the gtest_stack_trace_depth flag. The skip_count parameter6292// specifies the number of top frames to be skipped, which doesn't6293// count against the number of frames to be included.6294//6295// For example, if Foo() calls Bar(), which in turn calls6296// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in6297// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.6298GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string6299GetCurrentOsStackTraceExceptTop(int skip_count) {6300 // We pass skip_count + 1 to skip this wrapper function in addition6301 // to what the user really wants to skip.6302 return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);6303}6304 6305// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to6306// suppress unreachable code warnings.6307namespace {6308class ClassUniqueToAlwaysTrue {};6309} // namespace6310 6311bool IsTrue(bool condition) { return condition; }6312 6313bool AlwaysTrue() {6314#if GTEST_HAS_EXCEPTIONS6315 // This condition is always false so AlwaysTrue() never actually throws,6316 // but it makes the compiler think that it may throw.6317 if (IsTrue(false)) throw ClassUniqueToAlwaysTrue();6318#endif // GTEST_HAS_EXCEPTIONS6319 return true;6320}6321 6322// If *pstr starts with the given prefix, modifies *pstr to be right6323// past the prefix and returns true; otherwise leaves *pstr unchanged6324// and returns false. None of pstr, *pstr, and prefix can be NULL.6325bool SkipPrefix(const char* prefix, const char** pstr) {6326 const size_t prefix_len = strlen(prefix);6327 if (strncmp(*pstr, prefix, prefix_len) == 0) {6328 *pstr += prefix_len;6329 return true;6330 }6331 return false;6332}6333 6334// Parses a string as a command line flag. The string should have6335// the format "--flag=value". When def_optional is true, the "=value"6336// part can be omitted.6337//6338// Returns the value of the flag, or NULL if the parsing failed.6339static const char* ParseFlagValue(const char* str, const char* flag_name,6340 bool def_optional) {6341 // str and flag must not be NULL.6342 if (str == nullptr || flag_name == nullptr) return nullptr;6343 6344 // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.6345 const std::string flag_str =6346 std::string("--") + GTEST_FLAG_PREFIX_ + flag_name;6347 const size_t flag_len = flag_str.length();6348 if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;6349 6350 // Skips the flag name.6351 const char* flag_end = str + flag_len;6352 6353 // When def_optional is true, it's OK to not have a "=value" part.6354 if (def_optional && (flag_end[0] == '\0')) {6355 return flag_end;6356 }6357 6358 // If def_optional is true and there are more characters after the6359 // flag name, or if def_optional is false, there must be a '=' after6360 // the flag name.6361 if (flag_end[0] != '=') return nullptr;6362 6363 // Returns the string after "=".6364 return flag_end + 1;6365}6366 6367// Parses a string for a bool flag, in the form of either6368// "--flag=value" or "--flag".6369//6370// In the former case, the value is taken as true as long as it does6371// not start with '0', 'f', or 'F'.6372//6373// In the latter case, the value is taken as true.6374//6375// On success, stores the value of the flag in *value, and returns6376// true. On failure, returns false without changing *value.6377static bool ParseFlag(const char* str, const char* flag_name, bool* value) {6378 // Gets the value of the flag as a string.6379 const char* const value_str = ParseFlagValue(str, flag_name, true);6380 6381 // Aborts if the parsing failed.6382 if (value_str == nullptr) return false;6383 6384 // Converts the string value to a bool.6385 *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');6386 return true;6387}6388 6389// Parses a string for an int32_t flag, in the form of "--flag=value".6390//6391// On success, stores the value of the flag in *value, and returns6392// true. On failure, returns false without changing *value.6393bool ParseFlag(const char* str, const char* flag_name, int32_t* value) {6394 // Gets the value of the flag as a string.6395 const char* const value_str = ParseFlagValue(str, flag_name, false);6396 6397 // Aborts if the parsing failed.6398 if (value_str == nullptr) return false;6399 6400 // Sets *value to the value of the flag.6401 return ParseInt32(Message() << "The value of flag --" << flag_name, value_str,6402 value);6403}6404 6405// Parses a string for a string flag, in the form of "--flag=value".6406//6407// On success, stores the value of the flag in *value, and returns6408// true. On failure, returns false without changing *value.6409template <typename String>6410static bool ParseFlag(const char* str, const char* flag_name, String* value) {6411 // Gets the value of the flag as a string.6412 const char* const value_str = ParseFlagValue(str, flag_name, false);6413 6414 // Aborts if the parsing failed.6415 if (value_str == nullptr) return false;6416 6417 // Sets *value to the value of the flag.6418 *value = value_str;6419 return true;6420}6421 6422// Determines whether a string has a prefix that Google Test uses for its6423// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.6424// If Google Test detects that a command line flag has its prefix but is not6425// recognized, it will print its help message. Flags starting with6426// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test6427// internal flags and do not trigger the help message.6428static bool HasGoogleTestFlagPrefix(const char* str) {6429 return (SkipPrefix("--", &str) || SkipPrefix("-", &str) ||6430 SkipPrefix("/", &str)) &&6431 !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&6432 (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||6433 SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));6434}6435 6436// Prints a string containing code-encoded text. The following escape6437// sequences can be used in the string to control the text color:6438//6439// @@ prints a single '@' character.6440// @R changes the color to red.6441// @G changes the color to green.6442// @Y changes the color to yellow.6443// @D changes to the default terminal text color.6444//6445static void PrintColorEncoded(const char* str) {6446 GTestColor color = GTestColor::kDefault; // The current color.6447 6448 // Conceptually, we split the string into segments divided by escape6449 // sequences. Then we print one segment at a time. At the end of6450 // each iteration, the str pointer advances to the beginning of the6451 // next segment.6452 for (;;) {6453 const char* p = strchr(str, '@');6454 if (p == nullptr) {6455 ColoredPrintf(color, "%s", str);6456 return;6457 }6458 6459 ColoredPrintf(color, "%s", std::string(str, p).c_str());6460 6461 const char ch = p[1];6462 str = p + 2;6463 if (ch == '@') {6464 ColoredPrintf(color, "@");6465 } else if (ch == 'D') {6466 color = GTestColor::kDefault;6467 } else if (ch == 'R') {6468 color = GTestColor::kRed;6469 } else if (ch == 'G') {6470 color = GTestColor::kGreen;6471 } else if (ch == 'Y') {6472 color = GTestColor::kYellow;6473 } else {6474 --str;6475 }6476 }6477}6478 6479static const char kColorEncodedHelpMessage[] =6480 "This program contains tests written using " GTEST_NAME_6481 ". You can use the\n"6482 "following command line flags to control its behavior:\n"6483 "\n"6484 "Test Selection:\n"6485 " @G--" GTEST_FLAG_PREFIX_6486 "list_tests@D\n"6487 " List the names of all tests instead of running them. The name of\n"6488 " TEST(Foo, Bar) is \"Foo.Bar\".\n"6489 " @G--" GTEST_FLAG_PREFIX_6490 "filter=@YPOSITIVE_PATTERNS"6491 "[@G-@YNEGATIVE_PATTERNS]@D\n"6492 " Run only the tests whose name matches one of the positive patterns "6493 "but\n"6494 " none of the negative patterns. '?' matches any single character; "6495 "'*'\n"6496 " matches any substring; ':' separates two patterns.\n"6497 " @G--" GTEST_FLAG_PREFIX_6498 "also_run_disabled_tests@D\n"6499 " Run all disabled tests too.\n"6500 "\n"6501 "Test Execution:\n"6502 " @G--" GTEST_FLAG_PREFIX_6503 "repeat=@Y[COUNT]@D\n"6504 " Run the tests repeatedly; use a negative count to repeat forever.\n"6505 " @G--" GTEST_FLAG_PREFIX_6506 "shuffle@D\n"6507 " Randomize tests' orders on every iteration.\n"6508 " @G--" GTEST_FLAG_PREFIX_6509 "random_seed=@Y[NUMBER]@D\n"6510 " Random number seed to use for shuffling test orders (between 1 and\n"6511 " 99999, or 0 to use a seed based on the current time).\n"6512 " @G--" GTEST_FLAG_PREFIX_6513 "recreate_environments_when_repeating@D\n"6514 " Sets up and tears down the global test environment on each repeat\n"6515 " of the test.\n"6516 "\n"6517 "Test Output:\n"6518 " @G--" GTEST_FLAG_PREFIX_6519 "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"6520 " Enable/disable colored output. The default is @Gauto@D.\n"6521 " @G--" GTEST_FLAG_PREFIX_6522 "brief=1@D\n"6523 " Only print test failures.\n"6524 " @G--" GTEST_FLAG_PREFIX_6525 "print_time=0@D\n"6526 " Don't print the elapsed time of each test.\n"6527 " @G--" GTEST_FLAG_PREFIX_6528 "output=@Y(@Gjson@Y|@Gxml@Y)[@G:@YDIRECTORY_PATH@G" GTEST_PATH_SEP_6529 "@Y|@G:@YFILE_PATH]@D\n"6530 " Generate a JSON or XML report in the given directory or with the "6531 "given\n"6532 " file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n"6533#if GTEST_CAN_STREAM_RESULTS_6534 " @G--" GTEST_FLAG_PREFIX_6535 "stream_result_to=@YHOST@G:@YPORT@D\n"6536 " Stream test results to the given server.\n"6537#endif // GTEST_CAN_STREAM_RESULTS_6538 "\n"6539 "Assertion Behavior:\n"6540#if defined(GTEST_HAS_DEATH_TEST) && !defined(GTEST_OS_WINDOWS)6541 " @G--" GTEST_FLAG_PREFIX_6542 "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"6543 " Set the default death test style.\n"6544#endif // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS6545 " @G--" GTEST_FLAG_PREFIX_6546 "break_on_failure@D\n"6547 " Turn assertion failures into debugger break-points.\n"6548 " @G--" GTEST_FLAG_PREFIX_6549 "throw_on_failure@D\n"6550 " Turn assertion failures into C++ exceptions for use by an external\n"6551 " test framework.\n"6552 " @G--" GTEST_FLAG_PREFIX_6553 "catch_exceptions=0@D\n"6554 " Do not report exceptions as test failures. Instead, allow them\n"6555 " to crash the program or throw a pop-up (on Windows).\n"6556 "\n"6557 "Except for @G--" GTEST_FLAG_PREFIX_6558 "list_tests@D, you can alternatively set "6559 "the corresponding\n"6560 "environment variable of a flag (all letters in upper-case). For example, "6561 "to\n"6562 "disable colored text output, you can either specify "6563 "@G--" GTEST_FLAG_PREFIX_6564 "color=no@D or set\n"6565 "the @G" GTEST_FLAG_PREFIX_UPPER_6566 "COLOR@D environment variable to @Gno@D.\n"6567 "\n"6568 "For more information, please read the " GTEST_NAME_6569 " documentation at\n"6570 "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_6571 "\n"6572 "(not one in your own code or tests), please report it to\n"6573 "@G<" GTEST_DEV_EMAIL_ ">@D.\n";6574 6575static bool ParseGoogleTestFlag(const char* const arg) {6576#define GTEST_INTERNAL_PARSE_FLAG(flag_name) \6577 do { \6578 auto value = GTEST_FLAG_GET(flag_name); \6579 if (ParseFlag(arg, #flag_name, &value)) { \6580 GTEST_FLAG_SET(flag_name, value); \6581 return true; \6582 } \6583 } while (false)6584 6585 GTEST_INTERNAL_PARSE_FLAG(also_run_disabled_tests);6586 GTEST_INTERNAL_PARSE_FLAG(break_on_failure);6587 GTEST_INTERNAL_PARSE_FLAG(catch_exceptions);6588 GTEST_INTERNAL_PARSE_FLAG(color);6589 GTEST_INTERNAL_PARSE_FLAG(death_test_style);6590 GTEST_INTERNAL_PARSE_FLAG(death_test_use_fork);6591 GTEST_INTERNAL_PARSE_FLAG(fail_fast);6592 GTEST_INTERNAL_PARSE_FLAG(filter);6593 GTEST_INTERNAL_PARSE_FLAG(internal_run_death_test);6594 GTEST_INTERNAL_PARSE_FLAG(list_tests);6595 GTEST_INTERNAL_PARSE_FLAG(output);6596 GTEST_INTERNAL_PARSE_FLAG(brief);6597 GTEST_INTERNAL_PARSE_FLAG(print_time);6598 GTEST_INTERNAL_PARSE_FLAG(print_utf8);6599 GTEST_INTERNAL_PARSE_FLAG(random_seed);6600 GTEST_INTERNAL_PARSE_FLAG(repeat);6601 GTEST_INTERNAL_PARSE_FLAG(recreate_environments_when_repeating);6602 GTEST_INTERNAL_PARSE_FLAG(shuffle);6603 GTEST_INTERNAL_PARSE_FLAG(stack_trace_depth);6604 GTEST_INTERNAL_PARSE_FLAG(stream_result_to);6605 GTEST_INTERNAL_PARSE_FLAG(throw_on_failure);6606 return false;6607}6608 6609#if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM6610static void LoadFlagsFromFile(const std::string& path) {6611 FILE* flagfile = posix::FOpen(path.c_str(), "r");6612 if (!flagfile) {6613 GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG_GET(flagfile)6614 << "\"";6615 }6616 std::string contents(ReadEntireFile(flagfile));6617 posix::FClose(flagfile);6618 std::vector<std::string> lines;6619 SplitString(contents, '\n', &lines);6620 for (size_t i = 0; i < lines.size(); ++i) {6621 if (lines[i].empty()) continue;6622 if (!ParseGoogleTestFlag(lines[i].c_str())) g_help_flag = true;6623 }6624}6625#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM6626 6627// Parses the command line for Google Test flags, without initializing6628// other parts of Google Test. The type parameter CharType can be6629// instantiated to either char or wchar_t.6630template <typename CharType>6631void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {6632 std::string flagfile_value;6633 for (int i = 1; i < *argc; i++) {6634 const std::string arg_string = StreamableToString(argv[i]);6635 const char* const arg = arg_string.c_str();6636 6637 using internal::ParseFlag;6638 6639 bool remove_flag = false;6640 if (ParseGoogleTestFlag(arg)) {6641 remove_flag = true;6642#if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM6643 } else if (ParseFlag(arg, "flagfile", &flagfile_value)) {6644 GTEST_FLAG_SET(flagfile, flagfile_value);6645 LoadFlagsFromFile(flagfile_value);6646 remove_flag = true;6647#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM6648 } else if (arg_string == "--help" || HasGoogleTestFlagPrefix(arg)) {6649 // Both help flag and unrecognized Google Test flags (excluding6650 // internal ones) trigger help display.6651 g_help_flag = true;6652 }6653 6654 if (remove_flag) {6655 // Shift the remainder of the argv list left by one. Note6656 // that argv has (*argc + 1) elements, the last one always being6657 // NULL. The following loop moves the trailing NULL element as6658 // well.6659 for (int j = i; j != *argc; j++) {6660 argv[j] = argv[j + 1];6661 }6662 6663 // Decrements the argument count.6664 (*argc)--;6665 6666 // We also need to decrement the iterator as we just removed6667 // an element.6668 i--;6669 }6670 }6671 6672 if (g_help_flag) {6673 // We print the help here instead of in RUN_ALL_TESTS(), as the6674 // latter may not be called at all if the user is using Google6675 // Test with another testing framework.6676 PrintColorEncoded(kColorEncodedHelpMessage);6677 }6678}6679 6680// Parses the command line for Google Test flags, without initializing6681// other parts of Google Test. This function updates argc and argv by removing6682// flags that are known to GoogleTest (including other user flags defined using6683// ABSL_FLAG if GoogleTest is built with GTEST_USE_ABSL). Other arguments6684// remain in place. Unrecognized flags are not reported and do not cause the6685// program to exit.6686void ParseGoogleTestFlagsOnly(int* argc, char** argv) {6687#ifdef GTEST_HAS_ABSL6688 if (*argc <= 0) return;6689 6690 std::vector<char*> positional_args;6691 std::vector<absl::UnrecognizedFlag> unrecognized_flags;6692 absl::ParseAbseilFlagsOnly(*argc, argv, positional_args, unrecognized_flags);6693 absl::flat_hash_set<absl::string_view> unrecognized;6694 for (const auto& flag : unrecognized_flags) {6695 unrecognized.insert(flag.flag_name);6696 }6697 absl::flat_hash_set<char*> positional;6698 for (const auto& arg : positional_args) {6699 positional.insert(arg);6700 }6701 6702 int out_pos = 1;6703 int in_pos = 1;6704 for (; in_pos < *argc; ++in_pos) {6705 char* arg = argv[in_pos];6706 absl::string_view arg_str(arg);6707 if (absl::ConsumePrefix(&arg_str, "--")) {6708 // Flag-like argument. If the flag was unrecognized, keep it.6709 // If it was a GoogleTest flag, remove it.6710 if (unrecognized.contains(arg_str)) {6711 argv[out_pos++] = argv[in_pos];6712 continue;6713 }6714 }6715 6716 if (arg_str.empty()) {6717 ++in_pos;6718 break; // '--' indicates that the rest of the arguments are positional6719 }6720 6721 // Probably a positional argument. If it is in fact positional, keep it.6722 // If it was a value for the flag argument, remove it.6723 if (positional.contains(arg)) {6724 argv[out_pos++] = arg;6725 }6726 }6727 6728 // The rest are positional args for sure.6729 while (in_pos < *argc) {6730 argv[out_pos++] = argv[in_pos++];6731 }6732 6733 *argc = out_pos;6734 argv[out_pos] = nullptr;6735#else6736 ParseGoogleTestFlagsOnlyImpl(argc, argv);6737#endif6738 6739 // Fix the value of *_NSGetArgc() on macOS, but if and only if6740 // *_NSGetArgv() == argv6741 // Only applicable to char** version of argv6742#ifdef GTEST_OS_MAC6743#ifndef GTEST_OS_IOS6744 if (*_NSGetArgv() == argv) {6745 *_NSGetArgc() = *argc;6746 }6747#endif6748#endif6749}6750void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {6751 ParseGoogleTestFlagsOnlyImpl(argc, argv);6752}6753 6754// The internal implementation of InitGoogleTest().6755//6756// The type parameter CharType can be instantiated to either char or6757// wchar_t.6758template <typename CharType>6759void InitGoogleTestImpl(int* argc, CharType** argv) {6760 // We don't want to run the initialization code twice.6761 if (GTestIsInitialized()) return;6762 6763 if (*argc <= 0) return;6764 6765 g_argvs.clear();6766 for (int i = 0; i != *argc; i++) {6767 g_argvs.push_back(StreamableToString(argv[i]));6768 }6769 6770#ifdef GTEST_HAS_ABSL6771 absl::InitializeSymbolizer(g_argvs[0].c_str());6772 6773 // When using the Abseil Flags library, set the program usage message to the6774 // help message, but remove the color-encoding from the message first.6775 absl::SetProgramUsageMessage(absl::StrReplaceAll(6776 kColorEncodedHelpMessage,6777 {{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}}));6778#endif // GTEST_HAS_ABSL6779 6780 ParseGoogleTestFlagsOnly(argc, argv);6781 GetUnitTestImpl()->PostFlagParsingInit();6782}6783 6784} // namespace internal6785 6786// Initializes Google Test. This must be called before calling6787// RUN_ALL_TESTS(). In particular, it parses a command line for the6788// flags that Google Test recognizes. Whenever a Google Test flag is6789// seen, it is removed from argv, and *argc is decremented.6790//6791// No value is returned. Instead, the Google Test flag variables are6792// updated.6793//6794// Calling the function for the second time has no user-visible effect.6795void InitGoogleTest(int* argc, char** argv) {6796#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)6797 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);6798#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)6799 internal::InitGoogleTestImpl(argc, argv);6800#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)6801}6802 6803// This overloaded version can be used in Windows programs compiled in6804// UNICODE mode.6805void InitGoogleTest(int* argc, wchar_t** argv) {6806#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)6807 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);6808#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)6809 internal::InitGoogleTestImpl(argc, argv);6810#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)6811}6812 6813// This overloaded version can be used on Arduino/embedded platforms where6814// there is no argc/argv.6815void InitGoogleTest() {6816 // Since Arduino doesn't have a command line, fake out the argc/argv arguments6817 int argc = 1;6818 const auto arg0 = "dummy";6819 char* argv0 = const_cast<char*>(arg0);6820 char** argv = &argv0;6821 6822#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)6823 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);6824#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)6825 internal::InitGoogleTestImpl(&argc, argv);6826#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)6827}6828 6829#if !defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_) || \6830 !defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)6831// Returns the value of the first environment variable that is set and contains6832// a non-empty string. If there are none, returns the "fallback" string. Adds6833// the director-separator character as a suffix if not provided in the6834// environment variable value.6835static std::string GetDirFromEnv(6836 std::initializer_list<const char*> environment_variables,6837 const char* fallback, char separator) {6838 for (const char* variable_name : environment_variables) {6839 const char* value = internal::posix::GetEnv(variable_name);6840 if (value != nullptr && value[0] != '\0') {6841 if (value[strlen(value) - 1] != separator) {6842 return std::string(value).append(1, separator);6843 }6844 return value;6845 }6846 }6847 return fallback;6848}6849#endif6850 6851std::string TempDir() {6852#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)6853 return GTEST_CUSTOM_TEMPDIR_FUNCTION_();6854#elif defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_WINDOWS_MOBILE)6855 return GetDirFromEnv({"TEST_TMPDIR", "TEMP"}, "\\temp\\", '\\');6856#elif defined(GTEST_OS_LINUX_ANDROID)6857 return GetDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/data/local/tmp/", '/');6858#else6859 return GetDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/tmp/", '/');6860#endif6861}6862 6863#if GTEST_HAS_FILE_SYSTEM && !defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)6864// Returns the directory path (including terminating separator) of the current6865// executable as derived from argv[0].6866static std::string GetCurrentExecutableDirectory() {6867 internal::FilePath argv_0(internal::GetArgvs()[0]);6868 return argv_0.RemoveFileName().string();6869}6870#endif6871 6872#if GTEST_HAS_FILE_SYSTEM6873std::string SrcDir() {6874#if defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)6875 return GTEST_CUSTOM_SRCDIR_FUNCTION_();6876#elif defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_WINDOWS_MOBILE)6877 return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),6878 '\\');6879#elif defined(GTEST_OS_LINUX_ANDROID)6880 return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),6881 '/');6882#else6883 return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),6884 '/');6885#endif6886}6887#endif6888 6889// Class ScopedTrace6890 6891// Pushes the given source file location and message onto a per-thread6892// trace stack maintained by Google Test.6893void ScopedTrace::PushTrace(const char* file, int line, std::string message) {6894 internal::TraceInfo trace;6895 trace.file = file;6896 trace.line = line;6897 trace.message.swap(message);6898 6899 UnitTest::GetInstance()->PushGTestTrace(trace);6900}6901 6902// Pops the info pushed by the c'tor.6903ScopedTrace::~ScopedTrace() GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {6904 UnitTest::GetInstance()->PopGTestTrace();6905}6906 6907} // namespace testing6908