Wizard
Software Engineering Project - Wizard
Loading...
Searching...
No Matches
gtest.cc
1// Copyright 2005, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8// * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10// * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14// * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30//
31// The Google C++ Testing and Mocking Framework (Google Test)
32
33#include "gtest/gtest.h"
34#include "gtest/internal/custom/gtest.h"
35#include "gtest/gtest-spi.h"
36
37#include <ctype.h>
38#include <stdarg.h>
39#include <stdio.h>
40#include <stdlib.h>
41#include <time.h>
42#include <wchar.h>
43#include <wctype.h>
44
45#include <algorithm>
46#include <chrono> // NOLINT
47#include <cmath>
48#include <cstdint>
49#include <iomanip>
50#include <limits>
51#include <list>
52#include <map>
53#include <ostream> // NOLINT
54#include <sstream>
55#include <vector>
56
57#if GTEST_OS_LINUX
58
59# include <fcntl.h> // NOLINT
60# include <limits.h> // NOLINT
61# include <sched.h> // NOLINT
62// Declares vsnprintf(). This header is not available on Windows.
63# include <strings.h> // NOLINT
64# include <sys/mman.h> // NOLINT
65# include <sys/time.h> // NOLINT
66# include <unistd.h> // NOLINT
67# include <string>
68
69#elif GTEST_OS_ZOS
70# include <sys/time.h> // NOLINT
71
72// On z/OS we additionally need strings.h for strcasecmp.
73# include <strings.h> // NOLINT
74
75#elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE.
76
77# include <windows.h> // NOLINT
78# undef min
79
80#elif GTEST_OS_WINDOWS // We are on Windows proper.
81
82# include <windows.h> // NOLINT
83# undef min
84
85#ifdef _MSC_VER
86# include <crtdbg.h> // NOLINT
87#endif
88
89# include <io.h> // NOLINT
90# include <sys/timeb.h> // NOLINT
91# include <sys/types.h> // NOLINT
92# include <sys/stat.h> // NOLINT
93
94# if GTEST_OS_WINDOWS_MINGW
95# include <sys/time.h> // NOLINT
96# endif // GTEST_OS_WINDOWS_MINGW
97
98#else
99
100// cpplint thinks that the header is already included, so we want to
101// silence it.
102# include <sys/time.h> // NOLINT
103# include <unistd.h> // NOLINT
104
105#endif // GTEST_OS_LINUX
106
107#if GTEST_HAS_EXCEPTIONS
108# include <stdexcept>
109#endif
110
111#if GTEST_CAN_STREAM_RESULTS_
112# include <arpa/inet.h> // NOLINT
113# include <netdb.h> // NOLINT
114# include <sys/socket.h> // NOLINT
115# include <sys/types.h> // NOLINT
116#endif
117
118#include "src/gtest-internal-inl.h"
119
120#if GTEST_OS_WINDOWS
121# define vsnprintf _vsnprintf
122#endif // GTEST_OS_WINDOWS
123
124#if GTEST_OS_MAC
125#ifndef GTEST_OS_IOS
126#include <crt_externs.h>
127#endif
128#endif
129
130#if GTEST_HAS_ABSL
131#include "absl/debugging/failure_signal_handler.h"
132#include "absl/debugging/stacktrace.h"
133#include "absl/debugging/symbolize.h"
134#include "absl/strings/str_cat.h"
135#endif // GTEST_HAS_ABSL
136
137namespace testing {
138
139using internal::CountIf;
140using internal::ForEach;
141using internal::GetElementOr;
142using internal::Shuffle;
143
144// Constants.
145
146// A test whose test suite name or test name matches this filter is
147// disabled and not run.
148static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
149
150// A test suite whose name matches this filter is considered a death
151// test suite and will be run before test suites whose name doesn't
152// match this filter.
153static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*";
154
155// A test filter that matches everything.
156static const char kUniversalFilter[] = "*";
157
158// The default output format.
159static const char kDefaultOutputFormat[] = "xml";
160// The default output file.
161static const char kDefaultOutputFile[] = "test_detail";
162
163// The environment variable name for the test shard index.
164static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
165// The environment variable name for the total number of test shards.
166static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
167// The environment variable name for the test shard status file.
168static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";
169
170namespace internal {
171
172// The text used in failure messages to indicate the start of the
173// stack trace.
174const char kStackTraceMarker[] = "\nStack trace:\n";
175
176// g_help_flag is true if and only if the --help flag or an equivalent form
177// is specified on the command line.
178bool g_help_flag = false;
179
180// Utilty function to Open File for Writing
181static FILE* OpenFileForWriting(const std::string& output_file) {
182 FILE* fileout = nullptr;
183 FilePath output_file_path(output_file);
184 FilePath output_dir(output_file_path.RemoveFileName());
185
186 if (output_dir.CreateDirectoriesRecursively()) {
187 fileout = posix::FOpen(output_file.c_str(), "w");
188 }
189 if (fileout == nullptr) {
190 GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
191 }
192 return fileout;
193}
194
195} // namespace internal
196
197// Bazel passes in the argument to '--test_filter' via the TESTBRIDGE_TEST_ONLY
198// environment variable.
199static const char* GetDefaultFilter() {
200 const char* const testbridge_test_only =
201 internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
202 if (testbridge_test_only != nullptr) {
203 return testbridge_test_only;
204 }
205 return kUniversalFilter;
206}
207
208// Bazel passes in the argument to '--test_runner_fail_fast' via the
209// TESTBRIDGE_TEST_RUNNER_FAIL_FAST environment variable.
210static bool GetDefaultFailFast() {
211 const char* const testbridge_test_runner_fail_fast =
212 internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST");
213 if (testbridge_test_runner_fail_fast != nullptr) {
214 return strcmp(testbridge_test_runner_fail_fast, "1") == 0;
215 }
216 return false;
217}
218
219GTEST_DEFINE_bool_(
220 fail_fast, internal::BoolFromGTestEnv("fail_fast", GetDefaultFailFast()),
221 "True if and only if a test failure should stop further test execution.");
222
223GTEST_DEFINE_bool_(
224 also_run_disabled_tests,
225 internal::BoolFromGTestEnv("also_run_disabled_tests", false),
226 "Run disabled tests too, in addition to the tests normally being run.");
227
228GTEST_DEFINE_bool_(
229 break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false),
230 "True if and only if a failed assertion should be a debugger "
231 "break-point.");
232
233GTEST_DEFINE_bool_(catch_exceptions,
234 internal::BoolFromGTestEnv("catch_exceptions", true),
235 "True if and only if " GTEST_NAME_
236 " should catch exceptions and treat them as test failures.");
237
238GTEST_DEFINE_string_(
239 color,
240 internal::StringFromGTestEnv("color", "auto"),
241 "Whether to use colors in the output. Valid values: yes, no, "
242 "and auto. 'auto' means to use colors if the output is "
243 "being sent to a terminal and the TERM environment variable "
244 "is set to a terminal type that supports colors.");
245
246GTEST_DEFINE_string_(
247 filter,
248 internal::StringFromGTestEnv("filter", GetDefaultFilter()),
249 "A colon-separated list of glob (not regex) patterns "
250 "for filtering the tests to run, optionally followed by a "
251 "'-' and a : separated list of negative patterns (tests to "
252 "exclude). A test is run if it matches one of the positive "
253 "patterns and does not match any of the negative patterns.");
254
255GTEST_DEFINE_bool_(
256 install_failure_signal_handler,
257 internal::BoolFromGTestEnv("install_failure_signal_handler", false),
258 "If true and supported on the current platform, " GTEST_NAME_ " should "
259 "install a signal handler that dumps debugging information when fatal "
260 "signals are raised.");
261
262GTEST_DEFINE_bool_(list_tests, false,
263 "List all tests without running them.");
264
265// The net priority order after flag processing is thus:
266// --gtest_output command line flag
267// GTEST_OUTPUT environment variable
268// XML_OUTPUT_FILE environment variable
269// ''
270GTEST_DEFINE_string_(
271 output,
272 internal::StringFromGTestEnv("output",
273 internal::OutputFlagAlsoCheckEnvVar().c_str()),
274 "A format (defaults to \"xml\" but can be specified to be \"json\"), "
275 "optionally followed by a colon and an output file name or directory. "
276 "A directory is indicated by a trailing pathname separator. "
277 "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "
278 "If a directory is specified, output files will be created "
279 "within that directory, with file-names based on the test "
280 "executable's name and, if necessary, made unique by adding "
281 "digits.");
282
283GTEST_DEFINE_bool_(
284 brief, internal::BoolFromGTestEnv("brief", false),
285 "True if only test failures should be displayed in text output.");
286
287GTEST_DEFINE_bool_(print_time, internal::BoolFromGTestEnv("print_time", true),
288 "True if and only if " GTEST_NAME_
289 " should display elapsed time in text output.");
290
291GTEST_DEFINE_bool_(print_utf8, internal::BoolFromGTestEnv("print_utf8", true),
292 "True if and only if " GTEST_NAME_
293 " prints UTF8 characters as text.");
294
295GTEST_DEFINE_int32_(
296 random_seed,
297 internal::Int32FromGTestEnv("random_seed", 0),
298 "Random number seed to use when shuffling test orders. Must be in range "
299 "[1, 99999], or 0 to use a seed based on the current time.");
300
301GTEST_DEFINE_int32_(
302 repeat,
303 internal::Int32FromGTestEnv("repeat", 1),
304 "How many times to repeat each test. Specify a negative number "
305 "for repeating forever. Useful for shaking out flaky tests.");
306
307GTEST_DEFINE_bool_(show_internal_stack_frames, false,
308 "True if and only if " GTEST_NAME_
309 " should include internal stack frames when "
310 "printing test failure stack traces.");
311
312GTEST_DEFINE_bool_(shuffle, internal::BoolFromGTestEnv("shuffle", false),
313 "True if and only if " GTEST_NAME_
314 " should randomize tests' order on every run.");
315
316GTEST_DEFINE_int32_(
317 stack_trace_depth,
318 internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
319 "The maximum number of stack frames to print when an "
320 "assertion fails. The valid range is 0 through 100, inclusive.");
321
322GTEST_DEFINE_string_(
323 stream_result_to,
324 internal::StringFromGTestEnv("stream_result_to", ""),
325 "This flag specifies the host name and the port number on which to stream "
326 "test results. Example: \"localhost:555\". The flag is effective only on "
327 "Linux.");
328
329GTEST_DEFINE_bool_(
330 throw_on_failure,
331 internal::BoolFromGTestEnv("throw_on_failure", false),
332 "When this flag is specified, a failed assertion will throw an exception "
333 "if exceptions are enabled or exit the program with a non-zero code "
334 "otherwise. For use with an external test framework.");
335
336#if GTEST_USE_OWN_FLAGFILE_FLAG_
337GTEST_DEFINE_string_(
338 flagfile,
339 internal::StringFromGTestEnv("flagfile", ""),
340 "This flag specifies the flagfile to read command-line flags from.");
341#endif // GTEST_USE_OWN_FLAGFILE_FLAG_
342
343namespace internal {
344
345// Generates a random number from [0, range), using a Linear
346// Congruential Generator (LCG). Crashes if 'range' is 0 or greater
347// than kMaxRange.
348uint32_t Random::Generate(uint32_t range) {
349 // These constants are the same as are used in glibc's rand(3).
350 // Use wider types than necessary to prevent unsigned overflow diagnostics.
351 state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange;
352
353 GTEST_CHECK_(range > 0)
354 << "Cannot generate a number in the range [0, 0).";
355 GTEST_CHECK_(range <= kMaxRange)
356 << "Generation of a number in [0, " << range << ") was requested, "
357 << "but this can only generate numbers in [0, " << kMaxRange << ").";
358
359 // Converting via modulus introduces a bit of downward bias, but
360 // it's simple, and a linear congruential generator isn't too good
361 // to begin with.
362 return state_ % range;
363}
364
365// GTestIsInitialized() returns true if and only if the user has initialized
366// Google Test. Useful for catching the user mistake of not initializing
367// Google Test before calling RUN_ALL_TESTS().
368static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
369
370// Iterates over a vector of TestSuites, keeping a running sum of the
371// results of calling a given int-returning method on each.
372// Returns the sum.
373static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list,
374 int (TestSuite::*method)() const) {
375 int sum = 0;
376 for (size_t i = 0; i < case_list.size(); i++) {
377 sum += (case_list[i]->*method)();
378 }
379 return sum;
380}
381
382// Returns true if and only if the test suite passed.
383static bool TestSuitePassed(const TestSuite* test_suite) {
384 return test_suite->should_run() && test_suite->Passed();
385}
386
387// Returns true if and only if the test suite failed.
388static bool TestSuiteFailed(const TestSuite* test_suite) {
389 return test_suite->should_run() && test_suite->Failed();
390}
391
392// Returns true if and only if test_suite contains at least one test that
393// should run.
394static bool ShouldRunTestSuite(const TestSuite* test_suite) {
395 return test_suite->should_run();
396}
397
398// AssertHelper constructor.
399AssertHelper::AssertHelper(TestPartResult::Type type,
400 const char* file,
401 int line,
402 const char* message)
403 : data_(new AssertHelperData(type, file, line, message)) {
404}
405
406AssertHelper::~AssertHelper() {
407 delete data_;
408}
409
410// Message assignment, for assertion streaming support.
411void AssertHelper::operator=(const Message& message) const {
412 UnitTest::GetInstance()->
413 AddTestPartResult(data_->type, data_->file, data_->line,
414 AppendUserMessage(data_->message, message),
415 UnitTest::GetInstance()->impl()
416 ->CurrentOsStackTraceExceptTop(1)
417 // Skips the stack frame for this function itself.
418 ); // NOLINT
419}
420
421namespace {
422
423// When TEST_P is found without a matching INSTANTIATE_TEST_SUITE_P
424// to creates test cases for it, a syntetic test case is
425// inserted to report ether an error or a log message.
426//
427// This configuration bit will likely be removed at some point.
428constexpr bool kErrorOnUninstantiatedParameterizedTest = true;
429constexpr bool kErrorOnUninstantiatedTypeParameterizedTest = true;
430
431// A test that fails at a given file/line location with a given message.
432class FailureTest : public Test {
433 public:
434 explicit FailureTest(const CodeLocation& loc, std::string error_message,
435 bool as_error)
436 : loc_(loc),
437 error_message_(std::move(error_message)),
438 as_error_(as_error) {}
439
440 void TestBody() override {
441 if (as_error_) {
442 AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
443 loc_.line, "") = Message() << error_message_;
444 } else {
445 std::cout << error_message_ << std::endl;
446 }
447 }
448
449 private:
450 const CodeLocation loc_;
451 const std::string error_message_;
452 const bool as_error_;
453};
454
455
456} // namespace
457
458std::set<std::string>* GetIgnoredParameterizedTestSuites() {
459 return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites();
460}
461
462// Add a given test_suit to the list of them allow to go un-instantiated.
463MarkAsIgnored::MarkAsIgnored(const char* test_suite) {
464 GetIgnoredParameterizedTestSuites()->insert(test_suite);
465}
466
467// If this parameterized test suite has no instantiations (and that
468// has not been marked as okay), emit a test case reporting that.
469void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
470 bool has_test_p) {
471 const auto& ignored = *GetIgnoredParameterizedTestSuites();
472 if (ignored.find(name) != ignored.end()) return;
473
474 const char kMissingInstantiation[] = //
475 " is defined via TEST_P, but never instantiated. None of the test cases "
476 "will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only "
477 "ones provided expand to nothing."
478 "\n\n"
479 "Ideally, TEST_P definitions should only ever be included as part of "
480 "binaries that intend to use them. (As opposed to, for example, being "
481 "placed in a library that may be linked in to get other utilities.)";
482
483 const char kMissingTestCase[] = //
484 " is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are "
485 "defined via TEST_P . No test cases will run."
486 "\n\n"
487 "Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from "
488 "code that always depend on code that provides TEST_P. Failing to do "
489 "so is often an indication of dead code, e.g. the last TEST_P was "
490 "removed but the rest got left behind.";
491
492 std::string message =
493 "Parameterized test suite " + name +
494 (has_test_p ? kMissingInstantiation : kMissingTestCase) +
495 "\n\n"
496 "To suppress this error for this test suite, insert the following line "
497 "(in a non-header) in the namespace it is defined in:"
498 "\n\n"
499 "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + name + ");";
500
501 std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">";
502 RegisterTest( //
503 "GoogleTestVerification", full_name.c_str(),
504 nullptr, // No type parameter.
505 nullptr, // No value parameter.
506 location.file.c_str(), location.line, [message, location] {
507 return new FailureTest(location, message,
508 kErrorOnUninstantiatedParameterizedTest);
509 });
510}
511
512void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
513 CodeLocation code_location) {
514 GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
515 test_suite_name, code_location);
516}
517
518void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) {
519 GetUnitTestImpl()
520 ->type_parameterized_test_registry()
521 .RegisterInstantiation(case_name);
522}
523
524void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
525 const char* test_suite_name, CodeLocation code_location) {
526 suites_.emplace(std::string(test_suite_name),
527 TypeParameterizedTestSuiteInfo(code_location));
528}
529
530void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
531 const char* test_suite_name) {
532 auto it = suites_.find(std::string(test_suite_name));
533 if (it != suites_.end()) {
534 it->second.instantiated = true;
535 } else {
536 GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"
537 << test_suite_name << "'";
538 }
539}
540
541void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
542 const auto& ignored = *GetIgnoredParameterizedTestSuites();
543 for (const auto& testcase : suites_) {
544 if (testcase.second.instantiated) continue;
545 if (ignored.find(testcase.first) != ignored.end()) continue;
546
547 std::string message =
548 "Type parameterized test suite " + testcase.first +
549 " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "
550 "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."
551 "\n\n"
552 "Ideally, TYPED_TEST_P definitions should only ever be included as "
553 "part of binaries that intend to use them. (As opposed to, for "
554 "example, being placed in a library that may be linked in to get other "
555 "utilities.)"
556 "\n\n"
557 "To suppress this error for this test suite, insert the following line "
558 "(in a non-header) in the namespace it is defined in:"
559 "\n\n"
560 "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
561 testcase.first + ");";
562
563 std::string full_name =
564 "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">";
565 RegisterTest( //
566 "GoogleTestVerification", full_name.c_str(),
567 nullptr, // No type parameter.
568 nullptr, // No value parameter.
569 testcase.second.code_location.file.c_str(),
570 testcase.second.code_location.line, [message, testcase] {
571 return new FailureTest(testcase.second.code_location, message,
572 kErrorOnUninstantiatedTypeParameterizedTest);
573 });
574 }
575}
576
577// A copy of all command line arguments. Set by InitGoogleTest().
578static ::std::vector<std::string> g_argvs;
579
580::std::vector<std::string> GetArgvs() {
581#if defined(GTEST_CUSTOM_GET_ARGVS_)
582 // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
583 // ::string. This code converts it to the appropriate type.
584 const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
585 return ::std::vector<std::string>(custom.begin(), custom.end());
586#else // defined(GTEST_CUSTOM_GET_ARGVS_)
587 return g_argvs;
588#endif // defined(GTEST_CUSTOM_GET_ARGVS_)
589}
590
591// Returns the current application's name, removing directory path if that
592// is present.
593FilePath GetCurrentExecutableName() {
594 FilePath result;
595
596#if GTEST_OS_WINDOWS || GTEST_OS_OS2
597 result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
598#else
599 result.Set(FilePath(GetArgvs()[0]));
600#endif // GTEST_OS_WINDOWS
601
602 return result.RemoveDirectoryName();
603}
604
605// Functions for processing the gtest_output flag.
606
607// Returns the output format, or "" for normal printed output.
608std::string UnitTestOptions::GetOutputFormat() {
609 const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
610 const char* const colon = strchr(gtest_output_flag, ':');
611 return (colon == nullptr)
612 ? std::string(gtest_output_flag)
613 : std::string(gtest_output_flag,
614 static_cast<size_t>(colon - gtest_output_flag));
615}
616
617// Returns the name of the requested output file, or the default if none
618// was explicitly specified.
619std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
620 const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
621
622 std::string format = GetOutputFormat();
623 if (format.empty())
624 format = std::string(kDefaultOutputFormat);
625
626 const char* const colon = strchr(gtest_output_flag, ':');
627 if (colon == nullptr)
628 return internal::FilePath::MakeFileName(
629 internal::FilePath(
630 UnitTest::GetInstance()->original_working_dir()),
631 internal::FilePath(kDefaultOutputFile), 0,
632 format.c_str()).string();
633
634 internal::FilePath output_name(colon + 1);
635 if (!output_name.IsAbsolutePath())
636 output_name = internal::FilePath::ConcatPaths(
637 internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
638 internal::FilePath(colon + 1));
639
640 if (!output_name.IsDirectory())
641 return output_name.string();
642
643 internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
644 output_name, internal::GetCurrentExecutableName(),
645 GetOutputFormat().c_str()));
646 return result.string();
647}
648
649// Returns true if and only if the wildcard pattern matches the string. Each
650// pattern consists of regular characters, single-character wildcards (?), and
651// multi-character wildcards (*).
652//
653// This function implements a linear-time string globbing algorithm based on
654// https://research.swtch.com/glob.
655static bool PatternMatchesString(const std::string& name_str,
656 const char* pattern, const char* pattern_end) {
657 const char* name = name_str.c_str();
658 const char* const name_begin = name;
659 const char* const name_end = name + name_str.size();
660
661 const char* pattern_next = pattern;
662 const char* name_next = name;
663
664 while (pattern < pattern_end || name < name_end) {
665 if (pattern < pattern_end) {
666 switch (*pattern) {
667 default: // Match an ordinary character.
668 if (name < name_end && *name == *pattern) {
669 ++pattern;
670 ++name;
671 continue;
672 }
673 break;
674 case '?': // Match any single character.
675 if (name < name_end) {
676 ++pattern;
677 ++name;
678 continue;
679 }
680 break;
681 case '*':
682 // Match zero or more characters. Start by skipping over the wildcard
683 // and matching zero characters from name. If that fails, restart and
684 // match one more character than the last attempt.
685 pattern_next = pattern;
686 name_next = name + 1;
687 ++pattern;
688 continue;
689 }
690 }
691 // Failed to match a character. Restart if possible.
692 if (name_begin < name_next && name_next <= name_end) {
693 pattern = pattern_next;
694 name = name_next;
695 continue;
696 }
697 return false;
698 }
699 return true;
700}
701
702bool UnitTestOptions::MatchesFilter(const std::string& name_str,
703 const char* filter) {
704 // The filter is a list of patterns separated by colons (:).
705 const char* pattern = filter;
706 while (true) {
707 // Find the bounds of this pattern.
708 const char* const next_sep = strchr(pattern, ':');
709 const char* const pattern_end =
710 next_sep != nullptr ? next_sep : pattern + strlen(pattern);
711
712 // Check if this pattern matches name_str.
713 if (PatternMatchesString(name_str, pattern, pattern_end)) {
714 return true;
715 }
716
717 // Give up on this pattern. However, if we found a pattern separator (:),
718 // advance to the next pattern (skipping over the separator) and restart.
719 if (next_sep == nullptr) {
720 return false;
721 }
722 pattern = next_sep + 1;
723 }
724 return true;
725}
726
727// Returns true if and only if the user-specified filter matches the test
728// suite name and the test name.
729bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
730 const std::string& test_name) {
731 const std::string& full_name = test_suite_name + "." + test_name.c_str();
732
733 // Split --gtest_filter at '-', if there is one, to separate into
734 // positive filter and negative filter portions
735 const char* const p = GTEST_FLAG(filter).c_str();
736 const char* const dash = strchr(p, '-');
737 std::string positive;
738 std::string negative;
739 if (dash == nullptr) {
740 positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter
741 negative = "";
742 } else {
743 positive = std::string(p, dash); // Everything up to the dash
744 negative = std::string(dash + 1); // Everything after the dash
745 if (positive.empty()) {
746 // Treat '-test1' as the same as '*-test1'
747 positive = kUniversalFilter;
748 }
749 }
750
751 // A filter is a colon-separated list of patterns. It matches a
752 // test if any pattern in it matches the test.
753 return (MatchesFilter(full_name, positive.c_str()) &&
754 !MatchesFilter(full_name, negative.c_str()));
755}
756
757#if GTEST_HAS_SEH
758// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
759// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
760// This function is useful as an __except condition.
761int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
762 // Google Test should handle a SEH exception if:
763 // 1. the user wants it to, AND
764 // 2. this is not a breakpoint exception, AND
765 // 3. this is not a C++ exception (VC++ implements them via SEH,
766 // apparently).
767 //
768 // SEH exception code for C++ exceptions.
769 // (see http://support.microsoft.com/kb/185294 for more information).
770 const DWORD kCxxExceptionCode = 0xe06d7363;
771
772 bool should_handle = true;
773
774 if (!GTEST_FLAG(catch_exceptions))
775 should_handle = false;
776 else if (exception_code == EXCEPTION_BREAKPOINT)
777 should_handle = false;
778 else if (exception_code == kCxxExceptionCode)
779 should_handle = false;
780
781 return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
782}
783#endif // GTEST_HAS_SEH
784
785} // namespace internal
786
787// The c'tor sets this object as the test part result reporter used by
788// Google Test. The 'result' parameter specifies where to report the
789// results. Intercepts only failures from the current thread.
790ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
791 TestPartResultArray* result)
792 : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
793 result_(result) {
794 Init();
795}
796
797// The c'tor sets this object as the test part result reporter used by
798// Google Test. The 'result' parameter specifies where to report the
799// results.
800ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
801 InterceptMode intercept_mode, TestPartResultArray* result)
802 : intercept_mode_(intercept_mode),
803 result_(result) {
804 Init();
805}
806
807void ScopedFakeTestPartResultReporter::Init() {
808 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
809 if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
810 old_reporter_ = impl->GetGlobalTestPartResultReporter();
811 impl->SetGlobalTestPartResultReporter(this);
812 } else {
813 old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
814 impl->SetTestPartResultReporterForCurrentThread(this);
815 }
816}
817
818// The d'tor restores the test part result reporter used by Google Test
819// before.
820ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
821 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
822 if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
823 impl->SetGlobalTestPartResultReporter(old_reporter_);
824 } else {
825 impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
826 }
827}
828
829// Increments the test part result count and remembers the result.
830// This method is from the TestPartResultReporterInterface interface.
831void ScopedFakeTestPartResultReporter::ReportTestPartResult(
832 const TestPartResult& result) {
833 result_->Append(result);
834}
835
836namespace internal {
837
838// Returns the type ID of ::testing::Test. We should always call this
839// instead of GetTypeId< ::testing::Test>() to get the type ID of
840// testing::Test. This is to work around a suspected linker bug when
841// using Google Test as a framework on Mac OS X. The bug causes
842// GetTypeId< ::testing::Test>() to return different values depending
843// on whether the call is from the Google Test framework itself or
844// from user test code. GetTestTypeId() is guaranteed to always
845// return the same value, as it always calls GetTypeId<>() from the
846// gtest.cc, which is within the Google Test framework.
847TypeId GetTestTypeId() {
848 return GetTypeId<Test>();
849}
850
851// The value of GetTestTypeId() as seen from within the Google Test
852// library. This is solely for testing GetTestTypeId().
853extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();
854
855// This predicate-formatter checks that 'results' contains a test part
856// failure of the given type and that the failure message contains the
857// given substring.
858static AssertionResult HasOneFailure(const char* /* results_expr */,
859 const char* /* type_expr */,
860 const char* /* substr_expr */,
861 const TestPartResultArray& results,
862 TestPartResult::Type type,
863 const std::string& substr) {
864 const std::string expected(type == TestPartResult::kFatalFailure ?
865 "1 fatal failure" :
866 "1 non-fatal failure");
867 Message msg;
868 if (results.size() != 1) {
869 msg << "Expected: " << expected << "\n"
870 << " Actual: " << results.size() << " failures";
871 for (int i = 0; i < results.size(); i++) {
872 msg << "\n" << results.GetTestPartResult(i);
873 }
874 return AssertionFailure() << msg;
875 }
876
877 const TestPartResult& r = results.GetTestPartResult(0);
878 if (r.type() != type) {
879 return AssertionFailure() << "Expected: " << expected << "\n"
880 << " Actual:\n"
881 << r;
882 }
883
884 if (strstr(r.message(), substr.c_str()) == nullptr) {
885 return AssertionFailure() << "Expected: " << expected << " containing \""
886 << substr << "\"\n"
887 << " Actual:\n"
888 << r;
889 }
890
891 return AssertionSuccess();
892}
893
894// The constructor of SingleFailureChecker remembers where to look up
895// test part results, what type of failure we expect, and what
896// substring the failure message should contain.
897SingleFailureChecker::SingleFailureChecker(const TestPartResultArray* results,
898 TestPartResult::Type type,
899 const std::string& substr)
900 : results_(results), type_(type), substr_(substr) {}
901
902// The destructor of SingleFailureChecker verifies that the given
903// TestPartResultArray contains exactly one failure that has the given
904// type and contains the given substring. If that's not the case, a
905// non-fatal failure will be generated.
906SingleFailureChecker::~SingleFailureChecker() {
907 EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
908}
909
910DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
911 UnitTestImpl* unit_test) : unit_test_(unit_test) {}
912
913void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
914 const TestPartResult& result) {
915 unit_test_->current_test_result()->AddTestPartResult(result);
916 unit_test_->listeners()->repeater()->OnTestPartResult(result);
917}
918
919DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
920 UnitTestImpl* unit_test) : unit_test_(unit_test) {}
921
922void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
923 const TestPartResult& result) {
924 unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
925}
926
927// Returns the global test part result reporter.
928TestPartResultReporterInterface*
929UnitTestImpl::GetGlobalTestPartResultReporter() {
930 internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
931 return global_test_part_result_repoter_;
932}
933
934// Sets the global test part result reporter.
935void UnitTestImpl::SetGlobalTestPartResultReporter(
936 TestPartResultReporterInterface* reporter) {
937 internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
938 global_test_part_result_repoter_ = reporter;
939}
940
941// Returns the test part result reporter for the current thread.
942TestPartResultReporterInterface*
943UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
944 return per_thread_test_part_result_reporter_.get();
945}
946
947// Sets the test part result reporter for the current thread.
948void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
949 TestPartResultReporterInterface* reporter) {
950 per_thread_test_part_result_reporter_.set(reporter);
951}
952
953// Gets the number of successful test suites.
954int UnitTestImpl::successful_test_suite_count() const {
955 return CountIf(test_suites_, TestSuitePassed);
956}
957
958// Gets the number of failed test suites.
959int UnitTestImpl::failed_test_suite_count() const {
960 return CountIf(test_suites_, TestSuiteFailed);
961}
962
963// Gets the number of all test suites.
964int UnitTestImpl::total_test_suite_count() const {
965 return static_cast<int>(test_suites_.size());
966}
967
968// Gets the number of all test suites that contain at least one test
969// that should run.
970int UnitTestImpl::test_suite_to_run_count() const {
971 return CountIf(test_suites_, ShouldRunTestSuite);
972}
973
974// Gets the number of successful tests.
975int UnitTestImpl::successful_test_count() const {
976 return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count);
977}
978
979// Gets the number of skipped tests.
980int UnitTestImpl::skipped_test_count() const {
981 return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count);
982}
983
984// Gets the number of failed tests.
985int UnitTestImpl::failed_test_count() const {
986 return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count);
987}
988
989// Gets the number of disabled tests that will be reported in the XML report.
990int UnitTestImpl::reportable_disabled_test_count() const {
991 return SumOverTestSuiteList(test_suites_,
992 &TestSuite::reportable_disabled_test_count);
993}
994
995// Gets the number of disabled tests.
996int UnitTestImpl::disabled_test_count() const {
997 return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count);
998}
999
1000// Gets the number of tests to be printed in the XML report.
1001int UnitTestImpl::reportable_test_count() const {
1002 return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count);
1003}
1004
1005// Gets the number of all tests.
1006int UnitTestImpl::total_test_count() const {
1007 return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count);
1008}
1009
1010// Gets the number of tests that should run.
1011int UnitTestImpl::test_to_run_count() const {
1012 return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
1013}
1014
1015// Returns the current OS stack trace as an std::string.
1016//
1017// The maximum number of stack frames to be included is specified by
1018// the gtest_stack_trace_depth flag. The skip_count parameter
1019// specifies the number of top frames to be skipped, which doesn't
1020// count against the number of frames to be included.
1021//
1022// For example, if Foo() calls Bar(), which in turn calls
1023// CurrentOsStackTraceExceptTop(1), Foo() will be included in the
1024// trace but Bar() and CurrentOsStackTraceExceptTop() won't.
1025std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
1026 return os_stack_trace_getter()->CurrentStackTrace(
1027 static_cast<int>(GTEST_FLAG(stack_trace_depth)),
1028 skip_count + 1
1029 // Skips the user-specified number of frames plus this function
1030 // itself.
1031 ); // NOLINT
1032}
1033
1034// A helper class for measuring elapsed times.
1035class Timer {
1036 public:
1037 Timer() : start_(std::chrono::steady_clock::now()) {}
1038
1039 // Return time elapsed in milliseconds since the timer was created.
1040 TimeInMillis Elapsed() {
1041 return std::chrono::duration_cast<std::chrono::milliseconds>(
1042 std::chrono::steady_clock::now() - start_)
1043 .count();
1044 }
1045
1046 private:
1047 std::chrono::time_point<std::chrono::steady_clock> start_;
1048};
1049
1050// Returns a timestamp as milliseconds since the epoch. Note this time may jump
1051// around subject to adjustments by the system, to measure elapsed time use
1052// Timer instead.
1053TimeInMillis GetTimeInMillis() {
1054 return std::chrono::duration_cast<std::chrono::milliseconds>(
1055 std::chrono::system_clock::now() -
1056 std::chrono::system_clock::from_time_t(0))
1057 .count();
1058}
1059
1060// Utilities
1061
1062// class String.
1063
1064#if GTEST_OS_WINDOWS_MOBILE
1065// Creates a UTF-16 wide string from the given ANSI string, allocating
1066// memory using new. The caller is responsible for deleting the return
1067// value using delete[]. Returns the wide string, or NULL if the
1068// input is NULL.
1069LPCWSTR String::AnsiToUtf16(const char* ansi) {
1070 if (!ansi) return nullptr;
1071 const int length = strlen(ansi);
1072 const int unicode_length =
1073 MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 0);
1074 WCHAR* unicode = new WCHAR[unicode_length + 1];
1075 MultiByteToWideChar(CP_ACP, 0, ansi, length,
1076 unicode, unicode_length);
1077 unicode[unicode_length] = 0;
1078 return unicode;
1079}
1080
1081// Creates an ANSI string from the given wide string, allocating
1082// memory using new. The caller is responsible for deleting the return
1083// value using delete[]. Returns the ANSI string, or NULL if the
1084// input is NULL.
1085const char* String::Utf16ToAnsi(LPCWSTR utf16_str) {
1086 if (!utf16_str) return nullptr;
1087 const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, nullptr,
1088 0, nullptr, nullptr);
1089 char* ansi = new char[ansi_length + 1];
1090 WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length, nullptr,
1091 nullptr);
1092 ansi[ansi_length] = 0;
1093 return ansi;
1094}
1095
1096#endif // GTEST_OS_WINDOWS_MOBILE
1097
1098// Compares two C strings. Returns true if and only if they have the same
1099// content.
1100//
1101// Unlike strcmp(), this function can handle NULL argument(s). A NULL
1102// C string is considered different to any non-NULL C string,
1103// including the empty string.
1104bool String::CStringEquals(const char * lhs, const char * rhs) {
1105 if (lhs == nullptr) return rhs == nullptr;
1106
1107 if (rhs == nullptr) return false;
1108
1109 return strcmp(lhs, rhs) == 0;
1110}
1111
1112#if GTEST_HAS_STD_WSTRING
1113
1114// Converts an array of wide chars to a narrow string using the UTF-8
1115// encoding, and streams the result to the given Message object.
1116static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
1117 Message* msg) {
1118 for (size_t i = 0; i != length; ) { // NOLINT
1119 if (wstr[i] != L'\0') {
1120 *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
1121 while (i != length && wstr[i] != L'\0')
1122 i++;
1123 } else {
1124 *msg << '\0';
1125 i++;
1126 }
1127 }
1128}
1129
1130#endif // GTEST_HAS_STD_WSTRING
1131
1132void SplitString(const ::std::string& str, char delimiter,
1133 ::std::vector< ::std::string>* dest) {
1134 ::std::vector< ::std::string> parsed;
1135 ::std::string::size_type pos = 0;
1136 while (::testing::internal::AlwaysTrue()) {
1137 const ::std::string::size_type colon = str.find(delimiter, pos);
1138 if (colon == ::std::string::npos) {
1139 parsed.push_back(str.substr(pos));
1140 break;
1141 } else {
1142 parsed.push_back(str.substr(pos, colon - pos));
1143 pos = colon + 1;
1144 }
1145 }
1146 dest->swap(parsed);
1147}
1148
1149} // namespace internal
1150
1151// Constructs an empty Message.
1152// We allocate the stringstream separately because otherwise each use of
1153// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
1154// stack frame leading to huge stack frames in some cases; gcc does not reuse
1155// the stack space.
1156Message::Message() : ss_(new ::std::stringstream) {
1157 // By default, we want there to be enough precision when printing
1158 // a double to a Message.
1159 *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
1160}
1161
1162// These two overloads allow streaming a wide C string to a Message
1163// using the UTF-8 encoding.
1164Message& Message::operator <<(const wchar_t* wide_c_str) {
1165 return *this << internal::String::ShowWideCString(wide_c_str);
1166}
1167Message& Message::operator <<(wchar_t* wide_c_str) {
1168 return *this << internal::String::ShowWideCString(wide_c_str);
1169}
1170
1171#if GTEST_HAS_STD_WSTRING
1172// Converts the given wide string to a narrow string using the UTF-8
1173// encoding, and streams the result to this Message object.
1174Message& Message::operator <<(const ::std::wstring& wstr) {
1175 internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
1176 return *this;
1177}
1178#endif // GTEST_HAS_STD_WSTRING
1179
1180// Gets the text streamed to this object so far as an std::string.
1181// Each '\0' character in the buffer is replaced with "\\0".
1182std::string Message::GetString() const {
1183 return internal::StringStreamToString(ss_.get());
1184}
1185
1186// AssertionResult constructors.
1187// Used in EXPECT_TRUE/FALSE(assertion_result).
1188AssertionResult::AssertionResult(const AssertionResult& other)
1189 : success_(other.success_),
1190 message_(other.message_.get() != nullptr
1191 ? new ::std::string(*other.message_)
1192 : static_cast< ::std::string*>(nullptr)) {}
1193
1194// Swaps two AssertionResults.
1195void AssertionResult::swap(AssertionResult& other) {
1196 using std::swap;
1197 swap(success_, other.success_);
1198 swap(message_, other.message_);
1199}
1200
1201// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
1202AssertionResult AssertionResult::operator!() const {
1203 AssertionResult negation(!success_);
1204 if (message_.get() != nullptr) negation << *message_;
1205 return negation;
1206}
1207
1208// Makes a successful assertion result.
1209AssertionResult AssertionSuccess() {
1210 return AssertionResult(true);
1211}
1212
1213// Makes a failed assertion result.
1214AssertionResult AssertionFailure() {
1215 return AssertionResult(false);
1216}
1217
1218// Makes a failed assertion result with the given failure message.
1219// Deprecated; use AssertionFailure() << message.
1220AssertionResult AssertionFailure(const Message& message) {
1221 return AssertionFailure() << message;
1222}
1223
1224namespace internal {
1225
1226namespace edit_distance {
1227std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
1228 const std::vector<size_t>& right) {
1229 std::vector<std::vector<double> > costs(
1230 left.size() + 1, std::vector<double>(right.size() + 1));
1231 std::vector<std::vector<EditType> > best_move(
1232 left.size() + 1, std::vector<EditType>(right.size() + 1));
1233
1234 // Populate for empty right.
1235 for (size_t l_i = 0; l_i < costs.size(); ++l_i) {
1236 costs[l_i][0] = static_cast<double>(l_i);
1237 best_move[l_i][0] = kRemove;
1238 }
1239 // Populate for empty left.
1240 for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) {
1241 costs[0][r_i] = static_cast<double>(r_i);
1242 best_move[0][r_i] = kAdd;
1243 }
1244
1245 for (size_t l_i = 0; l_i < left.size(); ++l_i) {
1246 for (size_t r_i = 0; r_i < right.size(); ++r_i) {
1247 if (left[l_i] == right[r_i]) {
1248 // Found a match. Consume it.
1249 costs[l_i + 1][r_i + 1] = costs[l_i][r_i];
1250 best_move[l_i + 1][r_i + 1] = kMatch;
1251 continue;
1252 }
1253
1254 const double add = costs[l_i + 1][r_i];
1255 const double remove = costs[l_i][r_i + 1];
1256 const double replace = costs[l_i][r_i];
1257 if (add < remove && add < replace) {
1258 costs[l_i + 1][r_i + 1] = add + 1;
1259 best_move[l_i + 1][r_i + 1] = kAdd;
1260 } else if (remove < add && remove < replace) {
1261 costs[l_i + 1][r_i + 1] = remove + 1;
1262 best_move[l_i + 1][r_i + 1] = kRemove;
1263 } else {
1264 // We make replace a little more expensive than add/remove to lower
1265 // their priority.
1266 costs[l_i + 1][r_i + 1] = replace + 1.00001;
1267 best_move[l_i + 1][r_i + 1] = kReplace;
1268 }
1269 }
1270 }
1271
1272 // Reconstruct the best path. We do it in reverse order.
1273 std::vector<EditType> best_path;
1274 for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {
1275 EditType move = best_move[l_i][r_i];
1276 best_path.push_back(move);
1277 l_i -= move != kAdd;
1278 r_i -= move != kRemove;
1279 }
1280 std::reverse(best_path.begin(), best_path.end());
1281 return best_path;
1282}
1283
1284namespace {
1285
1286// Helper class to convert string into ids with deduplication.
1287class InternalStrings {
1288 public:
1289 size_t GetId(const std::string& str) {
1290 IdMap::iterator it = ids_.find(str);
1291 if (it != ids_.end()) return it->second;
1292 size_t id = ids_.size();
1293 return ids_[str] = id;
1294 }
1295
1296 private:
1297 typedef std::map<std::string, size_t> IdMap;
1298 IdMap ids_;
1299};
1300
1301} // namespace
1302
1303std::vector<EditType> CalculateOptimalEdits(
1304 const std::vector<std::string>& left,
1305 const std::vector<std::string>& right) {
1306 std::vector<size_t> left_ids, right_ids;
1307 {
1308 InternalStrings intern_table;
1309 for (size_t i = 0; i < left.size(); ++i) {
1310 left_ids.push_back(intern_table.GetId(left[i]));
1311 }
1312 for (size_t i = 0; i < right.size(); ++i) {
1313 right_ids.push_back(intern_table.GetId(right[i]));
1314 }
1315 }
1316 return CalculateOptimalEdits(left_ids, right_ids);
1317}
1318
1319namespace {
1320
1321// Helper class that holds the state for one hunk and prints it out to the
1322// stream.
1323// It reorders adds/removes when possible to group all removes before all
1324// adds. It also adds the hunk header before printint into the stream.
1325class Hunk {
1326 public:
1327 Hunk(size_t left_start, size_t right_start)
1328 : left_start_(left_start),
1329 right_start_(right_start),
1330 adds_(),
1331 removes_(),
1332 common_() {}
1333
1334 void PushLine(char edit, const char* line) {
1335 switch (edit) {
1336 case ' ':
1337 ++common_;
1338 FlushEdits();
1339 hunk_.push_back(std::make_pair(' ', line));
1340 break;
1341 case '-':
1342 ++removes_;
1343 hunk_removes_.push_back(std::make_pair('-', line));
1344 break;
1345 case '+':
1346 ++adds_;
1347 hunk_adds_.push_back(std::make_pair('+', line));
1348 break;
1349 }
1350 }
1351
1352 void PrintTo(std::ostream* os) {
1353 PrintHeader(os);
1354 FlushEdits();
1355 for (std::list<std::pair<char, const char*> >::const_iterator it =
1356 hunk_.begin();
1357 it != hunk_.end(); ++it) {
1358 *os << it->first << it->second << "\n";
1359 }
1360 }
1361
1362 bool has_edits() const { return adds_ || removes_; }
1363
1364 private:
1365 void FlushEdits() {
1366 hunk_.splice(hunk_.end(), hunk_removes_);
1367 hunk_.splice(hunk_.end(), hunk_adds_);
1368 }
1369
1370 // Print a unified diff header for one hunk.
1371 // The format is
1372 // "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@"
1373 // where the left/right parts are omitted if unnecessary.
1374 void PrintHeader(std::ostream* ss) const {
1375 *ss << "@@ ";
1376 if (removes_) {
1377 *ss << "-" << left_start_ << "," << (removes_ + common_);
1378 }
1379 if (removes_ && adds_) {
1380 *ss << " ";
1381 }
1382 if (adds_) {
1383 *ss << "+" << right_start_ << "," << (adds_ + common_);
1384 }
1385 *ss << " @@\n";
1386 }
1387
1388 size_t left_start_, right_start_;
1389 size_t adds_, removes_, common_;
1390 std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_;
1391};
1392
1393} // namespace
1394
1395// Create a list of diff hunks in Unified diff format.
1396// Each hunk has a header generated by PrintHeader above plus a body with
1397// lines prefixed with ' ' for no change, '-' for deletion and '+' for
1398// addition.
1399// 'context' represents the desired unchanged prefix/suffix around the diff.
1400// If two hunks are close enough that their contexts overlap, then they are
1401// joined into one hunk.
1402std::string CreateUnifiedDiff(const std::vector<std::string>& left,
1403 const std::vector<std::string>& right,
1404 size_t context) {
1405 const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
1406
1407 size_t l_i = 0, r_i = 0, edit_i = 0;
1408 std::stringstream ss;
1409 while (edit_i < edits.size()) {
1410 // Find first edit.
1411 while (edit_i < edits.size() && edits[edit_i] == kMatch) {
1412 ++l_i;
1413 ++r_i;
1414 ++edit_i;
1415 }
1416
1417 // Find the first line to include in the hunk.
1418 const size_t prefix_context = std::min(l_i, context);
1419 Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
1420 for (size_t i = prefix_context; i > 0; --i) {
1421 hunk.PushLine(' ', left[l_i - i].c_str());
1422 }
1423
1424 // Iterate the edits until we found enough suffix for the hunk or the input
1425 // is over.
1426 size_t n_suffix = 0;
1427 for (; edit_i < edits.size(); ++edit_i) {
1428 if (n_suffix >= context) {
1429 // Continue only if the next hunk is very close.
1430 auto it = edits.begin() + static_cast<int>(edit_i);
1431 while (it != edits.end() && *it == kMatch) ++it;
1432 if (it == edits.end() ||
1433 static_cast<size_t>(it - edits.begin()) - edit_i >= context) {
1434 // There is no next edit or it is too far away.
1435 break;
1436 }
1437 }
1438
1439 EditType edit = edits[edit_i];
1440 // Reset count when a non match is found.
1441 n_suffix = edit == kMatch ? n_suffix + 1 : 0;
1442
1443 if (edit == kMatch || edit == kRemove || edit == kReplace) {
1444 hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
1445 }
1446 if (edit == kAdd || edit == kReplace) {
1447 hunk.PushLine('+', right[r_i].c_str());
1448 }
1449
1450 // Advance indices, depending on edit type.
1451 l_i += edit != kAdd;
1452 r_i += edit != kRemove;
1453 }
1454
1455 if (!hunk.has_edits()) {
1456 // We are done. We don't want this hunk.
1457 break;
1458 }
1459
1460 hunk.PrintTo(&ss);
1461 }
1462 return ss.str();
1463}
1464
1465} // namespace edit_distance
1466
1467namespace {
1468
1469// The string representation of the values received in EqFailure() are already
1470// escaped. Split them on escaped '\n' boundaries. Leave all other escaped
1471// characters the same.
1472std::vector<std::string> SplitEscapedString(const std::string& str) {
1473 std::vector<std::string> lines;
1474 size_t start = 0, end = str.size();
1475 if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
1476 ++start;
1477 --end;
1478 }
1479 bool escaped = false;
1480 for (size_t i = start; i + 1 < end; ++i) {
1481 if (escaped) {
1482 escaped = false;
1483 if (str[i] == 'n') {
1484 lines.push_back(str.substr(start, i - start - 1));
1485 start = i + 1;
1486 }
1487 } else {
1488 escaped = str[i] == '\\';
1489 }
1490 }
1491 lines.push_back(str.substr(start, end - start));
1492 return lines;
1493}
1494
1495} // namespace
1496
1497// Constructs and returns the message for an equality assertion
1498// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
1499//
1500// The first four parameters are the expressions used in the assertion
1501// and their values, as strings. For example, for ASSERT_EQ(foo, bar)
1502// where foo is 5 and bar is 6, we have:
1503//
1504// lhs_expression: "foo"
1505// rhs_expression: "bar"
1506// lhs_value: "5"
1507// rhs_value: "6"
1508//
1509// The ignoring_case parameter is true if and only if the assertion is a
1510// *_STRCASEEQ*. When it's true, the string "Ignoring case" will
1511// be inserted into the message.
1512AssertionResult EqFailure(const char* lhs_expression,
1513 const char* rhs_expression,
1514 const std::string& lhs_value,
1515 const std::string& rhs_value,
1516 bool ignoring_case) {
1517 Message msg;
1518 msg << "Expected equality of these values:";
1519 msg << "\n " << lhs_expression;
1520 if (lhs_value != lhs_expression) {
1521 msg << "\n Which is: " << lhs_value;
1522 }
1523 msg << "\n " << rhs_expression;
1524 if (rhs_value != rhs_expression) {
1525 msg << "\n Which is: " << rhs_value;
1526 }
1527
1528 if (ignoring_case) {
1529 msg << "\nIgnoring case";
1530 }
1531
1532 if (!lhs_value.empty() && !rhs_value.empty()) {
1533 const std::vector<std::string> lhs_lines =
1534 SplitEscapedString(lhs_value);
1535 const std::vector<std::string> rhs_lines =
1536 SplitEscapedString(rhs_value);
1537 if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
1538 msg << "\nWith diff:\n"
1539 << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
1540 }
1541 }
1542
1543 return AssertionFailure() << msg;
1544}
1545
1546// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
1547std::string GetBoolAssertionFailureMessage(
1548 const AssertionResult& assertion_result,
1549 const char* expression_text,
1550 const char* actual_predicate_value,
1551 const char* expected_predicate_value) {
1552 const char* actual_message = assertion_result.message();
1553 Message msg;
1554 msg << "Value of: " << expression_text
1555 << "\n Actual: " << actual_predicate_value;
1556 if (actual_message[0] != '\0')
1557 msg << " (" << actual_message << ")";
1558 msg << "\nExpected: " << expected_predicate_value;
1559 return msg.GetString();
1560}
1561
1562// Helper function for implementing ASSERT_NEAR.
1563AssertionResult DoubleNearPredFormat(const char* expr1,
1564 const char* expr2,
1565 const char* abs_error_expr,
1566 double val1,
1567 double val2,
1568 double abs_error) {
1569 const double diff = fabs(val1 - val2);
1570 if (diff <= abs_error) return AssertionSuccess();
1571
1572 // Find the value which is closest to zero.
1573 const double min_abs = std::min(fabs(val1), fabs(val2));
1574 // Find the distance to the next double from that value.
1575 const double epsilon =
1576 nextafter(min_abs, std::numeric_limits<double>::infinity()) - min_abs;
1577 // Detect the case where abs_error is so small that EXPECT_NEAR is
1578 // effectively the same as EXPECT_EQUAL, and give an informative error
1579 // message so that the situation can be more easily understood without
1580 // requiring exotic floating-point knowledge.
1581 // Don't do an epsilon check if abs_error is zero because that implies
1582 // that an equality check was actually intended.
1583 if (!(std::isnan)(val1) && !(std::isnan)(val2) && abs_error > 0 &&
1584 abs_error < epsilon) {
1585 return AssertionFailure()
1586 << "The difference between " << expr1 << " and " << expr2 << " is "
1587 << diff << ", where\n"
1588 << expr1 << " evaluates to " << val1 << ",\n"
1589 << expr2 << " evaluates to " << val2 << ".\nThe abs_error parameter "
1590 << abs_error_expr << " evaluates to " << abs_error
1591 << " which is smaller than the minimum distance between doubles for "
1592 "numbers of this magnitude which is "
1593 << epsilon
1594 << ", thus making this EXPECT_NEAR check equivalent to "
1595 "EXPECT_EQUAL. Consider using EXPECT_DOUBLE_EQ instead.";
1596 }
1597 return AssertionFailure()
1598 << "The difference between " << expr1 << " and " << expr2
1599 << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
1600 << expr1 << " evaluates to " << val1 << ",\n"
1601 << expr2 << " evaluates to " << val2 << ", and\n"
1602 << abs_error_expr << " evaluates to " << abs_error << ".";
1603}
1604
1605
1606// Helper template for implementing FloatLE() and DoubleLE().
1607template <typename RawType>
1608AssertionResult FloatingPointLE(const char* expr1,
1609 const char* expr2,
1610 RawType val1,
1611 RawType val2) {
1612 // Returns success if val1 is less than val2,
1613 if (val1 < val2) {
1614 return AssertionSuccess();
1615 }
1616
1617 // or if val1 is almost equal to val2.
1618 const FloatingPoint<RawType> lhs(val1), rhs(val2);
1619 if (lhs.AlmostEquals(rhs)) {
1620 return AssertionSuccess();
1621 }
1622
1623 // Note that the above two checks will both fail if either val1 or
1624 // val2 is NaN, as the IEEE floating-point standard requires that
1625 // any predicate involving a NaN must return false.
1626
1627 ::std::stringstream val1_ss;
1628 val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
1629 << val1;
1630
1631 ::std::stringstream val2_ss;
1632 val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
1633 << val2;
1634
1635 return AssertionFailure()
1636 << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
1637 << " Actual: " << StringStreamToString(&val1_ss) << " vs "
1638 << StringStreamToString(&val2_ss);
1639}
1640
1641} // namespace internal
1642
1643// Asserts that val1 is less than, or almost equal to, val2. Fails
1644// otherwise. In particular, it fails if either val1 or val2 is NaN.
1645AssertionResult FloatLE(const char* expr1, const char* expr2,
1646 float val1, float val2) {
1647 return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
1648}
1649
1650// Asserts that val1 is less than, or almost equal to, val2. Fails
1651// otherwise. In particular, it fails if either val1 or val2 is NaN.
1652AssertionResult DoubleLE(const char* expr1, const char* expr2,
1653 double val1, double val2) {
1654 return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
1655}
1656
1657namespace internal {
1658
1659// The helper function for {ASSERT|EXPECT}_STREQ.
1660AssertionResult CmpHelperSTREQ(const char* lhs_expression,
1661 const char* rhs_expression,
1662 const char* lhs,
1663 const char* rhs) {
1664 if (String::CStringEquals(lhs, rhs)) {
1665 return AssertionSuccess();
1666 }
1667
1668 return EqFailure(lhs_expression,
1669 rhs_expression,
1670 PrintToString(lhs),
1671 PrintToString(rhs),
1672 false);
1673}
1674
1675// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
1676AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
1677 const char* rhs_expression,
1678 const char* lhs,
1679 const char* rhs) {
1680 if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
1681 return AssertionSuccess();
1682 }
1683
1684 return EqFailure(lhs_expression,
1685 rhs_expression,
1686 PrintToString(lhs),
1687 PrintToString(rhs),
1688 true);
1689}
1690
1691// The helper function for {ASSERT|EXPECT}_STRNE.
1692AssertionResult CmpHelperSTRNE(const char* s1_expression,
1693 const char* s2_expression,
1694 const char* s1,
1695 const char* s2) {
1696 if (!String::CStringEquals(s1, s2)) {
1697 return AssertionSuccess();
1698 } else {
1699 return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
1700 << s2_expression << "), actual: \""
1701 << s1 << "\" vs \"" << s2 << "\"";
1702 }
1703}
1704
1705// The helper function for {ASSERT|EXPECT}_STRCASENE.
1706AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
1707 const char* s2_expression,
1708 const char* s1,
1709 const char* s2) {
1710 if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
1711 return AssertionSuccess();
1712 } else {
1713 return AssertionFailure()
1714 << "Expected: (" << s1_expression << ") != ("
1715 << s2_expression << ") (ignoring case), actual: \""
1716 << s1 << "\" vs \"" << s2 << "\"";
1717 }
1718}
1719
1720} // namespace internal
1721
1722namespace {
1723
1724// Helper functions for implementing IsSubString() and IsNotSubstring().
1725
1726// This group of overloaded functions return true if and only if needle
1727// is a substring of haystack. NULL is considered a substring of
1728// itself only.
1729
1730bool IsSubstringPred(const char* needle, const char* haystack) {
1731 if (needle == nullptr || haystack == nullptr) return needle == haystack;
1732
1733 return strstr(haystack, needle) != nullptr;
1734}
1735
1736bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
1737 if (needle == nullptr || haystack == nullptr) return needle == haystack;
1738
1739 return wcsstr(haystack, needle) != nullptr;
1740}
1741
1742// StringType here can be either ::std::string or ::std::wstring.
1743template <typename StringType>
1744bool IsSubstringPred(const StringType& needle,
1745 const StringType& haystack) {
1746 return haystack.find(needle) != StringType::npos;
1747}
1748
1749// This function implements either IsSubstring() or IsNotSubstring(),
1750// depending on the value of the expected_to_be_substring parameter.
1751// StringType here can be const char*, const wchar_t*, ::std::string,
1752// or ::std::wstring.
1753template <typename StringType>
1754AssertionResult IsSubstringImpl(
1755 bool expected_to_be_substring,
1756 const char* needle_expr, const char* haystack_expr,
1757 const StringType& needle, const StringType& haystack) {
1758 if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
1759 return AssertionSuccess();
1760
1761 const bool is_wide_string = sizeof(needle[0]) > 1;
1762 const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
1763 return AssertionFailure()
1764 << "Value of: " << needle_expr << "\n"
1765 << " Actual: " << begin_string_quote << needle << "\"\n"
1766 << "Expected: " << (expected_to_be_substring ? "" : "not ")
1767 << "a substring of " << haystack_expr << "\n"
1768 << "Which is: " << begin_string_quote << haystack << "\"";
1769}
1770
1771} // namespace
1772
1773// IsSubstring() and IsNotSubstring() check whether needle is a
1774// substring of haystack (NULL is considered a substring of itself
1775// only), and return an appropriate error message when they fail.
1776
1777AssertionResult IsSubstring(
1778 const char* needle_expr, const char* haystack_expr,
1779 const char* needle, const char* haystack) {
1780 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
1781}
1782
1783AssertionResult IsSubstring(
1784 const char* needle_expr, const char* haystack_expr,
1785 const wchar_t* needle, const wchar_t* haystack) {
1786 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
1787}
1788
1789AssertionResult IsNotSubstring(
1790 const char* needle_expr, const char* haystack_expr,
1791 const char* needle, const char* haystack) {
1792 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
1793}
1794
1795AssertionResult IsNotSubstring(
1796 const char* needle_expr, const char* haystack_expr,
1797 const wchar_t* needle, const wchar_t* haystack) {
1798 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
1799}
1800
1801AssertionResult IsSubstring(
1802 const char* needle_expr, const char* haystack_expr,
1803 const ::std::string& needle, const ::std::string& haystack) {
1804 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
1805}
1806
1807AssertionResult IsNotSubstring(
1808 const char* needle_expr, const char* haystack_expr,
1809 const ::std::string& needle, const ::std::string& haystack) {
1810 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
1811}
1812
1813#if GTEST_HAS_STD_WSTRING
1814AssertionResult IsSubstring(
1815 const char* needle_expr, const char* haystack_expr,
1816 const ::std::wstring& needle, const ::std::wstring& haystack) {
1817 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
1818}
1819
1820AssertionResult IsNotSubstring(
1821 const char* needle_expr, const char* haystack_expr,
1822 const ::std::wstring& needle, const ::std::wstring& haystack) {
1823 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
1824}
1825#endif // GTEST_HAS_STD_WSTRING
1826
1827namespace internal {
1828
1829#if GTEST_OS_WINDOWS
1830
1831namespace {
1832
1833// Helper function for IsHRESULT{SuccessFailure} predicates
1834AssertionResult HRESULTFailureHelper(const char* expr,
1835 const char* expected,
1836 long hr) { // NOLINT
1837# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE
1838
1839 // Windows CE doesn't support FormatMessage.
1840 const char error_text[] = "";
1841
1842# else
1843
1844 // Looks up the human-readable system message for the HRESULT code
1845 // and since we're not passing any params to FormatMessage, we don't
1846 // want inserts expanded.
1847 const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
1848 FORMAT_MESSAGE_IGNORE_INSERTS;
1849 const DWORD kBufSize = 4096;
1850 // Gets the system's human readable message string for this HRESULT.
1851 char error_text[kBufSize] = { '\0' };
1852 DWORD message_length = ::FormatMessageA(kFlags,
1853 0, // no source, we're asking system
1854 static_cast<DWORD>(hr), // the error
1855 0, // no line width restrictions
1856 error_text, // output buffer
1857 kBufSize, // buf size
1858 nullptr); // no arguments for inserts
1859 // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
1860 for (; message_length && IsSpace(error_text[message_length - 1]);
1861 --message_length) {
1862 error_text[message_length - 1] = '\0';
1863 }
1864
1865# endif // GTEST_OS_WINDOWS_MOBILE
1866
1867 const std::string error_hex("0x" + String::FormatHexInt(hr));
1868 return ::testing::AssertionFailure()
1869 << "Expected: " << expr << " " << expected << ".\n"
1870 << " Actual: " << error_hex << " " << error_text << "\n";
1871}
1872
1873} // namespace
1874
1875AssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT
1876 if (SUCCEEDED(hr)) {
1877 return AssertionSuccess();
1878 }
1879 return HRESULTFailureHelper(expr, "succeeds", hr);
1880}
1881
1882AssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT
1883 if (FAILED(hr)) {
1884 return AssertionSuccess();
1885 }
1886 return HRESULTFailureHelper(expr, "fails", hr);
1887}
1888
1889#endif // GTEST_OS_WINDOWS
1890
1891// Utility functions for encoding Unicode text (wide strings) in
1892// UTF-8.
1893
1894// A Unicode code-point can have up to 21 bits, and is encoded in UTF-8
1895// like this:
1896//
1897// Code-point length Encoding
1898// 0 - 7 bits 0xxxxxxx
1899// 8 - 11 bits 110xxxxx 10xxxxxx
1900// 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx
1901// 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
1902
1903// The maximum code-point a one-byte UTF-8 sequence can represent.
1904constexpr uint32_t kMaxCodePoint1 = (static_cast<uint32_t>(1) << 7) - 1;
1905
1906// The maximum code-point a two-byte UTF-8 sequence can represent.
1907constexpr uint32_t kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1;
1908
1909// The maximum code-point a three-byte UTF-8 sequence can represent.
1910constexpr uint32_t kMaxCodePoint3 = (static_cast<uint32_t>(1) << (4 + 2*6)) - 1;
1911
1912// The maximum code-point a four-byte UTF-8 sequence can represent.
1913constexpr uint32_t kMaxCodePoint4 = (static_cast<uint32_t>(1) << (3 + 3*6)) - 1;
1914
1915// Chops off the n lowest bits from a bit pattern. Returns the n
1916// lowest bits. As a side effect, the original bit pattern will be
1917// shifted to the right by n bits.
1918inline uint32_t ChopLowBits(uint32_t* bits, int n) {
1919 const uint32_t low_bits = *bits & ((static_cast<uint32_t>(1) << n) - 1);
1920 *bits >>= n;
1921 return low_bits;
1922}
1923
1924// Converts a Unicode code point to a narrow string in UTF-8 encoding.
1925// code_point parameter is of type uint32_t because wchar_t may not be
1926// wide enough to contain a code point.
1927// If the code_point is not a valid Unicode code point
1928// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
1929// to "(Invalid Unicode 0xXXXXXXXX)".
1930std::string CodePointToUtf8(uint32_t code_point) {
1931 if (code_point > kMaxCodePoint4) {
1932 return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")";
1933 }
1934
1935 char str[5]; // Big enough for the largest valid code point.
1936 if (code_point <= kMaxCodePoint1) {
1937 str[1] = '\0';
1938 str[0] = static_cast<char>(code_point); // 0xxxxxxx
1939 } else if (code_point <= kMaxCodePoint2) {
1940 str[2] = '\0';
1941 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1942 str[0] = static_cast<char>(0xC0 | code_point); // 110xxxxx
1943 } else if (code_point <= kMaxCodePoint3) {
1944 str[3] = '\0';
1945 str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1946 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1947 str[0] = static_cast<char>(0xE0 | code_point); // 1110xxxx
1948 } else { // code_point <= kMaxCodePoint4
1949 str[4] = '\0';
1950 str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1951 str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1952 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
1953 str[0] = static_cast<char>(0xF0 | code_point); // 11110xxx
1954 }
1955 return str;
1956}
1957
1958// The following two functions only make sense if the system
1959// uses UTF-16 for wide string encoding. All supported systems
1960// with 16 bit wchar_t (Windows, Cygwin) do use UTF-16.
1961
1962// Determines if the arguments constitute UTF-16 surrogate pair
1963// and thus should be combined into a single Unicode code point
1964// using CreateCodePointFromUtf16SurrogatePair.
1965inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
1966 return sizeof(wchar_t) == 2 &&
1967 (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
1968}
1969
1970// Creates a Unicode code point from UTF16 surrogate pair.
1971inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
1972 wchar_t second) {
1973 const auto first_u = static_cast<uint32_t>(first);
1974 const auto second_u = static_cast<uint32_t>(second);
1975 const uint32_t mask = (1 << 10) - 1;
1976 return (sizeof(wchar_t) == 2)
1977 ? (((first_u & mask) << 10) | (second_u & mask)) + 0x10000
1978 :
1979 // This function should not be called when the condition is
1980 // false, but we provide a sensible default in case it is.
1981 first_u;
1982}
1983
1984// Converts a wide string to a narrow string in UTF-8 encoding.
1985// The wide string is assumed to have the following encoding:
1986// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
1987// UTF-32 if sizeof(wchar_t) == 4 (on Linux)
1988// Parameter str points to a null-terminated wide string.
1989// Parameter num_chars may additionally limit the number
1990// of wchar_t characters processed. -1 is used when the entire string
1991// should be processed.
1992// If the string contains code points that are not valid Unicode code points
1993// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
1994// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
1995// and contains invalid UTF-16 surrogate pairs, values in those pairs
1996// will be encoded as individual Unicode characters from Basic Normal Plane.
1997std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
1998 if (num_chars == -1)
1999 num_chars = static_cast<int>(wcslen(str));
2000
2001 ::std::stringstream stream;
2002 for (int i = 0; i < num_chars; ++i) {
2003 uint32_t unicode_code_point;
2004
2005 if (str[i] == L'\0') {
2006 break;
2007 } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
2008 unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
2009 str[i + 1]);
2010 i++;
2011 } else {
2012 unicode_code_point = static_cast<uint32_t>(str[i]);
2013 }
2014
2015 stream << CodePointToUtf8(unicode_code_point);
2016 }
2017 return StringStreamToString(&stream);
2018}
2019
2020// Converts a wide C string to an std::string using the UTF-8 encoding.
2021// NULL will be converted to "(null)".
2022std::string String::ShowWideCString(const wchar_t * wide_c_str) {
2023 if (wide_c_str == nullptr) return "(null)";
2024
2025 return internal::WideStringToUtf8(wide_c_str, -1);
2026}
2027
2028// Compares two wide C strings. Returns true if and only if they have the
2029// same content.
2030//
2031// Unlike wcscmp(), this function can handle NULL argument(s). A NULL
2032// C string is considered different to any non-NULL C string,
2033// including the empty string.
2034bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
2035 if (lhs == nullptr) return rhs == nullptr;
2036
2037 if (rhs == nullptr) return false;
2038
2039 return wcscmp(lhs, rhs) == 0;
2040}
2041
2042// Helper function for *_STREQ on wide strings.
2043AssertionResult CmpHelperSTREQ(const char* lhs_expression,
2044 const char* rhs_expression,
2045 const wchar_t* lhs,
2046 const wchar_t* rhs) {
2047 if (String::WideCStringEquals(lhs, rhs)) {
2048 return AssertionSuccess();
2049 }
2050
2051 return EqFailure(lhs_expression,
2052 rhs_expression,
2053 PrintToString(lhs),
2054 PrintToString(rhs),
2055 false);
2056}
2057
2058// Helper function for *_STRNE on wide strings.
2059AssertionResult CmpHelperSTRNE(const char* s1_expression,
2060 const char* s2_expression,
2061 const wchar_t* s1,
2062 const wchar_t* s2) {
2063 if (!String::WideCStringEquals(s1, s2)) {
2064 return AssertionSuccess();
2065 }
2066
2067 return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
2068 << s2_expression << "), actual: "
2069 << PrintToString(s1)
2070 << " vs " << PrintToString(s2);
2071}
2072
2073// Compares two C strings, ignoring case. Returns true if and only if they have
2074// the same content.
2075//
2076// Unlike strcasecmp(), this function can handle NULL argument(s). A
2077// NULL C string is considered different to any non-NULL C string,
2078// including the empty string.
2079bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
2080 if (lhs == nullptr) return rhs == nullptr;
2081 if (rhs == nullptr) return false;
2082 return posix::StrCaseCmp(lhs, rhs) == 0;
2083}
2084
2085// Compares two wide C strings, ignoring case. Returns true if and only if they
2086// have the same content.
2087//
2088// Unlike wcscasecmp(), this function can handle NULL argument(s).
2089// A NULL C string is considered different to any non-NULL wide C string,
2090// including the empty string.
2091// NB: The implementations on different platforms slightly differ.
2092// On windows, this method uses _wcsicmp which compares according to LC_CTYPE
2093// environment variable. On GNU platform this method uses wcscasecmp
2094// which compares according to LC_CTYPE category of the current locale.
2095// On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
2096// current locale.
2097bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
2098 const wchar_t* rhs) {
2099 if (lhs == nullptr) return rhs == nullptr;
2100
2101 if (rhs == nullptr) return false;
2102
2103#if GTEST_OS_WINDOWS
2104 return _wcsicmp(lhs, rhs) == 0;
2105#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
2106 return wcscasecmp(lhs, rhs) == 0;
2107#else
2108 // Android, Mac OS X and Cygwin don't define wcscasecmp.
2109 // Other unknown OSes may not define it either.
2110 wint_t left, right;
2111 do {
2112 left = towlower(static_cast<wint_t>(*lhs++));
2113 right = towlower(static_cast<wint_t>(*rhs++));
2114 } while (left && left == right);
2115 return left == right;
2116#endif // OS selector
2117}
2118
2119// Returns true if and only if str ends with the given suffix, ignoring case.
2120// Any string is considered to end with an empty suffix.
2121bool String::EndsWithCaseInsensitive(
2122 const std::string& str, const std::string& suffix) {
2123 const size_t str_len = str.length();
2124 const size_t suffix_len = suffix.length();
2125 return (str_len >= suffix_len) &&
2126 CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
2127 suffix.c_str());
2128}
2129
2130// Formats an int value as "%02d".
2131std::string String::FormatIntWidth2(int value) {
2132 return FormatIntWidthN(value, 2);
2133}
2134
2135// Formats an int value to given width with leading zeros.
2136std::string String::FormatIntWidthN(int value, int width) {
2137 std::stringstream ss;
2138 ss << std::setfill('0') << std::setw(width) << value;
2139 return ss.str();
2140}
2141
2142// Formats an int value as "%X".
2143std::string String::FormatHexUInt32(uint32_t value) {
2144 std::stringstream ss;
2145 ss << std::hex << std::uppercase << value;
2146 return ss.str();
2147}
2148
2149// Formats an int value as "%X".
2150std::string String::FormatHexInt(int value) {
2151 return FormatHexUInt32(static_cast<uint32_t>(value));
2152}
2153
2154// Formats a byte as "%02X".
2155std::string String::FormatByte(unsigned char value) {
2156 std::stringstream ss;
2157 ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
2158 << static_cast<unsigned int>(value);
2159 return ss.str();
2160}
2161
2162// Converts the buffer in a stringstream to an std::string, converting NUL
2163// bytes to "\\0" along the way.
2164std::string StringStreamToString(::std::stringstream* ss) {
2165 const ::std::string& str = ss->str();
2166 const char* const start = str.c_str();
2167 const char* const end = start + str.length();
2168
2169 std::string result;
2170 result.reserve(static_cast<size_t>(2 * (end - start)));
2171 for (const char* ch = start; ch != end; ++ch) {
2172 if (*ch == '\0') {
2173 result += "\\0"; // Replaces NUL with "\\0";
2174 } else {
2175 result += *ch;
2176 }
2177 }
2178
2179 return result;
2180}
2181
2182// Appends the user-supplied message to the Google-Test-generated message.
2183std::string AppendUserMessage(const std::string& gtest_msg,
2184 const Message& user_msg) {
2185 // Appends the user message if it's non-empty.
2186 const std::string user_msg_string = user_msg.GetString();
2187 if (user_msg_string.empty()) {
2188 return gtest_msg;
2189 }
2190 if (gtest_msg.empty()) {
2191 return user_msg_string;
2192 }
2193 return gtest_msg + "\n" + user_msg_string;
2194}
2195
2196} // namespace internal
2197
2198// class TestResult
2199
2200// Creates an empty TestResult.
2201TestResult::TestResult()
2202 : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
2203
2204// D'tor.
2205TestResult::~TestResult() {
2206}
2207
2208// Returns the i-th test part result among all the results. i can
2209// range from 0 to total_part_count() - 1. If i is not in that range,
2210// aborts the program.
2211const TestPartResult& TestResult::GetTestPartResult(int i) const {
2212 if (i < 0 || i >= total_part_count())
2213 internal::posix::Abort();
2214 return test_part_results_.at(static_cast<size_t>(i));
2215}
2216
2217// Returns the i-th test property. i can range from 0 to
2218// test_property_count() - 1. If i is not in that range, aborts the
2219// program.
2220const TestProperty& TestResult::GetTestProperty(int i) const {
2221 if (i < 0 || i >= test_property_count())
2222 internal::posix::Abort();
2223 return test_properties_.at(static_cast<size_t>(i));
2224}
2225
2226// Clears the test part results.
2227void TestResult::ClearTestPartResults() {
2228 test_part_results_.clear();
2229}
2230
2231// Adds a test part result to the list.
2232void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
2233 test_part_results_.push_back(test_part_result);
2234}
2235
2236// Adds a test property to the list. If a property with the same key as the
2237// supplied property is already represented, the value of this test_property
2238// replaces the old value for that key.
2239void TestResult::RecordProperty(const std::string& xml_element,
2240 const TestProperty& test_property) {
2241 if (!ValidateTestProperty(xml_element, test_property)) {
2242 return;
2243 }
2244 internal::MutexLock lock(&test_properites_mutex_);
2245 const std::vector<TestProperty>::iterator property_with_matching_key =
2246 std::find_if(test_properties_.begin(), test_properties_.end(),
2247 internal::TestPropertyKeyIs(test_property.key()));
2248 if (property_with_matching_key == test_properties_.end()) {
2249 test_properties_.push_back(test_property);
2250 return;
2251 }
2252 property_with_matching_key->SetValue(test_property.value());
2253}
2254
2255// The list of reserved attributes used in the <testsuites> element of XML
2256// output.
2257static const char* const kReservedTestSuitesAttributes[] = {
2258 "disabled",
2259 "errors",
2260 "failures",
2261 "name",
2262 "random_seed",
2263 "tests",
2264 "time",
2265 "timestamp"
2266};
2267
2268// The list of reserved attributes used in the <testsuite> element of XML
2269// output.
2270static const char* const kReservedTestSuiteAttributes[] = {
2271 "disabled", "errors", "failures", "name",
2272 "tests", "time", "timestamp", "skipped"};
2273
2274// The list of reserved attributes used in the <testcase> element of XML output.
2275static const char* const kReservedTestCaseAttributes[] = {
2276 "classname", "name", "status", "time", "type_param",
2277 "value_param", "file", "line"};
2278
2279// Use a slightly different set for allowed output to ensure existing tests can
2280// still RecordProperty("result") or "RecordProperty(timestamp")
2281static const char* const kReservedOutputTestCaseAttributes[] = {
2282 "classname", "name", "status", "time", "type_param",
2283 "value_param", "file", "line", "result", "timestamp"};
2284
2285template <size_t kSize>
2286std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
2287 return std::vector<std::string>(array, array + kSize);
2288}
2289
2290static std::vector<std::string> GetReservedAttributesForElement(
2291 const std::string& xml_element) {
2292 if (xml_element == "testsuites") {
2293 return ArrayAsVector(kReservedTestSuitesAttributes);
2294 } else if (xml_element == "testsuite") {
2295 return ArrayAsVector(kReservedTestSuiteAttributes);
2296 } else if (xml_element == "testcase") {
2297 return ArrayAsVector(kReservedTestCaseAttributes);
2298 } else {
2299 GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
2300 }
2301 // This code is unreachable but some compilers may not realizes that.
2302 return std::vector<std::string>();
2303}
2304
2305// TODO(jdesprez): Merge the two getReserved attributes once skip is improved
2306static std::vector<std::string> GetReservedOutputAttributesForElement(
2307 const std::string& xml_element) {
2308 if (xml_element == "testsuites") {
2309 return ArrayAsVector(kReservedTestSuitesAttributes);
2310 } else if (xml_element == "testsuite") {
2311 return ArrayAsVector(kReservedTestSuiteAttributes);
2312 } else if (xml_element == "testcase") {
2313 return ArrayAsVector(kReservedOutputTestCaseAttributes);
2314 } else {
2315 GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
2316 }
2317 // This code is unreachable but some compilers may not realizes that.
2318 return std::vector<std::string>();
2319}
2320
2321static std::string FormatWordList(const std::vector<std::string>& words) {
2322 Message word_list;
2323 for (size_t i = 0; i < words.size(); ++i) {
2324 if (i > 0 && words.size() > 2) {
2325 word_list << ", ";
2326 }
2327 if (i == words.size() - 1) {
2328 word_list << "and ";
2329 }
2330 word_list << "'" << words[i] << "'";
2331 }
2332 return word_list.GetString();
2333}
2334
2335static bool ValidateTestPropertyName(
2336 const std::string& property_name,
2337 const std::vector<std::string>& reserved_names) {
2338 if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
2339 reserved_names.end()) {
2340 ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
2341 << " (" << FormatWordList(reserved_names)
2342 << " are reserved by " << GTEST_NAME_ << ")";
2343 return false;
2344 }
2345 return true;
2346}
2347
2348// Adds a failure if the key is a reserved attribute of the element named
2349// xml_element. Returns true if the property is valid.
2350bool TestResult::ValidateTestProperty(const std::string& xml_element,
2351 const TestProperty& test_property) {
2352 return ValidateTestPropertyName(test_property.key(),
2353 GetReservedAttributesForElement(xml_element));
2354}
2355
2356// Clears the object.
2357void TestResult::Clear() {
2358 test_part_results_.clear();
2359 test_properties_.clear();
2360 death_test_count_ = 0;
2361 elapsed_time_ = 0;
2362}
2363
2364// Returns true off the test part was skipped.
2365static bool TestPartSkipped(const TestPartResult& result) {
2366 return result.skipped();
2367}
2368
2369// Returns true if and only if the test was skipped.
2370bool TestResult::Skipped() const {
2371 return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
2372}
2373
2374// Returns true if and only if the test failed.
2375bool TestResult::Failed() const {
2376 for (int i = 0; i < total_part_count(); ++i) {
2377 if (GetTestPartResult(i).failed())
2378 return true;
2379 }
2380 return false;
2381}
2382
2383// Returns true if and only if the test part fatally failed.
2384static bool TestPartFatallyFailed(const TestPartResult& result) {
2385 return result.fatally_failed();
2386}
2387
2388// Returns true if and only if the test fatally failed.
2389bool TestResult::HasFatalFailure() const {
2390 return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
2391}
2392
2393// Returns true if and only if the test part non-fatally failed.
2394static bool TestPartNonfatallyFailed(const TestPartResult& result) {
2395 return result.nonfatally_failed();
2396}
2397
2398// Returns true if and only if the test has a non-fatal failure.
2399bool TestResult::HasNonfatalFailure() const {
2400 return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
2401}
2402
2403// Gets the number of all test parts. This is the sum of the number
2404// of successful test parts and the number of failed test parts.
2405int TestResult::total_part_count() const {
2406 return static_cast<int>(test_part_results_.size());
2407}
2408
2409// Returns the number of the test properties.
2410int TestResult::test_property_count() const {
2411 return static_cast<int>(test_properties_.size());
2412}
2413
2414// class Test
2415
2416// Creates a Test object.
2417
2418// The c'tor saves the states of all flags.
2419Test::Test()
2420 : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
2421}
2422
2423// The d'tor restores the states of all flags. The actual work is
2424// done by the d'tor of the gtest_flag_saver_ field, and thus not
2425// visible here.
2426Test::~Test() {
2427}
2428
2429// Sets up the test fixture.
2430//
2431// A sub-class may override this.
2432void Test::SetUp() {
2433}
2434
2435// Tears down the test fixture.
2436//
2437// A sub-class may override this.
2438void Test::TearDown() {
2439}
2440
2441// Allows user supplied key value pairs to be recorded for later output.
2442void Test::RecordProperty(const std::string& key, const std::string& value) {
2443 UnitTest::GetInstance()->RecordProperty(key, value);
2444}
2445
2446// Allows user supplied key value pairs to be recorded for later output.
2447void Test::RecordProperty(const std::string& key, int value) {
2448 Message value_message;
2449 value_message << value;
2450 RecordProperty(key, value_message.GetString().c_str());
2451}
2452
2453namespace internal {
2454
2455void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
2456 const std::string& message) {
2457 // This function is a friend of UnitTest and as such has access to
2458 // AddTestPartResult.
2459 UnitTest::GetInstance()->AddTestPartResult(
2460 result_type,
2461 nullptr, // No info about the source file where the exception occurred.
2462 -1, // We have no info on which line caused the exception.
2463 message,
2464 ""); // No stack trace, either.
2465}
2466
2467} // namespace internal
2468
2469// Google Test requires all tests in the same test suite to use the same test
2470// fixture class. This function checks if the current test has the
2471// same fixture class as the first test in the current test suite. If
2472// yes, it returns true; otherwise it generates a Google Test failure and
2473// returns false.
2474bool Test::HasSameFixtureClass() {
2475 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
2476 const TestSuite* const test_suite = impl->current_test_suite();
2477
2478 // Info about the first test in the current test suite.
2479 const TestInfo* const first_test_info = test_suite->test_info_list()[0];
2480 const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
2481 const char* const first_test_name = first_test_info->name();
2482
2483 // Info about the current test.
2484 const TestInfo* const this_test_info = impl->current_test_info();
2485 const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
2486 const char* const this_test_name = this_test_info->name();
2487
2488 if (this_fixture_id != first_fixture_id) {
2489 // Is the first test defined using TEST?
2490 const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
2491 // Is this test defined using TEST?
2492 const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
2493
2494 if (first_is_TEST || this_is_TEST) {
2495 // Both TEST and TEST_F appear in same test suite, which is incorrect.
2496 // Tell the user how to fix this.
2497
2498 // Gets the name of the TEST and the name of the TEST_F. Note
2499 // that first_is_TEST and this_is_TEST cannot both be true, as
2500 // the fixture IDs are different for the two tests.
2501 const char* const TEST_name =
2502 first_is_TEST ? first_test_name : this_test_name;
2503 const char* const TEST_F_name =
2504 first_is_TEST ? this_test_name : first_test_name;
2505
2506 ADD_FAILURE()
2507 << "All tests in the same test suite must use the same test fixture\n"
2508 << "class, so mixing TEST_F and TEST in the same test suite is\n"
2509 << "illegal. In test suite " << this_test_info->test_suite_name()
2510 << ",\n"
2511 << "test " << TEST_F_name << " is defined using TEST_F but\n"
2512 << "test " << TEST_name << " is defined using TEST. You probably\n"
2513 << "want to change the TEST to TEST_F or move it to another test\n"
2514 << "case.";
2515 } else {
2516 // Two fixture classes with the same name appear in two different
2517 // namespaces, which is not allowed. Tell the user how to fix this.
2518 ADD_FAILURE()
2519 << "All tests in the same test suite must use the same test fixture\n"
2520 << "class. However, in test suite "
2521 << this_test_info->test_suite_name() << ",\n"
2522 << "you defined test " << first_test_name << " and test "
2523 << this_test_name << "\n"
2524 << "using two different test fixture classes. This can happen if\n"
2525 << "the two classes are from different namespaces or translation\n"
2526 << "units and have the same name. You should probably rename one\n"
2527 << "of the classes to put the tests into different test suites.";
2528 }
2529 return false;
2530 }
2531
2532 return true;
2533}
2534
2535#if GTEST_HAS_SEH
2536
2537// Adds an "exception thrown" fatal failure to the current test. This
2538// function returns its result via an output parameter pointer because VC++
2539// prohibits creation of objects with destructors on stack in functions
2540// using __try (see error C2712).
2541static std::string* FormatSehExceptionMessage(DWORD exception_code,
2542 const char* location) {
2543 Message message;
2544 message << "SEH exception with code 0x" << std::setbase(16) <<
2545 exception_code << std::setbase(10) << " thrown in " << location << ".";
2546
2547 return new std::string(message.GetString());
2548}
2549
2550#endif // GTEST_HAS_SEH
2551
2552namespace internal {
2553
2554#if GTEST_HAS_EXCEPTIONS
2555
2556// Adds an "exception thrown" fatal failure to the current test.
2557static std::string FormatCxxExceptionMessage(const char* description,
2558 const char* location) {
2559 Message message;
2560 if (description != nullptr) {
2561 message << "C++ exception with description \"" << description << "\"";
2562 } else {
2563 message << "Unknown C++ exception";
2564 }
2565 message << " thrown in " << location << ".";
2566
2567 return message.GetString();
2568}
2569
2570static std::string PrintTestPartResultToString(
2571 const TestPartResult& test_part_result);
2572
2573GoogleTestFailureException::GoogleTestFailureException(
2574 const TestPartResult& failure)
2575 : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
2576
2577#endif // GTEST_HAS_EXCEPTIONS
2578
2579// We put these helper functions in the internal namespace as IBM's xlC
2580// compiler rejects the code if they were declared static.
2581
2582// Runs the given method and handles SEH exceptions it throws, when
2583// SEH is supported; returns the 0-value for type Result in case of an
2584// SEH exception. (Microsoft compilers cannot handle SEH and C++
2585// exceptions in the same function. Therefore, we provide a separate
2586// wrapper function for handling SEH exceptions.)
2587template <class T, typename Result>
2588Result HandleSehExceptionsInMethodIfSupported(
2589 T* object, Result (T::*method)(), const char* location) {
2590#if GTEST_HAS_SEH
2591 __try {
2592 return (object->*method)();
2593 } __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT
2594 GetExceptionCode())) {
2595 // We create the exception message on the heap because VC++ prohibits
2596 // creation of objects with destructors on stack in functions using __try
2597 // (see error C2712).
2598 std::string* exception_message = FormatSehExceptionMessage(
2599 GetExceptionCode(), location);
2600 internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
2601 *exception_message);
2602 delete exception_message;
2603 return static_cast<Result>(0);
2604 }
2605#else
2606 (void)location;
2607 return (object->*method)();
2608#endif // GTEST_HAS_SEH
2609}
2610
2611// Runs the given method and catches and reports C++ and/or SEH-style
2612// exceptions, if they are supported; returns the 0-value for type
2613// Result in case of an SEH exception.
2614template <class T, typename Result>
2615Result HandleExceptionsInMethodIfSupported(
2616 T* object, Result (T::*method)(), const char* location) {
2617 // NOTE: The user code can affect the way in which Google Test handles
2618 // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
2619 // RUN_ALL_TESTS() starts. It is technically possible to check the flag
2620 // after the exception is caught and either report or re-throw the
2621 // exception based on the flag's value:
2622 //
2623 // try {
2624 // // Perform the test method.
2625 // } catch (...) {
2626 // if (GTEST_FLAG(catch_exceptions))
2627 // // Report the exception as failure.
2628 // else
2629 // throw; // Re-throws the original exception.
2630 // }
2631 //
2632 // However, the purpose of this flag is to allow the program to drop into
2633 // the debugger when the exception is thrown. On most platforms, once the
2634 // control enters the catch block, the exception origin information is
2635 // lost and the debugger will stop the program at the point of the
2636 // re-throw in this function -- instead of at the point of the original
2637 // throw statement in the code under test. For this reason, we perform
2638 // the check early, sacrificing the ability to affect Google Test's
2639 // exception handling in the method where the exception is thrown.
2640 if (internal::GetUnitTestImpl()->catch_exceptions()) {
2641#if GTEST_HAS_EXCEPTIONS
2642 try {
2643 return HandleSehExceptionsInMethodIfSupported(object, method, location);
2644 } catch (const AssertionException&) { // NOLINT
2645 // This failure was reported already.
2646 } catch (const internal::GoogleTestFailureException&) { // NOLINT
2647 // This exception type can only be thrown by a failed Google
2648 // Test assertion with the intention of letting another testing
2649 // framework catch it. Therefore we just re-throw it.
2650 throw;
2651 } catch (const std::exception& e) { // NOLINT
2652 internal::ReportFailureInUnknownLocation(
2653 TestPartResult::kFatalFailure,
2654 FormatCxxExceptionMessage(e.what(), location));
2655 } catch (...) { // NOLINT
2656 internal::ReportFailureInUnknownLocation(
2657 TestPartResult::kFatalFailure,
2658 FormatCxxExceptionMessage(nullptr, location));
2659 }
2660 return static_cast<Result>(0);
2661#else
2662 return HandleSehExceptionsInMethodIfSupported(object, method, location);
2663#endif // GTEST_HAS_EXCEPTIONS
2664 } else {
2665 return (object->*method)();
2666 }
2667}
2668
2669} // namespace internal
2670
2671// Runs the test and updates the test result.
2672void Test::Run() {
2673 if (!HasSameFixtureClass()) return;
2674
2675 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
2676 impl->os_stack_trace_getter()->UponLeavingGTest();
2677 internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
2678 // We will run the test only if SetUp() was successful and didn't call
2679 // GTEST_SKIP().
2680 if (!HasFatalFailure() && !IsSkipped()) {
2681 impl->os_stack_trace_getter()->UponLeavingGTest();
2682 internal::HandleExceptionsInMethodIfSupported(
2683 this, &Test::TestBody, "the test body");
2684 }
2685
2686 // However, we want to clean up as much as possible. Hence we will
2687 // always call TearDown(), even if SetUp() or the test body has
2688 // failed.
2689 impl->os_stack_trace_getter()->UponLeavingGTest();
2690 internal::HandleExceptionsInMethodIfSupported(
2691 this, &Test::TearDown, "TearDown()");
2692}
2693
2694// Returns true if and only if the current test has a fatal failure.
2695bool Test::HasFatalFailure() {
2696 return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
2697}
2698
2699// Returns true if and only if the current test has a non-fatal failure.
2700bool Test::HasNonfatalFailure() {
2701 return internal::GetUnitTestImpl()->current_test_result()->
2702 HasNonfatalFailure();
2703}
2704
2705// Returns true if and only if the current test was skipped.
2706bool Test::IsSkipped() {
2707 return internal::GetUnitTestImpl()->current_test_result()->Skipped();
2708}
2709
2710// class TestInfo
2711
2712// Constructs a TestInfo object. It assumes ownership of the test factory
2713// object.
2714TestInfo::TestInfo(const std::string& a_test_suite_name,
2715 const std::string& a_name, const char* a_type_param,
2716 const char* a_value_param,
2717 internal::CodeLocation a_code_location,
2718 internal::TypeId fixture_class_id,
2719 internal::TestFactoryBase* factory)
2720 : test_suite_name_(a_test_suite_name),
2721 name_(a_name),
2722 type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
2723 value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
2724 location_(a_code_location),
2725 fixture_class_id_(fixture_class_id),
2726 should_run_(false),
2727 is_disabled_(false),
2728 matches_filter_(false),
2729 is_in_another_shard_(false),
2730 factory_(factory),
2731 result_() {}
2732
2733// Destructs a TestInfo object.
2734TestInfo::~TestInfo() { delete factory_; }
2735
2736namespace internal {
2737
2738// Creates a new TestInfo object and registers it with Google Test;
2739// returns the created object.
2740//
2741// Arguments:
2742//
2743// test_suite_name: name of the test suite
2744// name: name of the test
2745// type_param: the name of the test's type parameter, or NULL if
2746// this is not a typed or a type-parameterized test.
2747// value_param: text representation of the test's value parameter,
2748// or NULL if this is not a value-parameterized test.
2749// code_location: code location where the test is defined
2750// fixture_class_id: ID of the test fixture class
2751// set_up_tc: pointer to the function that sets up the test suite
2752// tear_down_tc: pointer to the function that tears down the test suite
2753// factory: pointer to the factory that creates a test object.
2754// The newly created TestInfo instance will assume
2755// ownership of the factory object.
2756TestInfo* MakeAndRegisterTestInfo(
2757 const char* test_suite_name, const char* name, const char* type_param,
2758 const char* value_param, CodeLocation code_location,
2759 TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
2760 TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
2761 TestInfo* const test_info =
2762 new TestInfo(test_suite_name, name, type_param, value_param,
2763 code_location, fixture_class_id, factory);
2764 GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
2765 return test_info;
2766}
2767
2768void ReportInvalidTestSuiteType(const char* test_suite_name,
2769 CodeLocation code_location) {
2770 Message errors;
2771 errors
2772 << "Attempted redefinition of test suite " << test_suite_name << ".\n"
2773 << "All tests in the same test suite must use the same test fixture\n"
2774 << "class. However, in test suite " << test_suite_name << ", you tried\n"
2775 << "to define a test using a fixture class different from the one\n"
2776 << "used earlier. This can happen if the two fixture classes are\n"
2777 << "from different namespaces and have the same name. You should\n"
2778 << "probably rename one of the classes to put the tests into different\n"
2779 << "test suites.";
2780
2781 GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
2782 code_location.line)
2783 << " " << errors.GetString();
2784}
2785} // namespace internal
2786
2787namespace {
2788
2789// A predicate that checks the test name of a TestInfo against a known
2790// value.
2791//
2792// This is used for implementation of the TestSuite class only. We put
2793// it in the anonymous namespace to prevent polluting the outer
2794// namespace.
2795//
2796// TestNameIs is copyable.
2797class TestNameIs {
2798 public:
2799 // Constructor.
2800 //
2801 // TestNameIs has NO default constructor.
2802 explicit TestNameIs(const char* name)
2803 : name_(name) {}
2804
2805 // Returns true if and only if the test name of test_info matches name_.
2806 bool operator()(const TestInfo * test_info) const {
2807 return test_info && test_info->name() == name_;
2808 }
2809
2810 private:
2811 std::string name_;
2812};
2813
2814} // namespace
2815
2816namespace internal {
2817
2818// This method expands all parameterized tests registered with macros TEST_P
2819// and INSTANTIATE_TEST_SUITE_P into regular tests and registers those.
2820// This will be done just once during the program runtime.
2821void UnitTestImpl::RegisterParameterizedTests() {
2822 if (!parameterized_tests_registered_) {
2823 parameterized_test_registry_.RegisterTests();
2824 type_parameterized_test_registry_.CheckForInstantiations();
2825 parameterized_tests_registered_ = true;
2826 }
2827}
2828
2829} // namespace internal
2830
2831// Creates the test object, runs it, records its result, and then
2832// deletes it.
2833void TestInfo::Run() {
2834 if (!should_run_) return;
2835
2836 // Tells UnitTest where to store test result.
2837 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
2838 impl->set_current_test_info(this);
2839
2840 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
2841
2842 // Notifies the unit test event listeners that a test is about to start.
2843 repeater->OnTestStart(*this);
2844
2845 result_.set_start_timestamp(internal::GetTimeInMillis());
2846 internal::Timer timer;
2847
2848 impl->os_stack_trace_getter()->UponLeavingGTest();
2849
2850 // Creates the test object.
2851 Test* const test = internal::HandleExceptionsInMethodIfSupported(
2852 factory_, &internal::TestFactoryBase::CreateTest,
2853 "the test fixture's constructor");
2854
2855 // Runs the test if the constructor didn't generate a fatal failure or invoke
2856 // GTEST_SKIP().
2857 // Note that the object will not be null
2858 if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
2859 // This doesn't throw as all user code that can throw are wrapped into
2860 // exception handling code.
2861 test->Run();
2862 }
2863
2864 if (test != nullptr) {
2865 // Deletes the test object.
2866 impl->os_stack_trace_getter()->UponLeavingGTest();
2867 internal::HandleExceptionsInMethodIfSupported(
2868 test, &Test::DeleteSelf_, "the test fixture's destructor");
2869 }
2870
2871 result_.set_elapsed_time(timer.Elapsed());
2872
2873 // Notifies the unit test event listener that a test has just finished.
2874 repeater->OnTestEnd(*this);
2875
2876 // Tells UnitTest to stop associating assertion results to this
2877 // test.
2878 impl->set_current_test_info(nullptr);
2879}
2880
2881// Skip and records a skipped test result for this object.
2882void TestInfo::Skip() {
2883 if (!should_run_) return;
2884
2885 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
2886 impl->set_current_test_info(this);
2887
2888 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
2889
2890 // Notifies the unit test event listeners that a test is about to start.
2891 repeater->OnTestStart(*this);
2892
2893 const TestPartResult test_part_result =
2894 TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");
2895 impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
2896 test_part_result);
2897
2898 // Notifies the unit test event listener that a test has just finished.
2899 repeater->OnTestEnd(*this);
2900 impl->set_current_test_info(nullptr);
2901}
2902
2903// class TestSuite
2904
2905// Gets the number of successful tests in this test suite.
2906int TestSuite::successful_test_count() const {
2907 return CountIf(test_info_list_, TestPassed);
2908}
2909
2910// Gets the number of successful tests in this test suite.
2911int TestSuite::skipped_test_count() const {
2912 return CountIf(test_info_list_, TestSkipped);
2913}
2914
2915// Gets the number of failed tests in this test suite.
2916int TestSuite::failed_test_count() const {
2917 return CountIf(test_info_list_, TestFailed);
2918}
2919
2920// Gets the number of disabled tests that will be reported in the XML report.
2921int TestSuite::reportable_disabled_test_count() const {
2922 return CountIf(test_info_list_, TestReportableDisabled);
2923}
2924
2925// Gets the number of disabled tests in this test suite.
2926int TestSuite::disabled_test_count() const {
2927 return CountIf(test_info_list_, TestDisabled);
2928}
2929
2930// Gets the number of tests to be printed in the XML report.
2931int TestSuite::reportable_test_count() const {
2932 return CountIf(test_info_list_, TestReportable);
2933}
2934
2935// Get the number of tests in this test suite that should run.
2936int TestSuite::test_to_run_count() const {
2937 return CountIf(test_info_list_, ShouldRunTest);
2938}
2939
2940// Gets the number of all tests.
2941int TestSuite::total_test_count() const {
2942 return static_cast<int>(test_info_list_.size());
2943}
2944
2945// Creates a TestSuite with the given name.
2946//
2947// Arguments:
2948//
2949// a_name: name of the test suite
2950// a_type_param: the name of the test suite's type parameter, or NULL if
2951// this is not a typed or a type-parameterized test suite.
2952// set_up_tc: pointer to the function that sets up the test suite
2953// tear_down_tc: pointer to the function that tears down the test suite
2954TestSuite::TestSuite(const char* a_name, const char* a_type_param,
2955 internal::SetUpTestSuiteFunc set_up_tc,
2956 internal::TearDownTestSuiteFunc tear_down_tc)
2957 : name_(a_name),
2958 type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
2959 set_up_tc_(set_up_tc),
2960 tear_down_tc_(tear_down_tc),
2961 should_run_(false),
2962 start_timestamp_(0),
2963 elapsed_time_(0) {}
2964
2965// Destructor of TestSuite.
2966TestSuite::~TestSuite() {
2967 // Deletes every Test in the collection.
2968 ForEach(test_info_list_, internal::Delete<TestInfo>);
2969}
2970
2971// Returns the i-th test among all the tests. i can range from 0 to
2972// total_test_count() - 1. If i is not in that range, returns NULL.
2973const TestInfo* TestSuite::GetTestInfo(int i) const {
2974 const int index = GetElementOr(test_indices_, i, -1);
2975 return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
2976}
2977
2978// Returns the i-th test among all the tests. i can range from 0 to
2979// total_test_count() - 1. If i is not in that range, returns NULL.
2980TestInfo* TestSuite::GetMutableTestInfo(int i) {
2981 const int index = GetElementOr(test_indices_, i, -1);
2982 return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
2983}
2984
2985// Adds a test to this test suite. Will delete the test upon
2986// destruction of the TestSuite object.
2987void TestSuite::AddTestInfo(TestInfo* test_info) {
2988 test_info_list_.push_back(test_info);
2989 test_indices_.push_back(static_cast<int>(test_indices_.size()));
2990}
2991
2992// Runs every test in this TestSuite.
2993void TestSuite::Run() {
2994 if (!should_run_) return;
2995
2996 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
2997 impl->set_current_test_suite(this);
2998
2999 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
3000
3001 // Call both legacy and the new API
3002 repeater->OnTestSuiteStart(*this);
3003// Legacy API is deprecated but still available
3004#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3005 repeater->OnTestCaseStart(*this);
3006#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3007
3008 impl->os_stack_trace_getter()->UponLeavingGTest();
3009 internal::HandleExceptionsInMethodIfSupported(
3010 this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
3011
3012 start_timestamp_ = internal::GetTimeInMillis();
3013 internal::Timer timer;
3014 for (int i = 0; i < total_test_count(); i++) {
3015 GetMutableTestInfo(i)->Run();
3016 if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) {
3017 for (int j = i + 1; j < total_test_count(); j++) {
3018 GetMutableTestInfo(j)->Skip();
3019 }
3020 break;
3021 }
3022 }
3023 elapsed_time_ = timer.Elapsed();
3024
3025 impl->os_stack_trace_getter()->UponLeavingGTest();
3026 internal::HandleExceptionsInMethodIfSupported(
3027 this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
3028
3029 // Call both legacy and the new API
3030 repeater->OnTestSuiteEnd(*this);
3031// Legacy API is deprecated but still available
3032#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3033 repeater->OnTestCaseEnd(*this);
3034#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3035
3036 impl->set_current_test_suite(nullptr);
3037}
3038
3039// Skips all tests under this TestSuite.
3040void TestSuite::Skip() {
3041 if (!should_run_) return;
3042
3043 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
3044 impl->set_current_test_suite(this);
3045
3046 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
3047
3048 // Call both legacy and the new API
3049 repeater->OnTestSuiteStart(*this);
3050// Legacy API is deprecated but still available
3051#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3052 repeater->OnTestCaseStart(*this);
3053#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3054
3055 for (int i = 0; i < total_test_count(); i++) {
3056 GetMutableTestInfo(i)->Skip();
3057 }
3058
3059 // Call both legacy and the new API
3060 repeater->OnTestSuiteEnd(*this);
3061 // Legacy API is deprecated but still available
3062#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3063 repeater->OnTestCaseEnd(*this);
3064#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3065
3066 impl->set_current_test_suite(nullptr);
3067}
3068
3069// Clears the results of all tests in this test suite.
3070void TestSuite::ClearResult() {
3071 ad_hoc_test_result_.Clear();
3072 ForEach(test_info_list_, TestInfo::ClearTestResult);
3073}
3074
3075// Shuffles the tests in this test suite.
3076void TestSuite::ShuffleTests(internal::Random* random) {
3077 Shuffle(random, &test_indices_);
3078}
3079
3080// Restores the test order to before the first shuffle.
3081void TestSuite::UnshuffleTests() {
3082 for (size_t i = 0; i < test_indices_.size(); i++) {
3083 test_indices_[i] = static_cast<int>(i);
3084 }
3085}
3086
3087// Formats a countable noun. Depending on its quantity, either the
3088// singular form or the plural form is used. e.g.
3089//
3090// FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
3091// FormatCountableNoun(5, "book", "books") returns "5 books".
3092static std::string FormatCountableNoun(int count,
3093 const char * singular_form,
3094 const char * plural_form) {
3095 return internal::StreamableToString(count) + " " +
3096 (count == 1 ? singular_form : plural_form);
3097}
3098
3099// Formats the count of tests.
3100static std::string FormatTestCount(int test_count) {
3101 return FormatCountableNoun(test_count, "test", "tests");
3102}
3103
3104// Formats the count of test suites.
3105static std::string FormatTestSuiteCount(int test_suite_count) {
3106 return FormatCountableNoun(test_suite_count, "test suite", "test suites");
3107}
3108
3109// Converts a TestPartResult::Type enum to human-friendly string
3110// representation. Both kNonFatalFailure and kFatalFailure are translated
3111// to "Failure", as the user usually doesn't care about the difference
3112// between the two when viewing the test result.
3113static const char * TestPartResultTypeToString(TestPartResult::Type type) {
3114 switch (type) {
3115 case TestPartResult::kSkip:
3116 return "Skipped\n";
3117 case TestPartResult::kSuccess:
3118 return "Success";
3119
3120 case TestPartResult::kNonFatalFailure:
3121 case TestPartResult::kFatalFailure:
3122#ifdef _MSC_VER
3123 return "error: ";
3124#else
3125 return "Failure\n";
3126#endif
3127 default:
3128 return "Unknown result type";
3129 }
3130}
3131
3132namespace internal {
3133namespace {
3134enum class GTestColor { kDefault, kRed, kGreen, kYellow };
3135} // namespace
3136
3137// Prints a TestPartResult to an std::string.
3138static std::string PrintTestPartResultToString(
3139 const TestPartResult& test_part_result) {
3140 return (Message()
3141 << internal::FormatFileLocation(test_part_result.file_name(),
3142 test_part_result.line_number())
3143 << " " << TestPartResultTypeToString(test_part_result.type())
3144 << test_part_result.message()).GetString();
3145}
3146
3147// Prints a TestPartResult.
3148static void PrintTestPartResult(const TestPartResult& test_part_result) {
3149 const std::string& result =
3150 PrintTestPartResultToString(test_part_result);
3151 printf("%s\n", result.c_str());
3152 fflush(stdout);
3153 // If the test program runs in Visual Studio or a debugger, the
3154 // following statements add the test part result message to the Output
3155 // window such that the user can double-click on it to jump to the
3156 // corresponding source code location; otherwise they do nothing.
3157#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
3158 // We don't call OutputDebugString*() on Windows Mobile, as printing
3159 // to stdout is done by OutputDebugString() there already - we don't
3160 // want the same message printed twice.
3161 ::OutputDebugStringA(result.c_str());
3162 ::OutputDebugStringA("\n");
3163#endif
3164}
3165
3166// class PrettyUnitTestResultPrinter
3167#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
3168 !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
3169
3170// Returns the character attribute for the given color.
3171static WORD GetColorAttribute(GTestColor color) {
3172 switch (color) {
3173 case GTestColor::kRed:
3174 return FOREGROUND_RED;
3175 case GTestColor::kGreen:
3176 return FOREGROUND_GREEN;
3177 case GTestColor::kYellow:
3178 return FOREGROUND_RED | FOREGROUND_GREEN;
3179 default: return 0;
3180 }
3181}
3182
3183static int GetBitOffset(WORD color_mask) {
3184 if (color_mask == 0) return 0;
3185
3186 int bitOffset = 0;
3187 while ((color_mask & 1) == 0) {
3188 color_mask >>= 1;
3189 ++bitOffset;
3190 }
3191 return bitOffset;
3192}
3193
3194static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
3195 // Let's reuse the BG
3196 static const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN |
3197 BACKGROUND_RED | BACKGROUND_INTENSITY;
3198 static const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN |
3199 FOREGROUND_RED | FOREGROUND_INTENSITY;
3200 const WORD existing_bg = old_color_attrs & background_mask;
3201
3202 WORD new_color =
3203 GetColorAttribute(color) | existing_bg | FOREGROUND_INTENSITY;
3204 static const int bg_bitOffset = GetBitOffset(background_mask);
3205 static const int fg_bitOffset = GetBitOffset(foreground_mask);
3206
3207 if (((new_color & background_mask) >> bg_bitOffset) ==
3208 ((new_color & foreground_mask) >> fg_bitOffset)) {
3209 new_color ^= FOREGROUND_INTENSITY; // invert intensity
3210 }
3211 return new_color;
3212}
3213
3214#else
3215
3216// Returns the ANSI color code for the given color. GTestColor::kDefault is
3217// an invalid input.
3218static const char* GetAnsiColorCode(GTestColor color) {
3219 switch (color) {
3220 case GTestColor::kRed:
3221 return "1";
3222 case GTestColor::kGreen:
3223 return "2";
3224 case GTestColor::kYellow:
3225 return "3";
3226 default:
3227 return nullptr;
3228 }
3229}
3230
3231#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
3232
3233// Returns true if and only if Google Test should use colors in the output.
3234bool ShouldUseColor(bool stdout_is_tty) {
3235 const char* const gtest_color = GTEST_FLAG(color).c_str();
3236
3237 if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
3238#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
3239 // On Windows the TERM variable is usually not set, but the
3240 // console there does support colors.
3241 return stdout_is_tty;
3242#else
3243 // On non-Windows platforms, we rely on the TERM variable.
3244 const char* const term = posix::GetEnv("TERM");
3245 const bool term_supports_color =
3246 String::CStringEquals(term, "xterm") ||
3247 String::CStringEquals(term, "xterm-color") ||
3248 String::CStringEquals(term, "xterm-256color") ||
3249 String::CStringEquals(term, "screen") ||
3250 String::CStringEquals(term, "screen-256color") ||
3251 String::CStringEquals(term, "tmux") ||
3252 String::CStringEquals(term, "tmux-256color") ||
3253 String::CStringEquals(term, "rxvt-unicode") ||
3254 String::CStringEquals(term, "rxvt-unicode-256color") ||
3255 String::CStringEquals(term, "linux") ||
3256 String::CStringEquals(term, "cygwin");
3257 return stdout_is_tty && term_supports_color;
3258#endif // GTEST_OS_WINDOWS
3259 }
3260
3261 return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
3262 String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
3263 String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
3264 String::CStringEquals(gtest_color, "1");
3265 // We take "yes", "true", "t", and "1" as meaning "yes". If the
3266 // value is neither one of these nor "auto", we treat it as "no" to
3267 // be conservative.
3268}
3269
3270// Helpers for printing colored strings to stdout. Note that on Windows, we
3271// cannot simply emit special characters and have the terminal change colors.
3272// This routine must actually emit the characters rather than return a string
3273// that would be colored when printed, as can be done on Linux.
3274
3275GTEST_ATTRIBUTE_PRINTF_(2, 3)
3276static void ColoredPrintf(GTestColor color, const char *fmt, ...) {
3277 va_list args;
3278 va_start(args, fmt);
3279
3280#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
3281 GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
3282 const bool use_color = AlwaysFalse();
3283#else
3284 static const bool in_color_mode =
3285 ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
3286 const bool use_color = in_color_mode && (color != GTestColor::kDefault);
3287#endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS
3288
3289 if (!use_color) {
3290 vprintf(fmt, args);
3291 va_end(args);
3292 return;
3293 }
3294
3295#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
3296 !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
3297 const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
3298
3299 // Gets the current text color.
3300 CONSOLE_SCREEN_BUFFER_INFO buffer_info;
3301 GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
3302 const WORD old_color_attrs = buffer_info.wAttributes;
3303 const WORD new_color = GetNewColor(color, old_color_attrs);
3304
3305 // We need to flush the stream buffers into the console before each
3306 // SetConsoleTextAttribute call lest it affect the text that is already
3307 // printed but has not yet reached the console.
3308 fflush(stdout);
3309 SetConsoleTextAttribute(stdout_handle, new_color);
3310
3311 vprintf(fmt, args);
3312
3313 fflush(stdout);
3314 // Restores the text color.
3315 SetConsoleTextAttribute(stdout_handle, old_color_attrs);
3316#else
3317 printf("\033[0;3%sm", GetAnsiColorCode(color));
3318 vprintf(fmt, args);
3319 printf("\033[m"); // Resets the terminal to default.
3320#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
3321 va_end(args);
3322}
3323
3324// Text printed in Google Test's text output and --gtest_list_tests
3325// output to label the type parameter and value parameter for a test.
3326static const char kTypeParamLabel[] = "TypeParam";
3327static const char kValueParamLabel[] = "GetParam()";
3328
3329static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
3330 const char* const type_param = test_info.type_param();
3331 const char* const value_param = test_info.value_param();
3332
3333 if (type_param != nullptr || value_param != nullptr) {
3334 printf(", where ");
3335 if (type_param != nullptr) {
3336 printf("%s = %s", kTypeParamLabel, type_param);
3337 if (value_param != nullptr) printf(" and ");
3338 }
3339 if (value_param != nullptr) {
3340 printf("%s = %s", kValueParamLabel, value_param);
3341 }
3342 }
3343}
3344
3345// This class implements the TestEventListener interface.
3346//
3347// Class PrettyUnitTestResultPrinter is copyable.
3349 public:
3351 static void PrintTestName(const char* test_suite, const char* test) {
3352 printf("%s.%s", test_suite, test);
3353 }
3354
3355 // The following methods override what's in the TestEventListener class.
3356 void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
3357 void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
3358 void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
3359 void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
3360#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3361 void OnTestCaseStart(const TestCase& test_case) override;
3362#else
3363 void OnTestSuiteStart(const TestSuite& test_suite) override;
3364#endif // OnTestCaseStart
3365
3366 void OnTestStart(const TestInfo& test_info) override;
3367
3368 void OnTestPartResult(const TestPartResult& result) override;
3369 void OnTestEnd(const TestInfo& test_info) override;
3370#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3371 void OnTestCaseEnd(const TestCase& test_case) override;
3372#else
3373 void OnTestSuiteEnd(const TestSuite& test_suite) override;
3374#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3375
3376 void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
3377 void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
3378 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
3379 void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
3380
3381 private:
3382 static void PrintFailedTests(const UnitTest& unit_test);
3383 static void PrintFailedTestSuites(const UnitTest& unit_test);
3384 static void PrintSkippedTests(const UnitTest& unit_test);
3385};
3386
3387 // Fired before each iteration of tests starts.
3388void PrettyUnitTestResultPrinter::OnTestIterationStart(
3389 const UnitTest& unit_test, int iteration) {
3390 if (GTEST_FLAG(repeat) != 1)
3391 printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
3392
3393 const char* const filter = GTEST_FLAG(filter).c_str();
3394
3395 // Prints the filter if it's not *. This reminds the user that some
3396 // tests may be skipped.
3397 if (!String::CStringEquals(filter, kUniversalFilter)) {
3398 ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
3399 filter);
3400 }
3401
3402 if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
3403 const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
3404 ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
3405 static_cast<int>(shard_index) + 1,
3406 internal::posix::GetEnv(kTestTotalShards));
3407 }
3408
3409 if (GTEST_FLAG(shuffle)) {
3410 ColoredPrintf(GTestColor::kYellow,
3411 "Note: Randomizing tests' orders with a seed of %d .\n",
3412 unit_test.random_seed());
3413 }
3414
3415 ColoredPrintf(GTestColor::kGreen, "[==========] ");
3416 printf("Running %s from %s.\n",
3417 FormatTestCount(unit_test.test_to_run_count()).c_str(),
3418 FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
3419 fflush(stdout);
3420}
3421
3422void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
3423 const UnitTest& /*unit_test*/) {
3424 ColoredPrintf(GTestColor::kGreen, "[----------] ");
3425 printf("Global test environment set-up.\n");
3426 fflush(stdout);
3427}
3428
3429#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3430void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
3431 const std::string counts =
3432 FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
3433 ColoredPrintf(GTestColor::kGreen, "[----------] ");
3434 printf("%s from %s", counts.c_str(), test_case.name());
3435 if (test_case.type_param() == nullptr) {
3436 printf("\n");
3437 } else {
3438 printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
3439 }
3440 fflush(stdout);
3441}
3442#else
3443void PrettyUnitTestResultPrinter::OnTestSuiteStart(
3444 const TestSuite& test_suite) {
3445 const std::string counts =
3446 FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
3447 ColoredPrintf(GTestColor::kGreen, "[----------] ");
3448 printf("%s from %s", counts.c_str(), test_suite.name());
3449 if (test_suite.type_param() == nullptr) {
3450 printf("\n");
3451 } else {
3452 printf(", where %s = %s\n", kTypeParamLabel, test_suite.type_param());
3453 }
3454 fflush(stdout);
3455}
3456#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3457
3458void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
3459 ColoredPrintf(GTestColor::kGreen, "[ RUN ] ");
3460 PrintTestName(test_info.test_suite_name(), test_info.name());
3461 printf("\n");
3462 fflush(stdout);
3463}
3464
3465// Called after an assertion failure.
3466void PrettyUnitTestResultPrinter::OnTestPartResult(
3467 const TestPartResult& result) {
3468 switch (result.type()) {
3469 // If the test part succeeded, we don't need to do anything.
3470 case TestPartResult::kSuccess:
3471 return;
3472 default:
3473 // Print failure message from the assertion
3474 // (e.g. expected this and got that).
3475 PrintTestPartResult(result);
3476 fflush(stdout);
3477 }
3478}
3479
3480void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
3481 if (test_info.result()->Passed()) {
3482 ColoredPrintf(GTestColor::kGreen, "[ OK ] ");
3483 } else if (test_info.result()->Skipped()) {
3484 ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
3485 } else {
3486 ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
3487 }
3488 PrintTestName(test_info.test_suite_name(), test_info.name());
3489 if (test_info.result()->Failed())
3490 PrintFullTestCommentIfPresent(test_info);
3491
3492 if (GTEST_FLAG(print_time)) {
3493 printf(" (%s ms)\n", internal::StreamableToString(
3494 test_info.result()->elapsed_time()).c_str());
3495 } else {
3496 printf("\n");
3497 }
3498 fflush(stdout);
3499}
3500
3501#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3502void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
3503 if (!GTEST_FLAG(print_time)) return;
3504
3505 const std::string counts =
3506 FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
3507 ColoredPrintf(GTestColor::kGreen, "[----------] ");
3508 printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(),
3509 internal::StreamableToString(test_case.elapsed_time()).c_str());
3510 fflush(stdout);
3511}
3512#else
3513void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite& test_suite) {
3514 if (!GTEST_FLAG(print_time)) return;
3515
3516 const std::string counts =
3517 FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
3518 ColoredPrintf(GTestColor::kGreen, "[----------] ");
3519 printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name(),
3520 internal::StreamableToString(test_suite.elapsed_time()).c_str());
3521 fflush(stdout);
3522}
3523#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3524
3525void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
3526 const UnitTest& /*unit_test*/) {
3527 ColoredPrintf(GTestColor::kGreen, "[----------] ");
3528 printf("Global test environment tear-down\n");
3529 fflush(stdout);
3530}
3531
3532// Internal helper for printing the list of failed tests.
3533void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
3534 const int failed_test_count = unit_test.failed_test_count();
3535 ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
3536 printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
3537
3538 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
3539 const TestSuite& test_suite = *unit_test.GetTestSuite(i);
3540 if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) {
3541 continue;
3542 }
3543 for (int j = 0; j < test_suite.total_test_count(); ++j) {
3544 const TestInfo& test_info = *test_suite.GetTestInfo(j);
3545 if (!test_info.should_run() || !test_info.result()->Failed()) {
3546 continue;
3547 }
3548 ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
3549 printf("%s.%s", test_suite.name(), test_info.name());
3550 PrintFullTestCommentIfPresent(test_info);
3551 printf("\n");
3552 }
3553 }
3554 printf("\n%2d FAILED %s\n", failed_test_count,
3555 failed_test_count == 1 ? "TEST" : "TESTS");
3556}
3557
3558// Internal helper for printing the list of test suite failures not covered by
3559// PrintFailedTests.
3560void PrettyUnitTestResultPrinter::PrintFailedTestSuites(
3561 const UnitTest& unit_test) {
3562 int suite_failure_count = 0;
3563 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
3564 const TestSuite& test_suite = *unit_test.GetTestSuite(i);
3565 if (!test_suite.should_run()) {
3566 continue;
3567 }
3568 if (test_suite.ad_hoc_test_result().Failed()) {
3569 ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
3570 printf("%s: SetUpTestSuite or TearDownTestSuite\n", test_suite.name());
3571 ++suite_failure_count;
3572 }
3573 }
3574 if (suite_failure_count > 0) {
3575 printf("\n%2d FAILED TEST %s\n", suite_failure_count,
3576 suite_failure_count == 1 ? "SUITE" : "SUITES");
3577 }
3578}
3579
3580// Internal helper for printing the list of skipped tests.
3581void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
3582 const int skipped_test_count = unit_test.skipped_test_count();
3583 if (skipped_test_count == 0) {
3584 return;
3585 }
3586
3587 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
3588 const TestSuite& test_suite = *unit_test.GetTestSuite(i);
3589 if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) {
3590 continue;
3591 }
3592 for (int j = 0; j < test_suite.total_test_count(); ++j) {
3593 const TestInfo& test_info = *test_suite.GetTestInfo(j);
3594 if (!test_info.should_run() || !test_info.result()->Skipped()) {
3595 continue;
3596 }
3597 ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
3598 printf("%s.%s", test_suite.name(), test_info.name());
3599 printf("\n");
3600 }
3601 }
3602}
3603
3604void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
3605 int /*iteration*/) {
3606 ColoredPrintf(GTestColor::kGreen, "[==========] ");
3607 printf("%s from %s ran.",
3608 FormatTestCount(unit_test.test_to_run_count()).c_str(),
3609 FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
3610 if (GTEST_FLAG(print_time)) {
3611 printf(" (%s ms total)",
3612 internal::StreamableToString(unit_test.elapsed_time()).c_str());
3613 }
3614 printf("\n");
3615 ColoredPrintf(GTestColor::kGreen, "[ PASSED ] ");
3616 printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
3617
3618 const int skipped_test_count = unit_test.skipped_test_count();
3619 if (skipped_test_count > 0) {
3620 ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
3621 printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());
3622 PrintSkippedTests(unit_test);
3623 }
3624
3625 if (!unit_test.Passed()) {
3626 PrintFailedTests(unit_test);
3627 PrintFailedTestSuites(unit_test);
3628 }
3629
3630 int num_disabled = unit_test.reportable_disabled_test_count();
3631 if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
3632 if (unit_test.Passed()) {
3633 printf("\n"); // Add a spacer if no FAILURE banner is displayed.
3634 }
3635 ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",
3636 num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
3637 }
3638 // Ensure that Google Test output is printed before, e.g., heapchecker output.
3639 fflush(stdout);
3640}
3641
3642// End PrettyUnitTestResultPrinter
3643
3644// This class implements the TestEventListener interface.
3645//
3646// Class BriefUnitTestResultPrinter is copyable.
3648 public:
3650 static void PrintTestName(const char* test_suite, const char* test) {
3651 printf("%s.%s", test_suite, test);
3652 }
3653
3654 // The following methods override what's in the TestEventListener class.
3655 void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
3656 void OnTestIterationStart(const UnitTest& /*unit_test*/,
3657 int /*iteration*/) override {}
3658 void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
3659 void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
3660#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3661 void OnTestCaseStart(const TestCase& /*test_case*/) override {}
3662#else
3663 void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
3664#endif // OnTestCaseStart
3665
3666 void OnTestStart(const TestInfo& /*test_info*/) override {}
3667
3668 void OnTestPartResult(const TestPartResult& result) override;
3669 void OnTestEnd(const TestInfo& test_info) override;
3670#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3671 void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
3672#else
3673 void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
3674#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3675
3676 void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
3677 void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
3678 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
3679 void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
3680};
3681
3682// Called after an assertion failure.
3683void BriefUnitTestResultPrinter::OnTestPartResult(
3684 const TestPartResult& result) {
3685 switch (result.type()) {
3686 // If the test part succeeded, we don't need to do anything.
3687 case TestPartResult::kSuccess:
3688 return;
3689 default:
3690 // Print failure message from the assertion
3691 // (e.g. expected this and got that).
3692 PrintTestPartResult(result);
3693 fflush(stdout);
3694 }
3695}
3696
3697void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
3698 if (test_info.result()->Failed()) {
3699 ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
3700 PrintTestName(test_info.test_suite_name(), test_info.name());
3701 PrintFullTestCommentIfPresent(test_info);
3702
3703 if (GTEST_FLAG(print_time)) {
3704 printf(" (%s ms)\n",
3705 internal::StreamableToString(test_info.result()->elapsed_time())
3706 .c_str());
3707 } else {
3708 printf("\n");
3709 }
3710 fflush(stdout);
3711 }
3712}
3713
3714void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
3715 int /*iteration*/) {
3716 ColoredPrintf(GTestColor::kGreen, "[==========] ");
3717 printf("%s from %s ran.",
3718 FormatTestCount(unit_test.test_to_run_count()).c_str(),
3719 FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
3720 if (GTEST_FLAG(print_time)) {
3721 printf(" (%s ms total)",
3722 internal::StreamableToString(unit_test.elapsed_time()).c_str());
3723 }
3724 printf("\n");
3725 ColoredPrintf(GTestColor::kGreen, "[ PASSED ] ");
3726 printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
3727
3728 const int skipped_test_count = unit_test.skipped_test_count();
3729 if (skipped_test_count > 0) {
3730 ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
3731 printf("%s.\n", FormatTestCount(skipped_test_count).c_str());
3732 }
3733
3734 int num_disabled = unit_test.reportable_disabled_test_count();
3735 if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
3736 if (unit_test.Passed()) {
3737 printf("\n"); // Add a spacer if no FAILURE banner is displayed.
3738 }
3739 ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",
3740 num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
3741 }
3742 // Ensure that Google Test output is printed before, e.g., heapchecker output.
3743 fflush(stdout);
3744}
3745
3746// End BriefUnitTestResultPrinter
3747
3748// class TestEventRepeater
3749//
3750// This class forwards events to other event listeners.
3752 public:
3753 TestEventRepeater() : forwarding_enabled_(true) {}
3754 ~TestEventRepeater() override;
3755 void Append(TestEventListener *listener);
3756 TestEventListener* Release(TestEventListener* listener);
3757
3758 // Controls whether events will be forwarded to listeners_. Set to false
3759 // in death test child processes.
3760 bool forwarding_enabled() const { return forwarding_enabled_; }
3761 void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }
3762
3763 void OnTestProgramStart(const UnitTest& unit_test) override;
3764 void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
3765 void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
3766 void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) override;
3767// Legacy API is deprecated but still available
3768#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3769 void OnTestCaseStart(const TestSuite& parameter) override;
3770#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3771 void OnTestSuiteStart(const TestSuite& parameter) override;
3772 void OnTestStart(const TestInfo& test_info) override;
3773 void OnTestPartResult(const TestPartResult& result) override;
3774 void OnTestEnd(const TestInfo& test_info) override;
3775// Legacy API is deprecated but still available
3776#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3777 void OnTestCaseEnd(const TestCase& parameter) override;
3778#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3779 void OnTestSuiteEnd(const TestSuite& parameter) override;
3780 void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
3781 void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) override;
3782 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
3783 void OnTestProgramEnd(const UnitTest& unit_test) override;
3784
3785 private:
3786 // Controls whether events will be forwarded to listeners_. Set to false
3787 // in death test child processes.
3788 bool forwarding_enabled_;
3789 // The list of listeners that receive events.
3790 std::vector<TestEventListener*> listeners_;
3791
3792 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
3793};
3794
3795TestEventRepeater::~TestEventRepeater() {
3796 ForEach(listeners_, Delete<TestEventListener>);
3797}
3798
3799void TestEventRepeater::Append(TestEventListener *listener) {
3800 listeners_.push_back(listener);
3801}
3802
3803TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
3804 for (size_t i = 0; i < listeners_.size(); ++i) {
3805 if (listeners_[i] == listener) {
3806 listeners_.erase(listeners_.begin() + static_cast<int>(i));
3807 return listener;
3808 }
3809 }
3810
3811 return nullptr;
3812}
3813
3814// Since most methods are very similar, use macros to reduce boilerplate.
3815// This defines a member that forwards the call to all listeners.
3816#define GTEST_REPEATER_METHOD_(Name, Type) \
3817void TestEventRepeater::Name(const Type& parameter) { \
3818 if (forwarding_enabled_) { \
3819 for (size_t i = 0; i < listeners_.size(); i++) { \
3820 listeners_[i]->Name(parameter); \
3821 } \
3822 } \
3823}
3824// This defines a member that forwards the call to all listeners in reverse
3825// order.
3826#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \
3827 void TestEventRepeater::Name(const Type& parameter) { \
3828 if (forwarding_enabled_) { \
3829 for (size_t i = listeners_.size(); i != 0; i--) { \
3830 listeners_[i - 1]->Name(parameter); \
3831 } \
3832 } \
3833 }
3834
3835GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
3836GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
3837// Legacy API is deprecated but still available
3838#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3839GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite)
3840#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3841GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite)
3842GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
3843GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
3844GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
3845GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
3846GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
3847GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
3848// Legacy API is deprecated but still available
3849#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3850GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite)
3851#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
3852GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite)
3853GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
3854
3855#undef GTEST_REPEATER_METHOD_
3856#undef GTEST_REVERSE_REPEATER_METHOD_
3857
3858void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
3859 int iteration) {
3860 if (forwarding_enabled_) {
3861 for (size_t i = 0; i < listeners_.size(); i++) {
3862 listeners_[i]->OnTestIterationStart(unit_test, iteration);
3863 }
3864 }
3865}
3866
3867void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
3868 int iteration) {
3869 if (forwarding_enabled_) {
3870 for (size_t i = listeners_.size(); i > 0; i--) {
3871 listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);
3872 }
3873 }
3874}
3875
3876// End TestEventRepeater
3877
3878// This class generates an XML output file.
3880 public:
3881 explicit XmlUnitTestResultPrinter(const char* output_file);
3882
3883 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
3884 void ListTestsMatchingFilter(const std::vector<TestSuite*>& test_suites);
3885
3886 // Prints an XML summary of all unit tests.
3887 static void PrintXmlTestsList(std::ostream* stream,
3888 const std::vector<TestSuite*>& test_suites);
3889
3890 private:
3891 // Is c a whitespace character that is normalized to a space character
3892 // when it appears in an XML attribute value?
3893 static bool IsNormalizableWhitespace(char c) {
3894 return c == 0x9 || c == 0xA || c == 0xD;
3895 }
3896
3897 // May c appear in a well-formed XML document?
3898 static bool IsValidXmlCharacter(char c) {
3899 return IsNormalizableWhitespace(c) || c >= 0x20;
3900 }
3901
3902 // Returns an XML-escaped copy of the input string str. If
3903 // is_attribute is true, the text is meant to appear as an attribute
3904 // value, and normalizable whitespace is preserved by replacing it
3905 // with character references.
3906 static std::string EscapeXml(const std::string& str, bool is_attribute);
3907
3908 // Returns the given string with all characters invalid in XML removed.
3909 static std::string RemoveInvalidXmlCharacters(const std::string& str);
3910
3911 // Convenience wrapper around EscapeXml when str is an attribute value.
3912 static std::string EscapeXmlAttribute(const std::string& str) {
3913 return EscapeXml(str, true);
3914 }
3915
3916 // Convenience wrapper around EscapeXml when str is not an attribute value.
3917 static std::string EscapeXmlText(const char* str) {
3918 return EscapeXml(str, false);
3919 }
3920
3921 // Verifies that the given attribute belongs to the given element and
3922 // streams the attribute as XML.
3923 static void OutputXmlAttribute(std::ostream* stream,
3924 const std::string& element_name,
3925 const std::string& name,
3926 const std::string& value);
3927
3928 // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
3929 static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
3930
3931 // Streams a test suite XML stanza containing the given test result.
3932 //
3933 // Requires: result.Failed()
3934 static void OutputXmlTestSuiteForTestResult(::std::ostream* stream,
3935 const TestResult& result);
3936
3937 // Streams an XML representation of a TestResult object.
3938 static void OutputXmlTestResult(::std::ostream* stream,
3939 const TestResult& result);
3940
3941 // Streams an XML representation of a TestInfo object.
3942 static void OutputXmlTestInfo(::std::ostream* stream,
3943 const char* test_suite_name,
3944 const TestInfo& test_info);
3945
3946 // Prints an XML representation of a TestSuite object
3947 static void PrintXmlTestSuite(::std::ostream* stream,
3948 const TestSuite& test_suite);
3949
3950 // Prints an XML summary of unit_test to output stream out.
3951 static void PrintXmlUnitTest(::std::ostream* stream,
3952 const UnitTest& unit_test);
3953
3954 // Produces a string representing the test properties in a result as space
3955 // delimited XML attributes based on the property key="value" pairs.
3956 // When the std::string is not empty, it includes a space at the beginning,
3957 // to delimit this attribute from prior attributes.
3958 static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
3959
3960 // Streams an XML representation of the test properties of a TestResult
3961 // object.
3962 static void OutputXmlTestProperties(std::ostream* stream,
3963 const TestResult& result);
3964
3965 // The output file.
3966 const std::string output_file_;
3967
3968 GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
3969};
3970
3971// Creates a new XmlUnitTestResultPrinter.
3972XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
3973 : output_file_(output_file) {
3974 if (output_file_.empty()) {
3975 GTEST_LOG_(FATAL) << "XML output file may not be null";
3976 }
3977}
3978
3979// Called after the unit test ends.
3980void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
3981 int /*iteration*/) {
3982 FILE* xmlout = OpenFileForWriting(output_file_);
3983 std::stringstream stream;
3984 PrintXmlUnitTest(&stream, unit_test);
3985 fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
3986 fclose(xmlout);
3987}
3988
3989void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
3990 const std::vector<TestSuite*>& test_suites) {
3991 FILE* xmlout = OpenFileForWriting(output_file_);
3992 std::stringstream stream;
3993 PrintXmlTestsList(&stream, test_suites);
3994 fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
3995 fclose(xmlout);
3996}
3997
3998// Returns an XML-escaped copy of the input string str. If is_attribute
3999// is true, the text is meant to appear as an attribute value, and
4000// normalizable whitespace is preserved by replacing it with character
4001// references.
4002//
4003// Invalid XML characters in str, if any, are stripped from the output.
4004// It is expected that most, if not all, of the text processed by this
4005// module will consist of ordinary English text.
4006// If this module is ever modified to produce version 1.1 XML output,
4007// most invalid characters can be retained using character references.
4008std::string XmlUnitTestResultPrinter::EscapeXml(
4009 const std::string& str, bool is_attribute) {
4010 Message m;
4011
4012 for (size_t i = 0; i < str.size(); ++i) {
4013 const char ch = str[i];
4014 switch (ch) {
4015 case '<':
4016 m << "&lt;";
4017 break;
4018 case '>':
4019 m << "&gt;";
4020 break;
4021 case '&':
4022 m << "&amp;";
4023 break;
4024 case '\'':
4025 if (is_attribute)
4026 m << "&apos;";
4027 else
4028 m << '\'';
4029 break;
4030 case '"':
4031 if (is_attribute)
4032 m << "&quot;";
4033 else
4034 m << '"';
4035 break;
4036 default:
4037 if (IsValidXmlCharacter(ch)) {
4038 if (is_attribute && IsNormalizableWhitespace(ch))
4039 m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
4040 << ";";
4041 else
4042 m << ch;
4043 }
4044 break;
4045 }
4046 }
4047
4048 return m.GetString();
4049}
4050
4051// Returns the given string with all characters invalid in XML removed.
4052// Currently invalid characters are dropped from the string. An
4053// alternative is to replace them with certain characters such as . or ?.
4054std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
4055 const std::string& str) {
4056 std::string output;
4057 output.reserve(str.size());
4058 for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
4059 if (IsValidXmlCharacter(*it))
4060 output.push_back(*it);
4061
4062 return output;
4063}
4064
4065// The following routines generate an XML representation of a UnitTest
4066// object.
4067// GOOGLETEST_CM0009 DO NOT DELETE
4068//
4069// This is how Google Test concepts map to the DTD:
4070//
4071// <testsuites name="AllTests"> <-- corresponds to a UnitTest object
4072// <testsuite name="testcase-name"> <-- corresponds to a TestSuite object
4073// <testcase name="test-name"> <-- corresponds to a TestInfo object
4074// <failure message="...">...</failure>
4075// <failure message="...">...</failure>
4076// <failure message="...">...</failure>
4077// <-- individual assertion failures
4078// </testcase>
4079// </testsuite>
4080// </testsuites>
4081
4082// Formats the given time in milliseconds as seconds.
4083std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
4084 ::std::stringstream ss;
4085 ss << (static_cast<double>(ms) * 1e-3);
4086 return ss.str();
4087}
4088
4089static bool PortableLocaltime(time_t seconds, struct tm* out) {
4090#if defined(_MSC_VER)
4091 return localtime_s(out, &seconds) == 0;
4092#elif defined(__MINGW32__) || defined(__MINGW64__)
4093 // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
4094 // Windows' localtime(), which has a thread-local tm buffer.
4095 struct tm* tm_ptr = localtime(&seconds); // NOLINT
4096 if (tm_ptr == nullptr) return false;
4097 *out = *tm_ptr;
4098 return true;
4099#else
4100 return localtime_r(&seconds, out) != nullptr;
4101#endif
4102}
4103
4104// Converts the given epoch time in milliseconds to a date string in the ISO
4105// 8601 format, without the timezone information.
4106std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
4107 struct tm time_struct;
4108 if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
4109 return "";
4110 // YYYY-MM-DDThh:mm:ss.sss
4111 return StreamableToString(time_struct.tm_year + 1900) + "-" +
4112 String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
4113 String::FormatIntWidth2(time_struct.tm_mday) + "T" +
4114 String::FormatIntWidth2(time_struct.tm_hour) + ":" +
4115 String::FormatIntWidth2(time_struct.tm_min) + ":" +
4116 String::FormatIntWidth2(time_struct.tm_sec) + "." +
4117 String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);
4118}
4119
4120// Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
4121void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
4122 const char* data) {
4123 const char* segment = data;
4124 *stream << "<![CDATA[";
4125 for (;;) {
4126 const char* const next_segment = strstr(segment, "]]>");
4127 if (next_segment != nullptr) {
4128 stream->write(
4129 segment, static_cast<std::streamsize>(next_segment - segment));
4130 *stream << "]]>]]&gt;<![CDATA[";
4131 segment = next_segment + strlen("]]>");
4132 } else {
4133 *stream << segment;
4134 break;
4135 }
4136 }
4137 *stream << "]]>";
4138}
4139
4140void XmlUnitTestResultPrinter::OutputXmlAttribute(
4141 std::ostream* stream,
4142 const std::string& element_name,
4143 const std::string& name,
4144 const std::string& value) {
4145 const std::vector<std::string>& allowed_names =
4146 GetReservedOutputAttributesForElement(element_name);
4147
4148 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
4149 allowed_names.end())
4150 << "Attribute " << name << " is not allowed for element <" << element_name
4151 << ">.";
4152
4153 *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
4154}
4155
4156// Streams a test suite XML stanza containing the given test result.
4157void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(
4158 ::std::ostream* stream, const TestResult& result) {
4159 // Output the boilerplate for a minimal test suite with one test.
4160 *stream << " <testsuite";
4161 OutputXmlAttribute(stream, "testsuite", "name", "NonTestSuiteFailure");
4162 OutputXmlAttribute(stream, "testsuite", "tests", "1");
4163 OutputXmlAttribute(stream, "testsuite", "failures", "1");
4164 OutputXmlAttribute(stream, "testsuite", "disabled", "0");
4165 OutputXmlAttribute(stream, "testsuite", "skipped", "0");
4166 OutputXmlAttribute(stream, "testsuite", "errors", "0");
4167 OutputXmlAttribute(stream, "testsuite", "time",
4168 FormatTimeInMillisAsSeconds(result.elapsed_time()));
4169 OutputXmlAttribute(
4170 stream, "testsuite", "timestamp",
4171 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
4172 *stream << ">";
4173
4174 // Output the boilerplate for a minimal test case with a single test.
4175 *stream << " <testcase";
4176 OutputXmlAttribute(stream, "testcase", "name", "");
4177 OutputXmlAttribute(stream, "testcase", "status", "run");
4178 OutputXmlAttribute(stream, "testcase", "result", "completed");
4179 OutputXmlAttribute(stream, "testcase", "classname", "");
4180 OutputXmlAttribute(stream, "testcase", "time",
4181 FormatTimeInMillisAsSeconds(result.elapsed_time()));
4182 OutputXmlAttribute(
4183 stream, "testcase", "timestamp",
4184 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
4185
4186 // Output the actual test result.
4187 OutputXmlTestResult(stream, result);
4188
4189 // Complete the test suite.
4190 *stream << " </testsuite>\n";
4191}
4192
4193// Prints an XML representation of a TestInfo object.
4194void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
4195 const char* test_suite_name,
4196 const TestInfo& test_info) {
4197 const TestResult& result = *test_info.result();
4198 const std::string kTestsuite = "testcase";
4199
4200 if (test_info.is_in_another_shard()) {
4201 return;
4202 }
4203
4204 *stream << " <testcase";
4205 OutputXmlAttribute(stream, kTestsuite, "name", test_info.name());
4206
4207 if (test_info.value_param() != nullptr) {
4208 OutputXmlAttribute(stream, kTestsuite, "value_param",
4209 test_info.value_param());
4210 }
4211 if (test_info.type_param() != nullptr) {
4212 OutputXmlAttribute(stream, kTestsuite, "type_param",
4213 test_info.type_param());
4214 }
4215 if (GTEST_FLAG(list_tests)) {
4216 OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
4217 OutputXmlAttribute(stream, kTestsuite, "line",
4218 StreamableToString(test_info.line()));
4219 *stream << " />\n";
4220 return;
4221 }
4222
4223 OutputXmlAttribute(stream, kTestsuite, "status",
4224 test_info.should_run() ? "run" : "notrun");
4225 OutputXmlAttribute(stream, kTestsuite, "result",
4226 test_info.should_run()
4227 ? (result.Skipped() ? "skipped" : "completed")
4228 : "suppressed");
4229 OutputXmlAttribute(stream, kTestsuite, "time",
4230 FormatTimeInMillisAsSeconds(result.elapsed_time()));
4231 OutputXmlAttribute(
4232 stream, kTestsuite, "timestamp",
4233 FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
4234 OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name);
4235
4236 OutputXmlTestResult(stream, result);
4237}
4238
4239void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream,
4240 const TestResult& result) {
4241 int failures = 0;
4242 int skips = 0;
4243 for (int i = 0; i < result.total_part_count(); ++i) {
4244 const TestPartResult& part = result.GetTestPartResult(i);
4245 if (part.failed()) {
4246 if (++failures == 1 && skips == 0) {
4247 *stream << ">\n";
4248 }
4249 const std::string location =
4250 internal::FormatCompilerIndependentFileLocation(part.file_name(),
4251 part.line_number());
4252 const std::string summary = location + "\n" + part.summary();
4253 *stream << " <failure message=\""
4254 << EscapeXmlAttribute(summary)
4255 << "\" type=\"\">";
4256 const std::string detail = location + "\n" + part.message();
4257 OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
4258 *stream << "</failure>\n";
4259 } else if (part.skipped()) {
4260 if (++skips == 1 && failures == 0) {
4261 *stream << ">\n";
4262 }
4263 const std::string location =
4264 internal::FormatCompilerIndependentFileLocation(part.file_name(),
4265 part.line_number());
4266 const std::string summary = location + "\n" + part.summary();
4267 *stream << " <skipped message=\""
4268 << EscapeXmlAttribute(summary.c_str()) << "\">";
4269 const std::string detail = location + "\n" + part.message();
4270 OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
4271 *stream << "</skipped>\n";
4272 }
4273 }
4274
4275 if (failures == 0 && skips == 0 && result.test_property_count() == 0) {
4276 *stream << " />\n";
4277 } else {
4278 if (failures == 0 && skips == 0) {
4279 *stream << ">\n";
4280 }
4281 OutputXmlTestProperties(stream, result);
4282 *stream << " </testcase>\n";
4283 }
4284}
4285
4286// Prints an XML representation of a TestSuite object
4287void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
4288 const TestSuite& test_suite) {
4289 const std::string kTestsuite = "testsuite";
4290 *stream << " <" << kTestsuite;
4291 OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
4292 OutputXmlAttribute(stream, kTestsuite, "tests",
4293 StreamableToString(test_suite.reportable_test_count()));
4294 if (!GTEST_FLAG(list_tests)) {
4295 OutputXmlAttribute(stream, kTestsuite, "failures",
4296 StreamableToString(test_suite.failed_test_count()));
4297 OutputXmlAttribute(
4298 stream, kTestsuite, "disabled",
4299 StreamableToString(test_suite.reportable_disabled_test_count()));
4300 OutputXmlAttribute(stream, kTestsuite, "skipped",
4301 StreamableToString(test_suite.skipped_test_count()));
4302
4303 OutputXmlAttribute(stream, kTestsuite, "errors", "0");
4304
4305 OutputXmlAttribute(stream, kTestsuite, "time",
4306 FormatTimeInMillisAsSeconds(test_suite.elapsed_time()));
4307 OutputXmlAttribute(
4308 stream, kTestsuite, "timestamp",
4309 FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp()));
4310 *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());
4311 }
4312 *stream << ">\n";
4313 for (int i = 0; i < test_suite.total_test_count(); ++i) {
4314 if (test_suite.GetTestInfo(i)->is_reportable())
4315 OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
4316 }
4317 *stream << " </" << kTestsuite << ">\n";
4318}
4319
4320// Prints an XML summary of unit_test to output stream out.
4321void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
4322 const UnitTest& unit_test) {
4323 const std::string kTestsuites = "testsuites";
4324
4325 *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
4326 *stream << "<" << kTestsuites;
4327
4328 OutputXmlAttribute(stream, kTestsuites, "tests",
4329 StreamableToString(unit_test.reportable_test_count()));
4330 OutputXmlAttribute(stream, kTestsuites, "failures",
4331 StreamableToString(unit_test.failed_test_count()));
4332 OutputXmlAttribute(
4333 stream, kTestsuites, "disabled",
4334 StreamableToString(unit_test.reportable_disabled_test_count()));
4335 OutputXmlAttribute(stream, kTestsuites, "errors", "0");
4336 OutputXmlAttribute(stream, kTestsuites, "time",
4337 FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
4338 OutputXmlAttribute(
4339 stream, kTestsuites, "timestamp",
4340 FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
4341
4342 if (GTEST_FLAG(shuffle)) {
4343 OutputXmlAttribute(stream, kTestsuites, "random_seed",
4344 StreamableToString(unit_test.random_seed()));
4345 }
4346 *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
4347
4348 OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
4349 *stream << ">\n";
4350
4351 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
4352 if (unit_test.GetTestSuite(i)->reportable_test_count() > 0)
4353 PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i));
4354 }
4355
4356 // If there was a test failure outside of one of the test suites (like in a
4357 // test environment) include that in the output.
4358 if (unit_test.ad_hoc_test_result().Failed()) {
4359 OutputXmlTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
4360 }
4361
4362 *stream << "</" << kTestsuites << ">\n";
4363}
4364
4365void XmlUnitTestResultPrinter::PrintXmlTestsList(
4366 std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
4367 const std::string kTestsuites = "testsuites";
4368
4369 *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
4370 *stream << "<" << kTestsuites;
4371
4372 int total_tests = 0;
4373 for (auto test_suite : test_suites) {
4374 total_tests += test_suite->total_test_count();
4375 }
4376 OutputXmlAttribute(stream, kTestsuites, "tests",
4377 StreamableToString(total_tests));
4378 OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
4379 *stream << ">\n";
4380
4381 for (auto test_suite : test_suites) {
4382 PrintXmlTestSuite(stream, *test_suite);
4383 }
4384 *stream << "</" << kTestsuites << ">\n";
4385}
4386
4387// Produces a string representing the test properties in a result as space
4388// delimited XML attributes based on the property key="value" pairs.
4389std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
4390 const TestResult& result) {
4391 Message attributes;
4392 for (int i = 0; i < result.test_property_count(); ++i) {
4393 const TestProperty& property = result.GetTestProperty(i);
4394 attributes << " " << property.key() << "="
4395 << "\"" << EscapeXmlAttribute(property.value()) << "\"";
4396 }
4397 return attributes.GetString();
4398}
4399
4400void XmlUnitTestResultPrinter::OutputXmlTestProperties(
4401 std::ostream* stream, const TestResult& result) {
4402 const std::string kProperties = "properties";
4403 const std::string kProperty = "property";
4404
4405 if (result.test_property_count() <= 0) {
4406 return;
4407 }
4408
4409 *stream << "<" << kProperties << ">\n";
4410 for (int i = 0; i < result.test_property_count(); ++i) {
4411 const TestProperty& property = result.GetTestProperty(i);
4412 *stream << "<" << kProperty;
4413 *stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
4414 *stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
4415 *stream << "/>\n";
4416 }
4417 *stream << "</" << kProperties << ">\n";
4418}
4419
4420// End XmlUnitTestResultPrinter
4421
4422// This class generates an JSON output file.
4424 public:
4425 explicit JsonUnitTestResultPrinter(const char* output_file);
4426
4427 void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
4428
4429 // Prints an JSON summary of all unit tests.
4430 static void PrintJsonTestList(::std::ostream* stream,
4431 const std::vector<TestSuite*>& test_suites);
4432
4433 private:
4434 // Returns an JSON-escaped copy of the input string str.
4435 static std::string EscapeJson(const std::string& str);
4436
4439 static void OutputJsonKey(std::ostream* stream,
4440 const std::string& element_name,
4441 const std::string& name,
4442 const std::string& value,
4443 const std::string& indent,
4444 bool comma = true);
4445 static void OutputJsonKey(std::ostream* stream,
4446 const std::string& element_name,
4447 const std::string& name,
4448 int value,
4449 const std::string& indent,
4450 bool comma = true);
4451
4452 // Streams a test suite JSON stanza containing the given test result.
4453 //
4454 // Requires: result.Failed()
4455 static void OutputJsonTestSuiteForTestResult(::std::ostream* stream,
4456 const TestResult& result);
4457
4458 // Streams a JSON representation of a TestResult object.
4459 static void OutputJsonTestResult(::std::ostream* stream,
4460 const TestResult& result);
4461
4462 // Streams a JSON representation of a TestInfo object.
4463 static void OutputJsonTestInfo(::std::ostream* stream,
4464 const char* test_suite_name,
4465 const TestInfo& test_info);
4466
4467 // Prints a JSON representation of a TestSuite object
4468 static void PrintJsonTestSuite(::std::ostream* stream,
4469 const TestSuite& test_suite);
4470
4471 // Prints a JSON summary of unit_test to output stream out.
4472 static void PrintJsonUnitTest(::std::ostream* stream,
4473 const UnitTest& unit_test);
4474
4475 // Produces a string representing the test properties in a result as
4476 // a JSON dictionary.
4477 static std::string TestPropertiesAsJson(const TestResult& result,
4478 const std::string& indent);
4479
4480 // The output file.
4481 const std::string output_file_;
4482
4483 GTEST_DISALLOW_COPY_AND_ASSIGN_(JsonUnitTestResultPrinter);
4484};
4485
4486// Creates a new JsonUnitTestResultPrinter.
4487JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file)
4488 : output_file_(output_file) {
4489 if (output_file_.empty()) {
4490 GTEST_LOG_(FATAL) << "JSON output file may not be null";
4491 }
4492}
4493
4494void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
4495 int /*iteration*/) {
4496 FILE* jsonout = OpenFileForWriting(output_file_);
4497 std::stringstream stream;
4498 PrintJsonUnitTest(&stream, unit_test);
4499 fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
4500 fclose(jsonout);
4501}
4502
4503// Returns an JSON-escaped copy of the input string str.
4504std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
4505 Message m;
4506
4507 for (size_t i = 0; i < str.size(); ++i) {
4508 const char ch = str[i];
4509 switch (ch) {
4510 case '\\':
4511 case '"':
4512 case '/':
4513 m << '\\' << ch;
4514 break;
4515 case '\b':
4516 m << "\\b";
4517 break;
4518 case '\t':
4519 m << "\\t";
4520 break;
4521 case '\n':
4522 m << "\\n";
4523 break;
4524 case '\f':
4525 m << "\\f";
4526 break;
4527 case '\r':
4528 m << "\\r";
4529 break;
4530 default:
4531 if (ch < ' ') {
4532 m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch));
4533 } else {
4534 m << ch;
4535 }
4536 break;
4537 }
4538 }
4539
4540 return m.GetString();
4541}
4542
4543// The following routines generate an JSON representation of a UnitTest
4544// object.
4545
4546// Formats the given time in milliseconds as seconds.
4547static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
4548 ::std::stringstream ss;
4549 ss << (static_cast<double>(ms) * 1e-3) << "s";
4550 return ss.str();
4551}
4552
4553// Converts the given epoch time in milliseconds to a date string in the
4554// RFC3339 format, without the timezone information.
4555static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
4556 struct tm time_struct;
4557 if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
4558 return "";
4559 // YYYY-MM-DDThh:mm:ss
4560 return StreamableToString(time_struct.tm_year + 1900) + "-" +
4561 String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
4562 String::FormatIntWidth2(time_struct.tm_mday) + "T" +
4563 String::FormatIntWidth2(time_struct.tm_hour) + ":" +
4564 String::FormatIntWidth2(time_struct.tm_min) + ":" +
4565 String::FormatIntWidth2(time_struct.tm_sec) + "Z";
4566}
4567
4568static inline std::string Indent(size_t width) {
4569 return std::string(width, ' ');
4570}
4571
4572void JsonUnitTestResultPrinter::OutputJsonKey(
4573 std::ostream* stream,
4574 const std::string& element_name,
4575 const std::string& name,
4576 const std::string& value,
4577 const std::string& indent,
4578 bool comma) {
4579 const std::vector<std::string>& allowed_names =
4580 GetReservedOutputAttributesForElement(element_name);
4581
4582 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
4583 allowed_names.end())
4584 << "Key \"" << name << "\" is not allowed for value \"" << element_name
4585 << "\".";
4586
4587 *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\"";
4588 if (comma)
4589 *stream << ",\n";
4590}
4591
4592void JsonUnitTestResultPrinter::OutputJsonKey(
4593 std::ostream* stream,
4594 const std::string& element_name,
4595 const std::string& name,
4596 int value,
4597 const std::string& indent,
4598 bool comma) {
4599 const std::vector<std::string>& allowed_names =
4600 GetReservedOutputAttributesForElement(element_name);
4601
4602 GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
4603 allowed_names.end())
4604 << "Key \"" << name << "\" is not allowed for value \"" << element_name
4605 << "\".";
4606
4607 *stream << indent << "\"" << name << "\": " << StreamableToString(value);
4608 if (comma)
4609 *stream << ",\n";
4610}
4611
4612// Streams a test suite JSON stanza containing the given test result.
4613void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(
4614 ::std::ostream* stream, const TestResult& result) {
4615 // Output the boilerplate for a new test suite.
4616 *stream << Indent(4) << "{\n";
4617 OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6));
4618 OutputJsonKey(stream, "testsuite", "tests", 1, Indent(6));
4619 if (!GTEST_FLAG(list_tests)) {
4620 OutputJsonKey(stream, "testsuite", "failures", 1, Indent(6));
4621 OutputJsonKey(stream, "testsuite", "disabled", 0, Indent(6));
4622 OutputJsonKey(stream, "testsuite", "skipped", 0, Indent(6));
4623 OutputJsonKey(stream, "testsuite", "errors", 0, Indent(6));
4624 OutputJsonKey(stream, "testsuite", "time",
4625 FormatTimeInMillisAsDuration(result.elapsed_time()),
4626 Indent(6));
4627 OutputJsonKey(stream, "testsuite", "timestamp",
4628 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
4629 Indent(6));
4630 }
4631 *stream << Indent(6) << "\"testsuite\": [\n";
4632
4633 // Output the boilerplate for a new test case.
4634 *stream << Indent(8) << "{\n";
4635 OutputJsonKey(stream, "testcase", "name", "", Indent(10));
4636 OutputJsonKey(stream, "testcase", "status", "RUN", Indent(10));
4637 OutputJsonKey(stream, "testcase", "result", "COMPLETED", Indent(10));
4638 OutputJsonKey(stream, "testcase", "timestamp",
4639 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
4640 Indent(10));
4641 OutputJsonKey(stream, "testcase", "time",
4642 FormatTimeInMillisAsDuration(result.elapsed_time()),
4643 Indent(10));
4644 OutputJsonKey(stream, "testcase", "classname", "", Indent(10), false);
4645 *stream << TestPropertiesAsJson(result, Indent(10));
4646
4647 // Output the actual test result.
4648 OutputJsonTestResult(stream, result);
4649
4650 // Finish the test suite.
4651 *stream << "\n" << Indent(6) << "]\n" << Indent(4) << "}";
4652}
4653
4654// Prints a JSON representation of a TestInfo object.
4655void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
4656 const char* test_suite_name,
4657 const TestInfo& test_info) {
4658 const TestResult& result = *test_info.result();
4659 const std::string kTestsuite = "testcase";
4660 const std::string kIndent = Indent(10);
4661
4662 *stream << Indent(8) << "{\n";
4663 OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent);
4664
4665 if (test_info.value_param() != nullptr) {
4666 OutputJsonKey(stream, kTestsuite, "value_param", test_info.value_param(),
4667 kIndent);
4668 }
4669 if (test_info.type_param() != nullptr) {
4670 OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(),
4671 kIndent);
4672 }
4673 if (GTEST_FLAG(list_tests)) {
4674 OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);
4675 OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false);
4676 *stream << "\n" << Indent(8) << "}";
4677 return;
4678 }
4679
4680 OutputJsonKey(stream, kTestsuite, "status",
4681 test_info.should_run() ? "RUN" : "NOTRUN", kIndent);
4682 OutputJsonKey(stream, kTestsuite, "result",
4683 test_info.should_run()
4684 ? (result.Skipped() ? "SKIPPED" : "COMPLETED")
4685 : "SUPPRESSED",
4686 kIndent);
4687 OutputJsonKey(stream, kTestsuite, "timestamp",
4688 FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
4689 kIndent);
4690 OutputJsonKey(stream, kTestsuite, "time",
4691 FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent);
4692 OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent,
4693 false);
4694 *stream << TestPropertiesAsJson(result, kIndent);
4695
4696 OutputJsonTestResult(stream, result);
4697}
4698
4699void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
4700 const TestResult& result) {
4701 const std::string kIndent = Indent(10);
4702
4703 int failures = 0;
4704 for (int i = 0; i < result.total_part_count(); ++i) {
4705 const TestPartResult& part = result.GetTestPartResult(i);
4706 if (part.failed()) {
4707 *stream << ",\n";
4708 if (++failures == 1) {
4709 *stream << kIndent << "\"" << "failures" << "\": [\n";
4710 }
4711 const std::string location =
4712 internal::FormatCompilerIndependentFileLocation(part.file_name(),
4713 part.line_number());
4714 const std::string message = EscapeJson(location + "\n" + part.message());
4715 *stream << kIndent << " {\n"
4716 << kIndent << " \"failure\": \"" << message << "\",\n"
4717 << kIndent << " \"type\": \"\"\n"
4718 << kIndent << " }";
4719 }
4720 }
4721
4722 if (failures > 0)
4723 *stream << "\n" << kIndent << "]";
4724 *stream << "\n" << Indent(8) << "}";
4725}
4726
4727// Prints an JSON representation of a TestSuite object
4728void JsonUnitTestResultPrinter::PrintJsonTestSuite(
4729 std::ostream* stream, const TestSuite& test_suite) {
4730 const std::string kTestsuite = "testsuite";
4731 const std::string kIndent = Indent(6);
4732
4733 *stream << Indent(4) << "{\n";
4734 OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
4735 OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(),
4736 kIndent);
4737 if (!GTEST_FLAG(list_tests)) {
4738 OutputJsonKey(stream, kTestsuite, "failures",
4739 test_suite.failed_test_count(), kIndent);
4740 OutputJsonKey(stream, kTestsuite, "disabled",
4741 test_suite.reportable_disabled_test_count(), kIndent);
4742 OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);
4743 OutputJsonKey(
4744 stream, kTestsuite, "timestamp",
4745 FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()),
4746 kIndent);
4747 OutputJsonKey(stream, kTestsuite, "time",
4748 FormatTimeInMillisAsDuration(test_suite.elapsed_time()),
4749 kIndent, false);
4750 *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent)
4751 << ",\n";
4752 }
4753
4754 *stream << kIndent << "\"" << kTestsuite << "\": [\n";
4755
4756 bool comma = false;
4757 for (int i = 0; i < test_suite.total_test_count(); ++i) {
4758 if (test_suite.GetTestInfo(i)->is_reportable()) {
4759 if (comma) {
4760 *stream << ",\n";
4761 } else {
4762 comma = true;
4763 }
4764 OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
4765 }
4766 }
4767 *stream << "\n" << kIndent << "]\n" << Indent(4) << "}";
4768}
4769
4770// Prints a JSON summary of unit_test to output stream out.
4771void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
4772 const UnitTest& unit_test) {
4773 const std::string kTestsuites = "testsuites";
4774 const std::string kIndent = Indent(2);
4775 *stream << "{\n";
4776
4777 OutputJsonKey(stream, kTestsuites, "tests", unit_test.reportable_test_count(),
4778 kIndent);
4779 OutputJsonKey(stream, kTestsuites, "failures", unit_test.failed_test_count(),
4780 kIndent);
4781 OutputJsonKey(stream, kTestsuites, "disabled",
4782 unit_test.reportable_disabled_test_count(), kIndent);
4783 OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent);
4784 if (GTEST_FLAG(shuffle)) {
4785 OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(),
4786 kIndent);
4787 }
4788 OutputJsonKey(stream, kTestsuites, "timestamp",
4789 FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()),
4790 kIndent);
4791 OutputJsonKey(stream, kTestsuites, "time",
4792 FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent,
4793 false);
4794
4795 *stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent)
4796 << ",\n";
4797
4798 OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
4799 *stream << kIndent << "\"" << kTestsuites << "\": [\n";
4800
4801 bool comma = false;
4802 for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
4803 if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) {
4804 if (comma) {
4805 *stream << ",\n";
4806 } else {
4807 comma = true;
4808 }
4809 PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i));
4810 }
4811 }
4812
4813 // If there was a test failure outside of one of the test suites (like in a
4814 // test environment) include that in the output.
4815 if (unit_test.ad_hoc_test_result().Failed()) {
4816 OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
4817 }
4818
4819 *stream << "\n" << kIndent << "]\n" << "}\n";
4820}
4821
4822void JsonUnitTestResultPrinter::PrintJsonTestList(
4823 std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
4824 const std::string kTestsuites = "testsuites";
4825 const std::string kIndent = Indent(2);
4826 *stream << "{\n";
4827 int total_tests = 0;
4828 for (auto test_suite : test_suites) {
4829 total_tests += test_suite->total_test_count();
4830 }
4831 OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent);
4832
4833 OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
4834 *stream << kIndent << "\"" << kTestsuites << "\": [\n";
4835
4836 for (size_t i = 0; i < test_suites.size(); ++i) {
4837 if (i != 0) {
4838 *stream << ",\n";
4839 }
4840 PrintJsonTestSuite(stream, *test_suites[i]);
4841 }
4842
4843 *stream << "\n"
4844 << kIndent << "]\n"
4845 << "}\n";
4846}
4847// Produces a string representing the test properties in a result as
4848// a JSON dictionary.
4849std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
4850 const TestResult& result, const std::string& indent) {
4851 Message attributes;
4852 for (int i = 0; i < result.test_property_count(); ++i) {
4853 const TestProperty& property = result.GetTestProperty(i);
4854 attributes << ",\n" << indent << "\"" << property.key() << "\": "
4855 << "\"" << EscapeJson(property.value()) << "\"";
4856 }
4857 return attributes.GetString();
4858}
4859
4860// End JsonUnitTestResultPrinter
4861
4862#if GTEST_CAN_STREAM_RESULTS_
4863
4864// Checks if str contains '=', '&', '%' or '\n' characters. If yes,
4865// replaces them by "%xx" where xx is their hexadecimal value. For
4866// example, replaces "=" with "%3D". This algorithm is O(strlen(str))
4867// in both time and space -- important as the input str may contain an
4868// arbitrarily long test failure message and stack trace.
4869std::string StreamingListener::UrlEncode(const char* str) {
4870 std::string result;
4871 result.reserve(strlen(str) + 1);
4872 for (char ch = *str; ch != '\0'; ch = *++str) {
4873 switch (ch) {
4874 case '%':
4875 case '=':
4876 case '&':
4877 case '\n':
4878 result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
4879 break;
4880 default:
4881 result.push_back(ch);
4882 break;
4883 }
4884 }
4885 return result;
4886}
4887
4888void StreamingListener::SocketWriter::MakeConnection() {
4889 GTEST_CHECK_(sockfd_ == -1)
4890 << "MakeConnection() can't be called when there is already a connection.";
4891
4892 addrinfo hints;
4893 memset(&hints, 0, sizeof(hints));
4894 hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses.
4895 hints.ai_socktype = SOCK_STREAM;
4896 addrinfo* servinfo = nullptr;
4897
4898 // Use the getaddrinfo() to get a linked list of IP addresses for
4899 // the given host name.
4900 const int error_num = getaddrinfo(
4901 host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
4902 if (error_num != 0) {
4903 GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
4904 << gai_strerror(error_num);
4905 }
4906
4907 // Loop through all the results and connect to the first we can.
4908 for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;
4909 cur_addr = cur_addr->ai_next) {
4910 sockfd_ = socket(
4911 cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
4912 if (sockfd_ != -1) {
4913 // Connect the client socket to the server socket.
4914 if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
4915 close(sockfd_);
4916 sockfd_ = -1;
4917 }
4918 }
4919 }
4920
4921 freeaddrinfo(servinfo); // all done with this structure
4922
4923 if (sockfd_ == -1) {
4924 GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
4925 << host_name_ << ":" << port_num_;
4926 }
4927}
4928
4929// End of class Streaming Listener
4930#endif // GTEST_CAN_STREAM_RESULTS__
4931
4932// class OsStackTraceGetter
4933
4934const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
4935 "... " GTEST_NAME_ " internal frames ...";
4936
4937std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
4938 GTEST_LOCK_EXCLUDED_(mutex_) {
4939#if GTEST_HAS_ABSL
4940 std::string result;
4941
4942 if (max_depth <= 0) {
4943 return result;
4944 }
4945
4946 max_depth = std::min(max_depth, kMaxStackTraceDepth);
4947
4948 std::vector<void*> raw_stack(max_depth);
4949 // Skips the frames requested by the caller, plus this function.
4950 const int raw_stack_size =
4951 absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1);
4952
4953 void* caller_frame = nullptr;
4954 {
4955 MutexLock lock(&mutex_);
4956 caller_frame = caller_frame_;
4957 }
4958
4959 for (int i = 0; i < raw_stack_size; ++i) {
4960 if (raw_stack[i] == caller_frame &&
4961 !GTEST_FLAG(show_internal_stack_frames)) {
4962 // Add a marker to the trace and stop adding frames.
4963 absl::StrAppend(&result, kElidedFramesMarker, "\n");
4964 break;
4965 }
4966
4967 char tmp[1024];
4968 const char* symbol = "(unknown)";
4969 if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) {
4970 symbol = tmp;
4971 }
4972
4973 char line[1024];
4974 snprintf(line, sizeof(line), " %p: %s\n", raw_stack[i], symbol);
4975 result += line;
4976 }
4977
4978 return result;
4979
4980#else // !GTEST_HAS_ABSL
4981 static_cast<void>(max_depth);
4982 static_cast<void>(skip_count);
4983 return "";
4984#endif // GTEST_HAS_ABSL
4985}
4986
4987void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
4988#if GTEST_HAS_ABSL
4989 void* caller_frame = nullptr;
4990 if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
4991 caller_frame = nullptr;
4992 }
4993
4994 MutexLock lock(&mutex_);
4995 caller_frame_ = caller_frame;
4996#endif // GTEST_HAS_ABSL
4997}
4998
4999// A helper class that creates the premature-exit file in its
5000// constructor and deletes the file in its destructor.
5002 public:
5003 explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
5004 : premature_exit_filepath_(premature_exit_filepath ?
5005 premature_exit_filepath : "") {
5006 // If a path to the premature-exit file is specified...
5007 if (!premature_exit_filepath_.empty()) {
5008 // create the file with a single "0" character in it. I/O
5009 // errors are ignored as there's nothing better we can do and we
5010 // don't want to fail the test because of this.
5011 FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
5012 fwrite("0", 1, 1, pfile);
5013 fclose(pfile);
5014 }
5015 }
5016
5018#if !defined GTEST_OS_ESP8266
5019 if (!premature_exit_filepath_.empty()) {
5020 int retval = remove(premature_exit_filepath_.c_str());
5021 if (retval) {
5022 GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
5023 << premature_exit_filepath_ << "\" with error "
5024 << retval;
5025 }
5026 }
5027#endif
5028 }
5029
5030 private:
5031 const std::string premature_exit_filepath_;
5032
5033 GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
5034};
5035
5036} // namespace internal
5037
5038// class TestEventListeners
5039
5040TestEventListeners::TestEventListeners()
5041 : repeater_(new internal::TestEventRepeater()),
5042 default_result_printer_(nullptr),
5043 default_xml_generator_(nullptr) {}
5044
5045TestEventListeners::~TestEventListeners() { delete repeater_; }
5046
5047// Returns the standard listener responsible for the default console
5048// output. Can be removed from the listeners list to shut down default
5049// console output. Note that removing this object from the listener list
5050// with Release transfers its ownership to the user.
5051void TestEventListeners::Append(TestEventListener* listener) {
5052 repeater_->Append(listener);
5053}
5054
5055// Removes the given event listener from the list and returns it. It then
5056// becomes the caller's responsibility to delete the listener. Returns
5057// NULL if the listener is not found in the list.
5058TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
5059 if (listener == default_result_printer_)
5060 default_result_printer_ = nullptr;
5061 else if (listener == default_xml_generator_)
5062 default_xml_generator_ = nullptr;
5063 return repeater_->Release(listener);
5064}
5065
5066// Returns repeater that broadcasts the TestEventListener events to all
5067// subscribers.
5068TestEventListener* TestEventListeners::repeater() { return repeater_; }
5069
5070// Sets the default_result_printer attribute to the provided listener.
5071// The listener is also added to the listener list and previous
5072// default_result_printer is removed from it and deleted. The listener can
5073// also be NULL in which case it will not be added to the list. Does
5074// nothing if the previous and the current listener objects are the same.
5075void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
5076 if (default_result_printer_ != listener) {
5077 // It is an error to pass this method a listener that is already in the
5078 // list.
5079 delete Release(default_result_printer_);
5080 default_result_printer_ = listener;
5081 if (listener != nullptr) Append(listener);
5082 }
5083}
5084
5085// Sets the default_xml_generator attribute to the provided listener. The
5086// listener is also added to the listener list and previous
5087// default_xml_generator is removed from it and deleted. The listener can
5088// also be NULL in which case it will not be added to the list. Does
5089// nothing if the previous and the current listener objects are the same.
5090void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
5091 if (default_xml_generator_ != listener) {
5092 // It is an error to pass this method a listener that is already in the
5093 // list.
5094 delete Release(default_xml_generator_);
5095 default_xml_generator_ = listener;
5096 if (listener != nullptr) Append(listener);
5097 }
5098}
5099
5100// Controls whether events will be forwarded by the repeater to the
5101// listeners in the list.
5102bool TestEventListeners::EventForwardingEnabled() const {
5103 return repeater_->forwarding_enabled();
5104}
5105
5106void TestEventListeners::SuppressEventForwarding() {
5107 repeater_->set_forwarding_enabled(false);
5108}
5109
5110// class UnitTest
5111
5112// Gets the singleton UnitTest object. The first time this method is
5113// called, a UnitTest object is constructed and returned. Consecutive
5114// calls will return the same object.
5115//
5116// We don't protect this under mutex_ as a user is not supposed to
5117// call this before main() starts, from which point on the return
5118// value will never change.
5119UnitTest* UnitTest::GetInstance() {
5120 // CodeGear C++Builder insists on a public destructor for the
5121 // default implementation. Use this implementation to keep good OO
5122 // design with private destructor.
5123
5124#if defined(__BORLANDC__)
5125 static UnitTest* const instance = new UnitTest;
5126 return instance;
5127#else
5128 static UnitTest instance;
5129 return &instance;
5130#endif // defined(__BORLANDC__)
5131}
5132
5133// Gets the number of successful test suites.
5134int UnitTest::successful_test_suite_count() const {
5135 return impl()->successful_test_suite_count();
5136}
5137
5138// Gets the number of failed test suites.
5139int UnitTest::failed_test_suite_count() const {
5140 return impl()->failed_test_suite_count();
5141}
5142
5143// Gets the number of all test suites.
5144int UnitTest::total_test_suite_count() const {
5145 return impl()->total_test_suite_count();
5146}
5147
5148// Gets the number of all test suites that contain at least one test
5149// that should run.
5150int UnitTest::test_suite_to_run_count() const {
5151 return impl()->test_suite_to_run_count();
5152}
5153
5154// Legacy API is deprecated but still available
5155#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5156int UnitTest::successful_test_case_count() const {
5157 return impl()->successful_test_suite_count();
5158}
5159int UnitTest::failed_test_case_count() const {
5160 return impl()->failed_test_suite_count();
5161}
5162int UnitTest::total_test_case_count() const {
5163 return impl()->total_test_suite_count();
5164}
5165int UnitTest::test_case_to_run_count() const {
5166 return impl()->test_suite_to_run_count();
5167}
5168#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5169
5170// Gets the number of successful tests.
5171int UnitTest::successful_test_count() const {
5172 return impl()->successful_test_count();
5173}
5174
5175// Gets the number of skipped tests.
5176int UnitTest::skipped_test_count() const {
5177 return impl()->skipped_test_count();
5178}
5179
5180// Gets the number of failed tests.
5181int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
5182
5183// Gets the number of disabled tests that will be reported in the XML report.
5184int UnitTest::reportable_disabled_test_count() const {
5185 return impl()->reportable_disabled_test_count();
5186}
5187
5188// Gets the number of disabled tests.
5189int UnitTest::disabled_test_count() const {
5190 return impl()->disabled_test_count();
5191}
5192
5193// Gets the number of tests to be printed in the XML report.
5194int UnitTest::reportable_test_count() const {
5195 return impl()->reportable_test_count();
5196}
5197
5198// Gets the number of all tests.
5199int UnitTest::total_test_count() const { return impl()->total_test_count(); }
5200
5201// Gets the number of tests that should run.
5202int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
5203
5204// Gets the time of the test program start, in ms from the start of the
5205// UNIX epoch.
5206internal::TimeInMillis UnitTest::start_timestamp() const {
5207 return impl()->start_timestamp();
5208}
5209
5210// Gets the elapsed time, in milliseconds.
5211internal::TimeInMillis UnitTest::elapsed_time() const {
5212 return impl()->elapsed_time();
5213}
5214
5215// Returns true if and only if the unit test passed (i.e. all test suites
5216// passed).
5217bool UnitTest::Passed() const { return impl()->Passed(); }
5218
5219// Returns true if and only if the unit test failed (i.e. some test suite
5220// failed or something outside of all tests failed).
5221bool UnitTest::Failed() const { return impl()->Failed(); }
5222
5223// Gets the i-th test suite among all the test suites. i can range from 0 to
5224// total_test_suite_count() - 1. If i is not in that range, returns NULL.
5225const TestSuite* UnitTest::GetTestSuite(int i) const {
5226 return impl()->GetTestSuite(i);
5227}
5228
5229// Legacy API is deprecated but still available
5230#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5231const TestCase* UnitTest::GetTestCase(int i) const {
5232 return impl()->GetTestCase(i);
5233}
5234#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5235
5236// Returns the TestResult containing information on test failures and
5237// properties logged outside of individual test suites.
5238const TestResult& UnitTest::ad_hoc_test_result() const {
5239 return *impl()->ad_hoc_test_result();
5240}
5241
5242// Gets the i-th test suite among all the test suites. i can range from 0 to
5243// total_test_suite_count() - 1. If i is not in that range, returns NULL.
5244TestSuite* UnitTest::GetMutableTestSuite(int i) {
5245 return impl()->GetMutableSuiteCase(i);
5246}
5247
5248// Returns the list of event listeners that can be used to track events
5249// inside Google Test.
5250TestEventListeners& UnitTest::listeners() {
5251 return *impl()->listeners();
5252}
5253
5254// Registers and returns a global test environment. When a test
5255// program is run, all global test environments will be set-up in the
5256// order they were registered. After all tests in the program have
5257// finished, all global test environments will be torn-down in the
5258// *reverse* order they were registered.
5259//
5260// The UnitTest object takes ownership of the given environment.
5261//
5262// We don't protect this under mutex_, as we only support calling it
5263// from the main thread.
5264Environment* UnitTest::AddEnvironment(Environment* env) {
5265 if (env == nullptr) {
5266 return nullptr;
5267 }
5268
5269 impl_->environments().push_back(env);
5270 return env;
5271}
5272
5273// Adds a TestPartResult to the current TestResult object. All Google Test
5274// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
5275// this to report their results. The user code should use the
5276// assertion macros instead of calling this directly.
5277void UnitTest::AddTestPartResult(
5278 TestPartResult::Type result_type,
5279 const char* file_name,
5280 int line_number,
5281 const std::string& message,
5282 const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
5283 Message msg;
5284 msg << message;
5285
5286 internal::MutexLock lock(&mutex_);
5287 if (impl_->gtest_trace_stack().size() > 0) {
5288 msg << "\n" << GTEST_NAME_ << " trace:";
5289
5290 for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) {
5291 const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
5292 msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
5293 << " " << trace.message;
5294 }
5295 }
5296
5297 if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) {
5298 msg << internal::kStackTraceMarker << os_stack_trace;
5299 }
5300
5301 const TestPartResult result = TestPartResult(
5302 result_type, file_name, line_number, msg.GetString().c_str());
5303 impl_->GetTestPartResultReporterForCurrentThread()->
5304 ReportTestPartResult(result);
5305
5306 if (result_type != TestPartResult::kSuccess &&
5307 result_type != TestPartResult::kSkip) {
5308 // gtest_break_on_failure takes precedence over
5309 // gtest_throw_on_failure. This allows a user to set the latter
5310 // in the code (perhaps in order to use Google Test assertions
5311 // with another testing framework) and specify the former on the
5312 // command line for debugging.
5313 if (GTEST_FLAG(break_on_failure)) {
5314#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
5315 // Using DebugBreak on Windows allows gtest to still break into a debugger
5316 // when a failure happens and both the --gtest_break_on_failure and
5317 // the --gtest_catch_exceptions flags are specified.
5318 DebugBreak();
5319#elif (!defined(__native_client__)) && \
5320 ((defined(__clang__) || defined(__GNUC__)) && \
5321 (defined(__x86_64__) || defined(__i386__)))
5322 // with clang/gcc we can achieve the same effect on x86 by invoking int3
5323 asm("int3");
5324#else
5325 // Dereference nullptr through a volatile pointer to prevent the compiler
5326 // from removing. We use this rather than abort() or __builtin_trap() for
5327 // portability: some debuggers don't correctly trap abort().
5328 *static_cast<volatile int*>(nullptr) = 1;
5329#endif // GTEST_OS_WINDOWS
5330 } else if (GTEST_FLAG(throw_on_failure)) {
5331#if GTEST_HAS_EXCEPTIONS
5332 throw internal::GoogleTestFailureException(result);
5333#else
5334 // We cannot call abort() as it generates a pop-up in debug mode
5335 // that cannot be suppressed in VC 7.1 or below.
5336 exit(1);
5337#endif
5338 }
5339 }
5340}
5341
5342// Adds a TestProperty to the current TestResult object when invoked from
5343// inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
5344// from SetUpTestSuite or TearDownTestSuite, or to the global property set
5345// when invoked elsewhere. If the result already contains a property with
5346// the same key, the value will be updated.
5347void UnitTest::RecordProperty(const std::string& key,
5348 const std::string& value) {
5349 impl_->RecordProperty(TestProperty(key, value));
5350}
5351
5352// Runs all tests in this UnitTest object and prints the result.
5353// Returns 0 if successful, or 1 otherwise.
5354//
5355// We don't protect this under mutex_, as we only support calling it
5356// from the main thread.
5357int UnitTest::Run() {
5358 const bool in_death_test_child_process =
5359 internal::GTEST_FLAG(internal_run_death_test).length() > 0;
5360
5361 // Google Test implements this protocol for catching that a test
5362 // program exits before returning control to Google Test:
5363 //
5364 // 1. Upon start, Google Test creates a file whose absolute path
5365 // is specified by the environment variable
5366 // TEST_PREMATURE_EXIT_FILE.
5367 // 2. When Google Test has finished its work, it deletes the file.
5368 //
5369 // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
5370 // running a Google-Test-based test program and check the existence
5371 // of the file at the end of the test execution to see if it has
5372 // exited prematurely.
5373
5374 // If we are in the child process of a death test, don't
5375 // create/delete the premature exit file, as doing so is unnecessary
5376 // and will confuse the parent process. Otherwise, create/delete
5377 // the file upon entering/leaving this function. If the program
5378 // somehow exits before this function has a chance to return, the
5379 // premature-exit file will be left undeleted, causing a test runner
5380 // that understands the premature-exit-file protocol to report the
5381 // test as having failed.
5382 const internal::ScopedPrematureExitFile premature_exit_file(
5383 in_death_test_child_process
5384 ? nullptr
5385 : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
5386
5387 // Captures the value of GTEST_FLAG(catch_exceptions). This value will be
5388 // used for the duration of the program.
5389 impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
5390
5391#if GTEST_OS_WINDOWS
5392 // Either the user wants Google Test to catch exceptions thrown by the
5393 // tests or this is executing in the context of death test child
5394 // process. In either case the user does not want to see pop-up dialogs
5395 // about crashes - they are expected.
5396 if (impl()->catch_exceptions() || in_death_test_child_process) {
5397# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
5398 // SetErrorMode doesn't exist on CE.
5399 SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
5400 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
5401# endif // !GTEST_OS_WINDOWS_MOBILE
5402
5403# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
5404 // Death test children can be terminated with _abort(). On Windows,
5405 // _abort() can show a dialog with a warning message. This forces the
5406 // abort message to go to stderr instead.
5407 _set_error_mode(_OUT_TO_STDERR);
5408# endif
5409
5410# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
5411 // In the debug version, Visual Studio pops up a separate dialog
5412 // offering a choice to debug the aborted program. We need to suppress
5413 // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
5414 // executed. Google Test will notify the user of any unexpected
5415 // failure via stderr.
5416 if (!GTEST_FLAG(break_on_failure))
5417 _set_abort_behavior(
5418 0x0, // Clear the following flags:
5419 _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump.
5420
5421 // In debug mode, the Windows CRT can crash with an assertion over invalid
5422 // input (e.g. passing an invalid file descriptor). The default handling
5423 // for these assertions is to pop up a dialog and wait for user input.
5424 // Instead ask the CRT to dump such assertions to stderr non-interactively.
5425 if (!IsDebuggerPresent()) {
5426 (void)_CrtSetReportMode(_CRT_ASSERT,
5427 _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
5428 (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
5429 }
5430# endif
5431 }
5432#endif // GTEST_OS_WINDOWS
5433
5434 return internal::HandleExceptionsInMethodIfSupported(
5435 impl(),
5436 &internal::UnitTestImpl::RunAllTests,
5437 "auxiliary test code (environments or event listeners)") ? 0 : 1;
5438}
5439
5440// Returns the working directory when the first TEST() or TEST_F() was
5441// executed.
5442const char* UnitTest::original_working_dir() const {
5443 return impl_->original_working_dir_.c_str();
5444}
5445
5446// Returns the TestSuite object for the test that's currently running,
5447// or NULL if no test is running.
5448const TestSuite* UnitTest::current_test_suite() const
5449 GTEST_LOCK_EXCLUDED_(mutex_) {
5450 internal::MutexLock lock(&mutex_);
5451 return impl_->current_test_suite();
5452}
5453
5454// Legacy API is still available but deprecated
5455#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
5456const TestCase* UnitTest::current_test_case() const
5457 GTEST_LOCK_EXCLUDED_(mutex_) {
5458 internal::MutexLock lock(&mutex_);
5459 return impl_->current_test_suite();
5460}
5461#endif
5462
5463// Returns the TestInfo object for the test that's currently running,
5464// or NULL if no test is running.
5465const TestInfo* UnitTest::current_test_info() const
5466 GTEST_LOCK_EXCLUDED_(mutex_) {
5467 internal::MutexLock lock(&mutex_);
5468 return impl_->current_test_info();
5469}
5470
5471// Returns the random seed used at the start of the current test run.
5472int UnitTest::random_seed() const { return impl_->random_seed(); }
5473
5474// Returns ParameterizedTestSuiteRegistry object used to keep track of
5475// value-parameterized tests and instantiate and register them.
5476internal::ParameterizedTestSuiteRegistry&
5477UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {
5478 return impl_->parameterized_test_registry();
5479}
5480
5481// Creates an empty UnitTest.
5482UnitTest::UnitTest() {
5483 impl_ = new internal::UnitTestImpl(this);
5484}
5485
5486// Destructor of UnitTest.
5487UnitTest::~UnitTest() {
5488 delete impl_;
5489}
5490
5491// Pushes a trace defined by SCOPED_TRACE() on to the per-thread
5492// Google Test trace stack.
5493void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
5494 GTEST_LOCK_EXCLUDED_(mutex_) {
5495 internal::MutexLock lock(&mutex_);
5496 impl_->gtest_trace_stack().push_back(trace);
5497}
5498
5499// Pops a trace from the per-thread Google Test trace stack.
5500void UnitTest::PopGTestTrace()
5501 GTEST_LOCK_EXCLUDED_(mutex_) {
5502 internal::MutexLock lock(&mutex_);
5503 impl_->gtest_trace_stack().pop_back();
5504}
5505
5506namespace internal {
5507
5508UnitTestImpl::UnitTestImpl(UnitTest* parent)
5509 : parent_(parent),
5510 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
5511 default_global_test_part_result_reporter_(this),
5512 default_per_thread_test_part_result_reporter_(this),
5513 GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_(
5514 &default_global_test_part_result_reporter_),
5515 per_thread_test_part_result_reporter_(
5516 &default_per_thread_test_part_result_reporter_),
5517 parameterized_test_registry_(),
5518 parameterized_tests_registered_(false),
5519 last_death_test_suite_(-1),
5520 current_test_suite_(nullptr),
5521 current_test_info_(nullptr),
5522 ad_hoc_test_result_(),
5523 os_stack_trace_getter_(nullptr),
5524 post_flag_parse_init_performed_(false),
5525 random_seed_(0), // Will be overridden by the flag before first use.
5526 random_(0), // Will be reseeded before first use.
5527 start_timestamp_(0),
5528 elapsed_time_(0),
5529#if GTEST_HAS_DEATH_TEST
5530 death_test_factory_(new DefaultDeathTestFactory),
5531#endif
5532 // Will be overridden by the flag before first use.
5533 catch_exceptions_(false) {
5534 listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
5535}
5536
5537UnitTestImpl::~UnitTestImpl() {
5538 // Deletes every TestSuite.
5539 ForEach(test_suites_, internal::Delete<TestSuite>);
5540
5541 // Deletes every Environment.
5542 ForEach(environments_, internal::Delete<Environment>);
5543
5544 delete os_stack_trace_getter_;
5545}
5546
5547// Adds a TestProperty to the current TestResult object when invoked in a
5548// context of a test, to current test suite's ad_hoc_test_result when invoke
5549// from SetUpTestSuite/TearDownTestSuite, or to the global property set
5550// otherwise. If the result already contains a property with the same key,
5551// the value will be updated.
5552void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
5553 std::string xml_element;
5554 TestResult* test_result; // TestResult appropriate for property recording.
5555
5556 if (current_test_info_ != nullptr) {
5557 xml_element = "testcase";
5558 test_result = &(current_test_info_->result_);
5559 } else if (current_test_suite_ != nullptr) {
5560 xml_element = "testsuite";
5561 test_result = &(current_test_suite_->ad_hoc_test_result_);
5562 } else {
5563 xml_element = "testsuites";
5564 test_result = &ad_hoc_test_result_;
5565 }
5566 test_result->RecordProperty(xml_element, test_property);
5567}
5568
5569#if GTEST_HAS_DEATH_TEST
5570// Disables event forwarding if the control is currently in a death test
5571// subprocess. Must not be called before InitGoogleTest.
5572void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
5573 if (internal_run_death_test_flag_.get() != nullptr)
5574 listeners()->SuppressEventForwarding();
5575}
5576#endif // GTEST_HAS_DEATH_TEST
5577
5578// Initializes event listeners performing XML output as specified by
5579// UnitTestOptions. Must not be called before InitGoogleTest.
5580void UnitTestImpl::ConfigureXmlOutput() {
5581 const std::string& output_format = UnitTestOptions::GetOutputFormat();
5582 if (output_format == "xml") {
5583 listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
5584 UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
5585 } else if (output_format == "json") {
5586 listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
5587 UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
5588 } else if (output_format != "") {
5589 GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
5590 << output_format << "\" ignored.";
5591 }
5592}
5593
5594#if GTEST_CAN_STREAM_RESULTS_
5595// Initializes event listeners for streaming test results in string form.
5596// Must not be called before InitGoogleTest.
5597void UnitTestImpl::ConfigureStreamingOutput() {
5598 const std::string& target = GTEST_FLAG(stream_result_to);
5599 if (!target.empty()) {
5600 const size_t pos = target.find(':');
5601 if (pos != std::string::npos) {
5602 listeners()->Append(new StreamingListener(target.substr(0, pos),
5603 target.substr(pos+1)));
5604 } else {
5605 GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
5606 << "\" ignored.";
5607 }
5608 }
5609}
5610#endif // GTEST_CAN_STREAM_RESULTS_
5611
5612// Performs initialization dependent upon flag values obtained in
5613// ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to
5614// ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest
5615// this function is also called from RunAllTests. Since this function can be
5616// called more than once, it has to be idempotent.
5617void UnitTestImpl::PostFlagParsingInit() {
5618 // Ensures that this function does not execute more than once.
5619 if (!post_flag_parse_init_performed_) {
5620 post_flag_parse_init_performed_ = true;
5621
5622#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
5623 // Register to send notifications about key process state changes.
5624 listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
5625#endif // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
5626
5627#if GTEST_HAS_DEATH_TEST
5628 InitDeathTestSubprocessControlInfo();
5629 SuppressTestEventsIfInSubprocess();
5630#endif // GTEST_HAS_DEATH_TEST
5631
5632 // Registers parameterized tests. This makes parameterized tests
5633 // available to the UnitTest reflection API without running
5634 // RUN_ALL_TESTS.
5635 RegisterParameterizedTests();
5636
5637 // Configures listeners for XML output. This makes it possible for users
5638 // to shut down the default XML output before invoking RUN_ALL_TESTS.
5639 ConfigureXmlOutput();
5640
5641 if (GTEST_FLAG(brief)) {
5642 listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
5643 }
5644
5645#if GTEST_CAN_STREAM_RESULTS_
5646 // Configures listeners for streaming test results to the specified server.
5647 ConfigureStreamingOutput();
5648#endif // GTEST_CAN_STREAM_RESULTS_
5649
5650#if GTEST_HAS_ABSL
5651 if (GTEST_FLAG(install_failure_signal_handler)) {
5652 absl::FailureSignalHandlerOptions options;
5653 absl::InstallFailureSignalHandler(options);
5654 }
5655#endif // GTEST_HAS_ABSL
5656 }
5657}
5658
5659// A predicate that checks the name of a TestSuite against a known
5660// value.
5661//
5662// This is used for implementation of the UnitTest class only. We put
5663// it in the anonymous namespace to prevent polluting the outer
5664// namespace.
5665//
5666// TestSuiteNameIs is copyable.
5668 public:
5669 // Constructor.
5670 explicit TestSuiteNameIs(const std::string& name) : name_(name) {}
5671
5672 // Returns true if and only if the name of test_suite matches name_.
5673 bool operator()(const TestSuite* test_suite) const {
5674 return test_suite != nullptr &&
5675 strcmp(test_suite->name(), name_.c_str()) == 0;
5676 }
5677
5678 private:
5679 std::string name_;
5680};
5681
5682// Finds and returns a TestSuite with the given name. If one doesn't
5683// exist, creates one and returns it. It's the CALLER'S
5684// RESPONSIBILITY to ensure that this function is only called WHEN THE
5685// TESTS ARE NOT SHUFFLED.
5686//
5687// Arguments:
5688//
5689// test_suite_name: name of the test suite
5690// type_param: the name of the test suite's type parameter, or NULL if
5691// this is not a typed or a type-parameterized test suite.
5692// set_up_tc: pointer to the function that sets up the test suite
5693// tear_down_tc: pointer to the function that tears down the test suite
5694TestSuite* UnitTestImpl::GetTestSuite(
5695 const char* test_suite_name, const char* type_param,
5696 internal::SetUpTestSuiteFunc set_up_tc,
5697 internal::TearDownTestSuiteFunc tear_down_tc) {
5698 // Can we find a TestSuite with the given name?
5699 const auto test_suite =
5700 std::find_if(test_suites_.rbegin(), test_suites_.rend(),
5701 TestSuiteNameIs(test_suite_name));
5702
5703 if (test_suite != test_suites_.rend()) return *test_suite;
5704
5705 // No. Let's create one.
5706 auto* const new_test_suite =
5707 new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
5708
5709 // Is this a death test suite?
5710 if (internal::UnitTestOptions::MatchesFilter(test_suite_name,
5711 kDeathTestSuiteFilter)) {
5712 // Yes. Inserts the test suite after the last death test suite
5713 // defined so far. This only works when the test suites haven't
5714 // been shuffled. Otherwise we may end up running a death test
5715 // after a non-death test.
5716 ++last_death_test_suite_;
5717 test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
5718 new_test_suite);
5719 } else {
5720 // No. Appends to the end of the list.
5721 test_suites_.push_back(new_test_suite);
5722 }
5723
5724 test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));
5725 return new_test_suite;
5726}
5727
5728// Helpers for setting up / tearing down the given environment. They
5729// are for use in the ForEach() function.
5730static void SetUpEnvironment(Environment* env) { env->SetUp(); }
5731static void TearDownEnvironment(Environment* env) { env->TearDown(); }
5732
5733// Runs all tests in this UnitTest object, prints the result, and
5734// returns true if all tests are successful. If any exception is
5735// thrown during a test, the test is considered to be failed, but the
5736// rest of the tests will still be run.
5737//
5738// When parameterized tests are enabled, it expands and registers
5739// parameterized tests first in RegisterParameterizedTests().
5740// All other functions called from RunAllTests() may safely assume that
5741// parameterized tests are ready to be counted and run.
5742bool UnitTestImpl::RunAllTests() {
5743 // True if and only if Google Test is initialized before RUN_ALL_TESTS() is
5744 // called.
5745 const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
5746
5747 // Do not run any test if the --help flag was specified.
5748 if (g_help_flag)
5749 return true;
5750
5751 // Repeats the call to the post-flag parsing initialization in case the
5752 // user didn't call InitGoogleTest.
5753 PostFlagParsingInit();
5754
5755 // Even if sharding is not on, test runners may want to use the
5756 // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
5757 // protocol.
5758 internal::WriteToShardStatusFileIfNeeded();
5759
5760 // True if and only if we are in a subprocess for running a thread-safe-style
5761 // death test.
5762 bool in_subprocess_for_death_test = false;
5763
5764#if GTEST_HAS_DEATH_TEST
5765 in_subprocess_for_death_test =
5766 (internal_run_death_test_flag_.get() != nullptr);
5767# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
5768 if (in_subprocess_for_death_test) {
5769 GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
5770 }
5771# endif // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
5772#endif // GTEST_HAS_DEATH_TEST
5773
5774 const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
5775 in_subprocess_for_death_test);
5776
5777 // Compares the full test names with the filter to decide which
5778 // tests to run.
5779 const bool has_tests_to_run = FilterTests(should_shard
5780 ? HONOR_SHARDING_PROTOCOL
5781 : IGNORE_SHARDING_PROTOCOL) > 0;
5782
5783 // Lists the tests and exits if the --gtest_list_tests flag was specified.
5784 if (GTEST_FLAG(list_tests)) {
5785 // This must be called *after* FilterTests() has been called.
5786 ListTestsMatchingFilter();
5787 return true;
5788 }
5789
5790 random_seed_ = GTEST_FLAG(shuffle) ?
5791 GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
5792
5793 // True if and only if at least one test has failed.
5794 bool failed = false;
5795
5796 TestEventListener* repeater = listeners()->repeater();
5797
5798 start_timestamp_ = GetTimeInMillis();
5799 repeater->OnTestProgramStart(*parent_);
5800
5801 // How many times to repeat the tests? We don't want to repeat them
5802 // when we are inside the subprocess of a death test.
5803 const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
5804 // Repeats forever if the repeat count is negative.
5805 const bool gtest_repeat_forever = repeat < 0;
5806 for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
5807 // We want to preserve failures generated by ad-hoc test
5808 // assertions executed before RUN_ALL_TESTS().
5809 ClearNonAdHocTestResult();
5810
5811 Timer timer;
5812
5813 // Shuffles test suites and tests if requested.
5814 if (has_tests_to_run && GTEST_FLAG(shuffle)) {
5815 random()->Reseed(static_cast<uint32_t>(random_seed_));
5816 // This should be done before calling OnTestIterationStart(),
5817 // such that a test event listener can see the actual test order
5818 // in the event.
5819 ShuffleTests();
5820 }
5821
5822 // Tells the unit test event listeners that the tests are about to start.
5823 repeater->OnTestIterationStart(*parent_, i);
5824
5825 // Runs each test suite if there is at least one test to run.
5826 if (has_tests_to_run) {
5827 // Sets up all environments beforehand.
5828 repeater->OnEnvironmentsSetUpStart(*parent_);
5829 ForEach(environments_, SetUpEnvironment);
5830 repeater->OnEnvironmentsSetUpEnd(*parent_);
5831
5832 // Runs the tests only if there was no fatal failure or skip triggered
5833 // during global set-up.
5834 if (Test::IsSkipped()) {
5835 // Emit diagnostics when global set-up calls skip, as it will not be
5836 // emitted by default.
5837 TestResult& test_result =
5838 *internal::GetUnitTestImpl()->current_test_result();
5839 for (int j = 0; j < test_result.total_part_count(); ++j) {
5840 const TestPartResult& test_part_result =
5841 test_result.GetTestPartResult(j);
5842 if (test_part_result.type() == TestPartResult::kSkip) {
5843 const std::string& result = test_part_result.message();
5844 printf("%s\n", result.c_str());
5845 }
5846 }
5847 fflush(stdout);
5848 } else if (!Test::HasFatalFailure()) {
5849 for (int test_index = 0; test_index < total_test_suite_count();
5850 test_index++) {
5851 GetMutableSuiteCase(test_index)->Run();
5852 if (GTEST_FLAG(fail_fast) &&
5853 GetMutableSuiteCase(test_index)->Failed()) {
5854 for (int j = test_index + 1; j < total_test_suite_count(); j++) {
5855 GetMutableSuiteCase(j)->Skip();
5856 }
5857 break;
5858 }
5859 }
5860 } else if (Test::HasFatalFailure()) {
5861 // If there was a fatal failure during the global setup then we know we
5862 // aren't going to run any tests. Explicitly mark all of the tests as
5863 // skipped to make this obvious in the output.
5864 for (int test_index = 0; test_index < total_test_suite_count();
5865 test_index++) {
5866 GetMutableSuiteCase(test_index)->Skip();
5867 }
5868 }
5869
5870 // Tears down all environments in reverse order afterwards.
5871 repeater->OnEnvironmentsTearDownStart(*parent_);
5872 std::for_each(environments_.rbegin(), environments_.rend(),
5873 TearDownEnvironment);
5874 repeater->OnEnvironmentsTearDownEnd(*parent_);
5875 }
5876
5877 elapsed_time_ = timer.Elapsed();
5878
5879 // Tells the unit test event listener that the tests have just finished.
5880 repeater->OnTestIterationEnd(*parent_, i);
5881
5882 // Gets the result and clears it.
5883 if (!Passed()) {
5884 failed = true;
5885 }
5886
5887 // Restores the original test order after the iteration. This
5888 // allows the user to quickly repro a failure that happens in the
5889 // N-th iteration without repeating the first (N - 1) iterations.
5890 // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
5891 // case the user somehow changes the value of the flag somewhere
5892 // (it's always safe to unshuffle the tests).
5893 UnshuffleTests();
5894
5895 if (GTEST_FLAG(shuffle)) {
5896 // Picks a new random seed for each iteration.
5897 random_seed_ = GetNextRandomSeed(random_seed_);
5898 }
5899 }
5900
5901 repeater->OnTestProgramEnd(*parent_);
5902
5903 if (!gtest_is_initialized_before_run_all_tests) {
5904 ColoredPrintf(
5905 GTestColor::kRed,
5906 "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
5907 "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
5908 "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
5909 " will start to enforce the valid usage. "
5910 "Please fix it ASAP, or IT WILL START TO FAIL.\n"); // NOLINT
5911#if GTEST_FOR_GOOGLE_
5912 ColoredPrintf(GTestColor::kRed,
5913 "For more details, see http://wiki/Main/ValidGUnitMain.\n");
5914#endif // GTEST_FOR_GOOGLE_
5915 }
5916
5917 return !failed;
5918}
5919
5920// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
5921// if the variable is present. If a file already exists at this location, this
5922// function will write over it. If the variable is present, but the file cannot
5923// be created, prints an error and exits.
5924void WriteToShardStatusFileIfNeeded() {
5925 const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
5926 if (test_shard_file != nullptr) {
5927 FILE* const file = posix::FOpen(test_shard_file, "w");
5928 if (file == nullptr) {
5929 ColoredPrintf(GTestColor::kRed,
5930 "Could not write to the test shard status file \"%s\" "
5931 "specified by the %s environment variable.\n",
5932 test_shard_file, kTestShardStatusFile);
5933 fflush(stdout);
5934 exit(EXIT_FAILURE);
5935 }
5936 fclose(file);
5937 }
5938}
5939
5940// Checks whether sharding is enabled by examining the relevant
5941// environment variable values. If the variables are present,
5942// but inconsistent (i.e., shard_index >= total_shards), prints
5943// an error and exits. If in_subprocess_for_death_test, sharding is
5944// disabled because it must only be applied to the original test
5945// process. Otherwise, we could filter out death tests we intended to execute.
5946bool ShouldShard(const char* total_shards_env,
5947 const char* shard_index_env,
5948 bool in_subprocess_for_death_test) {
5949 if (in_subprocess_for_death_test) {
5950 return false;
5951 }
5952
5953 const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
5954 const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);
5955
5956 if (total_shards == -1 && shard_index == -1) {
5957 return false;
5958 } else if (total_shards == -1 && shard_index != -1) {
5959 const Message msg = Message()
5960 << "Invalid environment variables: you have "
5961 << kTestShardIndex << " = " << shard_index
5962 << ", but have left " << kTestTotalShards << " unset.\n";
5963 ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
5964 fflush(stdout);
5965 exit(EXIT_FAILURE);
5966 } else if (total_shards != -1 && shard_index == -1) {
5967 const Message msg = Message()
5968 << "Invalid environment variables: you have "
5969 << kTestTotalShards << " = " << total_shards
5970 << ", but have left " << kTestShardIndex << " unset.\n";
5971 ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
5972 fflush(stdout);
5973 exit(EXIT_FAILURE);
5974 } else if (shard_index < 0 || shard_index >= total_shards) {
5975 const Message msg = Message()
5976 << "Invalid environment variables: we require 0 <= "
5977 << kTestShardIndex << " < " << kTestTotalShards
5978 << ", but you have " << kTestShardIndex << "=" << shard_index
5979 << ", " << kTestTotalShards << "=" << total_shards << ".\n";
5980 ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
5981 fflush(stdout);
5982 exit(EXIT_FAILURE);
5983 }
5984
5985 return total_shards > 1;
5986}
5987
5988// Parses the environment variable var as an Int32. If it is unset,
5989// returns default_val. If it is not an Int32, prints an error
5990// and aborts.
5991int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
5992 const char* str_val = posix::GetEnv(var);
5993 if (str_val == nullptr) {
5994 return default_val;
5995 }
5996
5997 int32_t result;
5998 if (!ParseInt32(Message() << "The value of environment variable " << var,
5999 str_val, &result)) {
6000 exit(EXIT_FAILURE);
6001 }
6002 return result;
6003}
6004
6005// Given the total number of shards, the shard index, and the test id,
6006// returns true if and only if the test should be run on this shard. The test id
6007// is some arbitrary but unique non-negative integer assigned to each test
6008// method. Assumes that 0 <= shard_index < total_shards.
6009bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
6010 return (test_id % total_shards) == shard_index;
6011}
6012
6013// Compares the name of each test with the user-specified filter to
6014// decide whether the test should be run, then records the result in
6015// each TestSuite and TestInfo object.
6016// If shard_tests == true, further filters tests based on sharding
6017// variables in the environment - see
6018// https://github.com/google/googletest/blob/master/googletest/docs/advanced.md
6019// . Returns the number of tests that should run.
6020int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
6021 const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
6022 Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
6023 const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
6024 Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
6025
6026 // num_runnable_tests are the number of tests that will
6027 // run across all shards (i.e., match filter and are not disabled).
6028 // num_selected_tests are the number of tests to be run on
6029 // this shard.
6030 int num_runnable_tests = 0;
6031 int num_selected_tests = 0;
6032 for (auto* test_suite : test_suites_) {
6033 const std::string& test_suite_name = test_suite->name();
6034 test_suite->set_should_run(false);
6035
6036 for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
6037 TestInfo* const test_info = test_suite->test_info_list()[j];
6038 const std::string test_name(test_info->name());
6039 // A test is disabled if test suite name or test name matches
6040 // kDisableTestFilter.
6041 const bool is_disabled = internal::UnitTestOptions::MatchesFilter(
6042 test_suite_name, kDisableTestFilter) ||
6043 internal::UnitTestOptions::MatchesFilter(
6044 test_name, kDisableTestFilter);
6045 test_info->is_disabled_ = is_disabled;
6046
6047 const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest(
6048 test_suite_name, test_name);
6049 test_info->matches_filter_ = matches_filter;
6050
6051 const bool is_runnable =
6052 (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
6053 matches_filter;
6054
6055 const bool is_in_another_shard =
6056 shard_tests != IGNORE_SHARDING_PROTOCOL &&
6057 !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
6058 test_info->is_in_another_shard_ = is_in_another_shard;
6059 const bool is_selected = is_runnable && !is_in_another_shard;
6060
6061 num_runnable_tests += is_runnable;
6062 num_selected_tests += is_selected;
6063
6064 test_info->should_run_ = is_selected;
6065 test_suite->set_should_run(test_suite->should_run() || is_selected);
6066 }
6067 }
6068 return num_selected_tests;
6069}
6070
6071// Prints the given C-string on a single line by replacing all '\n'
6072// characters with string "\\n". If the output takes more than
6073// max_length characters, only prints the first max_length characters
6074// and "...".
6075static void PrintOnOneLine(const char* str, int max_length) {
6076 if (str != nullptr) {
6077 for (int i = 0; *str != '\0'; ++str) {
6078 if (i >= max_length) {
6079 printf("...");
6080 break;
6081 }
6082 if (*str == '\n') {
6083 printf("\\n");
6084 i += 2;
6085 } else {
6086 printf("%c", *str);
6087 ++i;
6088 }
6089 }
6090 }
6091}
6092
6093// Prints the names of the tests matching the user-specified filter flag.
6094void UnitTestImpl::ListTestsMatchingFilter() {
6095 // Print at most this many characters for each type/value parameter.
6096 const int kMaxParamLength = 250;
6097
6098 for (auto* test_suite : test_suites_) {
6099 bool printed_test_suite_name = false;
6100
6101 for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
6102 const TestInfo* const test_info = test_suite->test_info_list()[j];
6103 if (test_info->matches_filter_) {
6104 if (!printed_test_suite_name) {
6105 printed_test_suite_name = true;
6106 printf("%s.", test_suite->name());
6107 if (test_suite->type_param() != nullptr) {
6108 printf(" # %s = ", kTypeParamLabel);
6109 // We print the type parameter on a single line to make
6110 // the output easy to parse by a program.
6111 PrintOnOneLine(test_suite->type_param(), kMaxParamLength);
6112 }
6113 printf("\n");
6114 }
6115 printf(" %s", test_info->name());
6116 if (test_info->value_param() != nullptr) {
6117 printf(" # %s = ", kValueParamLabel);
6118 // We print the value parameter on a single line to make the
6119 // output easy to parse by a program.
6120 PrintOnOneLine(test_info->value_param(), kMaxParamLength);
6121 }
6122 printf("\n");
6123 }
6124 }
6125 }
6126 fflush(stdout);
6127 const std::string& output_format = UnitTestOptions::GetOutputFormat();
6128 if (output_format == "xml" || output_format == "json") {
6129 FILE* fileout = OpenFileForWriting(
6130 UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
6131 std::stringstream stream;
6132 if (output_format == "xml") {
6133 XmlUnitTestResultPrinter(
6134 UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
6135 .PrintXmlTestsList(&stream, test_suites_);
6136 } else if (output_format == "json") {
6137 JsonUnitTestResultPrinter(
6138 UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
6139 .PrintJsonTestList(&stream, test_suites_);
6140 }
6141 fprintf(fileout, "%s", StringStreamToString(&stream).c_str());
6142 fclose(fileout);
6143 }
6144}
6145
6146// Sets the OS stack trace getter.
6147//
6148// Does nothing if the input and the current OS stack trace getter are
6149// the same; otherwise, deletes the old getter and makes the input the
6150// current getter.
6151void UnitTestImpl::set_os_stack_trace_getter(
6152 OsStackTraceGetterInterface* getter) {
6153 if (os_stack_trace_getter_ != getter) {
6154 delete os_stack_trace_getter_;
6155 os_stack_trace_getter_ = getter;
6156 }
6157}
6158
6159// Returns the current OS stack trace getter if it is not NULL;
6160// otherwise, creates an OsStackTraceGetter, makes it the current
6161// getter, and returns it.
6162OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
6163 if (os_stack_trace_getter_ == nullptr) {
6164#ifdef GTEST_OS_STACK_TRACE_GETTER_
6165 os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
6166#else
6167 os_stack_trace_getter_ = new OsStackTraceGetter;
6168#endif // GTEST_OS_STACK_TRACE_GETTER_
6169 }
6170
6171 return os_stack_trace_getter_;
6172}
6173
6174// Returns the most specific TestResult currently running.
6175TestResult* UnitTestImpl::current_test_result() {
6176 if (current_test_info_ != nullptr) {
6177 return &current_test_info_->result_;
6178 }
6179 if (current_test_suite_ != nullptr) {
6180 return &current_test_suite_->ad_hoc_test_result_;
6181 }
6182 return &ad_hoc_test_result_;
6183}
6184
6185// Shuffles all test suites, and the tests within each test suite,
6186// making sure that death tests are still run first.
6187void UnitTestImpl::ShuffleTests() {
6188 // Shuffles the death test suites.
6189 ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
6190
6191 // Shuffles the non-death test suites.
6192 ShuffleRange(random(), last_death_test_suite_ + 1,
6193 static_cast<int>(test_suites_.size()), &test_suite_indices_);
6194
6195 // Shuffles the tests inside each test suite.
6196 for (auto& test_suite : test_suites_) {
6197 test_suite->ShuffleTests(random());
6198 }
6199}
6200
6201// Restores the test suites and tests to their order before the first shuffle.
6202void UnitTestImpl::UnshuffleTests() {
6203 for (size_t i = 0; i < test_suites_.size(); i++) {
6204 // Unshuffles the tests in each test suite.
6205 test_suites_[i]->UnshuffleTests();
6206 // Resets the index of each test suite.
6207 test_suite_indices_[i] = static_cast<int>(i);
6208 }
6209}
6210
6211// Returns the current OS stack trace as an std::string.
6212//
6213// The maximum number of stack frames to be included is specified by
6214// the gtest_stack_trace_depth flag. The skip_count parameter
6215// specifies the number of top frames to be skipped, which doesn't
6216// count against the number of frames to be included.
6217//
6218// For example, if Foo() calls Bar(), which in turn calls
6219// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
6220// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
6221std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
6222 int skip_count) {
6223 // We pass skip_count + 1 to skip this wrapper function in addition
6224 // to what the user really wants to skip.
6225 return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
6226}
6227
6228// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to
6229// suppress unreachable code warnings.
6230namespace {
6231class ClassUniqueToAlwaysTrue {};
6232}
6233
6234bool IsTrue(bool condition) { return condition; }
6235
6236bool AlwaysTrue() {
6237#if GTEST_HAS_EXCEPTIONS
6238 // This condition is always false so AlwaysTrue() never actually throws,
6239 // but it makes the compiler think that it may throw.
6240 if (IsTrue(false))
6241 throw ClassUniqueToAlwaysTrue();
6242#endif // GTEST_HAS_EXCEPTIONS
6243 return true;
6244}
6245
6246// If *pstr starts with the given prefix, modifies *pstr to be right
6247// past the prefix and returns true; otherwise leaves *pstr unchanged
6248// and returns false. None of pstr, *pstr, and prefix can be NULL.
6249bool SkipPrefix(const char* prefix, const char** pstr) {
6250 const size_t prefix_len = strlen(prefix);
6251 if (strncmp(*pstr, prefix, prefix_len) == 0) {
6252 *pstr += prefix_len;
6253 return true;
6254 }
6255 return false;
6256}
6257
6258// Parses a string as a command line flag. The string should have
6259// the format "--flag=value". When def_optional is true, the "=value"
6260// part can be omitted.
6261//
6262// Returns the value of the flag, or NULL if the parsing failed.
6263static const char* ParseFlagValue(const char* str, const char* flag,
6264 bool def_optional) {
6265 // str and flag must not be NULL.
6266 if (str == nullptr || flag == nullptr) return nullptr;
6267
6268 // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
6269 const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
6270 const size_t flag_len = flag_str.length();
6271 if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
6272
6273 // Skips the flag name.
6274 const char* flag_end = str + flag_len;
6275
6276 // When def_optional is true, it's OK to not have a "=value" part.
6277 if (def_optional && (flag_end[0] == '\0')) {
6278 return flag_end;
6279 }
6280
6281 // If def_optional is true and there are more characters after the
6282 // flag name, or if def_optional is false, there must be a '=' after
6283 // the flag name.
6284 if (flag_end[0] != '=') return nullptr;
6285
6286 // Returns the string after "=".
6287 return flag_end + 1;
6288}
6289
6290// Parses a string for a bool flag, in the form of either
6291// "--flag=value" or "--flag".
6292//
6293// In the former case, the value is taken as true as long as it does
6294// not start with '0', 'f', or 'F'.
6295//
6296// In the latter case, the value is taken as true.
6297//
6298// On success, stores the value of the flag in *value, and returns
6299// true. On failure, returns false without changing *value.
6300static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
6301 // Gets the value of the flag as a string.
6302 const char* const value_str = ParseFlagValue(str, flag, true);
6303
6304 // Aborts if the parsing failed.
6305 if (value_str == nullptr) return false;
6306
6307 // Converts the string value to a bool.
6308 *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
6309 return true;
6310}
6311
6312// Parses a string for an int32_t flag, in the form of "--flag=value".
6313//
6314// On success, stores the value of the flag in *value, and returns
6315// true. On failure, returns false without changing *value.
6316bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
6317 // Gets the value of the flag as a string.
6318 const char* const value_str = ParseFlagValue(str, flag, false);
6319
6320 // Aborts if the parsing failed.
6321 if (value_str == nullptr) return false;
6322
6323 // Sets *value to the value of the flag.
6324 return ParseInt32(Message() << "The value of flag --" << flag,
6325 value_str, value);
6326}
6327
6328// Parses a string for a string flag, in the form of "--flag=value".
6329//
6330// On success, stores the value of the flag in *value, and returns
6331// true. On failure, returns false without changing *value.
6332template <typename String>
6333static bool ParseStringFlag(const char* str, const char* flag, String* value) {
6334 // Gets the value of the flag as a string.
6335 const char* const value_str = ParseFlagValue(str, flag, false);
6336
6337 // Aborts if the parsing failed.
6338 if (value_str == nullptr) return false;
6339
6340 // Sets *value to the value of the flag.
6341 *value = value_str;
6342 return true;
6343}
6344
6345// Determines whether a string has a prefix that Google Test uses for its
6346// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.
6347// If Google Test detects that a command line flag has its prefix but is not
6348// recognized, it will print its help message. Flags starting with
6349// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
6350// internal flags and do not trigger the help message.
6351static bool HasGoogleTestFlagPrefix(const char* str) {
6352 return (SkipPrefix("--", &str) ||
6353 SkipPrefix("-", &str) ||
6354 SkipPrefix("/", &str)) &&
6355 !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
6356 (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
6357 SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
6358}
6359
6360// Prints a string containing code-encoded text. The following escape
6361// sequences can be used in the string to control the text color:
6362//
6363// @@ prints a single '@' character.
6364// @R changes the color to red.
6365// @G changes the color to green.
6366// @Y changes the color to yellow.
6367// @D changes to the default terminal text color.
6368//
6369static void PrintColorEncoded(const char* str) {
6370 GTestColor color = GTestColor::kDefault; // The current color.
6371
6372 // Conceptually, we split the string into segments divided by escape
6373 // sequences. Then we print one segment at a time. At the end of
6374 // each iteration, the str pointer advances to the beginning of the
6375 // next segment.
6376 for (;;) {
6377 const char* p = strchr(str, '@');
6378 if (p == nullptr) {
6379 ColoredPrintf(color, "%s", str);
6380 return;
6381 }
6382
6383 ColoredPrintf(color, "%s", std::string(str, p).c_str());
6384
6385 const char ch = p[1];
6386 str = p + 2;
6387 if (ch == '@') {
6388 ColoredPrintf(color, "@");
6389 } else if (ch == 'D') {
6390 color = GTestColor::kDefault;
6391 } else if (ch == 'R') {
6392 color = GTestColor::kRed;
6393 } else if (ch == 'G') {
6394 color = GTestColor::kGreen;
6395 } else if (ch == 'Y') {
6396 color = GTestColor::kYellow;
6397 } else {
6398 --str;
6399 }
6400 }
6401}
6402
6403static const char kColorEncodedHelpMessage[] =
6404 "This program contains tests written using " GTEST_NAME_
6405 ". You can use the\n"
6406 "following command line flags to control its behavior:\n"
6407 "\n"
6408 "Test Selection:\n"
6409 " @G--" GTEST_FLAG_PREFIX_
6410 "list_tests@D\n"
6411 " List the names of all tests instead of running them. The name of\n"
6412 " TEST(Foo, Bar) is \"Foo.Bar\".\n"
6413 " @G--" GTEST_FLAG_PREFIX_
6414 "filter=@YPOSITIVE_PATTERNS"
6415 "[@G-@YNEGATIVE_PATTERNS]@D\n"
6416 " Run only the tests whose name matches one of the positive patterns "
6417 "but\n"
6418 " none of the negative patterns. '?' matches any single character; "
6419 "'*'\n"
6420 " matches any substring; ':' separates two patterns.\n"
6421 " @G--" GTEST_FLAG_PREFIX_
6422 "also_run_disabled_tests@D\n"
6423 " Run all disabled tests too.\n"
6424 "\n"
6425 "Test Execution:\n"
6426 " @G--" GTEST_FLAG_PREFIX_
6427 "repeat=@Y[COUNT]@D\n"
6428 " Run the tests repeatedly; use a negative count to repeat forever.\n"
6429 " @G--" GTEST_FLAG_PREFIX_
6430 "shuffle@D\n"
6431 " Randomize tests' orders on every iteration.\n"
6432 " @G--" GTEST_FLAG_PREFIX_
6433 "random_seed=@Y[NUMBER]@D\n"
6434 " Random number seed to use for shuffling test orders (between 1 and\n"
6435 " 99999, or 0 to use a seed based on the current time).\n"
6436 "\n"
6437 "Test Output:\n"
6438 " @G--" GTEST_FLAG_PREFIX_
6439 "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
6440 " Enable/disable colored output. The default is @Gauto@D.\n"
6441 " @G--" GTEST_FLAG_PREFIX_
6442 "brief=1@D\n"
6443 " Only print test failures.\n"
6444 " @G--" GTEST_FLAG_PREFIX_
6445 "print_time=0@D\n"
6446 " Don't print the elapsed time of each test.\n"
6447 " @G--" GTEST_FLAG_PREFIX_
6448 "output=@Y(@Gjson@Y|@Gxml@Y)[@G:@YDIRECTORY_PATH@G" GTEST_PATH_SEP_
6449 "@Y|@G:@YFILE_PATH]@D\n"
6450 " Generate a JSON or XML report in the given directory or with the "
6451 "given\n"
6452 " file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n"
6453# if GTEST_CAN_STREAM_RESULTS_
6454 " @G--" GTEST_FLAG_PREFIX_
6455 "stream_result_to=@YHOST@G:@YPORT@D\n"
6456 " Stream test results to the given server.\n"
6457# endif // GTEST_CAN_STREAM_RESULTS_
6458 "\n"
6459 "Assertion Behavior:\n"
6460# if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
6461 " @G--" GTEST_FLAG_PREFIX_
6462 "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
6463 " Set the default death test style.\n"
6464# endif // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
6465 " @G--" GTEST_FLAG_PREFIX_
6466 "break_on_failure@D\n"
6467 " Turn assertion failures into debugger break-points.\n"
6468 " @G--" GTEST_FLAG_PREFIX_
6469 "throw_on_failure@D\n"
6470 " Turn assertion failures into C++ exceptions for use by an external\n"
6471 " test framework.\n"
6472 " @G--" GTEST_FLAG_PREFIX_
6473 "catch_exceptions=0@D\n"
6474 " Do not report exceptions as test failures. Instead, allow them\n"
6475 " to crash the program or throw a pop-up (on Windows).\n"
6476 "\n"
6477 "Except for @G--" GTEST_FLAG_PREFIX_
6478 "list_tests@D, you can alternatively set "
6479 "the corresponding\n"
6480 "environment variable of a flag (all letters in upper-case). For example, "
6481 "to\n"
6482 "disable colored text output, you can either specify "
6483 "@G--" GTEST_FLAG_PREFIX_
6484 "color=no@D or set\n"
6485 "the @G" GTEST_FLAG_PREFIX_UPPER_
6486 "COLOR@D environment variable to @Gno@D.\n"
6487 "\n"
6488 "For more information, please read the " GTEST_NAME_
6489 " documentation at\n"
6490 "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_
6491 "\n"
6492 "(not one in your own code or tests), please report it to\n"
6493 "@G<" GTEST_DEV_EMAIL_ ">@D.\n";
6494
6495static bool ParseGoogleTestFlag(const char* const arg) {
6496 return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
6497 &GTEST_FLAG(also_run_disabled_tests)) ||
6498 ParseBoolFlag(arg, kBreakOnFailureFlag,
6499 &GTEST_FLAG(break_on_failure)) ||
6500 ParseBoolFlag(arg, kCatchExceptionsFlag,
6501 &GTEST_FLAG(catch_exceptions)) ||
6502 ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
6503 ParseStringFlag(arg, kDeathTestStyleFlag,
6504 &GTEST_FLAG(death_test_style)) ||
6505 ParseBoolFlag(arg, kDeathTestUseFork,
6506 &GTEST_FLAG(death_test_use_fork)) ||
6507 ParseBoolFlag(arg, kFailFast, &GTEST_FLAG(fail_fast)) ||
6508 ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
6509 ParseStringFlag(arg, kInternalRunDeathTestFlag,
6510 &GTEST_FLAG(internal_run_death_test)) ||
6511 ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
6512 ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
6513 ParseBoolFlag(arg, kBriefFlag, &GTEST_FLAG(brief)) ||
6514 ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
6515 ParseBoolFlag(arg, kPrintUTF8Flag, &GTEST_FLAG(print_utf8)) ||
6516 ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
6517 ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
6518 ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
6519 ParseInt32Flag(arg, kStackTraceDepthFlag,
6520 &GTEST_FLAG(stack_trace_depth)) ||
6521 ParseStringFlag(arg, kStreamResultToFlag,
6522 &GTEST_FLAG(stream_result_to)) ||
6523 ParseBoolFlag(arg, kThrowOnFailureFlag, &GTEST_FLAG(throw_on_failure));
6524}
6525
6526#if GTEST_USE_OWN_FLAGFILE_FLAG_
6527static void LoadFlagsFromFile(const std::string& path) {
6528 FILE* flagfile = posix::FOpen(path.c_str(), "r");
6529 if (!flagfile) {
6530 GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG(flagfile)
6531 << "\"";
6532 }
6533 std::string contents(ReadEntireFile(flagfile));
6534 posix::FClose(flagfile);
6535 std::vector<std::string> lines;
6536 SplitString(contents, '\n', &lines);
6537 for (size_t i = 0; i < lines.size(); ++i) {
6538 if (lines[i].empty())
6539 continue;
6540 if (!ParseGoogleTestFlag(lines[i].c_str()))
6541 g_help_flag = true;
6542 }
6543}
6544#endif // GTEST_USE_OWN_FLAGFILE_FLAG_
6545
6546// Parses the command line for Google Test flags, without initializing
6547// other parts of Google Test. The type parameter CharType can be
6548// instantiated to either char or wchar_t.
6549template <typename CharType>
6550void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
6551 for (int i = 1; i < *argc; i++) {
6552 const std::string arg_string = StreamableToString(argv[i]);
6553 const char* const arg = arg_string.c_str();
6554
6555 using internal::ParseBoolFlag;
6556 using internal::ParseInt32Flag;
6557 using internal::ParseStringFlag;
6558
6559 bool remove_flag = false;
6560 if (ParseGoogleTestFlag(arg)) {
6561 remove_flag = true;
6562#if GTEST_USE_OWN_FLAGFILE_FLAG_
6563 } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
6564 LoadFlagsFromFile(GTEST_FLAG(flagfile));
6565 remove_flag = true;
6566#endif // GTEST_USE_OWN_FLAGFILE_FLAG_
6567 } else if (arg_string == "--help" || arg_string == "-h" ||
6568 arg_string == "-?" || arg_string == "/?" ||
6569 HasGoogleTestFlagPrefix(arg)) {
6570 // Both help flag and unrecognized Google Test flags (excluding
6571 // internal ones) trigger help display.
6572 g_help_flag = true;
6573 }
6574
6575 if (remove_flag) {
6576 // Shift the remainder of the argv list left by one. Note
6577 // that argv has (*argc + 1) elements, the last one always being
6578 // NULL. The following loop moves the trailing NULL element as
6579 // well.
6580 for (int j = i; j != *argc; j++) {
6581 argv[j] = argv[j + 1];
6582 }
6583
6584 // Decrements the argument count.
6585 (*argc)--;
6586
6587 // We also need to decrement the iterator as we just removed
6588 // an element.
6589 i--;
6590 }
6591 }
6592
6593 if (g_help_flag) {
6594 // We print the help here instead of in RUN_ALL_TESTS(), as the
6595 // latter may not be called at all if the user is using Google
6596 // Test with another testing framework.
6597 PrintColorEncoded(kColorEncodedHelpMessage);
6598 }
6599}
6600
6601// Parses the command line for Google Test flags, without initializing
6602// other parts of Google Test.
6603void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
6604 ParseGoogleTestFlagsOnlyImpl(argc, argv);
6605
6606 // Fix the value of *_NSGetArgc() on macOS, but if and only if
6607 // *_NSGetArgv() == argv
6608 // Only applicable to char** version of argv
6609#if GTEST_OS_MAC
6610#ifndef GTEST_OS_IOS
6611 if (*_NSGetArgv() == argv) {
6612 *_NSGetArgc() = *argc;
6613 }
6614#endif
6615#endif
6616}
6617void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
6618 ParseGoogleTestFlagsOnlyImpl(argc, argv);
6619}
6620
6621// The internal implementation of InitGoogleTest().
6622//
6623// The type parameter CharType can be instantiated to either char or
6624// wchar_t.
6625template <typename CharType>
6626void InitGoogleTestImpl(int* argc, CharType** argv) {
6627 // We don't want to run the initialization code twice.
6628 if (GTestIsInitialized()) return;
6629
6630 if (*argc <= 0) return;
6631
6632 g_argvs.clear();
6633 for (int i = 0; i != *argc; i++) {
6634 g_argvs.push_back(StreamableToString(argv[i]));
6635 }
6636
6637#if GTEST_HAS_ABSL
6638 absl::InitializeSymbolizer(g_argvs[0].c_str());
6639#endif // GTEST_HAS_ABSL
6640
6641 ParseGoogleTestFlagsOnly(argc, argv);
6642 GetUnitTestImpl()->PostFlagParsingInit();
6643}
6644
6645} // namespace internal
6646
6647// Initializes Google Test. This must be called before calling
6648// RUN_ALL_TESTS(). In particular, it parses a command line for the
6649// flags that Google Test recognizes. Whenever a Google Test flag is
6650// seen, it is removed from argv, and *argc is decremented.
6651//
6652// No value is returned. Instead, the Google Test flag variables are
6653// updated.
6654//
6655// Calling the function for the second time has no user-visible effect.
6656void InitGoogleTest(int* argc, char** argv) {
6657#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6658 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
6659#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6660 internal::InitGoogleTestImpl(argc, argv);
6661#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6662}
6663
6664// This overloaded version can be used in Windows programs compiled in
6665// UNICODE mode.
6666void InitGoogleTest(int* argc, wchar_t** argv) {
6667#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6668 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
6669#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6670 internal::InitGoogleTestImpl(argc, argv);
6671#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6672}
6673
6674// This overloaded version can be used on Arduino/embedded platforms where
6675// there is no argc/argv.
6676void InitGoogleTest() {
6677 // Since Arduino doesn't have a command line, fake out the argc/argv arguments
6678 int argc = 1;
6679 const auto arg0 = "dummy";
6680 char* argv0 = const_cast<char*>(arg0);
6681 char** argv = &argv0;
6682
6683#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6684 GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
6685#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6686 internal::InitGoogleTestImpl(&argc, argv);
6687#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
6688}
6689
6690std::string TempDir() {
6691#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
6692 return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
6693#elif GTEST_OS_WINDOWS_MOBILE
6694 return "\\temp\\";
6695#elif GTEST_OS_WINDOWS
6696 const char* temp_dir = internal::posix::GetEnv("TEMP");
6697 if (temp_dir == nullptr || temp_dir[0] == '\0') {
6698 return "\\temp\\";
6699 } else if (temp_dir[strlen(temp_dir) - 1] == '\\') {
6700 return temp_dir;
6701 } else {
6702 return std::string(temp_dir) + "\\";
6703 }
6704#elif GTEST_OS_LINUX_ANDROID
6705 const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
6706 if (temp_dir == nullptr || temp_dir[0] == '\0') {
6707 return "/data/local/tmp/";
6708 } else {
6709 return temp_dir;
6710 }
6711#elif GTEST_OS_LINUX
6712 const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
6713 if (temp_dir == nullptr || temp_dir[0] == '\0') {
6714 return "/tmp/";
6715 } else {
6716 return temp_dir;
6717 }
6718#else
6719 return "/tmp/";
6720#endif // GTEST_OS_WINDOWS_MOBILE
6721}
6722
6723// Class ScopedTrace
6724
6725// Pushes the given source file location and message onto a per-thread
6726// trace stack maintained by Google Test.
6727void ScopedTrace::PushTrace(const char* file, int line, std::string message) {
6728 internal::TraceInfo trace;
6729 trace.file = file;
6730 trace.line = line;
6731 trace.message.swap(message);
6732
6733 UnitTest::GetInstance()->PushGTestTrace(trace);
6734}
6735
6736// Pops the info pushed by the c'tor.
6737ScopedTrace::~ScopedTrace()
6738 GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
6739 UnitTest::GetInstance()->PopGTestTrace();
6740}
6741
6742} // namespace testing
Definition gtest.h:1158
Definition gtest.h:1093
Definition gtest.h:704
Definition gtest.h:571
Definition gtest.h:842
Definition gtest.h:1274
Definition gtest.cc:3751
Definition gtest.cc:5667
Definition gtest.cc:1035