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// Author: wan@google.com (Zhanyong Wan) 31// 32// The Google C++ Testing Framework (Google Test) 33 34#include "gtest/gtest.h" 35#include "gtest/gtest-spi.h" 36 37#include <ctype.h> 38#include <math.h> 39#include <stdarg.h> 40#include <stdio.h> 41#include <stdlib.h> 42#include <wchar.h> 43#include <wctype.h> 44 45#include <algorithm> 46#include <ostream> // NOLINT 47#include <sstream> 48#include <vector> 49 50#if GTEST_OS_LINUX 51 52// TODO(kenton@google.com): Use autoconf to detect availability of 53// gettimeofday(). 54# define GTEST_HAS_GETTIMEOFDAY_ 1 55 56# include <fcntl.h> // NOLINT 57# include <limits.h> // NOLINT 58# include <sched.h> // NOLINT 59// Declares vsnprintf(). This header is not available on Windows. 60# include <strings.h> // NOLINT 61# include <sys/mman.h> // NOLINT 62# include <sys/time.h> // NOLINT 63# include <unistd.h> // NOLINT 64# include <string> 65 66#elif GTEST_OS_SYMBIAN 67# define GTEST_HAS_GETTIMEOFDAY_ 1 68# include <sys/time.h> // NOLINT 69 70#elif GTEST_OS_ZOS 71# define GTEST_HAS_GETTIMEOFDAY_ 1 72# include <sys/time.h> // NOLINT 73 74// On z/OS we additionally need strings.h for strcasecmp. 75# include <strings.h> // NOLINT 76 77#elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE. 78 79# include <windows.h> // NOLINT 80 81#elif GTEST_OS_WINDOWS // We are on Windows proper. 82 83# include <io.h> // NOLINT 84# include <sys/timeb.h> // NOLINT 85# include <sys/types.h> // NOLINT 86# include <sys/stat.h> // NOLINT 87 88# if GTEST_OS_WINDOWS_MINGW 89// MinGW has gettimeofday() but not _ftime64(). 90// TODO(kenton@google.com): Use autoconf to detect availability of 91// gettimeofday(). 92// TODO(kenton@google.com): There are other ways to get the time on 93// Windows, like GetTickCount() or GetSystemTimeAsFileTime(). MinGW 94// supports these. consider using them instead. 95# define GTEST_HAS_GETTIMEOFDAY_ 1 96# include <sys/time.h> // NOLINT 97# endif // GTEST_OS_WINDOWS_MINGW 98 99// cpplint thinks that the header is already included, so we want to 100// silence it. 101# include <windows.h> // NOLINT 102 103#else 104 105// Assume other platforms have gettimeofday(). 106// TODO(kenton@google.com): Use autoconf to detect availability of 107// gettimeofday(). 108# define GTEST_HAS_GETTIMEOFDAY_ 1 109 110// cpplint thinks that the header is already included, so we want to 111// silence it. 112# include <sys/time.h> // NOLINT 113# include <unistd.h> // NOLINT 114 115#endif // GTEST_OS_LINUX 116 117#if GTEST_HAS_EXCEPTIONS 118# include <stdexcept> 119#endif 120 121#if GTEST_CAN_STREAM_RESULTS_ 122# include <arpa/inet.h> // NOLINT 123# include <netdb.h> // NOLINT 124#endif 125 126// Indicates that this translation unit is part of Google Test's 127// implementation. It must come before gtest-internal-inl.h is 128// included, or there will be a compiler error. This trick is to 129// prevent a user from accidentally including gtest-internal-inl.h in 130// his code. 131#define GTEST_IMPLEMENTATION_ 1 132#include "src/gtest-internal-inl.h" 133#undef GTEST_IMPLEMENTATION_ 134 135#if GTEST_OS_WINDOWS 136# define vsnprintf _vsnprintf 137#endif // GTEST_OS_WINDOWS 138 139namespace testing { 140 141using internal::CountIf; 142using internal::ForEach; 143using internal::GetElementOr; 144using internal::Shuffle; 145 146// Constants. 147 148// A test whose test case name or test name matches this filter is 149// disabled and not run. 150static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*"; 151 152// A test case whose name matches this filter is considered a death 153// test case and will be run before test cases whose name doesn't 154// match this filter. 155static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*"; 156 157// A test filter that matches everything. 158static const char kUniversalFilter[] = "*"; 159 160// The default output file for XML output. 161static const char kDefaultOutputFile[] = "test_detail.xml"; 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 iff the --help flag or an equivalent form is 177// specified on the command line. 178bool g_help_flag = false; 179 180} // namespace internal 181 182GTEST_DEFINE_bool_( 183 also_run_disabled_tests, 184 internal::BoolFromGTestEnv("also_run_disabled_tests", false), 185 "Run disabled tests too, in addition to the tests normally being run."); 186 187GTEST_DEFINE_bool_( 188 break_on_failure, 189 internal::BoolFromGTestEnv("break_on_failure", false), 190 "True iff a failed assertion should be a debugger break-point."); 191 192GTEST_DEFINE_bool_( 193 catch_exceptions, 194 internal::BoolFromGTestEnv("catch_exceptions", true), 195 "True iff " GTEST_NAME_ 196 " should catch exceptions and treat them as test failures."); 197 198GTEST_DEFINE_string_( 199 color, 200 internal::StringFromGTestEnv("color", "auto"), 201 "Whether to use colors in the output. Valid values: yes, no, " 202 "and auto. 'auto' means to use colors if the output is " 203 "being sent to a terminal and the TERM environment variable " 204 "is set to xterm, xterm-color, xterm-256color, linux or cygwin."); 205 206GTEST_DEFINE_string_( 207 filter, 208 internal::StringFromGTestEnv("filter", kUniversalFilter), 209 "A colon-separated list of glob (not regex) patterns " 210 "for filtering the tests to run, optionally followed by a " 211 "'-' and a : separated list of negative patterns (tests to " 212 "exclude). A test is run if it matches one of the positive " 213 "patterns and does not match any of the negative patterns."); 214 215GTEST_DEFINE_bool_(list_tests, false, 216 "List all tests without running them."); 217 218GTEST_DEFINE_string_( 219 output, 220 internal::StringFromGTestEnv("output", ""), 221 "A format (currently must be \"xml\"), optionally followed " 222 "by a colon and an output file name or directory. A directory " 223 "is indicated by a trailing pathname separator. " 224 "Examples: \"xml:filename.xml\", \"xml::directoryname/\". " 225 "If a directory is specified, output files will be created " 226 "within that directory, with file-names based on the test " 227 "executable's name and, if necessary, made unique by adding " 228 "digits."); 229 230GTEST_DEFINE_bool_( 231 print_time, 232 internal::BoolFromGTestEnv("print_time", true), 233 "True iff " GTEST_NAME_ 234 " should display elapsed time in text output."); 235 236GTEST_DEFINE_int32_( 237 random_seed, 238 internal::Int32FromGTestEnv("random_seed", 0), 239 "Random number seed to use when shuffling test orders. Must be in range " 240 "[1, 99999], or 0 to use a seed based on the current time."); 241 242GTEST_DEFINE_int32_( 243 repeat, 244 internal::Int32FromGTestEnv("repeat", 1), 245 "How many times to repeat each test. Specify a negative number " 246 "for repeating forever. Useful for shaking out flaky tests."); 247 248GTEST_DEFINE_bool_( 249 show_internal_stack_frames, false, 250 "True iff " GTEST_NAME_ " should include internal stack frames when " 251 "printing test failure stack traces."); 252 253GTEST_DEFINE_bool_( 254 shuffle, 255 internal::BoolFromGTestEnv("shuffle", false), 256 "True iff " GTEST_NAME_ 257 " should randomize tests' order on every run."); 258 259GTEST_DEFINE_int32_( 260 stack_trace_depth, 261 internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth), 262 "The maximum number of stack frames to print when an " 263 "assertion fails. The valid range is 0 through 100, inclusive."); 264 265GTEST_DEFINE_string_( 266 stream_result_to, 267 internal::StringFromGTestEnv("stream_result_to", ""), 268 "This flag specifies the host name and the port number on which to stream " 269 "test results. Example: \"localhost:555\". The flag is effective only on " 270 "Linux."); 271 272GTEST_DEFINE_bool_( 273 throw_on_failure, 274 internal::BoolFromGTestEnv("throw_on_failure", false), 275 "When this flag is specified, a failed assertion will throw an exception " 276 "if exceptions are enabled or exit the program with a non-zero code " 277 "otherwise."); 278 279namespace internal { 280 281// Generates a random number from [0, range), using a Linear 282// Congruential Generator (LCG). Crashes if 'range' is 0 or greater 283// than kMaxRange. 284UInt32 Random::Generate(UInt32 range) { 285 // These constants are the same as are used in glibc's rand(3). 286 state_ = (1103515245U*state_ + 12345U) % kMaxRange; 287 288 GTEST_CHECK_(range > 0) 289 << "Cannot generate a number in the range [0, 0)."; 290 GTEST_CHECK_(range <= kMaxRange) 291 << "Generation of a number in [0, " << range << ") was requested, " 292 << "but this can only generate numbers in [0, " << kMaxRange << ")."; 293 294 // Converting via modulus introduces a bit of downward bias, but 295 // it's simple, and a linear congruential generator isn't too good 296 // to begin with. 297 return state_ % range; 298} 299 300// GTestIsInitialized() returns true iff the user has initialized 301// Google Test. Useful for catching the user mistake of not initializing 302// Google Test before calling RUN_ALL_TESTS(). 303// 304// A user must call testing::InitGoogleTest() to initialize Google 305// Test. g_init_gtest_count is set to the number of times 306// InitGoogleTest() has been called. We don't protect this variable 307// under a mutex as it is only accessed in the main thread. 308int g_init_gtest_count = 0; 309static bool GTestIsInitialized() { return g_init_gtest_count != 0; } 310 311// Iterates over a vector of TestCases, keeping a running sum of the 312// results of calling a given int-returning method on each. 313// Returns the sum. 314static int SumOverTestCaseList(const std::vector<TestCase*>& case_list, 315 int (TestCase::*method)() const) { 316 int sum = 0; 317 for (size_t i = 0; i < case_list.size(); i++) { 318 sum += (case_list[i]->*method)(); 319 } 320 return sum; 321} 322 323// Returns true iff the test case passed. 324static bool TestCasePassed(const TestCase* test_case) { 325 return test_case->should_run() && test_case->Passed(); 326} 327 328// Returns true iff the test case failed. 329static bool TestCaseFailed(const TestCase* test_case) { 330 return test_case->should_run() && test_case->Failed(); 331} 332 333// Returns true iff test_case contains at least one test that should 334// run. 335static bool ShouldRunTestCase(const TestCase* test_case) { 336 return test_case->should_run(); 337} 338 339// AssertHelper constructor. 340AssertHelper::AssertHelper(TestPartResult::Type type, 341 const char* file, 342 int line, 343 const char* message) 344 : data_(new AssertHelperData(type, file, line, message)) { 345} 346 347AssertHelper::~AssertHelper() { 348 delete data_; 349} 350 351// Message assignment, for assertion streaming support. 352void AssertHelper::operator=(const Message& message) const { 353 UnitTest::GetInstance()-> 354 AddTestPartResult(data_->type, data_->file, data_->line, 355 AppendUserMessage(data_->message, message), 356 UnitTest::GetInstance()->impl() 357 ->CurrentOsStackTraceExceptTop(1) 358 // Skips the stack frame for this function itself. 359 ); // NOLINT 360} 361 362// Mutex for linked pointers. 363GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex); 364 365// Application pathname gotten in InitGoogleTest. 366String g_executable_path; 367 368// Returns the current application's name, removing directory path if that 369// is present. 370FilePath GetCurrentExecutableName() { 371 FilePath result; 372 373#if GTEST_OS_WINDOWS 374 result.Set(FilePath(g_executable_path).RemoveExtension("exe")); 375#else 376 result.Set(FilePath(g_executable_path)); 377#endif // GTEST_OS_WINDOWS 378 379 return result.RemoveDirectoryName(); 380} 381 382// Functions for processing the gtest_output flag. 383 384// Returns the output format, or "" for normal printed output. 385String UnitTestOptions::GetOutputFormat() { 386 const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); 387 if (gtest_output_flag == NULL) return String(""); 388 389 const char* const colon = strchr(gtest_output_flag, ':'); 390 return (colon == NULL) ? 391 String(gtest_output_flag) : 392 String(gtest_output_flag, colon - gtest_output_flag); 393} 394 395// Returns the name of the requested output file, or the default if none 396// was explicitly specified. 397String UnitTestOptions::GetAbsolutePathToOutputFile() { 398 const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); 399 if (gtest_output_flag == NULL) 400 return String(""); 401 402 const char* const colon = strchr(gtest_output_flag, ':'); 403 if (colon == NULL) 404 return String(internal::FilePath::ConcatPaths( 405 internal::FilePath( 406 UnitTest::GetInstance()->original_working_dir()), 407 internal::FilePath(kDefaultOutputFile)).ToString() ); 408 409 internal::FilePath output_name(colon + 1); 410 if (!output_name.IsAbsolutePath()) 411 // TODO(wan@google.com): on Windows \some\path is not an absolute 412 // path (as its meaning depends on the current drive), yet the 413 // following logic for turning it into an absolute path is wrong. 414 // Fix it. 415 output_name = internal::FilePath::ConcatPaths( 416 internal::FilePath(UnitTest::GetInstance()->original_working_dir()), 417 internal::FilePath(colon + 1)); 418 419 if (!output_name.IsDirectory()) 420 return output_name.ToString(); 421 422 internal::FilePath result(internal::FilePath::GenerateUniqueFileName( 423 output_name, internal::GetCurrentExecutableName(), 424 GetOutputFormat().c_str())); 425 return result.ToString(); 426} 427 428// Returns true iff the wildcard pattern matches the string. The 429// first ':' or '\0' character in pattern marks the end of it. 430// 431// This recursive algorithm isn't very efficient, but is clear and 432// works well enough for matching test names, which are short. 433bool UnitTestOptions::PatternMatchesString(const char *pattern, 434 const char *str) { 435 switch (*pattern) { 436 case '\0': 437 case ':': // Either ':' or '\0' marks the end of the pattern. 438 return *str == '\0'; 439 case '?': // Matches any single character. 440 return *str != '\0' && PatternMatchesString(pattern + 1, str + 1); 441 case '*': // Matches any string (possibly empty) of characters. 442 return (*str != '\0' && PatternMatchesString(pattern, str + 1)) || 443 PatternMatchesString(pattern + 1, str); 444 default: // Non-special character. Matches itself. 445 return *pattern == *str && 446 PatternMatchesString(pattern + 1, str + 1); 447 } 448} 449 450bool UnitTestOptions::MatchesFilter(const String& name, const char* filter) { 451 const char *cur_pattern = filter; 452 for (;;) { 453 if (PatternMatchesString(cur_pattern, name.c_str())) { 454 return true; 455 } 456 457 // Finds the next pattern in the filter. 458 cur_pattern = strchr(cur_pattern, ':'); 459 460 // Returns if no more pattern can be found. 461 if (cur_pattern == NULL) { 462 return false; 463 } 464 465 // Skips the pattern separater (the ':' character). 466 cur_pattern++; 467 } 468} 469 470// TODO(keithray): move String function implementations to gtest-string.cc. 471 472// Returns true iff the user-specified filter matches the test case 473// name and the test name. 474bool UnitTestOptions::FilterMatchesTest(const String &test_case_name, 475 const String &test_name) { 476 const String& full_name = String::Format("%s.%s", 477 test_case_name.c_str(), 478 test_name.c_str()); 479 480 // Split --gtest_filter at '-', if there is one, to separate into 481 // positive filter and negative filter portions 482 const char* const p = GTEST_FLAG(filter).c_str(); 483 const char* const dash = strchr(p, '-'); 484 String positive; 485 String negative; 486 if (dash == NULL) { 487 positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter 488 negative = String(""); 489 } else { 490 positive = String(p, dash - p); // Everything up to the dash 491 negative = String(dash+1); // Everything after the dash 492 if (positive.empty()) { 493 // Treat '-test1' as the same as '*-test1' 494 positive = kUniversalFilter; 495 } 496 } 497 498 // A filter is a colon-separated list of patterns. It matches a 499 // test if any pattern in it matches the test. 500 return (MatchesFilter(full_name, positive.c_str()) && 501 !MatchesFilter(full_name, negative.c_str())); 502} 503 504#if GTEST_HAS_SEH 505// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the 506// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. 507// This function is useful as an __except condition. 508int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) { 509 // Google Test should handle a SEH exception if: 510 // 1. the user wants it to, AND 511 // 2. this is not a breakpoint exception, AND 512 // 3. this is not a C++ exception (VC++ implements them via SEH, 513 // apparently). 514 // 515 // SEH exception code for C++ exceptions. 516 // (see http://support.microsoft.com/kb/185294 for more information). 517 const DWORD kCxxExceptionCode = 0xe06d7363; 518 519 bool should_handle = true; 520 521 if (!GTEST_FLAG(catch_exceptions)) 522 should_handle = false; 523 else if (exception_code == EXCEPTION_BREAKPOINT) 524 should_handle = false; 525 else if (exception_code == kCxxExceptionCode) 526 should_handle = false; 527 528 return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH; 529} 530#endif // GTEST_HAS_SEH 531 532} // namespace internal 533 534// The c'tor sets this object as the test part result reporter used by 535// Google Test. The 'result' parameter specifies where to report the 536// results. Intercepts only failures from the current thread. 537ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( 538 TestPartResultArray* result) 539 : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD), 540 result_(result) { 541 Init(); 542} 543 544// The c'tor sets this object as the test part result reporter used by 545// Google Test. The 'result' parameter specifies where to report the 546// results. 547ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( 548 InterceptMode intercept_mode, TestPartResultArray* result) 549 : intercept_mode_(intercept_mode), 550 result_(result) { 551 Init(); 552} 553 554void ScopedFakeTestPartResultReporter::Init() { 555 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 556 if (intercept_mode_ == INTERCEPT_ALL_THREADS) { 557 old_reporter_ = impl->GetGlobalTestPartResultReporter(); 558 impl->SetGlobalTestPartResultReporter(this); 559 } else { 560 old_reporter_ = impl->GetTestPartResultReporterForCurrentThread(); 561 impl->SetTestPartResultReporterForCurrentThread(this); 562 } 563} 564 565// The d'tor restores the test part result reporter used by Google Test 566// before. 567ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() { 568 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 569 if (intercept_mode_ == INTERCEPT_ALL_THREADS) { 570 impl->SetGlobalTestPartResultReporter(old_reporter_); 571 } else { 572 impl->SetTestPartResultReporterForCurrentThread(old_reporter_); 573 } 574} 575 576// Increments the test part result count and remembers the result. 577// This method is from the TestPartResultReporterInterface interface. 578void ScopedFakeTestPartResultReporter::ReportTestPartResult( 579 const TestPartResult& result) { 580 result_->Append(result); 581} 582 583namespace internal { 584 585// Returns the type ID of ::testing::Test. We should always call this 586// instead of GetTypeId< ::testing::Test>() to get the type ID of 587// testing::Test. This is to work around a suspected linker bug when 588// using Google Test as a framework on Mac OS X. The bug causes 589// GetTypeId< ::testing::Test>() to return different values depending 590// on whether the call is from the Google Test framework itself or 591// from user test code. GetTestTypeId() is guaranteed to always 592// return the same value, as it always calls GetTypeId<>() from the 593// gtest.cc, which is within the Google Test framework. 594TypeId GetTestTypeId() { 595 return GetTypeId<Test>(); 596} 597 598// The value of GetTestTypeId() as seen from within the Google Test 599// library. This is solely for testing GetTestTypeId(). 600extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId(); 601 602// This predicate-formatter checks that 'results' contains a test part 603// failure of the given type and that the failure message contains the 604// given substring. 605AssertionResult HasOneFailure(const char* /* results_expr */, 606 const char* /* type_expr */, 607 const char* /* substr_expr */, 608 const TestPartResultArray& results, 609 TestPartResult::Type type, 610 const string& substr) { 611 const String expected(type == TestPartResult::kFatalFailure ? 612 "1 fatal failure" : 613 "1 non-fatal failure"); 614 Message msg; 615 if (results.size() != 1) { 616 msg << "Expected: " << expected << "\n" 617 << " Actual: " << results.size() << " failures"; 618 for (int i = 0; i < results.size(); i++) { 619 msg << "\n" << results.GetTestPartResult(i); 620 } 621 return AssertionFailure() << msg; 622 } 623 624 const TestPartResult& r = results.GetTestPartResult(0); 625 if (r.type() != type) { 626 return AssertionFailure() << "Expected: " << expected << "\n" 627 << " Actual:\n" 628 << r; 629 } 630 631 if (strstr(r.message(), substr.c_str()) == NULL) { 632 return AssertionFailure() << "Expected: " << expected << " containing \"" 633 << substr << "\"\n" 634 << " Actual:\n" 635 << r; 636 } 637 638 return AssertionSuccess(); 639} 640 641// The constructor of SingleFailureChecker remembers where to look up 642// test part results, what type of failure we expect, and what 643// substring the failure message should contain. 644SingleFailureChecker:: SingleFailureChecker( 645 const TestPartResultArray* results, 646 TestPartResult::Type type, 647 const string& substr) 648 : results_(results), 649 type_(type), 650 substr_(substr) {} 651 652// The destructor of SingleFailureChecker verifies that the given 653// TestPartResultArray contains exactly one failure that has the given 654// type and contains the given substring. If that's not the case, a 655// non-fatal failure will be generated. 656SingleFailureChecker::~SingleFailureChecker() { 657 EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_); 658} 659 660DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter( 661 UnitTestImpl* unit_test) : unit_test_(unit_test) {} 662 663void DefaultGlobalTestPartResultReporter::ReportTestPartResult( 664 const TestPartResult& result) { 665 unit_test_->current_test_result()->AddTestPartResult(result); 666 unit_test_->listeners()->repeater()->OnTestPartResult(result); 667} 668 669DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter( 670 UnitTestImpl* unit_test) : unit_test_(unit_test) {} 671 672void DefaultPerThreadTestPartResultReporter::ReportTestPartResult( 673 const TestPartResult& result) { 674 unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result); 675} 676 677// Returns the global test part result reporter. 678TestPartResultReporterInterface* 679UnitTestImpl::GetGlobalTestPartResultReporter() { 680 internal::MutexLock lock(&global_test_part_result_reporter_mutex_); 681 return global_test_part_result_repoter_; 682} 683 684// Sets the global test part result reporter. 685void UnitTestImpl::SetGlobalTestPartResultReporter( 686 TestPartResultReporterInterface* reporter) { 687 internal::MutexLock lock(&global_test_part_result_reporter_mutex_); 688 global_test_part_result_repoter_ = reporter; 689} 690 691// Returns the test part result reporter for the current thread. 692TestPartResultReporterInterface* 693UnitTestImpl::GetTestPartResultReporterForCurrentThread() { 694 return per_thread_test_part_result_reporter_.get(); 695} 696 697// Sets the test part result reporter for the current thread. 698void UnitTestImpl::SetTestPartResultReporterForCurrentThread( 699 TestPartResultReporterInterface* reporter) { 700 per_thread_test_part_result_reporter_.set(reporter); 701} 702 703// Gets the number of successful test cases. 704int UnitTestImpl::successful_test_case_count() const { 705 return CountIf(test_cases_, TestCasePassed); 706} 707 708// Gets the number of failed test cases. 709int UnitTestImpl::failed_test_case_count() const { 710 return CountIf(test_cases_, TestCaseFailed); 711} 712 713// Gets the number of all test cases. 714int UnitTestImpl::total_test_case_count() const { 715 return static_cast<int>(test_cases_.size()); 716} 717 718// Gets the number of all test cases that contain at least one test 719// that should run. 720int UnitTestImpl::test_case_to_run_count() const { 721 return CountIf(test_cases_, ShouldRunTestCase); 722} 723 724// Gets the number of successful tests. 725int UnitTestImpl::successful_test_count() const { 726 return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count); 727} 728 729// Gets the number of failed tests. 730int UnitTestImpl::failed_test_count() const { 731 return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count); 732} 733 734// Gets the number of disabled tests. 735int UnitTestImpl::disabled_test_count() const { 736 return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count); 737} 738 739// Gets the number of all tests. 740int UnitTestImpl::total_test_count() const { 741 return SumOverTestCaseList(test_cases_, &TestCase::total_test_count); 742} 743 744// Gets the number of tests that should run. 745int UnitTestImpl::test_to_run_count() const { 746 return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count); 747} 748 749// Returns the current OS stack trace as a String. 750// 751// The maximum number of stack frames to be included is specified by 752// the gtest_stack_trace_depth flag. The skip_count parameter 753// specifies the number of top frames to be skipped, which doesn't 754// count against the number of frames to be included. 755// 756// For example, if Foo() calls Bar(), which in turn calls 757// CurrentOsStackTraceExceptTop(1), Foo() will be included in the 758// trace but Bar() and CurrentOsStackTraceExceptTop() won't. 759String UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) { 760 (void)skip_count; 761 return String(""); 762} 763 764// Returns the current time in milliseconds. 765TimeInMillis GetTimeInMillis() { 766#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__) 767 // Difference between 1970-01-01 and 1601-01-01 in milliseconds. 768 // http://analogous.blogspot.com/2005/04/epoch.html 769 const TimeInMillis kJavaEpochToWinFileTimeDelta = 770 static_cast<TimeInMillis>(116444736UL) * 100000UL; 771 const DWORD kTenthMicrosInMilliSecond = 10000; 772 773 SYSTEMTIME now_systime; 774 FILETIME now_filetime; 775 ULARGE_INTEGER now_int64; 776 // TODO(kenton@google.com): Shouldn't this just use 777 // GetSystemTimeAsFileTime()? 778 GetSystemTime(&now_systime); 779 if (SystemTimeToFileTime(&now_systime, &now_filetime)) { 780 now_int64.LowPart = now_filetime.dwLowDateTime; 781 now_int64.HighPart = now_filetime.dwHighDateTime; 782 now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) - 783 kJavaEpochToWinFileTimeDelta; 784 return now_int64.QuadPart; 785 } 786 return 0; 787#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_ 788 __timeb64 now; 789 790# ifdef _MSC_VER 791 792 // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996 793 // (deprecated function) there. 794 // TODO(kenton@google.com): Use GetTickCount()? Or use 795 // SystemTimeToFileTime() 796# pragma warning(push) // Saves the current warning state. 797# pragma warning(disable:4996) // Temporarily disables warning 4996. 798 _ftime64(&now); 799# pragma warning(pop) // Restores the warning state. 800# else 801 802 _ftime64(&now); 803 804# endif // _MSC_VER 805 806 return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm; 807#elif GTEST_HAS_GETTIMEOFDAY_ 808 struct timeval now; 809 gettimeofday(&now, NULL); 810 return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000; 811#else 812# error "Don't know how to get the current time on your system." 813#endif 814} 815 816// Utilities 817 818// class String 819 820// Returns the input enclosed in double quotes if it's not NULL; 821// otherwise returns "(null)". For example, "\"Hello\"" is returned 822// for input "Hello". 823// 824// This is useful for printing a C string in the syntax of a literal. 825// 826// Known issue: escape sequences are not handled yet. 827String String::ShowCStringQuoted(const char* c_str) { 828 return c_str ? String::Format("\"%s\"", c_str) : String("(null)"); 829} 830 831// Copies at most length characters from str into a newly-allocated 832// piece of memory of size length+1. The memory is allocated with new[]. 833// A terminating null byte is written to the memory, and a pointer to it 834// is returned. If str is NULL, NULL is returned. 835static char* CloneString(const char* str, size_t length) { 836 if (str == NULL) { 837 return NULL; 838 } else { 839 char* const clone = new char[length + 1]; 840 posix::StrNCpy(clone, str, length); 841 clone[length] = '\0'; 842 return clone; 843 } 844} 845 846// Clones a 0-terminated C string, allocating memory using new. The 847// caller is responsible for deleting[] the return value. Returns the 848// cloned string, or NULL if the input is NULL. 849const char * String::CloneCString(const char* c_str) { 850 return (c_str == NULL) ? 851 NULL : CloneString(c_str, strlen(c_str)); 852} 853 854#if GTEST_OS_WINDOWS_MOBILE 855// Creates a UTF-16 wide string from the given ANSI string, allocating 856// memory using new. The caller is responsible for deleting the return 857// value using delete[]. Returns the wide string, or NULL if the 858// input is NULL. 859LPCWSTR String::AnsiToUtf16(const char* ansi) { 860 if (!ansi) return NULL; 861 const int length = strlen(ansi); 862 const int unicode_length = 863 MultiByteToWideChar(CP_ACP, 0, ansi, length, 864 NULL, 0); 865 WCHAR* unicode = new WCHAR[unicode_length + 1]; 866 MultiByteToWideChar(CP_ACP, 0, ansi, length, 867 unicode, unicode_length); 868 unicode[unicode_length] = 0; 869 return unicode; 870} 871 872// Creates an ANSI string from the given wide string, allocating 873// memory using new. The caller is responsible for deleting the return 874// value using delete[]. Returns the ANSI string, or NULL if the 875// input is NULL. 876const char* String::Utf16ToAnsi(LPCWSTR utf16_str) { 877 if (!utf16_str) return NULL; 878 const int ansi_length = 879 WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, 880 NULL, 0, NULL, NULL); 881 char* ansi = new char[ansi_length + 1]; 882 WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, 883 ansi, ansi_length, NULL, NULL); 884 ansi[ansi_length] = 0; 885 return ansi; 886} 887 888#endif // GTEST_OS_WINDOWS_MOBILE 889 890// Compares two C strings. Returns true iff they have the same content. 891// 892// Unlike strcmp(), this function can handle NULL argument(s). A NULL 893// C string is considered different to any non-NULL C string, 894// including the empty string. 895bool String::CStringEquals(const char * lhs, const char * rhs) { 896 if ( lhs == NULL ) return rhs == NULL; 897 898 if ( rhs == NULL ) return false; 899 900 return strcmp(lhs, rhs) == 0; 901} 902 903#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 904 905// Converts an array of wide chars to a narrow string using the UTF-8 906// encoding, and streams the result to the given Message object. 907static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length, 908 Message* msg) { 909 // TODO(wan): consider allowing a testing::String object to 910 // contain '\0'. This will make it behave more like std::string, 911 // and will allow ToUtf8String() to return the correct encoding 912 // for '\0' s.t. we can get rid of the conditional here (and in 913 // several other places). 914 for (size_t i = 0; i != length; ) { // NOLINT 915 if (wstr[i] != L'\0') { 916 *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i)); 917 while (i != length && wstr[i] != L'\0') 918 i++; 919 } else { 920 *msg << '\0'; 921 i++; 922 } 923 } 924} 925 926#endif // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 927 928} // namespace internal 929 930#if GTEST_HAS_STD_WSTRING 931// Converts the given wide string to a narrow string using the UTF-8 932// encoding, and streams the result to this Message object. 933Message& Message::operator <<(const ::std::wstring& wstr) { 934 internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); 935 return *this; 936} 937#endif // GTEST_HAS_STD_WSTRING 938 939#if GTEST_HAS_GLOBAL_WSTRING 940// Converts the given wide string to a narrow string using the UTF-8 941// encoding, and streams the result to this Message object. 942Message& Message::operator <<(const ::wstring& wstr) { 943 internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); 944 return *this; 945} 946#endif // GTEST_HAS_GLOBAL_WSTRING 947 948// AssertionResult constructors. 949// Used in EXPECT_TRUE/FALSE(assertion_result). 950AssertionResult::AssertionResult(const AssertionResult& other) 951 : success_(other.success_), 952 message_(other.message_.get() != NULL ? 953 new ::std::string(*other.message_) : 954 static_cast< ::std::string*>(NULL)) { 955} 956 957// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. 958AssertionResult AssertionResult::operator!() const { 959 AssertionResult negation(!success_); 960 if (message_.get() != NULL) 961 negation << *message_; 962 return negation; 963} 964 965// Makes a successful assertion result. 966AssertionResult AssertionSuccess() { 967 return AssertionResult(true); 968} 969 970// Makes a failed assertion result. 971AssertionResult AssertionFailure() { 972 return AssertionResult(false); 973} 974 975// Makes a failed assertion result with the given failure message. 976// Deprecated; use AssertionFailure() << message. 977AssertionResult AssertionFailure(const Message& message) { 978 return AssertionFailure() << message; 979} 980 981namespace internal { 982 983// Constructs and returns the message for an equality assertion 984// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. 985// 986// The first four parameters are the expressions used in the assertion 987// and their values, as strings. For example, for ASSERT_EQ(foo, bar) 988// where foo is 5 and bar is 6, we have: 989// 990// expected_expression: "foo" 991// actual_expression: "bar" 992// expected_value: "5" 993// actual_value: "6" 994// 995// The ignoring_case parameter is true iff the assertion is a 996// *_STRCASEEQ*. When it's true, the string " (ignoring case)" will 997// be inserted into the message. 998AssertionResult EqFailure(const char* expected_expression, 999 const char* actual_expression, 1000 const String& expected_value, 1001 const String& actual_value, 1002 bool ignoring_case) { 1003 Message msg; 1004 msg << "Value of: " << actual_expression; 1005 if (actual_value != actual_expression) { 1006 msg << "\n Actual: " << actual_value; 1007 } 1008 1009 msg << "\nExpected: " << expected_expression; 1010 if (ignoring_case) { 1011 msg << " (ignoring case)"; 1012 } 1013 if (expected_value != expected_expression) { 1014 msg << "\nWhich is: " << expected_value; 1015 } 1016 1017 return AssertionFailure() << msg; 1018} 1019 1020// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. 1021String GetBoolAssertionFailureMessage(const AssertionResult& assertion_result, 1022 const char* expression_text, 1023 const char* actual_predicate_value, 1024 const char* expected_predicate_value) { 1025 const char* actual_message = assertion_result.message(); 1026 Message msg; 1027 msg << "Value of: " << expression_text 1028 << "\n Actual: " << actual_predicate_value; 1029 if (actual_message[0] != '\0') 1030 msg << " (" << actual_message << ")"; 1031 msg << "\nExpected: " << expected_predicate_value; 1032 return msg.GetString(); 1033} 1034 1035// Helper function for implementing ASSERT_NEAR. 1036AssertionResult DoubleNearPredFormat(const char* expr1, 1037 const char* expr2, 1038 const char* abs_error_expr, 1039 double val1, 1040 double val2, 1041 double abs_error) { 1042 const double diff = fabs(val1 - val2); 1043 if (diff <= abs_error) return AssertionSuccess(); 1044 1045 // TODO(wan): do not print the value of an expression if it's 1046 // already a literal. 1047 return AssertionFailure() 1048 << "The difference between " << expr1 << " and " << expr2 1049 << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n" 1050 << expr1 << " evaluates to " << val1 << ",\n" 1051 << expr2 << " evaluates to " << val2 << ", and\n" 1052 << abs_error_expr << " evaluates to " << abs_error << "."; 1053} 1054 1055 1056// Helper template for implementing FloatLE() and DoubleLE(). 1057template <typename RawType> 1058AssertionResult FloatingPointLE(const char* expr1, 1059 const char* expr2, 1060 RawType val1, 1061 RawType val2) { 1062 // Returns success if val1 is less than val2, 1063 if (val1 < val2) { 1064 return AssertionSuccess(); 1065 } 1066 1067 // or if val1 is almost equal to val2. 1068 const FloatingPoint<RawType> lhs(val1), rhs(val2); 1069 if (lhs.AlmostEquals(rhs)) { 1070 return AssertionSuccess(); 1071 } 1072 1073 // Note that the above two checks will both fail if either val1 or 1074 // val2 is NaN, as the IEEE floating-point standard requires that 1075 // any predicate involving a NaN must return false. 1076 1077 ::std::stringstream val1_ss; 1078 val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) 1079 << val1; 1080 1081 ::std::stringstream val2_ss; 1082 val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) 1083 << val2; 1084 1085 return AssertionFailure() 1086 << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n" 1087 << " Actual: " << StringStreamToString(&val1_ss) << " vs " 1088 << StringStreamToString(&val2_ss); 1089} 1090 1091} // namespace internal 1092 1093// Asserts that val1 is less than, or almost equal to, val2. Fails 1094// otherwise. In particular, it fails if either val1 or val2 is NaN. 1095AssertionResult FloatLE(const char* expr1, const char* expr2, 1096 float val1, float val2) { 1097 return internal::FloatingPointLE<float>(expr1, expr2, val1, val2); 1098} 1099 1100// Asserts that val1 is less than, or almost equal to, val2. Fails 1101// otherwise. In particular, it fails if either val1 or val2 is NaN. 1102AssertionResult DoubleLE(const char* expr1, const char* expr2, 1103 double val1, double val2) { 1104 return internal::FloatingPointLE<double>(expr1, expr2, val1, val2); 1105} 1106 1107namespace internal { 1108 1109// The helper function for {ASSERT|EXPECT}_EQ with int or enum 1110// arguments. 1111AssertionResult CmpHelperEQ(const char* expected_expression, 1112 const char* actual_expression, 1113 BiggestInt expected, 1114 BiggestInt actual) { 1115 if (expected == actual) { 1116 return AssertionSuccess(); 1117 } 1118 1119 return EqFailure(expected_expression, 1120 actual_expression, 1121 FormatForComparisonFailureMessage(expected, actual), 1122 FormatForComparisonFailureMessage(actual, expected), 1123 false); 1124} 1125 1126// A macro for implementing the helper functions needed to implement 1127// ASSERT_?? and EXPECT_?? with integer or enum arguments. It is here 1128// just to avoid copy-and-paste of similar code. 1129#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ 1130AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ 1131 BiggestInt val1, BiggestInt val2) {\ 1132 if (val1 op val2) {\ 1133 return AssertionSuccess();\ 1134 } else {\ 1135 return AssertionFailure() \ 1136 << "Expected: (" << expr1 << ") " #op " (" << expr2\ 1137 << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ 1138 << " vs " << FormatForComparisonFailureMessage(val2, val1);\ 1139 }\ 1140} 1141 1142// Implements the helper function for {ASSERT|EXPECT}_NE with int or 1143// enum arguments. 1144GTEST_IMPL_CMP_HELPER_(NE, !=) 1145// Implements the helper function for {ASSERT|EXPECT}_LE with int or 1146// enum arguments. 1147GTEST_IMPL_CMP_HELPER_(LE, <=) 1148// Implements the helper function for {ASSERT|EXPECT}_LT with int or 1149// enum arguments. 1150GTEST_IMPL_CMP_HELPER_(LT, < ) 1151// Implements the helper function for {ASSERT|EXPECT}_GE with int or 1152// enum arguments. 1153GTEST_IMPL_CMP_HELPER_(GE, >=) 1154// Implements the helper function for {ASSERT|EXPECT}_GT with int or 1155// enum arguments. 1156GTEST_IMPL_CMP_HELPER_(GT, > ) 1157 1158#undef GTEST_IMPL_CMP_HELPER_ 1159 1160// The helper function for {ASSERT|EXPECT}_STREQ. 1161AssertionResult CmpHelperSTREQ(const char* expected_expression, 1162 const char* actual_expression, 1163 const char* expected, 1164 const char* actual) { 1165 if (String::CStringEquals(expected, actual)) { 1166 return AssertionSuccess(); 1167 } 1168 1169 return EqFailure(expected_expression, 1170 actual_expression, 1171 String::ShowCStringQuoted(expected), 1172 String::ShowCStringQuoted(actual), 1173 false); 1174} 1175 1176// The helper function for {ASSERT|EXPECT}_STRCASEEQ. 1177AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, 1178 const char* actual_expression, 1179 const char* expected, 1180 const char* actual) { 1181 if (String::CaseInsensitiveCStringEquals(expected, actual)) { 1182 return AssertionSuccess(); 1183 } 1184 1185 return EqFailure(expected_expression, 1186 actual_expression, 1187 String::ShowCStringQuoted(expected), 1188 String::ShowCStringQuoted(actual), 1189 true); 1190} 1191 1192// The helper function for {ASSERT|EXPECT}_STRNE. 1193AssertionResult CmpHelperSTRNE(const char* s1_expression, 1194 const char* s2_expression, 1195 const char* s1, 1196 const char* s2) { 1197 if (!String::CStringEquals(s1, s2)) { 1198 return AssertionSuccess(); 1199 } else { 1200 return AssertionFailure() << "Expected: (" << s1_expression << ") != (" 1201 << s2_expression << "), actual: \"" 1202 << s1 << "\" vs \"" << s2 << "\""; 1203 } 1204} 1205 1206// The helper function for {ASSERT|EXPECT}_STRCASENE. 1207AssertionResult CmpHelperSTRCASENE(const char* s1_expression, 1208 const char* s2_expression, 1209 const char* s1, 1210 const char* s2) { 1211 if (!String::CaseInsensitiveCStringEquals(s1, s2)) { 1212 return AssertionSuccess(); 1213 } else { 1214 return AssertionFailure() 1215 << "Expected: (" << s1_expression << ") != (" 1216 << s2_expression << ") (ignoring case), actual: \"" 1217 << s1 << "\" vs \"" << s2 << "\""; 1218 } 1219} 1220 1221} // namespace internal 1222 1223namespace { 1224 1225// Helper functions for implementing IsSubString() and IsNotSubstring(). 1226 1227// This group of overloaded functions return true iff needle is a 1228// substring of haystack. NULL is considered a substring of itself 1229// only. 1230 1231bool IsSubstringPred(const char* needle, const char* haystack) { 1232 if (needle == NULL || haystack == NULL) 1233 return needle == haystack; 1234 1235 return strstr(haystack, needle) != NULL; 1236} 1237 1238bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) { 1239 if (needle == NULL || haystack == NULL) 1240 return needle == haystack; 1241 1242 return wcsstr(haystack, needle) != NULL; 1243} 1244 1245// StringType here can be either ::std::string or ::std::wstring. 1246template <typename StringType> 1247bool IsSubstringPred(const StringType& needle, 1248 const StringType& haystack) { 1249 return haystack.find(needle) != StringType::npos; 1250} 1251 1252// This function implements either IsSubstring() or IsNotSubstring(), 1253// depending on the value of the expected_to_be_substring parameter. 1254// StringType here can be const char*, const wchar_t*, ::std::string, 1255// or ::std::wstring. 1256template <typename StringType> 1257AssertionResult IsSubstringImpl( 1258 bool expected_to_be_substring, 1259 const char* needle_expr, const char* haystack_expr, 1260 const StringType& needle, const StringType& haystack) { 1261 if (IsSubstringPred(needle, haystack) == expected_to_be_substring) 1262 return AssertionSuccess(); 1263 1264 const bool is_wide_string = sizeof(needle[0]) > 1; 1265 const char* const begin_string_quote = is_wide_string ? "L\"" : "\""; 1266 return AssertionFailure() 1267 << "Value of: " << needle_expr << "\n" 1268 << " Actual: " << begin_string_quote << needle << "\"\n" 1269 << "Expected: " << (expected_to_be_substring ? "" : "not ") 1270 << "a substring of " << haystack_expr << "\n" 1271 << "Which is: " << begin_string_quote << haystack << "\""; 1272} 1273 1274} // namespace 1275 1276// IsSubstring() and IsNotSubstring() check whether needle is a 1277// substring of haystack (NULL is considered a substring of itself 1278// only), and return an appropriate error message when they fail. 1279 1280AssertionResult IsSubstring( 1281 const char* needle_expr, const char* haystack_expr, 1282 const char* needle, const char* haystack) { 1283 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 1284} 1285 1286AssertionResult IsSubstring( 1287 const char* needle_expr, const char* haystack_expr, 1288 const wchar_t* needle, const wchar_t* haystack) { 1289 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 1290} 1291 1292AssertionResult IsNotSubstring( 1293 const char* needle_expr, const char* haystack_expr, 1294 const char* needle, const char* haystack) { 1295 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 1296} 1297 1298AssertionResult IsNotSubstring( 1299 const char* needle_expr, const char* haystack_expr, 1300 const wchar_t* needle, const wchar_t* haystack) { 1301 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 1302} 1303 1304AssertionResult IsSubstring( 1305 const char* needle_expr, const char* haystack_expr, 1306 const ::std::string& needle, const ::std::string& haystack) { 1307 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 1308} 1309 1310AssertionResult IsNotSubstring( 1311 const char* needle_expr, const char* haystack_expr, 1312 const ::std::string& needle, const ::std::string& haystack) { 1313 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 1314} 1315 1316#if GTEST_HAS_STD_WSTRING 1317AssertionResult IsSubstring( 1318 const char* needle_expr, const char* haystack_expr, 1319 const ::std::wstring& needle, const ::std::wstring& haystack) { 1320 return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 1321} 1322 1323AssertionResult IsNotSubstring( 1324 const char* needle_expr, const char* haystack_expr, 1325 const ::std::wstring& needle, const ::std::wstring& haystack) { 1326 return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 1327} 1328#endif // GTEST_HAS_STD_WSTRING 1329 1330namespace internal { 1331 1332#if GTEST_OS_WINDOWS 1333 1334namespace { 1335 1336// Helper function for IsHRESULT{SuccessFailure} predicates 1337AssertionResult HRESULTFailureHelper(const char* expr, 1338 const char* expected, 1339 long hr) { // NOLINT 1340# if GTEST_OS_WINDOWS_MOBILE 1341 1342 // Windows CE doesn't support FormatMessage. 1343 const char error_text[] = ""; 1344 1345# else 1346 1347 // Looks up the human-readable system message for the HRESULT code 1348 // and since we're not passing any params to FormatMessage, we don't 1349 // want inserts expanded. 1350 const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM | 1351 FORMAT_MESSAGE_IGNORE_INSERTS; 1352 const DWORD kBufSize = 4096; // String::Format can't exceed this length. 1353 // Gets the system's human readable message string for this HRESULT. 1354 char error_text[kBufSize] = { '\0' }; 1355 DWORD message_length = ::FormatMessageA(kFlags, 1356 0, // no source, we're asking system 1357 hr, // the error 1358 0, // no line width restrictions 1359 error_text, // output buffer 1360 kBufSize, // buf size 1361 NULL); // no arguments for inserts 1362 // Trims tailing white space (FormatMessage leaves a trailing cr-lf) 1363 for (; message_length && IsSpace(error_text[message_length - 1]); 1364 --message_length) { 1365 error_text[message_length - 1] = '\0'; 1366 } 1367 1368# endif // GTEST_OS_WINDOWS_MOBILE 1369 1370 const String error_hex(String::Format("0x%08X ", hr)); 1371 return ::testing::AssertionFailure() 1372 << "Expected: " << expr << " " << expected << ".\n" 1373 << " Actual: " << error_hex << error_text << "\n"; 1374} 1375 1376} // namespace 1377 1378AssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT 1379 if (SUCCEEDED(hr)) { 1380 return AssertionSuccess(); 1381 } 1382 return HRESULTFailureHelper(expr, "succeeds", hr); 1383} 1384 1385AssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT 1386 if (FAILED(hr)) { 1387 return AssertionSuccess(); 1388 } 1389 return HRESULTFailureHelper(expr, "fails", hr); 1390} 1391 1392#endif // GTEST_OS_WINDOWS 1393 1394// Utility functions for encoding Unicode text (wide strings) in 1395// UTF-8. 1396 1397// A Unicode code-point can have upto 21 bits, and is encoded in UTF-8 1398// like this: 1399// 1400// Code-point length Encoding 1401// 0 - 7 bits 0xxxxxxx 1402// 8 - 11 bits 110xxxxx 10xxxxxx 1403// 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx 1404// 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 1405 1406// The maximum code-point a one-byte UTF-8 sequence can represent. 1407const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) << 7) - 1; 1408 1409// The maximum code-point a two-byte UTF-8 sequence can represent. 1410const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1; 1411 1412// The maximum code-point a three-byte UTF-8 sequence can represent. 1413const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1; 1414 1415// The maximum code-point a four-byte UTF-8 sequence can represent. 1416const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1; 1417 1418// Chops off the n lowest bits from a bit pattern. Returns the n 1419// lowest bits. As a side effect, the original bit pattern will be 1420// shifted to the right by n bits. 1421inline UInt32 ChopLowBits(UInt32* bits, int n) { 1422 const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1); 1423 *bits >>= n; 1424 return low_bits; 1425} 1426 1427// Converts a Unicode code point to a narrow string in UTF-8 encoding. 1428// code_point parameter is of type UInt32 because wchar_t may not be 1429// wide enough to contain a code point. 1430// The output buffer str must containt at least 32 characters. 1431// The function returns the address of the output buffer. 1432// If the code_point is not a valid Unicode code point 1433// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output 1434// as '(Invalid Unicode 0xXXXXXXXX)'. 1435char* CodePointToUtf8(UInt32 code_point, char* str) { 1436 if (code_point <= kMaxCodePoint1) { 1437 str[1] = '\0'; 1438 str[0] = static_cast<char>(code_point); // 0xxxxxxx 1439 } else if (code_point <= kMaxCodePoint2) { 1440 str[2] = '\0'; 1441 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1442 str[0] = static_cast<char>(0xC0 | code_point); // 110xxxxx 1443 } else if (code_point <= kMaxCodePoint3) { 1444 str[3] = '\0'; 1445 str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1446 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1447 str[0] = static_cast<char>(0xE0 | code_point); // 1110xxxx 1448 } else if (code_point <= kMaxCodePoint4) { 1449 str[4] = '\0'; 1450 str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1451 str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1452 str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1453 str[0] = static_cast<char>(0xF0 | code_point); // 11110xxx 1454 } else { 1455 // The longest string String::Format can produce when invoked 1456 // with these parameters is 28 character long (not including 1457 // the terminating nul character). We are asking for 32 character 1458 // buffer just in case. This is also enough for strncpy to 1459 // null-terminate the destination string. 1460 posix::StrNCpy( 1461 str, String::Format("(Invalid Unicode 0x%X)", code_point).c_str(), 32); 1462 str[31] = '\0'; // Makes sure no change in the format to strncpy leaves 1463 // the result unterminated. 1464 } 1465 return str; 1466} 1467 1468// The following two functions only make sense if the the system 1469// uses UTF-16 for wide string encoding. All supported systems 1470// with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16. 1471 1472// Determines if the arguments constitute UTF-16 surrogate pair 1473// and thus should be combined into a single Unicode code point 1474// using CreateCodePointFromUtf16SurrogatePair. 1475inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) { 1476 return sizeof(wchar_t) == 2 && 1477 (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00; 1478} 1479 1480// Creates a Unicode code point from UTF16 surrogate pair. 1481inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first, 1482 wchar_t second) { 1483 const UInt32 mask = (1 << 10) - 1; 1484 return (sizeof(wchar_t) == 2) ? 1485 (((first & mask) << 10) | (second & mask)) + 0x10000 : 1486 // This function should not be called when the condition is 1487 // false, but we provide a sensible default in case it is. 1488 static_cast<UInt32>(first); 1489} 1490 1491// Converts a wide string to a narrow string in UTF-8 encoding. 1492// The wide string is assumed to have the following encoding: 1493// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS) 1494// UTF-32 if sizeof(wchar_t) == 4 (on Linux) 1495// Parameter str points to a null-terminated wide string. 1496// Parameter num_chars may additionally limit the number 1497// of wchar_t characters processed. -1 is used when the entire string 1498// should be processed. 1499// If the string contains code points that are not valid Unicode code points 1500// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output 1501// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding 1502// and contains invalid UTF-16 surrogate pairs, values in those pairs 1503// will be encoded as individual Unicode characters from Basic Normal Plane. 1504String WideStringToUtf8(const wchar_t* str, int num_chars) { 1505 if (num_chars == -1) 1506 num_chars = static_cast<int>(wcslen(str)); 1507 1508 ::std::stringstream stream; 1509 for (int i = 0; i < num_chars; ++i) { 1510 UInt32 unicode_code_point; 1511 1512 if (str[i] == L'\0') { 1513 break; 1514 } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) { 1515 unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i], 1516 str[i + 1]); 1517 i++; 1518 } else { 1519 unicode_code_point = static_cast<UInt32>(str[i]); 1520 } 1521 1522 char buffer[32]; // CodePointToUtf8 requires a buffer this big. 1523 stream << CodePointToUtf8(unicode_code_point, buffer); 1524 } 1525 return StringStreamToString(&stream); 1526} 1527 1528// Converts a wide C string to a String using the UTF-8 encoding. 1529// NULL will be converted to "(null)". 1530String String::ShowWideCString(const wchar_t * wide_c_str) { 1531 if (wide_c_str == NULL) return String("(null)"); 1532 1533 return String(internal::WideStringToUtf8(wide_c_str, -1).c_str()); 1534} 1535 1536// Similar to ShowWideCString(), except that this function encloses 1537// the converted string in double quotes. 1538String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) { 1539 if (wide_c_str == NULL) return String("(null)"); 1540 1541 return String::Format("L\"%s\"", 1542 String::ShowWideCString(wide_c_str).c_str()); 1543} 1544 1545// Compares two wide C strings. Returns true iff they have the same 1546// content. 1547// 1548// Unlike wcscmp(), this function can handle NULL argument(s). A NULL 1549// C string is considered different to any non-NULL C string, 1550// including the empty string. 1551bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) { 1552 if (lhs == NULL) return rhs == NULL; 1553 1554 if (rhs == NULL) return false; 1555 1556 return wcscmp(lhs, rhs) == 0; 1557} 1558 1559// Helper function for *_STREQ on wide strings. 1560AssertionResult CmpHelperSTREQ(const char* expected_expression, 1561 const char* actual_expression, 1562 const wchar_t* expected, 1563 const wchar_t* actual) { 1564 if (String::WideCStringEquals(expected, actual)) { 1565 return AssertionSuccess(); 1566 } 1567 1568 return EqFailure(expected_expression, 1569 actual_expression, 1570 String::ShowWideCStringQuoted(expected), 1571 String::ShowWideCStringQuoted(actual), 1572 false); 1573} 1574 1575// Helper function for *_STRNE on wide strings. 1576AssertionResult CmpHelperSTRNE(const char* s1_expression, 1577 const char* s2_expression, 1578 const wchar_t* s1, 1579 const wchar_t* s2) { 1580 if (!String::WideCStringEquals(s1, s2)) { 1581 return AssertionSuccess(); 1582 } 1583 1584 return AssertionFailure() << "Expected: (" << s1_expression << ") != (" 1585 << s2_expression << "), actual: " 1586 << String::ShowWideCStringQuoted(s1) 1587 << " vs " << String::ShowWideCStringQuoted(s2); 1588} 1589 1590// Compares two C strings, ignoring case. Returns true iff they have 1591// the same content. 1592// 1593// Unlike strcasecmp(), this function can handle NULL argument(s). A 1594// NULL C string is considered different to any non-NULL C string, 1595// including the empty string. 1596bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) { 1597 if (lhs == NULL) 1598 return rhs == NULL; 1599 if (rhs == NULL) 1600 return false; 1601 return posix::StrCaseCmp(lhs, rhs) == 0; 1602} 1603 1604 // Compares two wide C strings, ignoring case. Returns true iff they 1605 // have the same content. 1606 // 1607 // Unlike wcscasecmp(), this function can handle NULL argument(s). 1608 // A NULL C string is considered different to any non-NULL wide C string, 1609 // including the empty string. 1610 // NB: The implementations on different platforms slightly differ. 1611 // On windows, this method uses _wcsicmp which compares according to LC_CTYPE 1612 // environment variable. On GNU platform this method uses wcscasecmp 1613 // which compares according to LC_CTYPE category of the current locale. 1614 // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the 1615 // current locale. 1616bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs, 1617 const wchar_t* rhs) { 1618 if (lhs == NULL) return rhs == NULL; 1619 1620 if (rhs == NULL) return false; 1621 1622#if GTEST_OS_WINDOWS 1623 return _wcsicmp(lhs, rhs) == 0; 1624#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID 1625 return wcscasecmp(lhs, rhs) == 0; 1626#else 1627 // Android, Mac OS X and Cygwin don't define wcscasecmp. 1628 // Other unknown OSes may not define it either. 1629 wint_t left, right; 1630 do { 1631 left = towlower(*lhs++); 1632 right = towlower(*rhs++); 1633 } while (left && left == right); 1634 return left == right; 1635#endif // OS selector 1636} 1637 1638// Compares this with another String. 1639// Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0 1640// if this is greater than rhs. 1641int String::Compare(const String & rhs) const { 1642 const char* const lhs_c_str = c_str(); 1643 const char* const rhs_c_str = rhs.c_str(); 1644 1645 if (lhs_c_str == NULL) { 1646 return rhs_c_str == NULL ? 0 : -1; // NULL < anything except NULL 1647 } else if (rhs_c_str == NULL) { 1648 return 1; 1649 } 1650 1651 const size_t shorter_str_len = 1652 length() <= rhs.length() ? length() : rhs.length(); 1653 for (size_t i = 0; i != shorter_str_len; i++) { 1654 if (lhs_c_str[i] < rhs_c_str[i]) { 1655 return -1; 1656 } else if (lhs_c_str[i] > rhs_c_str[i]) { 1657 return 1; 1658 } 1659 } 1660 return (length() < rhs.length()) ? -1 : 1661 (length() > rhs.length()) ? 1 : 0; 1662} 1663 1664// Returns true iff this String ends with the given suffix. *Any* 1665// String is considered to end with a NULL or empty suffix. 1666bool String::EndsWith(const char* suffix) const { 1667 if (suffix == NULL || CStringEquals(suffix, "")) return true; 1668 1669 if (c_str() == NULL) return false; 1670 1671 const size_t this_len = strlen(c_str()); 1672 const size_t suffix_len = strlen(suffix); 1673 return (this_len >= suffix_len) && 1674 CStringEquals(c_str() + this_len - suffix_len, suffix); 1675} 1676 1677// Returns true iff this String ends with the given suffix, ignoring case. 1678// Any String is considered to end with a NULL or empty suffix. 1679bool String::EndsWithCaseInsensitive(const char* suffix) const { 1680 if (suffix == NULL || CStringEquals(suffix, "")) return true; 1681 1682 if (c_str() == NULL) return false; 1683 1684 const size_t this_len = strlen(c_str()); 1685 const size_t suffix_len = strlen(suffix); 1686 return (this_len >= suffix_len) && 1687 CaseInsensitiveCStringEquals(c_str() + this_len - suffix_len, suffix); 1688} 1689 1690// Formats a list of arguments to a String, using the same format 1691// spec string as for printf. 1692// 1693// We do not use the StringPrintf class as it is not universally 1694// available. 1695// 1696// The result is limited to 4096 characters (including the tailing 0). 1697// If 4096 characters are not enough to format the input, or if 1698// there's an error, "<formatting error or buffer exceeded>" is 1699// returned. 1700String String::Format(const char * format, ...) { 1701 va_list args; 1702 va_start(args, format); 1703 1704 char buffer[4096]; 1705 const int kBufferSize = sizeof(buffer)/sizeof(buffer[0]); 1706 1707 // MSVC 8 deprecates vsnprintf(), so we want to suppress warning 1708 // 4996 (deprecated function) there. 1709#ifdef _MSC_VER // We are using MSVC. 1710# pragma warning(push) // Saves the current warning state. 1711# pragma warning(disable:4996) // Temporarily disables warning 4996. 1712 1713 const int size = vsnprintf(buffer, kBufferSize, format, args); 1714 1715# pragma warning(pop) // Restores the warning state. 1716#else // We are not using MSVC. 1717 const int size = vsnprintf(buffer, kBufferSize, format, args); 1718#endif // _MSC_VER 1719 va_end(args); 1720 1721 // vsnprintf()'s behavior is not portable. When the buffer is not 1722 // big enough, it returns a negative value in MSVC, and returns the 1723 // needed buffer size on Linux. When there is an output error, it 1724 // always returns a negative value. For simplicity, we lump the two 1725 // error cases together. 1726 if (size < 0 || size >= kBufferSize) { 1727 return String("<formatting error or buffer exceeded>"); 1728 } else { 1729 return String(buffer, size); 1730 } 1731} 1732 1733// Converts the buffer in a stringstream to a String, converting NUL 1734// bytes to "\\0" along the way. 1735String StringStreamToString(::std::stringstream* ss) { 1736 const ::std::string& str = ss->str(); 1737 const char* const start = str.c_str(); 1738 const char* const end = start + str.length(); 1739 1740 // We need to use a helper stringstream to do this transformation 1741 // because String doesn't support push_back(). 1742 ::std::stringstream helper; 1743 for (const char* ch = start; ch != end; ++ch) { 1744 if (*ch == '\0') { 1745 helper << "\\0"; // Replaces NUL with "\\0"; 1746 } else { 1747 helper.put(*ch); 1748 } 1749 } 1750 1751 return String(helper.str().c_str()); 1752} 1753 1754// Appends the user-supplied message to the Google-Test-generated message. 1755String AppendUserMessage(const String& gtest_msg, 1756 const Message& user_msg) { 1757 // Appends the user message if it's non-empty. 1758 const String user_msg_string = user_msg.GetString(); 1759 if (user_msg_string.empty()) { 1760 return gtest_msg; 1761 } 1762 1763 Message msg; 1764 msg << gtest_msg << "\n" << user_msg_string; 1765 1766 return msg.GetString(); 1767} 1768 1769} // namespace internal 1770 1771// class TestResult 1772 1773// Creates an empty TestResult. 1774TestResult::TestResult() 1775 : death_test_count_(0), 1776 elapsed_time_(0) { 1777} 1778 1779// D'tor. 1780TestResult::~TestResult() { 1781} 1782 1783// Returns the i-th test part result among all the results. i can 1784// range from 0 to total_part_count() - 1. If i is not in that range, 1785// aborts the program. 1786const TestPartResult& TestResult::GetTestPartResult(int i) const { 1787 if (i < 0 || i >= total_part_count()) 1788 internal::posix::Abort(); 1789 return test_part_results_.at(i); 1790} 1791 1792// Returns the i-th test property. i can range from 0 to 1793// test_property_count() - 1. If i is not in that range, aborts the 1794// program. 1795const TestProperty& TestResult::GetTestProperty(int i) const { 1796 if (i < 0 || i >= test_property_count()) 1797 internal::posix::Abort(); 1798 return test_properties_.at(i); 1799} 1800 1801// Clears the test part results. 1802void TestResult::ClearTestPartResults() { 1803 test_part_results_.clear(); 1804} 1805 1806// Adds a test part result to the list. 1807void TestResult::AddTestPartResult(const TestPartResult& test_part_result) { 1808 test_part_results_.push_back(test_part_result); 1809} 1810 1811// Adds a test property to the list. If a property with the same key as the 1812// supplied property is already represented, the value of this test_property 1813// replaces the old value for that key. 1814void TestResult::RecordProperty(const TestProperty& test_property) { 1815 if (!ValidateTestProperty(test_property)) { 1816 return; 1817 } 1818 internal::MutexLock lock(&test_properites_mutex_); 1819 const std::vector<TestProperty>::iterator property_with_matching_key = 1820 std::find_if(test_properties_.begin(), test_properties_.end(), 1821 internal::TestPropertyKeyIs(test_property.key())); 1822 if (property_with_matching_key == test_properties_.end()) { 1823 test_properties_.push_back(test_property); 1824 return; 1825 } 1826 property_with_matching_key->SetValue(test_property.value()); 1827} 1828 1829// Adds a failure if the key is a reserved attribute of Google Test 1830// testcase tags. Returns true if the property is valid. 1831bool TestResult::ValidateTestProperty(const TestProperty& test_property) { 1832 internal::String key(test_property.key()); 1833 if (key == "name" || key == "status" || key == "time" || key == "classname") { 1834 ADD_FAILURE() 1835 << "Reserved key used in RecordProperty(): " 1836 << key 1837 << " ('name', 'status', 'time', and 'classname' are reserved by " 1838 << GTEST_NAME_ << ")"; 1839 return false; 1840 } 1841 return true; 1842} 1843 1844// Clears the object. 1845void TestResult::Clear() { 1846 test_part_results_.clear(); 1847 test_properties_.clear(); 1848 death_test_count_ = 0; 1849 elapsed_time_ = 0; 1850} 1851 1852// Returns true iff the test failed. 1853bool TestResult::Failed() const { 1854 for (int i = 0; i < total_part_count(); ++i) { 1855 if (GetTestPartResult(i).failed()) 1856 return true; 1857 } 1858 return false; 1859} 1860 1861// Returns true iff the test part fatally failed. 1862static bool TestPartFatallyFailed(const TestPartResult& result) { 1863 return result.fatally_failed(); 1864} 1865 1866// Returns true iff the test fatally failed. 1867bool TestResult::HasFatalFailure() const { 1868 return CountIf(test_part_results_, TestPartFatallyFailed) > 0; 1869} 1870 1871// Returns true iff the test part non-fatally failed. 1872static bool TestPartNonfatallyFailed(const TestPartResult& result) { 1873 return result.nonfatally_failed(); 1874} 1875 1876// Returns true iff the test has a non-fatal failure. 1877bool TestResult::HasNonfatalFailure() const { 1878 return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0; 1879} 1880 1881// Gets the number of all test parts. This is the sum of the number 1882// of successful test parts and the number of failed test parts. 1883int TestResult::total_part_count() const { 1884 return static_cast<int>(test_part_results_.size()); 1885} 1886 1887// Returns the number of the test properties. 1888int TestResult::test_property_count() const { 1889 return static_cast<int>(test_properties_.size()); 1890} 1891 1892// class Test 1893 1894// Creates a Test object. 1895 1896// The c'tor saves the values of all Google Test flags. 1897Test::Test() 1898 : gtest_flag_saver_(new internal::GTestFlagSaver) { 1899} 1900 1901// The d'tor restores the values of all Google Test flags. 1902Test::~Test() { 1903 delete gtest_flag_saver_; 1904} 1905 1906// Sets up the test fixture. 1907// 1908// A sub-class may override this. 1909void Test::SetUp() { 1910} 1911 1912// Tears down the test fixture. 1913// 1914// A sub-class may override this. 1915void Test::TearDown() { 1916} 1917 1918// Allows user supplied key value pairs to be recorded for later output. 1919void Test::RecordProperty(const char* key, const char* value) { 1920 UnitTest::GetInstance()->RecordPropertyForCurrentTest(key, value); 1921} 1922 1923// Allows user supplied key value pairs to be recorded for later output. 1924void Test::RecordProperty(const char* key, int value) { 1925 Message value_message; 1926 value_message << value; 1927 RecordProperty(key, value_message.GetString().c_str()); 1928} 1929 1930namespace internal { 1931 1932void ReportFailureInUnknownLocation(TestPartResult::Type result_type, 1933 const String& message) { 1934 // This function is a friend of UnitTest and as such has access to 1935 // AddTestPartResult. 1936 UnitTest::GetInstance()->AddTestPartResult( 1937 result_type, 1938 NULL, // No info about the source file where the exception occurred. 1939 -1, // We have no info on which line caused the exception. 1940 message, 1941 String()); // No stack trace, either. 1942} 1943 1944} // namespace internal 1945 1946// Google Test requires all tests in the same test case to use the same test 1947// fixture class. This function checks if the current test has the 1948// same fixture class as the first test in the current test case. If 1949// yes, it returns true; otherwise it generates a Google Test failure and 1950// returns false. 1951bool Test::HasSameFixtureClass() { 1952 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 1953 const TestCase* const test_case = impl->current_test_case(); 1954 1955 // Info about the first test in the current test case. 1956 const TestInfo* const first_test_info = test_case->test_info_list()[0]; 1957 const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_; 1958 const char* const first_test_name = first_test_info->name(); 1959 1960 // Info about the current test. 1961 const TestInfo* const this_test_info = impl->current_test_info(); 1962 const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_; 1963 const char* const this_test_name = this_test_info->name(); 1964 1965 if (this_fixture_id != first_fixture_id) { 1966 // Is the first test defined using TEST? 1967 const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId(); 1968 // Is this test defined using TEST? 1969 const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId(); 1970 1971 if (first_is_TEST || this_is_TEST) { 1972 // The user mixed TEST and TEST_F in this test case - we'll tell 1973 // him/her how to fix it. 1974 1975 // Gets the name of the TEST and the name of the TEST_F. Note 1976 // that first_is_TEST and this_is_TEST cannot both be true, as 1977 // the fixture IDs are different for the two tests. 1978 const char* const TEST_name = 1979 first_is_TEST ? first_test_name : this_test_name; 1980 const char* const TEST_F_name = 1981 first_is_TEST ? this_test_name : first_test_name; 1982 1983 ADD_FAILURE() 1984 << "All tests in the same test case must use the same test fixture\n" 1985 << "class, so mixing TEST_F and TEST in the same test case is\n" 1986 << "illegal. In test case " << this_test_info->test_case_name() 1987 << ",\n" 1988 << "test " << TEST_F_name << " is defined using TEST_F but\n" 1989 << "test " << TEST_name << " is defined using TEST. You probably\n" 1990 << "want to change the TEST to TEST_F or move it to another test\n" 1991 << "case."; 1992 } else { 1993 // The user defined two fixture classes with the same name in 1994 // two namespaces - we'll tell him/her how to fix it. 1995 ADD_FAILURE() 1996 << "All tests in the same test case must use the same test fixture\n" 1997 << "class. However, in test case " 1998 << this_test_info->test_case_name() << ",\n" 1999 << "you defined test " << first_test_name 2000 << " and test " << this_test_name << "\n" 2001 << "using two different test fixture classes. This can happen if\n" 2002 << "the two classes are from different namespaces or translation\n" 2003 << "units and have the same name. You should probably rename one\n" 2004 << "of the classes to put the tests into different test cases."; 2005 } 2006 return false; 2007 } 2008 2009 return true; 2010} 2011 2012#if GTEST_HAS_SEH 2013 2014// Adds an "exception thrown" fatal failure to the current test. This 2015// function returns its result via an output parameter pointer because VC++ 2016// prohibits creation of objects with destructors on stack in functions 2017// using __try (see error C2712). 2018static internal::String* FormatSehExceptionMessage(DWORD exception_code, 2019 const char* location) { 2020 Message message; 2021 message << "SEH exception with code 0x" << std::setbase(16) << 2022 exception_code << std::setbase(10) << " thrown in " << location << "."; 2023 2024 return new internal::String(message.GetString()); 2025} 2026 2027#endif // GTEST_HAS_SEH 2028 2029#if GTEST_HAS_EXCEPTIONS 2030 2031// Adds an "exception thrown" fatal failure to the current test. 2032static internal::String FormatCxxExceptionMessage(const char* description, 2033 const char* location) { 2034 Message message; 2035 if (description != NULL) { 2036 message << "C++ exception with description \"" << description << "\""; 2037 } else { 2038 message << "Unknown C++ exception"; 2039 } 2040 message << " thrown in " << location << "."; 2041 2042 return message.GetString(); 2043} 2044 2045static internal::String PrintTestPartResultToString( 2046 const TestPartResult& test_part_result); 2047 2048// A failed Google Test assertion will throw an exception of this type when 2049// GTEST_FLAG(throw_on_failure) is true (if exceptions are enabled). We 2050// derive it from std::runtime_error, which is for errors presumably 2051// detectable only at run time. Since std::runtime_error inherits from 2052// std::exception, many testing frameworks know how to extract and print the 2053// message inside it. 2054class GoogleTestFailureException : public ::std::runtime_error { 2055 public: 2056 explicit GoogleTestFailureException(const TestPartResult& failure) 2057 : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {} 2058}; 2059#endif // GTEST_HAS_EXCEPTIONS 2060 2061namespace internal { 2062// We put these helper functions in the internal namespace as IBM's xIC_r 2063// compiler rejects the code if they were declared static. 2064 2065// Runs the given method and handles SEH exceptions it throws, when 2066// SEH is supported; returns the 0-value for type Result in case of an 2067// SEH exception. (Microsoft compilers cannot handle SEH and C++ 2068// exceptions in the same function. Therefore, we provide a separate 2069// wrapper function for handling SEH exceptions.) 2070template <class T, typename Result> 2071Result HandleSehExceptionsInMethodIfSupported( 2072 T* object, Result (T::*method)(), const char* location) { 2073#if GTEST_HAS_SEH 2074 __try { 2075 return (object->*method)(); 2076 } __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT 2077 GetExceptionCode())) { 2078 // We create the exception message on the heap because VC++ prohibits 2079 // creation of objects with destructors on stack in functions using __try 2080 // (see error C2712). 2081 internal::String* exception_message = FormatSehExceptionMessage( 2082 GetExceptionCode(), location); 2083 internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure, 2084 *exception_message); 2085 delete exception_message; 2086 return static_cast<Result>(0); 2087 } 2088#else 2089 (void)location; 2090 return (object->*method)(); 2091#endif // GTEST_HAS_SEH 2092} 2093 2094// Runs the given method and catches and reports C++ and/or SEH-style 2095// exceptions, if they are supported; returns the 0-value for type 2096// Result in case of an SEH exception. 2097template <class T, typename Result> 2098Result HandleExceptionsInMethodIfSupported( 2099 T* object, Result (T::*method)(), const char* location) { 2100 // NOTE: The user code can affect the way in which Google Test handles 2101 // exceptions by setting GTEST_FLAG(catch_exceptions), but only before 2102 // RUN_ALL_TESTS() starts. It is technically possible to check the flag 2103 // after the exception is caught and either report or re-throw the 2104 // exception based on the flag's value: 2105 // 2106 // try { 2107 // // Perform the test method. 2108 // } catch (...) { 2109 // if (GTEST_FLAG(catch_exceptions)) 2110 // // Report the exception as failure. 2111 // else 2112 // throw; // Re-throws the original exception. 2113 // } 2114 // 2115 // However, the purpose of this flag is to allow the program to drop into 2116 // the debugger when the exception is thrown. On most platforms, once the 2117 // control enters the catch block, the exception origin information is 2118 // lost and the debugger will stop the program at the point of the 2119 // re-throw in this function -- instead of at the point of the original 2120 // throw statement in the code under test. For this reason, we perform 2121 // the check early, sacrificing the ability to affect Google Test's 2122 // exception handling in the method where the exception is thrown. 2123 if (internal::GetUnitTestImpl()->catch_exceptions()) { 2124#if GTEST_HAS_EXCEPTIONS 2125 try { 2126 return HandleSehExceptionsInMethodIfSupported(object, method, location); 2127 } catch (const GoogleTestFailureException&) { // NOLINT 2128 // This exception doesn't originate in code under test. It makes no 2129 // sense to report it as a test failure. 2130 throw; 2131 } catch (const std::exception& e) { // NOLINT 2132 internal::ReportFailureInUnknownLocation( 2133 TestPartResult::kFatalFailure, 2134 FormatCxxExceptionMessage(e.what(), location)); 2135 } catch (...) { // NOLINT 2136 internal::ReportFailureInUnknownLocation( 2137 TestPartResult::kFatalFailure, 2138 FormatCxxExceptionMessage(NULL, location)); 2139 } 2140 return static_cast<Result>(0); 2141#else 2142 return HandleSehExceptionsInMethodIfSupported(object, method, location); 2143#endif // GTEST_HAS_EXCEPTIONS 2144 } else { 2145 return (object->*method)(); 2146 } 2147} 2148 2149} // namespace internal 2150 2151// Runs the test and updates the test result. 2152void Test::Run() { 2153 if (!HasSameFixtureClass()) return; 2154 2155 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 2156 impl->os_stack_trace_getter()->UponLeavingGTest(); 2157 internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()"); 2158 // We will run the test only if SetUp() was successful. 2159 if (!HasFatalFailure()) { 2160 impl->os_stack_trace_getter()->UponLeavingGTest(); 2161 internal::HandleExceptionsInMethodIfSupported( 2162 this, &Test::TestBody, "the test body"); 2163 } 2164 2165 // However, we want to clean up as much as possible. Hence we will 2166 // always call TearDown(), even if SetUp() or the test body has 2167 // failed. 2168 impl->os_stack_trace_getter()->UponLeavingGTest(); 2169 internal::HandleExceptionsInMethodIfSupported( 2170 this, &Test::TearDown, "TearDown()"); 2171} 2172 2173// Returns true iff the current test has a fatal failure. 2174bool Test::HasFatalFailure() { 2175 return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure(); 2176} 2177 2178// Returns true iff the current test has a non-fatal failure. 2179bool Test::HasNonfatalFailure() { 2180 return internal::GetUnitTestImpl()->current_test_result()-> 2181 HasNonfatalFailure(); 2182} 2183 2184// class TestInfo 2185 2186// Constructs a TestInfo object. It assumes ownership of the test factory 2187// object. 2188// TODO(vladl@google.com): Make a_test_case_name and a_name const string&'s 2189// to signify they cannot be NULLs. 2190TestInfo::TestInfo(const char* a_test_case_name, 2191 const char* a_name, 2192 const char* a_type_param, 2193 const char* a_value_param, 2194 internal::TypeId fixture_class_id, 2195 internal::TestFactoryBase* factory) 2196 : test_case_name_(a_test_case_name), 2197 name_(a_name), 2198 type_param_(a_type_param ? new std::string(a_type_param) : NULL), 2199 value_param_(a_value_param ? new std::string(a_value_param) : NULL), 2200 fixture_class_id_(fixture_class_id), 2201 should_run_(false), 2202 is_disabled_(false), 2203 matches_filter_(false), 2204 factory_(factory), 2205 result_() {} 2206 2207// Destructs a TestInfo object. 2208TestInfo::~TestInfo() { delete factory_; } 2209 2210namespace internal { 2211 2212// Creates a new TestInfo object and registers it with Google Test; 2213// returns the created object. 2214// 2215// Arguments: 2216// 2217// test_case_name: name of the test case 2218// name: name of the test 2219// type_param: the name of the test's type parameter, or NULL if 2220// this is not a typed or a type-parameterized test. 2221// value_param: text representation of the test's value parameter, 2222// or NULL if this is not a value-parameterized test. 2223// fixture_class_id: ID of the test fixture class 2224// set_up_tc: pointer to the function that sets up the test case 2225// tear_down_tc: pointer to the function that tears down the test case 2226// factory: pointer to the factory that creates a test object. 2227// The newly created TestInfo instance will assume 2228// ownership of the factory object. 2229TestInfo* MakeAndRegisterTestInfo( 2230 const char* test_case_name, const char* name, 2231 const char* type_param, 2232 const char* value_param, 2233 TypeId fixture_class_id, 2234 SetUpTestCaseFunc set_up_tc, 2235 TearDownTestCaseFunc tear_down_tc, 2236 TestFactoryBase* factory) { 2237 TestInfo* const test_info = 2238 new TestInfo(test_case_name, name, type_param, value_param, 2239 fixture_class_id, factory); 2240 GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info); 2241 return test_info; 2242} 2243 2244#if GTEST_HAS_PARAM_TEST 2245void ReportInvalidTestCaseType(const char* test_case_name, 2246 const char* file, int line) { 2247 Message errors; 2248 errors 2249 << "Attempted redefinition of test case " << test_case_name << ".\n" 2250 << "All tests in the same test case must use the same test fixture\n" 2251 << "class. However, in test case " << test_case_name << ", you tried\n" 2252 << "to define a test using a fixture class different from the one\n" 2253 << "used earlier. This can happen if the two fixture classes are\n" 2254 << "from different namespaces and have the same name. You should\n" 2255 << "probably rename one of the classes to put the tests into different\n" 2256 << "test cases."; 2257 2258 fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), 2259 errors.GetString().c_str()); 2260} 2261#endif // GTEST_HAS_PARAM_TEST 2262 2263} // namespace internal 2264 2265namespace { 2266 2267// A predicate that checks the test name of a TestInfo against a known 2268// value. 2269// 2270// This is used for implementation of the TestCase class only. We put 2271// it in the anonymous namespace to prevent polluting the outer 2272// namespace. 2273// 2274// TestNameIs is copyable. 2275class TestNameIs { 2276 public: 2277 // Constructor. 2278 // 2279 // TestNameIs has NO default constructor. 2280 explicit TestNameIs(const char* name) 2281 : name_(name) {} 2282 2283 // Returns true iff the test name of test_info matches name_. 2284 bool operator()(const TestInfo * test_info) const { 2285 return test_info && internal::String(test_info->name()).Compare(name_) == 0; 2286 } 2287 2288 private: 2289 internal::String name_; 2290}; 2291 2292} // namespace 2293 2294namespace internal { 2295 2296// This method expands all parameterized tests registered with macros TEST_P 2297// and INSTANTIATE_TEST_CASE_P into regular tests and registers those. 2298// This will be done just once during the program runtime. 2299void UnitTestImpl::RegisterParameterizedTests() { 2300#if GTEST_HAS_PARAM_TEST 2301 if (!parameterized_tests_registered_) { 2302 parameterized_test_registry_.RegisterTests(); 2303 parameterized_tests_registered_ = true; 2304 } 2305#endif 2306} 2307 2308} // namespace internal 2309 2310// Creates the test object, runs it, records its result, and then 2311// deletes it. 2312void TestInfo::Run() { 2313 if (!should_run_) return; 2314 2315 // Tells UnitTest where to store test result. 2316 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 2317 impl->set_current_test_info(this); 2318 2319 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); 2320 2321 // Notifies the unit test event listeners that a test is about to start. 2322 repeater->OnTestStart(*this); 2323 2324 const TimeInMillis start = internal::GetTimeInMillis(); 2325 2326 impl->os_stack_trace_getter()->UponLeavingGTest(); 2327 2328 // Creates the test object. 2329 Test* const test = internal::HandleExceptionsInMethodIfSupported( 2330 factory_, &internal::TestFactoryBase::CreateTest, 2331 "the test fixture's constructor"); 2332 2333 // Runs the test only if the test object was created and its 2334 // constructor didn't generate a fatal failure. 2335 if ((test != NULL) && !Test::HasFatalFailure()) { 2336 // This doesn't throw as all user code that can throw are wrapped into 2337 // exception handling code. 2338 test->Run(); 2339 } 2340 2341 // Deletes the test object. 2342 impl->os_stack_trace_getter()->UponLeavingGTest(); 2343 internal::HandleExceptionsInMethodIfSupported( 2344 test, &Test::DeleteSelf_, "the test fixture's destructor"); 2345 2346 result_.set_elapsed_time(internal::GetTimeInMillis() - start); 2347 2348 // Notifies the unit test event listener that a test has just finished. 2349 repeater->OnTestEnd(*this); 2350 2351 // Tells UnitTest to stop associating assertion results to this 2352 // test. 2353 impl->set_current_test_info(NULL); 2354} 2355 2356// class TestCase 2357 2358// Gets the number of successful tests in this test case. 2359int TestCase::successful_test_count() const { 2360 return CountIf(test_info_list_, TestPassed); 2361} 2362 2363// Gets the number of failed tests in this test case. 2364int TestCase::failed_test_count() const { 2365 return CountIf(test_info_list_, TestFailed); 2366} 2367 2368int TestCase::disabled_test_count() const { 2369 return CountIf(test_info_list_, TestDisabled); 2370} 2371 2372// Get the number of tests in this test case that should run. 2373int TestCase::test_to_run_count() const { 2374 return CountIf(test_info_list_, ShouldRunTest); 2375} 2376 2377// Gets the number of all tests. 2378int TestCase::total_test_count() const { 2379 return static_cast<int>(test_info_list_.size()); 2380} 2381 2382// Creates a TestCase with the given name. 2383// 2384// Arguments: 2385// 2386// name: name of the test case 2387// a_type_param: the name of the test case's type parameter, or NULL if 2388// this is not a typed or a type-parameterized test case. 2389// set_up_tc: pointer to the function that sets up the test case 2390// tear_down_tc: pointer to the function that tears down the test case 2391TestCase::TestCase(const char* a_name, const char* a_type_param, 2392 Test::SetUpTestCaseFunc set_up_tc, 2393 Test::TearDownTestCaseFunc tear_down_tc) 2394 : name_(a_name), 2395 type_param_(a_type_param ? new std::string(a_type_param) : NULL), 2396 set_up_tc_(set_up_tc), 2397 tear_down_tc_(tear_down_tc), 2398 should_run_(false), 2399 elapsed_time_(0) { 2400} 2401 2402// Destructor of TestCase. 2403TestCase::~TestCase() { 2404 // Deletes every Test in the collection. 2405 ForEach(test_info_list_, internal::Delete<TestInfo>); 2406} 2407 2408// Returns the i-th test among all the tests. i can range from 0 to 2409// total_test_count() - 1. If i is not in that range, returns NULL. 2410const TestInfo* TestCase::GetTestInfo(int i) const { 2411 const int index = GetElementOr(test_indices_, i, -1); 2412 return index < 0 ? NULL : test_info_list_[index]; 2413} 2414 2415// Returns the i-th test among all the tests. i can range from 0 to 2416// total_test_count() - 1. If i is not in that range, returns NULL. 2417TestInfo* TestCase::GetMutableTestInfo(int i) { 2418 const int index = GetElementOr(test_indices_, i, -1); 2419 return index < 0 ? NULL : test_info_list_[index]; 2420} 2421 2422// Adds a test to this test case. Will delete the test upon 2423// destruction of the TestCase object. 2424void TestCase::AddTestInfo(TestInfo * test_info) { 2425 test_info_list_.push_back(test_info); 2426 test_indices_.push_back(static_cast<int>(test_indices_.size())); 2427} 2428 2429// Runs every test in this TestCase. 2430void TestCase::Run() { 2431 if (!should_run_) return; 2432 2433 internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 2434 impl->set_current_test_case(this); 2435 2436 TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); 2437 2438 repeater->OnTestCaseStart(*this); 2439 impl->os_stack_trace_getter()->UponLeavingGTest(); 2440 internal::HandleExceptionsInMethodIfSupported( 2441 this, &TestCase::RunSetUpTestCase, "SetUpTestCase()"); 2442 2443 const internal::TimeInMillis start = internal::GetTimeInMillis(); 2444 for (int i = 0; i < total_test_count(); i++) { 2445 GetMutableTestInfo(i)->Run(); 2446 } 2447 elapsed_time_ = internal::GetTimeInMillis() - start; 2448 2449 impl->os_stack_trace_getter()->UponLeavingGTest(); 2450 internal::HandleExceptionsInMethodIfSupported( 2451 this, &TestCase::RunTearDownTestCase, "TearDownTestCase()"); 2452 2453 repeater->OnTestCaseEnd(*this); 2454 impl->set_current_test_case(NULL); 2455} 2456 2457// Clears the results of all tests in this test case. 2458void TestCase::ClearResult() { 2459 ForEach(test_info_list_, TestInfo::ClearTestResult); 2460} 2461 2462// Shuffles the tests in this test case. 2463void TestCase::ShuffleTests(internal::Random* random) { 2464 Shuffle(random, &test_indices_); 2465} 2466 2467// Restores the test order to before the first shuffle. 2468void TestCase::UnshuffleTests() { 2469 for (size_t i = 0; i < test_indices_.size(); i++) { 2470 test_indices_[i] = static_cast<int>(i); 2471 } 2472} 2473 2474// Formats a countable noun. Depending on its quantity, either the 2475// singular form or the plural form is used. e.g. 2476// 2477// FormatCountableNoun(1, "formula", "formuli") returns "1 formula". 2478// FormatCountableNoun(5, "book", "books") returns "5 books". 2479static internal::String FormatCountableNoun(int count, 2480 const char * singular_form, 2481 const char * plural_form) { 2482 return internal::String::Format("%d %s", count, 2483 count == 1 ? singular_form : plural_form); 2484} 2485 2486// Formats the count of tests. 2487static internal::String FormatTestCount(int test_count) { 2488 return FormatCountableNoun(test_count, "test", "tests"); 2489} 2490 2491// Formats the count of test cases. 2492static internal::String FormatTestCaseCount(int test_case_count) { 2493 return FormatCountableNoun(test_case_count, "test case", "test cases"); 2494} 2495 2496// Converts a TestPartResult::Type enum to human-friendly string 2497// representation. Both kNonFatalFailure and kFatalFailure are translated 2498// to "Failure", as the user usually doesn't care about the difference 2499// between the two when viewing the test result. 2500static const char * TestPartResultTypeToString(TestPartResult::Type type) { 2501 switch (type) { 2502 case TestPartResult::kSuccess: 2503 return "Success"; 2504 2505 case TestPartResult::kNonFatalFailure: 2506 case TestPartResult::kFatalFailure: 2507#ifdef _MSC_VER 2508 return "error: "; 2509#else 2510 return "Failure\n"; 2511#endif 2512 default: 2513 return "Unknown result type"; 2514 } 2515} 2516 2517// Prints a TestPartResult to a String. 2518static internal::String PrintTestPartResultToString( 2519 const TestPartResult& test_part_result) { 2520 return (Message() 2521 << internal::FormatFileLocation(test_part_result.file_name(), 2522 test_part_result.line_number()) 2523 << " " << TestPartResultTypeToString(test_part_result.type()) 2524 << test_part_result.message()).GetString(); 2525} 2526 2527// Prints a TestPartResult. 2528static void PrintTestPartResult(const TestPartResult& test_part_result) { 2529 const internal::String& result = 2530 PrintTestPartResultToString(test_part_result); 2531 printf("%s\n", result.c_str()); 2532 fflush(stdout); 2533 // If the test program runs in Visual Studio or a debugger, the 2534 // following statements add the test part result message to the Output 2535 // window such that the user can double-click on it to jump to the 2536 // corresponding source code location; otherwise they do nothing. 2537#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 2538 // We don't call OutputDebugString*() on Windows Mobile, as printing 2539 // to stdout is done by OutputDebugString() there already - we don't 2540 // want the same message printed twice. 2541 ::OutputDebugStringA(result.c_str()); 2542 ::OutputDebugStringA("\n"); 2543#endif 2544} 2545 2546// class PrettyUnitTestResultPrinter 2547 2548namespace internal { 2549 2550enum GTestColor { 2551 COLOR_DEFAULT, 2552 COLOR_RED, 2553 COLOR_GREEN, 2554 COLOR_YELLOW 2555}; 2556 2557#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 2558 2559// Returns the character attribute for the given color. 2560WORD GetColorAttribute(GTestColor color) { 2561 switch (color) { 2562 case COLOR_RED: return FOREGROUND_RED; 2563 case COLOR_GREEN: return FOREGROUND_GREEN; 2564 case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN; 2565 default: return 0; 2566 } 2567} 2568 2569#else 2570 2571// Returns the ANSI color code for the given color. COLOR_DEFAULT is 2572// an invalid input. 2573const char* GetAnsiColorCode(GTestColor color) { 2574 switch (color) { 2575 case COLOR_RED: return "1"; 2576 case COLOR_GREEN: return "2"; 2577 case COLOR_YELLOW: return "3"; 2578 default: return NULL; 2579 }; 2580} 2581 2582#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 2583 2584// Returns true iff Google Test should use colors in the output. 2585bool ShouldUseColor(bool stdout_is_tty) { 2586 const char* const gtest_color = GTEST_FLAG(color).c_str(); 2587 2588 if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) { 2589#if GTEST_OS_WINDOWS 2590 // On Windows the TERM variable is usually not set, but the 2591 // console there does support colors. 2592 return stdout_is_tty; 2593#else 2594 // On non-Windows platforms, we rely on the TERM variable. 2595 const char* const term = posix::GetEnv("TERM"); 2596 const bool term_supports_color = 2597 String::CStringEquals(term, "xterm") || 2598 String::CStringEquals(term, "xterm-color") || 2599 String::CStringEquals(term, "xterm-256color") || 2600 String::CStringEquals(term, "screen") || 2601 String::CStringEquals(term, "linux") || 2602 String::CStringEquals(term, "cygwin"); 2603 return stdout_is_tty && term_supports_color; 2604#endif // GTEST_OS_WINDOWS 2605 } 2606 2607 return String::CaseInsensitiveCStringEquals(gtest_color, "yes") || 2608 String::CaseInsensitiveCStringEquals(gtest_color, "true") || 2609 String::CaseInsensitiveCStringEquals(gtest_color, "t") || 2610 String::CStringEquals(gtest_color, "1"); 2611 // We take "yes", "true", "t", and "1" as meaning "yes". If the 2612 // value is neither one of these nor "auto", we treat it as "no" to 2613 // be conservative. 2614} 2615 2616// Helpers for printing colored strings to stdout. Note that on Windows, we 2617// cannot simply emit special characters and have the terminal change colors. 2618// This routine must actually emit the characters rather than return a string 2619// that would be colored when printed, as can be done on Linux. 2620void ColoredPrintf(GTestColor color, const char* fmt, ...) { 2621 va_list args; 2622 va_start(args, fmt); 2623 2624#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS 2625 const bool use_color = false; 2626#else 2627 static const bool in_color_mode = 2628 ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0); 2629 const bool use_color = in_color_mode && (color != COLOR_DEFAULT); 2630#endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS 2631 // The '!= 0' comparison is necessary to satisfy MSVC 7.1. 2632 2633 if (!use_color) { 2634 vprintf(fmt, args); 2635 va_end(args); 2636 return; 2637 } 2638 2639#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 2640 const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); 2641 2642 // Gets the current text color. 2643 CONSOLE_SCREEN_BUFFER_INFO buffer_info; 2644 GetConsoleScreenBufferInfo(stdout_handle, &buffer_info); 2645 const WORD old_color_attrs = buffer_info.wAttributes; 2646 2647 // We need to flush the stream buffers into the console before each 2648 // SetConsoleTextAttribute call lest it affect the text that is already 2649 // printed but has not yet reached the console. 2650 fflush(stdout); 2651 SetConsoleTextAttribute(stdout_handle, 2652 GetColorAttribute(color) | FOREGROUND_INTENSITY); 2653 vprintf(fmt, args); 2654 2655 fflush(stdout); 2656 // Restores the text color. 2657 SetConsoleTextAttribute(stdout_handle, old_color_attrs); 2658#else 2659 printf("\033[0;3%sm", GetAnsiColorCode(color)); 2660 vprintf(fmt, args); 2661 printf("\033[m"); // Resets the terminal to default. 2662#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 2663 va_end(args); 2664} 2665 2666void PrintFullTestCommentIfPresent(const TestInfo& test_info) { 2667 const char* const type_param = test_info.type_param(); 2668 const char* const value_param = test_info.value_param(); 2669 2670 if (type_param != NULL || value_param != NULL) { 2671 printf(", where "); 2672 if (type_param != NULL) { 2673 printf("TypeParam = %s", type_param); 2674 if (value_param != NULL) 2675 printf(" and "); 2676 } 2677 if (value_param != NULL) { 2678 printf("GetParam() = %s", value_param); 2679 } 2680 } 2681} 2682 2683// This class implements the TestEventListener interface. 2684// 2685// Class PrettyUnitTestResultPrinter is copyable. 2686class PrettyUnitTestResultPrinter : public TestEventListener { 2687 public: 2688 PrettyUnitTestResultPrinter() {} 2689 static void PrintTestName(const char * test_case, const char * test) { 2690 printf("%s.%s", test_case, test); 2691 } 2692 2693 // The following methods override what's in the TestEventListener class. 2694 virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} 2695 virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); 2696 virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); 2697 virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} 2698 virtual void OnTestCaseStart(const TestCase& test_case); 2699 virtual void OnTestStart(const TestInfo& test_info); 2700 virtual void OnTestPartResult(const TestPartResult& result); 2701 virtual void OnTestEnd(const TestInfo& test_info); 2702 virtual void OnTestCaseEnd(const TestCase& test_case); 2703 virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); 2704 virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} 2705 virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); 2706 virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} 2707 2708 private: 2709 static void PrintFailedTests(const UnitTest& unit_test); 2710 2711 internal::String test_case_name_; 2712}; 2713 2714 // Fired before each iteration of tests starts. 2715void PrettyUnitTestResultPrinter::OnTestIterationStart( 2716 const UnitTest& unit_test, int iteration) { 2717 if (GTEST_FLAG(repeat) != 1) 2718 printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1); 2719 2720 const char* const filter = GTEST_FLAG(filter).c_str(); 2721 2722 // Prints the filter if it's not *. This reminds the user that some 2723 // tests may be skipped. 2724 if (!internal::String::CStringEquals(filter, kUniversalFilter)) { 2725 ColoredPrintf(COLOR_YELLOW, 2726 "Note: %s filter = %s\n", GTEST_NAME_, filter); 2727 } 2728 2729 if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) { 2730 const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1); 2731 ColoredPrintf(COLOR_YELLOW, 2732 "Note: This is test shard %d of %s.\n", 2733 static_cast<int>(shard_index) + 1, 2734 internal::posix::GetEnv(kTestTotalShards)); 2735 } 2736 2737 if (GTEST_FLAG(shuffle)) { 2738 ColoredPrintf(COLOR_YELLOW, 2739 "Note: Randomizing tests' orders with a seed of %d .\n", 2740 unit_test.random_seed()); 2741 } 2742 2743 ColoredPrintf(COLOR_GREEN, "[==========] "); 2744 printf("Running %s from %s.\n", 2745 FormatTestCount(unit_test.test_to_run_count()).c_str(), 2746 FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); 2747 fflush(stdout); 2748} 2749 2750void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart( 2751 const UnitTest& /*unit_test*/) { 2752 ColoredPrintf(COLOR_GREEN, "[----------] "); 2753 printf("Global test environment set-up.\n"); 2754 fflush(stdout); 2755} 2756 2757void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) { 2758 test_case_name_ = test_case.name(); 2759 const internal::String counts = 2760 FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); 2761 ColoredPrintf(COLOR_GREEN, "[----------] "); 2762 printf("%s from %s", counts.c_str(), test_case_name_.c_str()); 2763 if (test_case.type_param() == NULL) { 2764 printf("\n"); 2765 } else { 2766 printf(", where TypeParam = %s\n", test_case.type_param()); 2767 } 2768 fflush(stdout); 2769} 2770 2771void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) { 2772 ColoredPrintf(COLOR_GREEN, "[ RUN ] "); 2773 PrintTestName(test_case_name_.c_str(), test_info.name()); 2774 printf("\n"); 2775 fflush(stdout); 2776} 2777 2778// Called after an assertion failure. 2779void PrettyUnitTestResultPrinter::OnTestPartResult( 2780 const TestPartResult& result) { 2781 // If the test part succeeded, we don't need to do anything. 2782 if (result.type() == TestPartResult::kSuccess) 2783 return; 2784 2785 // Print failure message from the assertion (e.g. expected this and got that). 2786 PrintTestPartResult(result); 2787 fflush(stdout); 2788} 2789 2790void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) { 2791 if (test_info.result()->Passed()) { 2792 ColoredPrintf(COLOR_GREEN, "[ OK ] "); 2793 } else { 2794 ColoredPrintf(COLOR_RED, "[ FAILED ] "); 2795 } 2796 PrintTestName(test_case_name_.c_str(), test_info.name()); 2797 if (test_info.result()->Failed()) 2798 PrintFullTestCommentIfPresent(test_info); 2799 2800 if (GTEST_FLAG(print_time)) { 2801 printf(" (%s ms)\n", internal::StreamableToString( 2802 test_info.result()->elapsed_time()).c_str()); 2803 } else { 2804 printf("\n"); 2805 } 2806 fflush(stdout); 2807} 2808 2809void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) { 2810 if (!GTEST_FLAG(print_time)) return; 2811 2812 test_case_name_ = test_case.name(); 2813 const internal::String counts = 2814 FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); 2815 ColoredPrintf(COLOR_GREEN, "[----------] "); 2816 printf("%s from %s (%s ms total)\n\n", 2817 counts.c_str(), test_case_name_.c_str(), 2818 internal::StreamableToString(test_case.elapsed_time()).c_str()); 2819 fflush(stdout); 2820} 2821 2822void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart( 2823 const UnitTest& /*unit_test*/) { 2824 ColoredPrintf(COLOR_GREEN, "[----------] "); 2825 printf("Global test environment tear-down\n"); 2826 fflush(stdout); 2827} 2828 2829// Internal helper for printing the list of failed tests. 2830void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) { 2831 const int failed_test_count = unit_test.failed_test_count(); 2832 if (failed_test_count == 0) { 2833 return; 2834 } 2835 2836 for (int i = 0; i < unit_test.total_test_case_count(); ++i) { 2837 const TestCase& test_case = *unit_test.GetTestCase(i); 2838 if (!test_case.should_run() || (test_case.failed_test_count() == 0)) { 2839 continue; 2840 } 2841 for (int j = 0; j < test_case.total_test_count(); ++j) { 2842 const TestInfo& test_info = *test_case.GetTestInfo(j); 2843 if (!test_info.should_run() || test_info.result()->Passed()) { 2844 continue; 2845 } 2846 ColoredPrintf(COLOR_RED, "[ FAILED ] "); 2847 printf("%s.%s", test_case.name(), test_info.name()); 2848 PrintFullTestCommentIfPresent(test_info); 2849 printf("\n"); 2850 } 2851 } 2852} 2853 2854void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, 2855 int /*iteration*/) { 2856 ColoredPrintf(COLOR_GREEN, "[==========] "); 2857 printf("%s from %s ran.", 2858 FormatTestCount(unit_test.test_to_run_count()).c_str(), 2859 FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); 2860 if (GTEST_FLAG(print_time)) { 2861 printf(" (%s ms total)", 2862 internal::StreamableToString(unit_test.elapsed_time()).c_str()); 2863 } 2864 printf("\n"); 2865 ColoredPrintf(COLOR_GREEN, "[ PASSED ] "); 2866 printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str()); 2867 2868 int num_failures = unit_test.failed_test_count(); 2869 if (!unit_test.Passed()) { 2870 const int failed_test_count = unit_test.failed_test_count(); 2871 ColoredPrintf(COLOR_RED, "[ FAILED ] "); 2872 printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str()); 2873 PrintFailedTests(unit_test); 2874 printf("\n%2d FAILED %s\n", num_failures, 2875 num_failures == 1 ? "TEST" : "TESTS"); 2876 } 2877 2878 int num_disabled = unit_test.disabled_test_count(); 2879 if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) { 2880 if (!num_failures) { 2881 printf("\n"); // Add a spacer if no FAILURE banner is displayed. 2882 } 2883 ColoredPrintf(COLOR_YELLOW, 2884 " YOU HAVE %d DISABLED %s\n\n", 2885 num_disabled, 2886 num_disabled == 1 ? "TEST" : "TESTS"); 2887 } 2888 // Ensure that Google Test output is printed before, e.g., heapchecker output. 2889 fflush(stdout); 2890} 2891 2892// End PrettyUnitTestResultPrinter 2893 2894// class TestEventRepeater 2895// 2896// This class forwards events to other event listeners. 2897class TestEventRepeater : public TestEventListener { 2898 public: 2899 TestEventRepeater() : forwarding_enabled_(true) {} 2900 virtual ~TestEventRepeater(); 2901 void Append(TestEventListener *listener); 2902 TestEventListener* Release(TestEventListener* listener); 2903 2904 // Controls whether events will be forwarded to listeners_. Set to false 2905 // in death test child processes. 2906 bool forwarding_enabled() const { return forwarding_enabled_; } 2907 void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; } 2908 2909 virtual void OnTestProgramStart(const UnitTest& unit_test); 2910 virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); 2911 virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); 2912 virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test); 2913 virtual void OnTestCaseStart(const TestCase& test_case); 2914 virtual void OnTestStart(const TestInfo& test_info); 2915 virtual void OnTestPartResult(const TestPartResult& result); 2916 virtual void OnTestEnd(const TestInfo& test_info); 2917 virtual void OnTestCaseEnd(const TestCase& test_case); 2918 virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); 2919 virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test); 2920 virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); 2921 virtual void OnTestProgramEnd(const UnitTest& unit_test); 2922 2923 private: 2924 // Controls whether events will be forwarded to listeners_. Set to false 2925 // in death test child processes. 2926 bool forwarding_enabled_; 2927 // The list of listeners that receive events. 2928 std::vector<TestEventListener*> listeners_; 2929 2930 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater); 2931}; 2932 2933TestEventRepeater::~TestEventRepeater() { 2934 ForEach(listeners_, Delete<TestEventListener>); 2935} 2936 2937void TestEventRepeater::Append(TestEventListener *listener) { 2938 listeners_.push_back(listener); 2939} 2940 2941// TODO(vladl@google.com): Factor the search functionality into Vector::Find. 2942TestEventListener* TestEventRepeater::Release(TestEventListener *listener) { 2943 for (size_t i = 0; i < listeners_.size(); ++i) { 2944 if (listeners_[i] == listener) { 2945 listeners_.erase(listeners_.begin() + i); 2946 return listener; 2947 } 2948 } 2949 2950 return NULL; 2951} 2952 2953// Since most methods are very similar, use macros to reduce boilerplate. 2954// This defines a member that forwards the call to all listeners. 2955#define GTEST_REPEATER_METHOD_(Name, Type) \ 2956void TestEventRepeater::Name(const Type& parameter) { \ 2957 if (forwarding_enabled_) { \ 2958 for (size_t i = 0; i < listeners_.size(); i++) { \ 2959 listeners_[i]->Name(parameter); \ 2960 } \ 2961 } \ 2962} 2963// This defines a member that forwards the call to all listeners in reverse 2964// order. 2965#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \ 2966void TestEventRepeater::Name(const Type& parameter) { \ 2967 if (forwarding_enabled_) { \ 2968 for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \ 2969 listeners_[i]->Name(parameter); \ 2970 } \ 2971 } \ 2972} 2973 2974GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest) 2975GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest) 2976GTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase) 2977GTEST_REPEATER_METHOD_(OnTestStart, TestInfo) 2978GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult) 2979GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest) 2980GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest) 2981GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest) 2982GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo) 2983GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase) 2984GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest) 2985 2986#undef GTEST_REPEATER_METHOD_ 2987#undef GTEST_REVERSE_REPEATER_METHOD_ 2988 2989void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test, 2990 int iteration) { 2991 if (forwarding_enabled_) { 2992 for (size_t i = 0; i < listeners_.size(); i++) { 2993 listeners_[i]->OnTestIterationStart(unit_test, iteration); 2994 } 2995 } 2996} 2997 2998void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test, 2999 int iteration) { 3000 if (forwarding_enabled_) { 3001 for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { 3002 listeners_[i]->OnTestIterationEnd(unit_test, iteration); 3003 } 3004 } 3005} 3006 3007// End TestEventRepeater 3008 3009// This class generates an XML output file. 3010class XmlUnitTestResultPrinter : public EmptyTestEventListener { 3011 public: 3012 explicit XmlUnitTestResultPrinter(const char* output_file); 3013 3014 virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); 3015 3016 private: 3017 // Is c a whitespace character that is normalized to a space character 3018 // when it appears in an XML attribute value? 3019 static bool IsNormalizableWhitespace(char c) { 3020 return c == 0x9 || c == 0xA || c == 0xD; 3021 } 3022 3023 // May c appear in a well-formed XML document? 3024 static bool IsValidXmlCharacter(char c) { 3025 return IsNormalizableWhitespace(c) || c >= 0x20; 3026 } 3027 3028 // Returns an XML-escaped copy of the input string str. If 3029 // is_attribute is true, the text is meant to appear as an attribute 3030 // value, and normalizable whitespace is preserved by replacing it 3031 // with character references. 3032 static String EscapeXml(const char* str, bool is_attribute); 3033 3034 // Returns the given string with all characters invalid in XML removed. 3035 static string RemoveInvalidXmlCharacters(const string& str); 3036 3037 // Convenience wrapper around EscapeXml when str is an attribute value. 3038 static String EscapeXmlAttribute(const char* str) { 3039 return EscapeXml(str, true); 3040 } 3041 3042 // Convenience wrapper around EscapeXml when str is not an attribute value. 3043 static String EscapeXmlText(const char* str) { return EscapeXml(str, false); } 3044 3045 // Streams an XML CDATA section, escaping invalid CDATA sequences as needed. 3046 static void OutputXmlCDataSection(::std::ostream* stream, const char* data); 3047 3048 // Streams an XML representation of a TestInfo object. 3049 static void OutputXmlTestInfo(::std::ostream* stream, 3050 const char* test_case_name, 3051 const TestInfo& test_info); 3052 3053 // Prints an XML representation of a TestCase object 3054 static void PrintXmlTestCase(FILE* out, const TestCase& test_case); 3055 3056 // Prints an XML summary of unit_test to output stream out. 3057 static void PrintXmlUnitTest(FILE* out, const UnitTest& unit_test); 3058 3059 // Produces a string representing the test properties in a result as space 3060 // delimited XML attributes based on the property key="value" pairs. 3061 // When the String is not empty, it includes a space at the beginning, 3062 // to delimit this attribute from prior attributes. 3063 static String TestPropertiesAsXmlAttributes(const TestResult& result); 3064 3065 // The output file. 3066 const String output_file_; 3067 3068 GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter); 3069}; 3070 3071// Creates a new XmlUnitTestResultPrinter. 3072XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file) 3073 : output_file_(output_file) { 3074 if (output_file_.c_str() == NULL || output_file_.empty()) { 3075 fprintf(stderr, "XML output file may not be null\n"); 3076 fflush(stderr); 3077 exit(EXIT_FAILURE); 3078 } 3079} 3080 3081// Called after the unit test ends. 3082void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, 3083 int /*iteration*/) { 3084 FILE* xmlout = NULL; 3085 FilePath output_file(output_file_); 3086 FilePath output_dir(output_file.RemoveFileName()); 3087 3088 if (output_dir.CreateDirectoriesRecursively()) { 3089 xmlout = posix::FOpen(output_file_.c_str(), "w"); 3090 } 3091 if (xmlout == NULL) { 3092 // TODO(wan): report the reason of the failure. 3093 // 3094 // We don't do it for now as: 3095 // 3096 // 1. There is no urgent need for it. 3097 // 2. It's a bit involved to make the errno variable thread-safe on 3098 // all three operating systems (Linux, Windows, and Mac OS). 3099 // 3. To interpret the meaning of errno in a thread-safe way, 3100 // we need the strerror_r() function, which is not available on 3101 // Windows. 3102 fprintf(stderr, 3103 "Unable to open file \"%s\"\n", 3104 output_file_.c_str()); 3105 fflush(stderr); 3106 exit(EXIT_FAILURE); 3107 } 3108 PrintXmlUnitTest(xmlout, unit_test); 3109 fclose(xmlout); 3110} 3111 3112// Returns an XML-escaped copy of the input string str. If is_attribute 3113// is true, the text is meant to appear as an attribute value, and 3114// normalizable whitespace is preserved by replacing it with character 3115// references. 3116// 3117// Invalid XML characters in str, if any, are stripped from the output. 3118// It is expected that most, if not all, of the text processed by this 3119// module will consist of ordinary English text. 3120// If this module is ever modified to produce version 1.1 XML output, 3121// most invalid characters can be retained using character references. 3122// TODO(wan): It might be nice to have a minimally invasive, human-readable 3123// escaping scheme for invalid characters, rather than dropping them. 3124String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_attribute) { 3125 Message m; 3126 3127 if (str != NULL) { 3128 for (const char* src = str; *src; ++src) { 3129 switch (*src) { 3130 case '<': 3131 m << "<"; 3132 break; 3133 case '>': 3134 m << ">"; 3135 break; 3136 case '&': 3137 m << "&"; 3138 break; 3139 case '\'': 3140 if (is_attribute) 3141 m << "'"; 3142 else 3143 m << '\''; 3144 break; 3145 case '"': 3146 if (is_attribute) 3147 m << """; 3148 else 3149 m << '"'; 3150 break; 3151 default: 3152 if (IsValidXmlCharacter(*src)) { 3153 if (is_attribute && IsNormalizableWhitespace(*src)) 3154 m << String::Format("&#x%02X;", unsigned(*src)); 3155 else 3156 m << *src; 3157 } 3158 break; 3159 } 3160 } 3161 } 3162 3163 return m.GetString(); 3164} 3165 3166// Returns the given string with all characters invalid in XML removed. 3167// Currently invalid characters are dropped from the string. An 3168// alternative is to replace them with certain characters such as . or ?. 3169string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const string& str) { 3170 string output; 3171 output.reserve(str.size()); 3172 for (string::const_iterator it = str.begin(); it != str.end(); ++it) 3173 if (IsValidXmlCharacter(*it)) 3174 output.push_back(*it); 3175 3176 return output; 3177} 3178 3179// The following routines generate an XML representation of a UnitTest 3180// object. 3181// 3182// This is how Google Test concepts map to the DTD: 3183// 3184// <testsuites name="AllTests"> <-- corresponds to a UnitTest object 3185// <testsuite name="testcase-name"> <-- corresponds to a TestCase object 3186// <testcase name="test-name"> <-- corresponds to a TestInfo object 3187// <failure message="...">...</failure> 3188// <failure message="...">...</failure> 3189// <failure message="...">...</failure> 3190// <-- individual assertion failures 3191// </testcase> 3192// </testsuite> 3193// </testsuites> 3194 3195// Formats the given time in milliseconds as seconds. 3196std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) { 3197 ::std::stringstream ss; 3198 ss << ms/1000.0; 3199 return ss.str(); 3200} 3201 3202// Streams an XML CDATA section, escaping invalid CDATA sequences as needed. 3203void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream, 3204 const char* data) { 3205 const char* segment = data; 3206 *stream << "<![CDATA["; 3207 for (;;) { 3208 const char* const next_segment = strstr(segment, "]]>"); 3209 if (next_segment != NULL) { 3210 stream->write( 3211 segment, static_cast<std::streamsize>(next_segment - segment)); 3212 *stream << "]]>]]><![CDATA["; 3213 segment = next_segment + strlen("]]>"); 3214 } else { 3215 *stream << segment; 3216 break; 3217 } 3218 } 3219 *stream << "]]>"; 3220} 3221 3222// Prints an XML representation of a TestInfo object. 3223// TODO(wan): There is also value in printing properties with the plain printer. 3224void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream, 3225 const char* test_case_name, 3226 const TestInfo& test_info) { 3227 const TestResult& result = *test_info.result(); 3228 *stream << " <testcase name=\"" 3229 << EscapeXmlAttribute(test_info.name()).c_str() << "\""; 3230 3231 if (test_info.value_param() != NULL) { 3232 *stream << " value_param=\"" << EscapeXmlAttribute(test_info.value_param()) 3233 << "\""; 3234 } 3235 if (test_info.type_param() != NULL) { 3236 *stream << " type_param=\"" << EscapeXmlAttribute(test_info.type_param()) 3237 << "\""; 3238 } 3239 3240 *stream << " status=\"" 3241 << (test_info.should_run() ? "run" : "notrun") 3242 << "\" time=\"" 3243 << FormatTimeInMillisAsSeconds(result.elapsed_time()) 3244 << "\" classname=\"" << EscapeXmlAttribute(test_case_name).c_str() 3245 << "\"" << TestPropertiesAsXmlAttributes(result).c_str(); 3246 3247 int failures = 0; 3248 for (int i = 0; i < result.total_part_count(); ++i) { 3249 const TestPartResult& part = result.GetTestPartResult(i); 3250 if (part.failed()) { 3251 if (++failures == 1) 3252 *stream << ">\n"; 3253 *stream << " <failure message=\"" 3254 << EscapeXmlAttribute(part.summary()).c_str() 3255 << "\" type=\"\">"; 3256 const string location = internal::FormatCompilerIndependentFileLocation( 3257 part.file_name(), part.line_number()); 3258 const string message = location + "\n" + part.message(); 3259 OutputXmlCDataSection(stream, 3260 RemoveInvalidXmlCharacters(message).c_str()); 3261 *stream << "</failure>\n"; 3262 } 3263 } 3264 3265 if (failures == 0) 3266 *stream << " />\n"; 3267 else 3268 *stream << " </testcase>\n"; 3269} 3270 3271// Prints an XML representation of a TestCase object 3272void XmlUnitTestResultPrinter::PrintXmlTestCase(FILE* out, 3273 const TestCase& test_case) { 3274 fprintf(out, 3275 " <testsuite name=\"%s\" tests=\"%d\" failures=\"%d\" " 3276 "disabled=\"%d\" ", 3277 EscapeXmlAttribute(test_case.name()).c_str(), 3278 test_case.total_test_count(), 3279 test_case.failed_test_count(), 3280 test_case.disabled_test_count()); 3281 fprintf(out, 3282 "errors=\"0\" time=\"%s\">\n", 3283 FormatTimeInMillisAsSeconds(test_case.elapsed_time()).c_str()); 3284 for (int i = 0; i < test_case.total_test_count(); ++i) { 3285 ::std::stringstream stream; 3286 OutputXmlTestInfo(&stream, test_case.name(), *test_case.GetTestInfo(i)); 3287 fprintf(out, "%s", StringStreamToString(&stream).c_str()); 3288 } 3289 fprintf(out, " </testsuite>\n"); 3290} 3291 3292// Prints an XML summary of unit_test to output stream out. 3293void XmlUnitTestResultPrinter::PrintXmlUnitTest(FILE* out, 3294 const UnitTest& unit_test) { 3295 fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); 3296 fprintf(out, 3297 "<testsuites tests=\"%d\" failures=\"%d\" disabled=\"%d\" " 3298 "errors=\"0\" time=\"%s\" ", 3299 unit_test.total_test_count(), 3300 unit_test.failed_test_count(), 3301 unit_test.disabled_test_count(), 3302 FormatTimeInMillisAsSeconds(unit_test.elapsed_time()).c_str()); 3303 if (GTEST_FLAG(shuffle)) { 3304 fprintf(out, "random_seed=\"%d\" ", unit_test.random_seed()); 3305 } 3306 fprintf(out, "name=\"AllTests\">\n"); 3307 for (int i = 0; i < unit_test.total_test_case_count(); ++i) 3308 PrintXmlTestCase(out, *unit_test.GetTestCase(i)); 3309 fprintf(out, "</testsuites>\n"); 3310} 3311 3312// Produces a string representing the test properties in a result as space 3313// delimited XML attributes based on the property key="value" pairs. 3314String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes( 3315 const TestResult& result) { 3316 Message attributes; 3317 for (int i = 0; i < result.test_property_count(); ++i) { 3318 const TestProperty& property = result.GetTestProperty(i); 3319 attributes << " " << property.key() << "=" 3320 << "\"" << EscapeXmlAttribute(property.value()) << "\""; 3321 } 3322 return attributes.GetString(); 3323} 3324 3325// End XmlUnitTestResultPrinter 3326 3327#if GTEST_CAN_STREAM_RESULTS_ 3328 3329// Streams test results to the given port on the given host machine. 3330class StreamingListener : public EmptyTestEventListener { 3331 public: 3332 // Escapes '=', '&', '%', and '\n' characters in str as "%xx". 3333 static string UrlEncode(const char* str); 3334 3335 StreamingListener(const string& host, const string& port) 3336 : sockfd_(-1), host_name_(host), port_num_(port) { 3337 MakeConnection(); 3338 Send("gtest_streaming_protocol_version=1.0\n"); 3339 } 3340 3341 virtual ~StreamingListener() { 3342 if (sockfd_ != -1) 3343 CloseConnection(); 3344 } 3345 3346 void OnTestProgramStart(const UnitTest& /* unit_test */) { 3347 Send("event=TestProgramStart\n"); 3348 } 3349 3350 void OnTestProgramEnd(const UnitTest& unit_test) { 3351 // Note that Google Test current only report elapsed time for each 3352 // test iteration, not for the entire test program. 3353 Send(String::Format("event=TestProgramEnd&passed=%d\n", 3354 unit_test.Passed())); 3355 3356 // Notify the streaming server to stop. 3357 CloseConnection(); 3358 } 3359 3360 void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) { 3361 Send(String::Format("event=TestIterationStart&iteration=%d\n", 3362 iteration)); 3363 } 3364 3365 void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) { 3366 Send(String::Format("event=TestIterationEnd&passed=%d&elapsed_time=%sms\n", 3367 unit_test.Passed(), 3368 StreamableToString(unit_test.elapsed_time()).c_str())); 3369 } 3370 3371 void OnTestCaseStart(const TestCase& test_case) { 3372 Send(String::Format("event=TestCaseStart&name=%s\n", test_case.name())); 3373 } 3374 3375 void OnTestCaseEnd(const TestCase& test_case) { 3376 Send(String::Format("event=TestCaseEnd&passed=%d&elapsed_time=%sms\n", 3377 test_case.Passed(), 3378 StreamableToString(test_case.elapsed_time()).c_str())); 3379 } 3380 3381 void OnTestStart(const TestInfo& test_info) { 3382 Send(String::Format("event=TestStart&name=%s\n", test_info.name())); 3383 } 3384 3385 void OnTestEnd(const TestInfo& test_info) { 3386 Send(String::Format( 3387 "event=TestEnd&passed=%d&elapsed_time=%sms\n", 3388 (test_info.result())->Passed(), 3389 StreamableToString((test_info.result())->elapsed_time()).c_str())); 3390 } 3391 3392 void OnTestPartResult(const TestPartResult& test_part_result) { 3393 const char* file_name = test_part_result.file_name(); 3394 if (file_name == NULL) 3395 file_name = ""; 3396 Send(String::Format("event=TestPartResult&file=%s&line=%d&message=", 3397 UrlEncode(file_name).c_str(), 3398 test_part_result.line_number())); 3399 Send(UrlEncode(test_part_result.message()) + "\n"); 3400 } 3401 3402 private: 3403 // Creates a client socket and connects to the server. 3404 void MakeConnection(); 3405 3406 // Closes the socket. 3407 void CloseConnection() { 3408 GTEST_CHECK_(sockfd_ != -1) 3409 << "CloseConnection() can be called only when there is a connection."; 3410 3411 close(sockfd_); 3412 sockfd_ = -1; 3413 } 3414 3415 // Sends a string to the socket. 3416 void Send(const string& message) { 3417 GTEST_CHECK_(sockfd_ != -1) 3418 << "Send() can be called only when there is a connection."; 3419 3420 const int len = static_cast<int>(message.length()); 3421 if (write(sockfd_, message.c_str(), len) != len) { 3422 GTEST_LOG_(WARNING) 3423 << "stream_result_to: failed to stream to " 3424 << host_name_ << ":" << port_num_; 3425 } 3426 } 3427 3428 int sockfd_; // socket file descriptor 3429 const string host_name_; 3430 const string port_num_; 3431 3432 GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener); 3433}; // class StreamingListener 3434 3435// Checks if str contains '=', '&', '%' or '\n' characters. If yes, 3436// replaces them by "%xx" where xx is their hexadecimal value. For 3437// example, replaces "=" with "%3D". This algorithm is O(strlen(str)) 3438// in both time and space -- important as the input str may contain an 3439// arbitrarily long test failure message and stack trace. 3440string StreamingListener::UrlEncode(const char* str) { 3441 string result; 3442 result.reserve(strlen(str) + 1); 3443 for (char ch = *str; ch != '\0'; ch = *++str) { 3444 switch (ch) { 3445 case '%': 3446 case '=': 3447 case '&': 3448 case '\n': 3449 result.append(String::Format("%%%02x", static_cast<unsigned char>(ch))); 3450 break; 3451 default: 3452 result.push_back(ch); 3453 break; 3454 } 3455 } 3456 return result; 3457} 3458 3459void StreamingListener::MakeConnection() { 3460 GTEST_CHECK_(sockfd_ == -1) 3461 << "MakeConnection() can't be called when there is already a connection."; 3462 3463 addrinfo hints; 3464 memset(&hints, 0, sizeof(hints)); 3465 hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses. 3466 hints.ai_socktype = SOCK_STREAM; 3467 addrinfo* servinfo = NULL; 3468 3469 // Use the getaddrinfo() to get a linked list of IP addresses for 3470 // the given host name. 3471 const int error_num = getaddrinfo( 3472 host_name_.c_str(), port_num_.c_str(), &hints, &servinfo); 3473 if (error_num != 0) { 3474 GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: " 3475 << gai_strerror(error_num); 3476 } 3477 3478 // Loop through all the results and connect to the first we can. 3479 for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL; 3480 cur_addr = cur_addr->ai_next) { 3481 sockfd_ = socket( 3482 cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol); 3483 if (sockfd_ != -1) { 3484 // Connect the client socket to the server socket. 3485 if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) { 3486 close(sockfd_); 3487 sockfd_ = -1; 3488 } 3489 } 3490 } 3491 3492 freeaddrinfo(servinfo); // all done with this structure 3493 3494 if (sockfd_ == -1) { 3495 GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to " 3496 << host_name_ << ":" << port_num_; 3497 } 3498} 3499 3500// End of class Streaming Listener 3501#endif // GTEST_CAN_STREAM_RESULTS__ 3502 3503// Class ScopedTrace 3504 3505// Pushes the given source file location and message onto a per-thread 3506// trace stack maintained by Google Test. 3507// L < UnitTest::mutex_ 3508ScopedTrace::ScopedTrace(const char* file, int line, const Message& message) { 3509 TraceInfo trace; 3510 trace.file = file; 3511 trace.line = line; 3512 trace.message = message.GetString(); 3513 3514 UnitTest::GetInstance()->PushGTestTrace(trace); 3515} 3516 3517// Pops the info pushed by the c'tor. 3518// L < UnitTest::mutex_ 3519ScopedTrace::~ScopedTrace() { 3520 UnitTest::GetInstance()->PopGTestTrace(); 3521} 3522 3523 3524// class OsStackTraceGetter 3525 3526// Returns the current OS stack trace as a String. Parameters: 3527// 3528// max_depth - the maximum number of stack frames to be included 3529// in the trace. 3530// skip_count - the number of top frames to be skipped; doesn't count 3531// against max_depth. 3532// 3533// L < mutex_ 3534// We use "L < mutex_" to denote that the function may acquire mutex_. 3535String OsStackTraceGetter::CurrentStackTrace(int, int) { 3536 return String(""); 3537} 3538 3539// L < mutex_ 3540void OsStackTraceGetter::UponLeavingGTest() { 3541} 3542 3543const char* const 3544OsStackTraceGetter::kElidedFramesMarker = 3545 "... " GTEST_NAME_ " internal frames ..."; 3546 3547} // namespace internal 3548 3549// class TestEventListeners 3550 3551TestEventListeners::TestEventListeners() 3552 : repeater_(new internal::TestEventRepeater()), 3553 default_result_printer_(NULL), 3554 default_xml_generator_(NULL) { 3555} 3556 3557TestEventListeners::~TestEventListeners() { delete repeater_; } 3558 3559// Returns the standard listener responsible for the default console 3560// output. Can be removed from the listeners list to shut down default 3561// console output. Note that removing this object from the listener list 3562// with Release transfers its ownership to the user. 3563void TestEventListeners::Append(TestEventListener* listener) { 3564 repeater_->Append(listener); 3565} 3566 3567// Removes the given event listener from the list and returns it. It then 3568// becomes the caller's responsibility to delete the listener. Returns 3569// NULL if the listener is not found in the list. 3570TestEventListener* TestEventListeners::Release(TestEventListener* listener) { 3571 if (listener == default_result_printer_) 3572 default_result_printer_ = NULL; 3573 else if (listener == default_xml_generator_) 3574 default_xml_generator_ = NULL; 3575 return repeater_->Release(listener); 3576} 3577 3578// Returns repeater that broadcasts the TestEventListener events to all 3579// subscribers. 3580TestEventListener* TestEventListeners::repeater() { return repeater_; } 3581 3582// Sets the default_result_printer attribute to the provided listener. 3583// The listener is also added to the listener list and previous 3584// default_result_printer is removed from it and deleted. The listener can 3585// also be NULL in which case it will not be added to the list. Does 3586// nothing if the previous and the current listener objects are the same. 3587void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) { 3588 if (default_result_printer_ != listener) { 3589 // It is an error to pass this method a listener that is already in the 3590 // list. 3591 delete Release(default_result_printer_); 3592 default_result_printer_ = listener; 3593 if (listener != NULL) 3594 Append(listener); 3595 } 3596} 3597 3598// Sets the default_xml_generator attribute to the provided listener. The 3599// listener is also added to the listener list and previous 3600// default_xml_generator is removed from it and deleted. The listener can 3601// also be NULL in which case it will not be added to the list. Does 3602// nothing if the previous and the current listener objects are the same. 3603void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) { 3604 if (default_xml_generator_ != listener) { 3605 // It is an error to pass this method a listener that is already in the 3606 // list. 3607 delete Release(default_xml_generator_); 3608 default_xml_generator_ = listener; 3609 if (listener != NULL) 3610 Append(listener); 3611 } 3612} 3613 3614// Controls whether events will be forwarded by the repeater to the 3615// listeners in the list. 3616bool TestEventListeners::EventForwardingEnabled() const { 3617 return repeater_->forwarding_enabled(); 3618} 3619 3620void TestEventListeners::SuppressEventForwarding() { 3621 repeater_->set_forwarding_enabled(false); 3622} 3623 3624// class UnitTest 3625 3626// Gets the singleton UnitTest object. The first time this method is 3627// called, a UnitTest object is constructed and returned. Consecutive 3628// calls will return the same object. 3629// 3630// We don't protect this under mutex_ as a user is not supposed to 3631// call this before main() starts, from which point on the return 3632// value will never change. 3633UnitTest * UnitTest::GetInstance() { 3634 // When compiled with MSVC 7.1 in optimized mode, destroying the 3635 // UnitTest object upon exiting the program messes up the exit code, 3636 // causing successful tests to appear failed. We have to use a 3637 // different implementation in this case to bypass the compiler bug. 3638 // This implementation makes the compiler happy, at the cost of 3639 // leaking the UnitTest object. 3640 3641 // CodeGear C++Builder insists on a public destructor for the 3642 // default implementation. Use this implementation to keep good OO 3643 // design with private destructor. 3644 3645#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) 3646 static UnitTest* const instance = new UnitTest; 3647 return instance; 3648#else 3649 static UnitTest instance; 3650 return &instance; 3651#endif // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) 3652} 3653 3654// Gets the number of successful test cases. 3655int UnitTest::successful_test_case_count() const { 3656 return impl()->successful_test_case_count(); 3657} 3658 3659// Gets the number of failed test cases. 3660int UnitTest::failed_test_case_count() const { 3661 return impl()->failed_test_case_count(); 3662} 3663 3664// Gets the number of all test cases. 3665int UnitTest::total_test_case_count() const { 3666 return impl()->total_test_case_count(); 3667} 3668 3669// Gets the number of all test cases that contain at least one test 3670// that should run. 3671int UnitTest::test_case_to_run_count() const { 3672 return impl()->test_case_to_run_count(); 3673} 3674 3675// Gets the number of successful tests. 3676int UnitTest::successful_test_count() const { 3677 return impl()->successful_test_count(); 3678} 3679 3680// Gets the number of failed tests. 3681int UnitTest::failed_test_count() const { return impl()->failed_test_count(); } 3682 3683// Gets the number of disabled tests. 3684int UnitTest::disabled_test_count() const { 3685 return impl()->disabled_test_count(); 3686} 3687 3688// Gets the number of all tests. 3689int UnitTest::total_test_count() const { return impl()->total_test_count(); } 3690 3691// Gets the number of tests that should run. 3692int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); } 3693 3694// Gets the elapsed time, in milliseconds. 3695internal::TimeInMillis UnitTest::elapsed_time() const { 3696 return impl()->elapsed_time(); 3697} 3698 3699// Returns true iff the unit test passed (i.e. all test cases passed). 3700bool UnitTest::Passed() const { return impl()->Passed(); } 3701 3702// Returns true iff the unit test failed (i.e. some test case failed 3703// or something outside of all tests failed). 3704bool UnitTest::Failed() const { return impl()->Failed(); } 3705 3706// Gets the i-th test case among all the test cases. i can range from 0 to 3707// total_test_case_count() - 1. If i is not in that range, returns NULL. 3708const TestCase* UnitTest::GetTestCase(int i) const { 3709 return impl()->GetTestCase(i); 3710} 3711 3712// Gets the i-th test case among all the test cases. i can range from 0 to 3713// total_test_case_count() - 1. If i is not in that range, returns NULL. 3714TestCase* UnitTest::GetMutableTestCase(int i) { 3715 return impl()->GetMutableTestCase(i); 3716} 3717 3718// Returns the list of event listeners that can be used to track events 3719// inside Google Test. 3720TestEventListeners& UnitTest::listeners() { 3721 return *impl()->listeners(); 3722} 3723 3724// Registers and returns a global test environment. When a test 3725// program is run, all global test environments will be set-up in the 3726// order they were registered. After all tests in the program have 3727// finished, all global test environments will be torn-down in the 3728// *reverse* order they were registered. 3729// 3730// The UnitTest object takes ownership of the given environment. 3731// 3732// We don't protect this under mutex_, as we only support calling it 3733// from the main thread. 3734Environment* UnitTest::AddEnvironment(Environment* env) { 3735 if (env == NULL) { 3736 return NULL; 3737 } 3738 3739 impl_->environments().push_back(env); 3740 return env; 3741} 3742 3743// Adds a TestPartResult to the current TestResult object. All Google Test 3744// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call 3745// this to report their results. The user code should use the 3746// assertion macros instead of calling this directly. 3747// L < mutex_ 3748void UnitTest::AddTestPartResult(TestPartResult::Type result_type, 3749 const char* file_name, 3750 int line_number, 3751 const internal::String& message, 3752 const internal::String& os_stack_trace) { 3753 Message msg; 3754 msg << message; 3755 3756 internal::MutexLock lock(&mutex_); 3757 if (impl_->gtest_trace_stack().size() > 0) { 3758 msg << "\n" << GTEST_NAME_ << " trace:"; 3759 3760 for (int i = static_cast<int>(impl_->gtest_trace_stack().size()); 3761 i > 0; --i) { 3762 const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1]; 3763 msg << "\n" << internal::FormatFileLocation(trace.file, trace.line) 3764 << " " << trace.message; 3765 } 3766 } 3767 3768 if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) { 3769 msg << internal::kStackTraceMarker << os_stack_trace; 3770 } 3771 3772 const TestPartResult result = 3773 TestPartResult(result_type, file_name, line_number, 3774 msg.GetString().c_str()); 3775 impl_->GetTestPartResultReporterForCurrentThread()-> 3776 ReportTestPartResult(result); 3777 3778 if (result_type != TestPartResult::kSuccess) { 3779 // gtest_break_on_failure takes precedence over 3780 // gtest_throw_on_failure. This allows a user to set the latter 3781 // in the code (perhaps in order to use Google Test assertions 3782 // with another testing framework) and specify the former on the 3783 // command line for debugging. 3784 if (GTEST_FLAG(break_on_failure)) { 3785#if GTEST_OS_WINDOWS 3786 // Using DebugBreak on Windows allows gtest to still break into a debugger 3787 // when a failure happens and both the --gtest_break_on_failure and 3788 // the --gtest_catch_exceptions flags are specified. 3789 DebugBreak(); 3790#else 3791 // Dereference NULL through a volatile pointer to prevent the compiler 3792 // from removing. We use this rather than abort() or __builtin_trap() for 3793 // portability: Symbian doesn't implement abort() well, and some debuggers 3794 // don't correctly trap abort(). 3795 *static_cast<volatile int*>(NULL) = 1; 3796#endif // GTEST_OS_WINDOWS 3797 } else if (GTEST_FLAG(throw_on_failure)) { 3798#if GTEST_HAS_EXCEPTIONS 3799 throw GoogleTestFailureException(result); 3800#else 3801 // We cannot call abort() as it generates a pop-up in debug mode 3802 // that cannot be suppressed in VC 7.1 or below. 3803 exit(1); 3804#endif 3805 } 3806 } 3807} 3808 3809// Creates and adds a property to the current TestResult. If a property matching 3810// the supplied value already exists, updates its value instead. 3811void UnitTest::RecordPropertyForCurrentTest(const char* key, 3812 const char* value) { 3813 const TestProperty test_property(key, value); 3814 impl_->current_test_result()->RecordProperty(test_property); 3815} 3816 3817// Runs all tests in this UnitTest object and prints the result. 3818// Returns 0 if successful, or 1 otherwise. 3819// 3820// We don't protect this under mutex_, as we only support calling it 3821// from the main thread. 3822int UnitTest::Run() { 3823 // Captures the value of GTEST_FLAG(catch_exceptions). This value will be 3824 // used for the duration of the program. 3825 impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions)); 3826 3827#if GTEST_HAS_SEH 3828 const bool in_death_test_child_process = 3829 internal::GTEST_FLAG(internal_run_death_test).length() > 0; 3830 3831 // Either the user wants Google Test to catch exceptions thrown by the 3832 // tests or this is executing in the context of death test child 3833 // process. In either case the user does not want to see pop-up dialogs 3834 // about crashes - they are expected. 3835 if (impl()->catch_exceptions() || in_death_test_child_process) { 3836 3837# if !GTEST_OS_WINDOWS_MOBILE 3838 // SetErrorMode doesn't exist on CE. 3839 SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT | 3840 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); 3841# endif // !GTEST_OS_WINDOWS_MOBILE 3842 3843# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE 3844 // Death test children can be terminated with _abort(). On Windows, 3845 // _abort() can show a dialog with a warning message. This forces the 3846 // abort message to go to stderr instead. 3847 _set_error_mode(_OUT_TO_STDERR); 3848# endif 3849 3850# if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE 3851 // In the debug version, Visual Studio pops up a separate dialog 3852 // offering a choice to debug the aborted program. We need to suppress 3853 // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement 3854 // executed. Google Test will notify the user of any unexpected 3855 // failure via stderr. 3856 // 3857 // VC++ doesn't define _set_abort_behavior() prior to the version 8.0. 3858 // Users of prior VC versions shall suffer the agony and pain of 3859 // clicking through the countless debug dialogs. 3860 // TODO(vladl@google.com): find a way to suppress the abort dialog() in the 3861 // debug mode when compiled with VC 7.1 or lower. 3862 if (!GTEST_FLAG(break_on_failure)) 3863 _set_abort_behavior( 3864 0x0, // Clear the following flags: 3865 _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump. 3866# endif 3867 3868 } 3869#endif // GTEST_HAS_SEH 3870 3871 return internal::HandleExceptionsInMethodIfSupported( 3872 impl(), 3873 &internal::UnitTestImpl::RunAllTests, 3874 "auxiliary test code (environments or event listeners)") ? 0 : 1; 3875} 3876 3877// Returns the working directory when the first TEST() or TEST_F() was 3878// executed. 3879const char* UnitTest::original_working_dir() const { 3880 return impl_->original_working_dir_.c_str(); 3881} 3882 3883// Returns the TestCase object for the test that's currently running, 3884// or NULL if no test is running. 3885// L < mutex_ 3886const TestCase* UnitTest::current_test_case() const { 3887 internal::MutexLock lock(&mutex_); 3888 return impl_->current_test_case(); 3889} 3890 3891// Returns the TestInfo object for the test that's currently running, 3892// or NULL if no test is running. 3893// L < mutex_ 3894const TestInfo* UnitTest::current_test_info() const { 3895 internal::MutexLock lock(&mutex_); 3896 return impl_->current_test_info(); 3897} 3898 3899// Returns the random seed used at the start of the current test run. 3900int UnitTest::random_seed() const { return impl_->random_seed(); } 3901 3902#if GTEST_HAS_PARAM_TEST 3903// Returns ParameterizedTestCaseRegistry object used to keep track of 3904// value-parameterized tests and instantiate and register them. 3905// L < mutex_ 3906internal::ParameterizedTestCaseRegistry& 3907 UnitTest::parameterized_test_registry() { 3908 return impl_->parameterized_test_registry(); 3909} 3910#endif // GTEST_HAS_PARAM_TEST 3911 3912// Creates an empty UnitTest. 3913UnitTest::UnitTest() { 3914 impl_ = new internal::UnitTestImpl(this); 3915} 3916 3917// Destructor of UnitTest. 3918UnitTest::~UnitTest() { 3919 delete impl_; 3920} 3921 3922// Pushes a trace defined by SCOPED_TRACE() on to the per-thread 3923// Google Test trace stack. 3924// L < mutex_ 3925void UnitTest::PushGTestTrace(const internal::TraceInfo& trace) { 3926 internal::MutexLock lock(&mutex_); 3927 impl_->gtest_trace_stack().push_back(trace); 3928} 3929 3930// Pops a trace from the per-thread Google Test trace stack. 3931// L < mutex_ 3932void UnitTest::PopGTestTrace() { 3933 internal::MutexLock lock(&mutex_); 3934 impl_->gtest_trace_stack().pop_back(); 3935} 3936 3937namespace internal { 3938 3939UnitTestImpl::UnitTestImpl(UnitTest* parent) 3940 : parent_(parent), 3941#ifdef _MSC_VER 3942# pragma warning(push) // Saves the current warning state. 3943# pragma warning(disable:4355) // Temporarily disables warning 4355 3944 // (using this in initializer). 3945 default_global_test_part_result_reporter_(this), 3946 default_per_thread_test_part_result_reporter_(this), 3947# pragma warning(pop) // Restores the warning state again. 3948#else 3949 default_global_test_part_result_reporter_(this), 3950 default_per_thread_test_part_result_reporter_(this), 3951#endif // _MSC_VER 3952 global_test_part_result_repoter_( 3953 &default_global_test_part_result_reporter_), 3954 per_thread_test_part_result_reporter_( 3955 &default_per_thread_test_part_result_reporter_), 3956#if GTEST_HAS_PARAM_TEST 3957 parameterized_test_registry_(), 3958 parameterized_tests_registered_(false), 3959#endif // GTEST_HAS_PARAM_TEST 3960 last_death_test_case_(-1), 3961 current_test_case_(NULL), 3962 current_test_info_(NULL), 3963 ad_hoc_test_result_(), 3964 os_stack_trace_getter_(NULL), 3965 post_flag_parse_init_performed_(false), 3966 random_seed_(0), // Will be overridden by the flag before first use. 3967 random_(0), // Will be reseeded before first use. 3968 elapsed_time_(0), 3969#if GTEST_HAS_DEATH_TEST 3970 internal_run_death_test_flag_(NULL), 3971 death_test_factory_(new DefaultDeathTestFactory), 3972#endif 3973 // Will be overridden by the flag before first use. 3974 catch_exceptions_(false) { 3975 listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter); 3976} 3977 3978UnitTestImpl::~UnitTestImpl() { 3979 // Deletes every TestCase. 3980 ForEach(test_cases_, internal::Delete<TestCase>); 3981 3982 // Deletes every Environment. 3983 ForEach(environments_, internal::Delete<Environment>); 3984 3985 delete os_stack_trace_getter_; 3986} 3987 3988#if GTEST_HAS_DEATH_TEST 3989// Disables event forwarding if the control is currently in a death test 3990// subprocess. Must not be called before InitGoogleTest. 3991void UnitTestImpl::SuppressTestEventsIfInSubprocess() { 3992 if (internal_run_death_test_flag_.get() != NULL) 3993 listeners()->SuppressEventForwarding(); 3994} 3995#endif // GTEST_HAS_DEATH_TEST 3996 3997// Initializes event listeners performing XML output as specified by 3998// UnitTestOptions. Must not be called before InitGoogleTest. 3999void UnitTestImpl::ConfigureXmlOutput() { 4000 const String& output_format = UnitTestOptions::GetOutputFormat(); 4001 if (output_format == "xml") { 4002 listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter( 4003 UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); 4004 } else if (output_format != "") { 4005 printf("WARNING: unrecognized output format \"%s\" ignored.\n", 4006 output_format.c_str()); 4007 fflush(stdout); 4008 } 4009} 4010 4011#if GTEST_CAN_STREAM_RESULTS_ 4012// Initializes event listeners for streaming test results in String form. 4013// Must not be called before InitGoogleTest. 4014void UnitTestImpl::ConfigureStreamingOutput() { 4015 const string& target = GTEST_FLAG(stream_result_to); 4016 if (!target.empty()) { 4017 const size_t pos = target.find(':'); 4018 if (pos != string::npos) { 4019 listeners()->Append(new StreamingListener(target.substr(0, pos), 4020 target.substr(pos+1))); 4021 } else { 4022 printf("WARNING: unrecognized streaming target \"%s\" ignored.\n", 4023 target.c_str()); 4024 fflush(stdout); 4025 } 4026 } 4027} 4028#endif // GTEST_CAN_STREAM_RESULTS_ 4029 4030// Performs initialization dependent upon flag values obtained in 4031// ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to 4032// ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest 4033// this function is also called from RunAllTests. Since this function can be 4034// called more than once, it has to be idempotent. 4035void UnitTestImpl::PostFlagParsingInit() { 4036 // Ensures that this function does not execute more than once. 4037 if (!post_flag_parse_init_performed_) { 4038 post_flag_parse_init_performed_ = true; 4039 4040#if GTEST_HAS_DEATH_TEST 4041 InitDeathTestSubprocessControlInfo(); 4042 SuppressTestEventsIfInSubprocess(); 4043#endif // GTEST_HAS_DEATH_TEST 4044 4045 // Registers parameterized tests. This makes parameterized tests 4046 // available to the UnitTest reflection API without running 4047 // RUN_ALL_TESTS. 4048 RegisterParameterizedTests(); 4049 4050 // Configures listeners for XML output. This makes it possible for users 4051 // to shut down the default XML output before invoking RUN_ALL_TESTS. 4052 ConfigureXmlOutput(); 4053 4054#if GTEST_CAN_STREAM_RESULTS_ 4055 // Configures listeners for streaming test results to the specified server. 4056 ConfigureStreamingOutput(); 4057#endif // GTEST_CAN_STREAM_RESULTS_ 4058 } 4059} 4060 4061// A predicate that checks the name of a TestCase against a known 4062// value. 4063// 4064// This is used for implementation of the UnitTest class only. We put 4065// it in the anonymous namespace to prevent polluting the outer 4066// namespace. 4067// 4068// TestCaseNameIs is copyable. 4069class TestCaseNameIs { 4070 public: 4071 // Constructor. 4072 explicit TestCaseNameIs(const String& name) 4073 : name_(name) {} 4074 4075 // Returns true iff the name of test_case matches name_. 4076 bool operator()(const TestCase* test_case) const { 4077 return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0; 4078 } 4079 4080 private: 4081 String name_; 4082}; 4083 4084// Finds and returns a TestCase with the given name. If one doesn't 4085// exist, creates one and returns it. It's the CALLER'S 4086// RESPONSIBILITY to ensure that this function is only called WHEN THE 4087// TESTS ARE NOT SHUFFLED. 4088// 4089// Arguments: 4090// 4091// test_case_name: name of the test case 4092// type_param: the name of the test case's type parameter, or NULL if 4093// this is not a typed or a type-parameterized test case. 4094// set_up_tc: pointer to the function that sets up the test case 4095// tear_down_tc: pointer to the function that tears down the test case 4096TestCase* UnitTestImpl::GetTestCase(const char* test_case_name, 4097 const char* type_param, 4098 Test::SetUpTestCaseFunc set_up_tc, 4099 Test::TearDownTestCaseFunc tear_down_tc) { 4100 // Can we find a TestCase with the given name? 4101 const std::vector<TestCase*>::const_iterator test_case = 4102 std::find_if(test_cases_.begin(), test_cases_.end(), 4103 TestCaseNameIs(test_case_name)); 4104 4105 if (test_case != test_cases_.end()) 4106 return *test_case; 4107 4108 // No. Let's create one. 4109 TestCase* const new_test_case = 4110 new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc); 4111 4112 // Is this a death test case? 4113 if (internal::UnitTestOptions::MatchesFilter(String(test_case_name), 4114 kDeathTestCaseFilter)) { 4115 // Yes. Inserts the test case after the last death test case 4116 // defined so far. This only works when the test cases haven't 4117 // been shuffled. Otherwise we may end up running a death test 4118 // after a non-death test. 4119 ++last_death_test_case_; 4120 test_cases_.insert(test_cases_.begin() + last_death_test_case_, 4121 new_test_case); 4122 } else { 4123 // No. Appends to the end of the list. 4124 test_cases_.push_back(new_test_case); 4125 } 4126 4127 test_case_indices_.push_back(static_cast<int>(test_case_indices_.size())); 4128 return new_test_case; 4129} 4130 4131// Helpers for setting up / tearing down the given environment. They 4132// are for use in the ForEach() function. 4133static void SetUpEnvironment(Environment* env) { env->SetUp(); } 4134static void TearDownEnvironment(Environment* env) { env->TearDown(); } 4135 4136// Runs all tests in this UnitTest object, prints the result, and 4137// returns true if all tests are successful. If any exception is 4138// thrown during a test, the test is considered to be failed, but the 4139// rest of the tests will still be run. 4140// 4141// When parameterized tests are enabled, it expands and registers 4142// parameterized tests first in RegisterParameterizedTests(). 4143// All other functions called from RunAllTests() may safely assume that 4144// parameterized tests are ready to be counted and run. 4145bool UnitTestImpl::RunAllTests() { 4146 // Makes sure InitGoogleTest() was called. 4147 if (!GTestIsInitialized()) { 4148 printf("%s", 4149 "\nThis test program did NOT call ::testing::InitGoogleTest " 4150 "before calling RUN_ALL_TESTS(). Please fix it.\n"); 4151 return false; 4152 } 4153 4154 // Do not run any test if the --help flag was specified. 4155 if (g_help_flag) 4156 return true; 4157 4158 // Repeats the call to the post-flag parsing initialization in case the 4159 // user didn't call InitGoogleTest. 4160 PostFlagParsingInit(); 4161 4162 // Even if sharding is not on, test runners may want to use the 4163 // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding 4164 // protocol. 4165 internal::WriteToShardStatusFileIfNeeded(); 4166 4167 // True iff we are in a subprocess for running a thread-safe-style 4168 // death test. 4169 bool in_subprocess_for_death_test = false; 4170 4171#if GTEST_HAS_DEATH_TEST 4172 in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL); 4173#endif // GTEST_HAS_DEATH_TEST 4174 4175 const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex, 4176 in_subprocess_for_death_test); 4177 4178 // Compares the full test names with the filter to decide which 4179 // tests to run. 4180 const bool has_tests_to_run = FilterTests(should_shard 4181 ? HONOR_SHARDING_PROTOCOL 4182 : IGNORE_SHARDING_PROTOCOL) > 0; 4183 4184 // Lists the tests and exits if the --gtest_list_tests flag was specified. 4185 if (GTEST_FLAG(list_tests)) { 4186 // This must be called *after* FilterTests() has been called. 4187 ListTestsMatchingFilter(); 4188 return true; 4189 } 4190 4191 random_seed_ = GTEST_FLAG(shuffle) ? 4192 GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0; 4193 4194 // True iff at least one test has failed. 4195 bool failed = false; 4196 4197 TestEventListener* repeater = listeners()->repeater(); 4198 4199 repeater->OnTestProgramStart(*parent_); 4200 4201 // How many times to repeat the tests? We don't want to repeat them 4202 // when we are inside the subprocess of a death test. 4203 const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat); 4204 // Repeats forever if the repeat count is negative. 4205 const bool forever = repeat < 0; 4206 for (int i = 0; forever || i != repeat; i++) { 4207 // We want to preserve failures generated by ad-hoc test 4208 // assertions executed before RUN_ALL_TESTS(). 4209 ClearNonAdHocTestResult(); 4210 4211 const TimeInMillis start = GetTimeInMillis(); 4212 4213 // Shuffles test cases and tests if requested. 4214 if (has_tests_to_run && GTEST_FLAG(shuffle)) { 4215 random()->Reseed(random_seed_); 4216 // This should be done before calling OnTestIterationStart(), 4217 // such that a test event listener can see the actual test order 4218 // in the event. 4219 ShuffleTests(); 4220 } 4221 4222 // Tells the unit test event listeners that the tests are about to start. 4223 repeater->OnTestIterationStart(*parent_, i); 4224 4225 // Runs each test case if there is at least one test to run. 4226 if (has_tests_to_run) { 4227 // Sets up all environments beforehand. 4228 repeater->OnEnvironmentsSetUpStart(*parent_); 4229 ForEach(environments_, SetUpEnvironment); 4230 repeater->OnEnvironmentsSetUpEnd(*parent_); 4231 4232 // Runs the tests only if there was no fatal failure during global 4233 // set-up. 4234 if (!Test::HasFatalFailure()) { 4235 for (int test_index = 0; test_index < total_test_case_count(); 4236 test_index++) { 4237 GetMutableTestCase(test_index)->Run(); 4238 } 4239 } 4240 4241 // Tears down all environments in reverse order afterwards. 4242 repeater->OnEnvironmentsTearDownStart(*parent_); 4243 std::for_each(environments_.rbegin(), environments_.rend(), 4244 TearDownEnvironment); 4245 repeater->OnEnvironmentsTearDownEnd(*parent_); 4246 } 4247 4248 elapsed_time_ = GetTimeInMillis() - start; 4249 4250 // Tells the unit test event listener that the tests have just finished. 4251 repeater->OnTestIterationEnd(*parent_, i); 4252 4253 // Gets the result and clears it. 4254 if (!Passed()) { 4255 failed = true; 4256 } 4257 4258 // Restores the original test order after the iteration. This 4259 // allows the user to quickly repro a failure that happens in the 4260 // N-th iteration without repeating the first (N - 1) iterations. 4261 // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in 4262 // case the user somehow changes the value of the flag somewhere 4263 // (it's always safe to unshuffle the tests). 4264 UnshuffleTests(); 4265 4266 if (GTEST_FLAG(shuffle)) { 4267 // Picks a new random seed for each iteration. 4268 random_seed_ = GetNextRandomSeed(random_seed_); 4269 } 4270 } 4271 4272 repeater->OnTestProgramEnd(*parent_); 4273 4274 return !failed; 4275} 4276 4277// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file 4278// if the variable is present. If a file already exists at this location, this 4279// function will write over it. If the variable is present, but the file cannot 4280// be created, prints an error and exits. 4281void WriteToShardStatusFileIfNeeded() { 4282 const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile); 4283 if (test_shard_file != NULL) { 4284 FILE* const file = posix::FOpen(test_shard_file, "w"); 4285 if (file == NULL) { 4286 ColoredPrintf(COLOR_RED, 4287 "Could not write to the test shard status file \"%s\" " 4288 "specified by the %s environment variable.\n", 4289 test_shard_file, kTestShardStatusFile); 4290 fflush(stdout); 4291 exit(EXIT_FAILURE); 4292 } 4293 fclose(file); 4294 } 4295} 4296 4297// Checks whether sharding is enabled by examining the relevant 4298// environment variable values. If the variables are present, 4299// but inconsistent (i.e., shard_index >= total_shards), prints 4300// an error and exits. If in_subprocess_for_death_test, sharding is 4301// disabled because it must only be applied to the original test 4302// process. Otherwise, we could filter out death tests we intended to execute. 4303bool ShouldShard(const char* total_shards_env, 4304 const char* shard_index_env, 4305 bool in_subprocess_for_death_test) { 4306 if (in_subprocess_for_death_test) { 4307 return false; 4308 } 4309 4310 const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1); 4311 const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1); 4312 4313 if (total_shards == -1 && shard_index == -1) { 4314 return false; 4315 } else if (total_shards == -1 && shard_index != -1) { 4316 const Message msg = Message() 4317 << "Invalid environment variables: you have " 4318 << kTestShardIndex << " = " << shard_index 4319 << ", but have left " << kTestTotalShards << " unset.\n"; 4320 ColoredPrintf(COLOR_RED, msg.GetString().c_str()); 4321 fflush(stdout); 4322 exit(EXIT_FAILURE); 4323 } else if (total_shards != -1 && shard_index == -1) { 4324 const Message msg = Message() 4325 << "Invalid environment variables: you have " 4326 << kTestTotalShards << " = " << total_shards 4327 << ", but have left " << kTestShardIndex << " unset.\n"; 4328 ColoredPrintf(COLOR_RED, msg.GetString().c_str()); 4329 fflush(stdout); 4330 exit(EXIT_FAILURE); 4331 } else if (shard_index < 0 || shard_index >= total_shards) { 4332 const Message msg = Message() 4333 << "Invalid environment variables: we require 0 <= " 4334 << kTestShardIndex << " < " << kTestTotalShards 4335 << ", but you have " << kTestShardIndex << "=" << shard_index 4336 << ", " << kTestTotalShards << "=" << total_shards << ".\n"; 4337 ColoredPrintf(COLOR_RED, msg.GetString().c_str()); 4338 fflush(stdout); 4339 exit(EXIT_FAILURE); 4340 } 4341 4342 return total_shards > 1; 4343} 4344 4345// Parses the environment variable var as an Int32. If it is unset, 4346// returns default_val. If it is not an Int32, prints an error 4347// and aborts. 4348Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) { 4349 const char* str_val = posix::GetEnv(var); 4350 if (str_val == NULL) { 4351 return default_val; 4352 } 4353 4354 Int32 result; 4355 if (!ParseInt32(Message() << "The value of environment variable " << var, 4356 str_val, &result)) { 4357 exit(EXIT_FAILURE); 4358 } 4359 return result; 4360} 4361 4362// Given the total number of shards, the shard index, and the test id, 4363// returns true iff the test should be run on this shard. The test id is 4364// some arbitrary but unique non-negative integer assigned to each test 4365// method. Assumes that 0 <= shard_index < total_shards. 4366bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) { 4367 return (test_id % total_shards) == shard_index; 4368} 4369 4370// Compares the name of each test with the user-specified filter to 4371// decide whether the test should be run, then records the result in 4372// each TestCase and TestInfo object. 4373// If shard_tests == true, further filters tests based on sharding 4374// variables in the environment - see 4375// http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide. 4376// Returns the number of tests that should run. 4377int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) { 4378 const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ? 4379 Int32FromEnvOrDie(kTestTotalShards, -1) : -1; 4380 const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ? 4381 Int32FromEnvOrDie(kTestShardIndex, -1) : -1; 4382 4383 // num_runnable_tests are the number of tests that will 4384 // run across all shards (i.e., match filter and are not disabled). 4385 // num_selected_tests are the number of tests to be run on 4386 // this shard. 4387 int num_runnable_tests = 0; 4388 int num_selected_tests = 0; 4389 for (size_t i = 0; i < test_cases_.size(); i++) { 4390 TestCase* const test_case = test_cases_[i]; 4391 const String &test_case_name = test_case->name(); 4392 test_case->set_should_run(false); 4393 4394 for (size_t j = 0; j < test_case->test_info_list().size(); j++) { 4395 TestInfo* const test_info = test_case->test_info_list()[j]; 4396 const String test_name(test_info->name()); 4397 // A test is disabled if test case name or test name matches 4398 // kDisableTestFilter. 4399 const bool is_disabled = 4400 internal::UnitTestOptions::MatchesFilter(test_case_name, 4401 kDisableTestFilter) || 4402 internal::UnitTestOptions::MatchesFilter(test_name, 4403 kDisableTestFilter); 4404 test_info->is_disabled_ = is_disabled; 4405 4406 const bool matches_filter = 4407 internal::UnitTestOptions::FilterMatchesTest(test_case_name, 4408 test_name); 4409 test_info->matches_filter_ = matches_filter; 4410 4411 const bool is_runnable = 4412 (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) && 4413 matches_filter; 4414 4415 const bool is_selected = is_runnable && 4416 (shard_tests == IGNORE_SHARDING_PROTOCOL || 4417 ShouldRunTestOnShard(total_shards, shard_index, 4418 num_runnable_tests)); 4419 4420 num_runnable_tests += is_runnable; 4421 num_selected_tests += is_selected; 4422 4423 test_info->should_run_ = is_selected; 4424 test_case->set_should_run(test_case->should_run() || is_selected); 4425 } 4426 } 4427 return num_selected_tests; 4428} 4429 4430// Prints the names of the tests matching the user-specified filter flag. 4431void UnitTestImpl::ListTestsMatchingFilter() { 4432 for (size_t i = 0; i < test_cases_.size(); i++) { 4433 const TestCase* const test_case = test_cases_[i]; 4434 bool printed_test_case_name = false; 4435 4436 for (size_t j = 0; j < test_case->test_info_list().size(); j++) { 4437 const TestInfo* const test_info = 4438 test_case->test_info_list()[j]; 4439 if (test_info->matches_filter_) { 4440 if (!printed_test_case_name) { 4441 printed_test_case_name = true; 4442 printf("%s.\n", test_case->name()); 4443 } 4444 printf(" %s\n", test_info->name()); 4445 } 4446 } 4447 } 4448 fflush(stdout); 4449} 4450 4451// Sets the OS stack trace getter. 4452// 4453// Does nothing if the input and the current OS stack trace getter are 4454// the same; otherwise, deletes the old getter and makes the input the 4455// current getter. 4456void UnitTestImpl::set_os_stack_trace_getter( 4457 OsStackTraceGetterInterface* getter) { 4458 if (os_stack_trace_getter_ != getter) { 4459 delete os_stack_trace_getter_; 4460 os_stack_trace_getter_ = getter; 4461 } 4462} 4463 4464// Returns the current OS stack trace getter if it is not NULL; 4465// otherwise, creates an OsStackTraceGetter, makes it the current 4466// getter, and returns it. 4467OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() { 4468 if (os_stack_trace_getter_ == NULL) { 4469 os_stack_trace_getter_ = new OsStackTraceGetter; 4470 } 4471 4472 return os_stack_trace_getter_; 4473} 4474 4475// Returns the TestResult for the test that's currently running, or 4476// the TestResult for the ad hoc test if no test is running. 4477TestResult* UnitTestImpl::current_test_result() { 4478 return current_test_info_ ? 4479 &(current_test_info_->result_) : &ad_hoc_test_result_; 4480} 4481 4482// Shuffles all test cases, and the tests within each test case, 4483// making sure that death tests are still run first. 4484void UnitTestImpl::ShuffleTests() { 4485 // Shuffles the death test cases. 4486 ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_); 4487 4488 // Shuffles the non-death test cases. 4489 ShuffleRange(random(), last_death_test_case_ + 1, 4490 static_cast<int>(test_cases_.size()), &test_case_indices_); 4491 4492 // Shuffles the tests inside each test case. 4493 for (size_t i = 0; i < test_cases_.size(); i++) { 4494 test_cases_[i]->ShuffleTests(random()); 4495 } 4496} 4497 4498// Restores the test cases and tests to their order before the first shuffle. 4499void UnitTestImpl::UnshuffleTests() { 4500 for (size_t i = 0; i < test_cases_.size(); i++) { 4501 // Unshuffles the tests in each test case. 4502 test_cases_[i]->UnshuffleTests(); 4503 // Resets the index of each test case. 4504 test_case_indices_[i] = static_cast<int>(i); 4505 } 4506} 4507 4508// Returns the current OS stack trace as a String. 4509// 4510// The maximum number of stack frames to be included is specified by 4511// the gtest_stack_trace_depth flag. The skip_count parameter 4512// specifies the number of top frames to be skipped, which doesn't 4513// count against the number of frames to be included. 4514// 4515// For example, if Foo() calls Bar(), which in turn calls 4516// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in 4517// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. 4518String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/, 4519 int skip_count) { 4520 // We pass skip_count + 1 to skip this wrapper function in addition 4521 // to what the user really wants to skip. 4522 return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1); 4523} 4524 4525// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to 4526// suppress unreachable code warnings. 4527namespace { 4528class ClassUniqueToAlwaysTrue {}; 4529} 4530 4531bool IsTrue(bool condition) { return condition; } 4532 4533bool AlwaysTrue() { 4534#if GTEST_HAS_EXCEPTIONS 4535 // This condition is always false so AlwaysTrue() never actually throws, 4536 // but it makes the compiler think that it may throw. 4537 if (IsTrue(false)) 4538 throw ClassUniqueToAlwaysTrue(); 4539#endif // GTEST_HAS_EXCEPTIONS 4540 return true; 4541} 4542 4543// If *pstr starts with the given prefix, modifies *pstr to be right 4544// past the prefix and returns true; otherwise leaves *pstr unchanged 4545// and returns false. None of pstr, *pstr, and prefix can be NULL. 4546bool SkipPrefix(const char* prefix, const char** pstr) { 4547 const size_t prefix_len = strlen(prefix); 4548 if (strncmp(*pstr, prefix, prefix_len) == 0) { 4549 *pstr += prefix_len; 4550 return true; 4551 } 4552 return false; 4553} 4554 4555// Parses a string as a command line flag. The string should have 4556// the format "--flag=value". When def_optional is true, the "=value" 4557// part can be omitted. 4558// 4559// Returns the value of the flag, or NULL if the parsing failed. 4560const char* ParseFlagValue(const char* str, 4561 const char* flag, 4562 bool def_optional) { 4563 // str and flag must not be NULL. 4564 if (str == NULL || flag == NULL) return NULL; 4565 4566 // The flag must start with "--" followed by GTEST_FLAG_PREFIX_. 4567 const String flag_str = String::Format("--%s%s", GTEST_FLAG_PREFIX_, flag); 4568 const size_t flag_len = flag_str.length(); 4569 if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL; 4570 4571 // Skips the flag name. 4572 const char* flag_end = str + flag_len; 4573 4574 // When def_optional is true, it's OK to not have a "=value" part. 4575 if (def_optional && (flag_end[0] == '\0')) { 4576 return flag_end; 4577 } 4578 4579 // If def_optional is true and there are more characters after the 4580 // flag name, or if def_optional is false, there must be a '=' after 4581 // the flag name. 4582 if (flag_end[0] != '=') return NULL; 4583 4584 // Returns the string after "=". 4585 return flag_end + 1; 4586} 4587 4588// Parses a string for a bool flag, in the form of either 4589// "--flag=value" or "--flag". 4590// 4591// In the former case, the value is taken as true as long as it does 4592// not start with '0', 'f', or 'F'. 4593// 4594// In the latter case, the value is taken as true. 4595// 4596// On success, stores the value of the flag in *value, and returns 4597// true. On failure, returns false without changing *value. 4598bool ParseBoolFlag(const char* str, const char* flag, bool* value) { 4599 // Gets the value of the flag as a string. 4600 const char* const value_str = ParseFlagValue(str, flag, true); 4601 4602 // Aborts if the parsing failed. 4603 if (value_str == NULL) return false; 4604 4605 // Converts the string value to a bool. 4606 *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); 4607 return true; 4608} 4609 4610// Parses a string for an Int32 flag, in the form of 4611// "--flag=value". 4612// 4613// On success, stores the value of the flag in *value, and returns 4614// true. On failure, returns false without changing *value. 4615bool ParseInt32Flag(const char* str, const char* flag, Int32* value) { 4616 // Gets the value of the flag as a string. 4617 const char* const value_str = ParseFlagValue(str, flag, false); 4618 4619 // Aborts if the parsing failed. 4620 if (value_str == NULL) return false; 4621 4622 // Sets *value to the value of the flag. 4623 return ParseInt32(Message() << "The value of flag --" << flag, 4624 value_str, value); 4625} 4626 4627// Parses a string for a string flag, in the form of 4628// "--flag=value". 4629// 4630// On success, stores the value of the flag in *value, and returns 4631// true. On failure, returns false without changing *value. 4632bool ParseStringFlag(const char* str, const char* flag, String* value) { 4633 // Gets the value of the flag as a string. 4634 const char* const value_str = ParseFlagValue(str, flag, false); 4635 4636 // Aborts if the parsing failed. 4637 if (value_str == NULL) return false; 4638 4639 // Sets *value to the value of the flag. 4640 *value = value_str; 4641 return true; 4642} 4643 4644// Determines whether a string has a prefix that Google Test uses for its 4645// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_. 4646// If Google Test detects that a command line flag has its prefix but is not 4647// recognized, it will print its help message. Flags starting with 4648// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test 4649// internal flags and do not trigger the help message. 4650static bool HasGoogleTestFlagPrefix(const char* str) { 4651 return (SkipPrefix("--", &str) || 4652 SkipPrefix("-", &str) || 4653 SkipPrefix("/", &str)) && 4654 !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) && 4655 (SkipPrefix(GTEST_FLAG_PREFIX_, &str) || 4656 SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str)); 4657} 4658 4659// Prints a string containing code-encoded text. The following escape 4660// sequences can be used in the string to control the text color: 4661// 4662// @@ prints a single '@' character. 4663// @R changes the color to red. 4664// @G changes the color to green. 4665// @Y changes the color to yellow. 4666// @D changes to the default terminal text color. 4667// 4668// TODO(wan@google.com): Write tests for this once we add stdout 4669// capturing to Google Test. 4670static void PrintColorEncoded(const char* str) { 4671 GTestColor color = COLOR_DEFAULT; // The current color. 4672 4673 // Conceptually, we split the string into segments divided by escape 4674 // sequences. Then we print one segment at a time. At the end of 4675 // each iteration, the str pointer advances to the beginning of the 4676 // next segment. 4677 for (;;) { 4678 const char* p = strchr(str, '@'); 4679 if (p == NULL) { 4680 ColoredPrintf(color, "%s", str); 4681 return; 4682 } 4683 4684 ColoredPrintf(color, "%s", String(str, p - str).c_str()); 4685 4686 const char ch = p[1]; 4687 str = p + 2; 4688 if (ch == '@') { 4689 ColoredPrintf(color, "@"); 4690 } else if (ch == 'D') { 4691 color = COLOR_DEFAULT; 4692 } else if (ch == 'R') { 4693 color = COLOR_RED; 4694 } else if (ch == 'G') { 4695 color = COLOR_GREEN; 4696 } else if (ch == 'Y') { 4697 color = COLOR_YELLOW; 4698 } else { 4699 --str; 4700 } 4701 } 4702} 4703 4704static const char kColorEncodedHelpMessage[] = 4705"This program contains tests written using " GTEST_NAME_ ". You can use the\n" 4706"following command line flags to control its behavior:\n" 4707"\n" 4708"Test Selection:\n" 4709" @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n" 4710" List the names of all tests instead of running them. The name of\n" 4711" TEST(Foo, Bar) is \"Foo.Bar\".\n" 4712" @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS" 4713 "[@G-@YNEGATIVE_PATTERNS]@D\n" 4714" Run only the tests whose name matches one of the positive patterns but\n" 4715" none of the negative patterns. '?' matches any single character; '*'\n" 4716" matches any substring; ':' separates two patterns.\n" 4717" @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n" 4718" Run all disabled tests too.\n" 4719"\n" 4720"Test Execution:\n" 4721" @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n" 4722" Run the tests repeatedly; use a negative count to repeat forever.\n" 4723" @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n" 4724" Randomize tests' orders on every iteration.\n" 4725" @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n" 4726" Random number seed to use for shuffling test orders (between 1 and\n" 4727" 99999, or 0 to use a seed based on the current time).\n" 4728"\n" 4729"Test Output:\n" 4730" @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n" 4731" Enable/disable colored output. The default is @Gauto@D.\n" 4732" -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n" 4733" Don't print the elapsed time of each test.\n" 4734" @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G" 4735 GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n" 4736" Generate an XML report in the given directory or with the given file\n" 4737" name. @YFILE_PATH@D defaults to @Gtest_details.xml@D.\n" 4738#if GTEST_CAN_STREAM_RESULTS_ 4739" @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n" 4740" Stream test results to the given server.\n" 4741#endif // GTEST_CAN_STREAM_RESULTS_ 4742"\n" 4743"Assertion Behavior:\n" 4744#if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS 4745" @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n" 4746" Set the default death test style.\n" 4747#endif // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS 4748" @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n" 4749" Turn assertion failures into debugger break-points.\n" 4750" @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n" 4751" Turn assertion failures into C++ exceptions.\n" 4752" @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n" 4753" Do not report exceptions as test failures. Instead, allow them\n" 4754" to crash the program or throw a pop-up (on Windows).\n" 4755"\n" 4756"Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set " 4757 "the corresponding\n" 4758"environment variable of a flag (all letters in upper-case). For example, to\n" 4759"disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_ 4760 "color=no@D or set\n" 4761"the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n" 4762"\n" 4763"For more information, please read the " GTEST_NAME_ " documentation at\n" 4764"@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n" 4765"(not one in your own code or tests), please report it to\n" 4766"@G<" GTEST_DEV_EMAIL_ ">@D.\n"; 4767 4768// Parses the command line for Google Test flags, without initializing 4769// other parts of Google Test. The type parameter CharType can be 4770// instantiated to either char or wchar_t. 4771template <typename CharType> 4772void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { 4773 for (int i = 1; i < *argc; i++) { 4774 const String arg_string = StreamableToString(argv[i]); 4775 const char* const arg = arg_string.c_str(); 4776 4777 using internal::ParseBoolFlag; 4778 using internal::ParseInt32Flag; 4779 using internal::ParseStringFlag; 4780 4781 // Do we see a Google Test flag? 4782 if (ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag, 4783 >EST_FLAG(also_run_disabled_tests)) || 4784 ParseBoolFlag(arg, kBreakOnFailureFlag, 4785 >EST_FLAG(break_on_failure)) || 4786 ParseBoolFlag(arg, kCatchExceptionsFlag, 4787 >EST_FLAG(catch_exceptions)) || 4788 ParseStringFlag(arg, kColorFlag, >EST_FLAG(color)) || 4789 ParseStringFlag(arg, kDeathTestStyleFlag, 4790 >EST_FLAG(death_test_style)) || 4791 ParseBoolFlag(arg, kDeathTestUseFork, 4792 >EST_FLAG(death_test_use_fork)) || 4793 ParseStringFlag(arg, kFilterFlag, >EST_FLAG(filter)) || 4794 ParseStringFlag(arg, kInternalRunDeathTestFlag, 4795 >EST_FLAG(internal_run_death_test)) || 4796 ParseBoolFlag(arg, kListTestsFlag, >EST_FLAG(list_tests)) || 4797 ParseStringFlag(arg, kOutputFlag, >EST_FLAG(output)) || 4798 ParseBoolFlag(arg, kPrintTimeFlag, >EST_FLAG(print_time)) || 4799 ParseInt32Flag(arg, kRandomSeedFlag, >EST_FLAG(random_seed)) || 4800 ParseInt32Flag(arg, kRepeatFlag, >EST_FLAG(repeat)) || 4801 ParseBoolFlag(arg, kShuffleFlag, >EST_FLAG(shuffle)) || 4802 ParseInt32Flag(arg, kStackTraceDepthFlag, 4803 >EST_FLAG(stack_trace_depth)) || 4804 ParseStringFlag(arg, kStreamResultToFlag, 4805 >EST_FLAG(stream_result_to)) || 4806 ParseBoolFlag(arg, kThrowOnFailureFlag, 4807 >EST_FLAG(throw_on_failure)) 4808 ) { 4809 // Yes. Shift the remainder of the argv list left by one. Note 4810 // that argv has (*argc + 1) elements, the last one always being 4811 // NULL. The following loop moves the trailing NULL element as 4812 // well. 4813 for (int j = i; j != *argc; j++) { 4814 argv[j] = argv[j + 1]; 4815 } 4816 4817 // Decrements the argument count. 4818 (*argc)--; 4819 4820 // We also need to decrement the iterator as we just removed 4821 // an element. 4822 i--; 4823 } else if (arg_string == "--help" || arg_string == "-h" || 4824 arg_string == "-?" || arg_string == "/?" || 4825 HasGoogleTestFlagPrefix(arg)) { 4826 // Both help flag and unrecognized Google Test flags (excluding 4827 // internal ones) trigger help display. 4828 g_help_flag = true; 4829 } 4830 } 4831 4832 if (g_help_flag) { 4833 // We print the help here instead of in RUN_ALL_TESTS(), as the 4834 // latter may not be called at all if the user is using Google 4835 // Test with another testing framework. 4836 PrintColorEncoded(kColorEncodedHelpMessage); 4837 } 4838} 4839 4840// Parses the command line for Google Test flags, without initializing 4841// other parts of Google Test. 4842void ParseGoogleTestFlagsOnly(int* argc, char** argv) { 4843 ParseGoogleTestFlagsOnlyImpl(argc, argv); 4844} 4845void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) { 4846 ParseGoogleTestFlagsOnlyImpl(argc, argv); 4847} 4848 4849// The internal implementation of InitGoogleTest(). 4850// 4851// The type parameter CharType can be instantiated to either char or 4852// wchar_t. 4853template <typename CharType> 4854void InitGoogleTestImpl(int* argc, CharType** argv) { 4855 g_init_gtest_count++; 4856 4857 // We don't want to run the initialization code twice. 4858 if (g_init_gtest_count != 1) return; 4859 4860 if (*argc <= 0) return; 4861 4862 internal::g_executable_path = internal::StreamableToString(argv[0]); 4863 4864#if GTEST_HAS_DEATH_TEST 4865 4866 g_argvs.clear(); 4867 for (int i = 0; i != *argc; i++) { 4868 g_argvs.push_back(StreamableToString(argv[i])); 4869 } 4870 4871#endif // GTEST_HAS_DEATH_TEST 4872 4873 ParseGoogleTestFlagsOnly(argc, argv); 4874 GetUnitTestImpl()->PostFlagParsingInit(); 4875} 4876 4877} // namespace internal 4878 4879// Initializes Google Test. This must be called before calling 4880// RUN_ALL_TESTS(). In particular, it parses a command line for the 4881// flags that Google Test recognizes. Whenever a Google Test flag is 4882// seen, it is removed from argv, and *argc is decremented. 4883// 4884// No value is returned. Instead, the Google Test flag variables are 4885// updated. 4886// 4887// Calling the function for the second time has no user-visible effect. 4888void InitGoogleTest(int* argc, char** argv) { 4889 internal::InitGoogleTestImpl(argc, argv); 4890} 4891 4892// This overloaded version can be used in Windows programs compiled in 4893// UNICODE mode. 4894void InitGoogleTest(int* argc, wchar_t** argv) { 4895 internal::InitGoogleTestImpl(argc, argv); 4896} 4897 4898} // namespace testing 4899