Home | History | Annotate | Download | only in src
      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 (at) 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 (at) 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 (at) google.com): Use autoconf to detect availability of
     91 //   gettimeofday().
     92 // TODO(kenton (at) 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 (at) 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 
    139 namespace testing {
    140 
    141 using internal::CountIf;
    142 using internal::ForEach;
    143 using internal::GetElementOr;
    144 using 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.
    150 static 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.
    155 static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*";
    156 
    157 // A test filter that matches everything.
    158 static const char kUniversalFilter[] = "*";
    159 
    160 // The default output file for XML output.
    161 static const char kDefaultOutputFile[] = "test_detail.xml";
    162 
    163 // The environment variable name for the test shard index.
    164 static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
    165 // The environment variable name for the total number of test shards.
    166 static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
    167 // The environment variable name for the test shard status file.
    168 static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";
    169 
    170 namespace internal {
    171 
    172 // The text used in failure messages to indicate the start of the
    173 // stack trace.
    174 const 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.
    178 bool g_help_flag = false;
    179 
    180 }  // namespace internal
    181 
    182 GTEST_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 
    187 GTEST_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 
    192 GTEST_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 
    198 GTEST_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 
    206 GTEST_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 
    215 GTEST_DEFINE_bool_(list_tests, false,
    216                    "List all tests without running them.");
    217 
    218 GTEST_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 
    230 GTEST_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 
    236 GTEST_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 
    242 GTEST_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 
    248 GTEST_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 
    253 GTEST_DEFINE_bool_(
    254     shuffle,
    255     internal::BoolFromGTestEnv("shuffle", false),
    256     "True iff " GTEST_NAME_
    257     " should randomize tests' order on every run.");
    258 
    259 GTEST_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 
    265 GTEST_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 
    272 GTEST_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 
    279 namespace 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.
    284 UInt32 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.
    308 int g_init_gtest_count = 0;
    309 static 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.
    314 static 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.
    324 static 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.
    329 static 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.
    335 static bool ShouldRunTestCase(const TestCase* test_case) {
    336   return test_case->should_run();
    337 }
    338 
    339 // AssertHelper constructor.
    340 AssertHelper::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 
    347 AssertHelper::~AssertHelper() {
    348   delete data_;
    349 }
    350 
    351 // Message assignment, for assertion streaming support.
    352 void 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.
    363 GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
    364 
    365 // Application pathname gotten in InitGoogleTest.
    366 String g_executable_path;
    367 
    368 // Returns the current application's name, removing directory path if that
    369 // is present.
    370 FilePath 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.
    385 String 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.
    397 String 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 (at) 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.
    433 bool 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 
    450 bool 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.
    474 bool 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.
    508 int 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.
    537 ScopedFakeTestPartResultReporter::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.
    547 ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
    548     InterceptMode intercept_mode, TestPartResultArray* result)
    549     : intercept_mode_(intercept_mode),
    550       result_(result) {
    551   Init();
    552 }
    553 
    554 void 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.
    567 ScopedFakeTestPartResultReporter::~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.
    578 void ScopedFakeTestPartResultReporter::ReportTestPartResult(
    579     const TestPartResult& result) {
    580   result_->Append(result);
    581 }
    582 
    583 namespace 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.
    594 TypeId 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().
    600 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.
    605 AssertionResult 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.
    644 SingleFailureChecker:: 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.
    656 SingleFailureChecker::~SingleFailureChecker() {
    657   EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
    658 }
    659 
    660 DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
    661     UnitTestImpl* unit_test) : unit_test_(unit_test) {}
    662 
    663 void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
    664     const TestPartResult& result) {
    665   unit_test_->current_test_result()->AddTestPartResult(result);
    666   unit_test_->listeners()->repeater()->OnTestPartResult(result);
    667 }
    668 
    669 DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
    670     UnitTestImpl* unit_test) : unit_test_(unit_test) {}
    671 
    672 void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
    673     const TestPartResult& result) {
    674   unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
    675 }
    676 
    677 // Returns the global test part result reporter.
    678 TestPartResultReporterInterface*
    679 UnitTestImpl::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.
    685 void 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.
    692 TestPartResultReporterInterface*
    693 UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
    694   return per_thread_test_part_result_reporter_.get();
    695 }
    696 
    697 // Sets the test part result reporter for the current thread.
    698 void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
    699     TestPartResultReporterInterface* reporter) {
    700   per_thread_test_part_result_reporter_.set(reporter);
    701 }
    702 
    703 // Gets the number of successful test cases.
    704 int UnitTestImpl::successful_test_case_count() const {
    705   return CountIf(test_cases_, TestCasePassed);
    706 }
    707 
    708 // Gets the number of failed test cases.
    709 int UnitTestImpl::failed_test_case_count() const {
    710   return CountIf(test_cases_, TestCaseFailed);
    711 }
    712 
    713 // Gets the number of all test cases.
    714 int 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.
    720 int UnitTestImpl::test_case_to_run_count() const {
    721   return CountIf(test_cases_, ShouldRunTestCase);
    722 }
    723 
    724 // Gets the number of successful tests.
    725 int UnitTestImpl::successful_test_count() const {
    726   return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count);
    727 }
    728 
    729 // Gets the number of failed tests.
    730 int UnitTestImpl::failed_test_count() const {
    731   return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count);
    732 }
    733 
    734 // Gets the number of disabled tests.
    735 int UnitTestImpl::disabled_test_count() const {
    736   return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count);
    737 }
    738 
    739 // Gets the number of all tests.
    740 int 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.
    745 int 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.
    759 String UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
    760   (void)skip_count;
    761   return String("");
    762 }
    763 
    764 // Returns the current time in milliseconds.
    765 TimeInMillis 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 (at) 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 (at) 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.
    827 String 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.
    835 static 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.
    849 const 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.
    859 LPCWSTR 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.
    876 const 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.
    895 bool 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.
    907 static 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.
    933 Message& 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.
    942 Message& 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).
    950 AssertionResult::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.
    958 AssertionResult 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.
    966 AssertionResult AssertionSuccess() {
    967   return AssertionResult(true);
    968 }
    969 
    970 // Makes a failed assertion result.
    971 AssertionResult AssertionFailure() {
    972   return AssertionResult(false);
    973 }
    974 
    975 // Makes a failed assertion result with the given failure message.
    976 // Deprecated; use AssertionFailure() << message.
    977 AssertionResult AssertionFailure(const Message& message) {
    978   return AssertionFailure() << message;
    979 }
    980 
    981 namespace 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.
    998 AssertionResult 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.
   1021 String 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.
   1036 AssertionResult 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().
   1057 template <typename RawType>
   1058 AssertionResult 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.
   1095 AssertionResult 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.
   1102 AssertionResult DoubleLE(const char* expr1, const char* expr2,
   1103                          double val1, double val2) {
   1104   return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
   1105 }
   1106 
   1107 namespace internal {
   1108 
   1109 // The helper function for {ASSERT|EXPECT}_EQ with int or enum
   1110 // arguments.
   1111 AssertionResult 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)\
   1130 AssertionResult 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.
   1144 GTEST_IMPL_CMP_HELPER_(NE, !=)
   1145 // Implements the helper function for {ASSERT|EXPECT}_LE with int or
   1146 // enum arguments.
   1147 GTEST_IMPL_CMP_HELPER_(LE, <=)
   1148 // Implements the helper function for {ASSERT|EXPECT}_LT with int or
   1149 // enum arguments.
   1150 GTEST_IMPL_CMP_HELPER_(LT, < )
   1151 // Implements the helper function for {ASSERT|EXPECT}_GE with int or
   1152 // enum arguments.
   1153 GTEST_IMPL_CMP_HELPER_(GE, >=)
   1154 // Implements the helper function for {ASSERT|EXPECT}_GT with int or
   1155 // enum arguments.
   1156 GTEST_IMPL_CMP_HELPER_(GT, > )
   1157 
   1158 #undef GTEST_IMPL_CMP_HELPER_
   1159 
   1160 // The helper function for {ASSERT|EXPECT}_STREQ.
   1161 AssertionResult 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.
   1177 AssertionResult 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.
   1193 AssertionResult 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.
   1207 AssertionResult 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 
   1223 namespace {
   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 
   1231 bool 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 
   1238 bool 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.
   1246 template <typename StringType>
   1247 bool 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.
   1256 template <typename StringType>
   1257 AssertionResult 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 
   1280 AssertionResult 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 
   1286 AssertionResult 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 
   1292 AssertionResult 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 
   1298 AssertionResult 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 
   1304 AssertionResult 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 
   1310 AssertionResult 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
   1317 AssertionResult 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 
   1323 AssertionResult 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 
   1330 namespace internal {
   1331 
   1332 #if GTEST_OS_WINDOWS
   1333 
   1334 namespace {
   1335 
   1336 // Helper function for IsHRESULT{SuccessFailure} predicates
   1337 AssertionResult 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 
   1378 AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
   1379   if (SUCCEEDED(hr)) {
   1380     return AssertionSuccess();
   1381   }
   1382   return HRESULTFailureHelper(expr, "succeeds", hr);
   1383 }
   1384 
   1385 AssertionResult 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 up to 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.
   1407 const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) <<  7) - 1;
   1408 
   1409 // The maximum code-point a two-byte UTF-8 sequence can represent.
   1410 const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1;
   1411 
   1412 // The maximum code-point a three-byte UTF-8 sequence can represent.
   1413 const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1;
   1414 
   1415 // The maximum code-point a four-byte UTF-8 sequence can represent.
   1416 const 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.
   1421 inline 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)'.
   1435 char* 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 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.
   1475 inline 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.
   1481 inline 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.
   1504 String 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)".
   1530 String 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.
   1538 String 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.
   1551 bool 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.
   1560 AssertionResult 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.
   1576 AssertionResult 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.
   1596 bool 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.
   1616 bool 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.
   1641 int 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.
   1666 bool 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.
   1679 bool 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.
   1700 String 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.
   1735 String 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.
   1755 String 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.
   1774 TestResult::TestResult()
   1775     : death_test_count_(0),
   1776       elapsed_time_(0) {
   1777 }
   1778 
   1779 // D'tor.
   1780 TestResult::~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.
   1786 const 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.
   1795 const 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.
   1802 void TestResult::ClearTestPartResults() {
   1803   test_part_results_.clear();
   1804 }
   1805 
   1806 // Adds a test part result to the list.
   1807 void 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.
   1814 void 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.
   1831 bool 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.
   1845 void 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.
   1853 bool 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.
   1862 static bool TestPartFatallyFailed(const TestPartResult& result) {
   1863   return result.fatally_failed();
   1864 }
   1865 
   1866 // Returns true iff the test fatally failed.
   1867 bool TestResult::HasFatalFailure() const {
   1868   return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
   1869 }
   1870 
   1871 // Returns true iff the test part non-fatally failed.
   1872 static bool TestPartNonfatallyFailed(const TestPartResult& result) {
   1873   return result.nonfatally_failed();
   1874 }
   1875 
   1876 // Returns true iff the test has a non-fatal failure.
   1877 bool 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.
   1883 int TestResult::total_part_count() const {
   1884   return static_cast<int>(test_part_results_.size());
   1885 }
   1886 
   1887 // Returns the number of the test properties.
   1888 int 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.
   1897 Test::Test()
   1898     : gtest_flag_saver_(new internal::GTestFlagSaver) {
   1899 }
   1900 
   1901 // The d'tor restores the values of all Google Test flags.
   1902 Test::~Test() {
   1903   delete gtest_flag_saver_;
   1904 }
   1905 
   1906 // Sets up the test fixture.
   1907 //
   1908 // A sub-class may override this.
   1909 void Test::SetUp() {
   1910 }
   1911 
   1912 // Tears down the test fixture.
   1913 //
   1914 // A sub-class may override this.
   1915 void Test::TearDown() {
   1916 }
   1917 
   1918 // Allows user supplied key value pairs to be recorded for later output.
   1919 void 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.
   1924 void 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 
   1930 namespace internal {
   1931 
   1932 void 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.
   1951 bool 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).
   2018 static 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.
   2032 static 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 
   2045 static 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.
   2054 class 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 
   2061 namespace internal {
   2062 // We put these helper functions in the internal namespace as IBM's xlC
   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.)
   2070 template <class T, typename Result>
   2071 Result 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.
   2097 template <class T, typename Result>
   2098 Result 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.
   2152 void 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.
   2174 bool Test::HasFatalFailure() {
   2175   return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
   2176 }
   2177 
   2178 // Returns true iff the current test has a non-fatal failure.
   2179 bool 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 (at) google.com): Make a_test_case_name and a_name const string&'s
   2189 // to signify they cannot be NULLs.
   2190 TestInfo::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.
   2208 TestInfo::~TestInfo() { delete factory_; }
   2209 
   2210 namespace 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.
   2229 TestInfo* 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
   2245 void 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 
   2265 namespace internal {
   2266 
   2267 // This method expands all parameterized tests registered with macros TEST_P
   2268 // and INSTANTIATE_TEST_CASE_P into regular tests and registers those.
   2269 // This will be done just once during the program runtime.
   2270 void UnitTestImpl::RegisterParameterizedTests() {
   2271 #if GTEST_HAS_PARAM_TEST
   2272   if (!parameterized_tests_registered_) {
   2273     parameterized_test_registry_.RegisterTests();
   2274     parameterized_tests_registered_ = true;
   2275   }
   2276 #endif
   2277 }
   2278 
   2279 }  // namespace internal
   2280 
   2281 // Creates the test object, runs it, records its result, and then
   2282 // deletes it.
   2283 void TestInfo::Run() {
   2284   if (!should_run_) return;
   2285 
   2286   // Tells UnitTest where to store test result.
   2287   internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
   2288   impl->set_current_test_info(this);
   2289 
   2290   TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
   2291 
   2292   // Notifies the unit test event listeners that a test is about to start.
   2293   repeater->OnTestStart(*this);
   2294 
   2295   const TimeInMillis start = internal::GetTimeInMillis();
   2296 
   2297   impl->os_stack_trace_getter()->UponLeavingGTest();
   2298 
   2299   // Creates the test object.
   2300   Test* const test = internal::HandleExceptionsInMethodIfSupported(
   2301       factory_, &internal::TestFactoryBase::CreateTest,
   2302       "the test fixture's constructor");
   2303 
   2304   // Runs the test only if the test object was created and its
   2305   // constructor didn't generate a fatal failure.
   2306   if ((test != NULL) && !Test::HasFatalFailure()) {
   2307     // This doesn't throw as all user code that can throw are wrapped into
   2308     // exception handling code.
   2309     test->Run();
   2310   }
   2311 
   2312   // Deletes the test object.
   2313   impl->os_stack_trace_getter()->UponLeavingGTest();
   2314   internal::HandleExceptionsInMethodIfSupported(
   2315       test, &Test::DeleteSelf_, "the test fixture's destructor");
   2316 
   2317   result_.set_elapsed_time(internal::GetTimeInMillis() - start);
   2318 
   2319   // Notifies the unit test event listener that a test has just finished.
   2320   repeater->OnTestEnd(*this);
   2321 
   2322   // Tells UnitTest to stop associating assertion results to this
   2323   // test.
   2324   impl->set_current_test_info(NULL);
   2325 }
   2326 
   2327 // class TestCase
   2328 
   2329 // Gets the number of successful tests in this test case.
   2330 int TestCase::successful_test_count() const {
   2331   return CountIf(test_info_list_, TestPassed);
   2332 }
   2333 
   2334 // Gets the number of failed tests in this test case.
   2335 int TestCase::failed_test_count() const {
   2336   return CountIf(test_info_list_, TestFailed);
   2337 }
   2338 
   2339 int TestCase::disabled_test_count() const {
   2340   return CountIf(test_info_list_, TestDisabled);
   2341 }
   2342 
   2343 // Get the number of tests in this test case that should run.
   2344 int TestCase::test_to_run_count() const {
   2345   return CountIf(test_info_list_, ShouldRunTest);
   2346 }
   2347 
   2348 // Gets the number of all tests.
   2349 int TestCase::total_test_count() const {
   2350   return static_cast<int>(test_info_list_.size());
   2351 }
   2352 
   2353 // Creates a TestCase with the given name.
   2354 //
   2355 // Arguments:
   2356 //
   2357 //   name:         name of the test case
   2358 //   a_type_param: the name of the test case's type parameter, or NULL if
   2359 //                 this is not a typed or a type-parameterized test case.
   2360 //   set_up_tc:    pointer to the function that sets up the test case
   2361 //   tear_down_tc: pointer to the function that tears down the test case
   2362 TestCase::TestCase(const char* a_name, const char* a_type_param,
   2363                    Test::SetUpTestCaseFunc set_up_tc,
   2364                    Test::TearDownTestCaseFunc tear_down_tc)
   2365     : name_(a_name),
   2366       type_param_(a_type_param ? new std::string(a_type_param) : NULL),
   2367       set_up_tc_(set_up_tc),
   2368       tear_down_tc_(tear_down_tc),
   2369       should_run_(false),
   2370       elapsed_time_(0) {
   2371 }
   2372 
   2373 // Destructor of TestCase.
   2374 TestCase::~TestCase() {
   2375   // Deletes every Test in the collection.
   2376   ForEach(test_info_list_, internal::Delete<TestInfo>);
   2377 }
   2378 
   2379 // Returns the i-th test among all the tests. i can range from 0 to
   2380 // total_test_count() - 1. If i is not in that range, returns NULL.
   2381 const TestInfo* TestCase::GetTestInfo(int i) const {
   2382   const int index = GetElementOr(test_indices_, i, -1);
   2383   return index < 0 ? NULL : test_info_list_[index];
   2384 }
   2385 
   2386 // Returns the i-th test among all the tests. i can range from 0 to
   2387 // total_test_count() - 1. If i is not in that range, returns NULL.
   2388 TestInfo* TestCase::GetMutableTestInfo(int i) {
   2389   const int index = GetElementOr(test_indices_, i, -1);
   2390   return index < 0 ? NULL : test_info_list_[index];
   2391 }
   2392 
   2393 // Adds a test to this test case.  Will delete the test upon
   2394 // destruction of the TestCase object.
   2395 void TestCase::AddTestInfo(TestInfo * test_info) {
   2396   test_info_list_.push_back(test_info);
   2397   test_indices_.push_back(static_cast<int>(test_indices_.size()));
   2398 }
   2399 
   2400 // Runs every test in this TestCase.
   2401 void TestCase::Run() {
   2402   if (!should_run_) return;
   2403 
   2404   internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
   2405   impl->set_current_test_case(this);
   2406 
   2407   TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
   2408 
   2409   repeater->OnTestCaseStart(*this);
   2410   impl->os_stack_trace_getter()->UponLeavingGTest();
   2411   internal::HandleExceptionsInMethodIfSupported(
   2412       this, &TestCase::RunSetUpTestCase, "SetUpTestCase()");
   2413 
   2414   const internal::TimeInMillis start = internal::GetTimeInMillis();
   2415   for (int i = 0; i < total_test_count(); i++) {
   2416     GetMutableTestInfo(i)->Run();
   2417   }
   2418   elapsed_time_ = internal::GetTimeInMillis() - start;
   2419 
   2420   impl->os_stack_trace_getter()->UponLeavingGTest();
   2421   internal::HandleExceptionsInMethodIfSupported(
   2422       this, &TestCase::RunTearDownTestCase, "TearDownTestCase()");
   2423 
   2424   repeater->OnTestCaseEnd(*this);
   2425   impl->set_current_test_case(NULL);
   2426 }
   2427 
   2428 // Clears the results of all tests in this test case.
   2429 void TestCase::ClearResult() {
   2430   ForEach(test_info_list_, TestInfo::ClearTestResult);
   2431 }
   2432 
   2433 // Shuffles the tests in this test case.
   2434 void TestCase::ShuffleTests(internal::Random* random) {
   2435   Shuffle(random, &test_indices_);
   2436 }
   2437 
   2438 // Restores the test order to before the first shuffle.
   2439 void TestCase::UnshuffleTests() {
   2440   for (size_t i = 0; i < test_indices_.size(); i++) {
   2441     test_indices_[i] = static_cast<int>(i);
   2442   }
   2443 }
   2444 
   2445 // Formats a countable noun.  Depending on its quantity, either the
   2446 // singular form or the plural form is used. e.g.
   2447 //
   2448 // FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
   2449 // FormatCountableNoun(5, "book", "books") returns "5 books".
   2450 static internal::String FormatCountableNoun(int count,
   2451                                             const char * singular_form,
   2452                                             const char * plural_form) {
   2453   return internal::String::Format("%d %s", count,
   2454                                   count == 1 ? singular_form : plural_form);
   2455 }
   2456 
   2457 // Formats the count of tests.
   2458 static internal::String FormatTestCount(int test_count) {
   2459   return FormatCountableNoun(test_count, "test", "tests");
   2460 }
   2461 
   2462 // Formats the count of test cases.
   2463 static internal::String FormatTestCaseCount(int test_case_count) {
   2464   return FormatCountableNoun(test_case_count, "test case", "test cases");
   2465 }
   2466 
   2467 // Converts a TestPartResult::Type enum to human-friendly string
   2468 // representation.  Both kNonFatalFailure and kFatalFailure are translated
   2469 // to "Failure", as the user usually doesn't care about the difference
   2470 // between the two when viewing the test result.
   2471 static const char * TestPartResultTypeToString(TestPartResult::Type type) {
   2472   switch (type) {
   2473     case TestPartResult::kSuccess:
   2474       return "Success";
   2475 
   2476     case TestPartResult::kNonFatalFailure:
   2477     case TestPartResult::kFatalFailure:
   2478 #ifdef _MSC_VER
   2479       return "error: ";
   2480 #else
   2481       return "Failure\n";
   2482 #endif
   2483   }
   2484 
   2485   // All cases return, so this is unreachable but GCC doesn't know it
   2486   abort();
   2487 }
   2488 
   2489 // Prints a TestPartResult to a String.
   2490 static internal::String PrintTestPartResultToString(
   2491     const TestPartResult& test_part_result) {
   2492   return (Message()
   2493           << internal::FormatFileLocation(test_part_result.file_name(),
   2494                                           test_part_result.line_number())
   2495           << " " << TestPartResultTypeToString(test_part_result.type())
   2496           << test_part_result.message()).GetString();
   2497 }
   2498 
   2499 // Prints a TestPartResult.
   2500 static void PrintTestPartResult(const TestPartResult& test_part_result) {
   2501   const internal::String& result =
   2502       PrintTestPartResultToString(test_part_result);
   2503   printf("%s\n", result.c_str());
   2504   fflush(stdout);
   2505   // If the test program runs in Visual Studio or a debugger, the
   2506   // following statements add the test part result message to the Output
   2507   // window such that the user can double-click on it to jump to the
   2508   // corresponding source code location; otherwise they do nothing.
   2509 #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
   2510   // We don't call OutputDebugString*() on Windows Mobile, as printing
   2511   // to stdout is done by OutputDebugString() there already - we don't
   2512   // want the same message printed twice.
   2513   ::OutputDebugStringA(result.c_str());
   2514   ::OutputDebugStringA("\n");
   2515 #endif
   2516 }
   2517 
   2518 // class PrettyUnitTestResultPrinter
   2519 
   2520 namespace internal {
   2521 
   2522 enum GTestColor {
   2523   COLOR_DEFAULT,
   2524   COLOR_RED,
   2525   COLOR_GREEN,
   2526   COLOR_YELLOW
   2527 };
   2528 
   2529 #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
   2530 
   2531 // Returns the character attribute for the given color.
   2532 WORD GetColorAttribute(GTestColor color) {
   2533   switch (color) {
   2534     case COLOR_RED:    return FOREGROUND_RED;
   2535     case COLOR_GREEN:  return FOREGROUND_GREEN;
   2536     case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;
   2537     default:           return 0;
   2538   }
   2539 }
   2540 
   2541 #else
   2542 
   2543 // Returns the ANSI color code for the given color.  COLOR_DEFAULT is
   2544 // an invalid input.
   2545 const char* GetAnsiColorCode(GTestColor color) {
   2546   switch (color) {
   2547     case COLOR_RED:     return "1";
   2548     case COLOR_GREEN:   return "2";
   2549     case COLOR_YELLOW:  return "3";
   2550     default:            return NULL;
   2551   };
   2552 }
   2553 
   2554 #endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
   2555 
   2556 // Returns true iff Google Test should use colors in the output.
   2557 bool ShouldUseColor(bool stdout_is_tty) {
   2558   const char* const gtest_color = GTEST_FLAG(color).c_str();
   2559 
   2560   if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
   2561 #if GTEST_OS_WINDOWS
   2562     // On Windows the TERM variable is usually not set, but the
   2563     // console there does support colors.
   2564     return stdout_is_tty;
   2565 #else
   2566     // On non-Windows platforms, we rely on the TERM variable.
   2567     const char* const term = posix::GetEnv("TERM");
   2568     const bool term_supports_color =
   2569         String::CStringEquals(term, "xterm") ||
   2570         String::CStringEquals(term, "xterm-color") ||
   2571         String::CStringEquals(term, "xterm-256color") ||
   2572         String::CStringEquals(term, "screen") ||
   2573         String::CStringEquals(term, "linux") ||
   2574         String::CStringEquals(term, "cygwin");
   2575     return stdout_is_tty && term_supports_color;
   2576 #endif  // GTEST_OS_WINDOWS
   2577   }
   2578 
   2579   return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
   2580       String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
   2581       String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
   2582       String::CStringEquals(gtest_color, "1");
   2583   // We take "yes", "true", "t", and "1" as meaning "yes".  If the
   2584   // value is neither one of these nor "auto", we treat it as "no" to
   2585   // be conservative.
   2586 }
   2587 
   2588 // Helpers for printing colored strings to stdout. Note that on Windows, we
   2589 // cannot simply emit special characters and have the terminal change colors.
   2590 // This routine must actually emit the characters rather than return a string
   2591 // that would be colored when printed, as can be done on Linux.
   2592 void ColoredPrintf(GTestColor color, const char* fmt, ...) {
   2593   va_list args;
   2594   va_start(args, fmt);
   2595 
   2596 #if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
   2597   const bool use_color = false;
   2598 #else
   2599   static const bool in_color_mode =
   2600       ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
   2601   const bool use_color = in_color_mode && (color != COLOR_DEFAULT);
   2602 #endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
   2603   // The '!= 0' comparison is necessary to satisfy MSVC 7.1.
   2604 
   2605   if (!use_color) {
   2606     vprintf(fmt, args);
   2607     va_end(args);
   2608     return;
   2609   }
   2610 
   2611 #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
   2612   const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
   2613 
   2614   // Gets the current text color.
   2615   CONSOLE_SCREEN_BUFFER_INFO buffer_info;
   2616   GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
   2617   const WORD old_color_attrs = buffer_info.wAttributes;
   2618 
   2619   // We need to flush the stream buffers into the console before each
   2620   // SetConsoleTextAttribute call lest it affect the text that is already
   2621   // printed but has not yet reached the console.
   2622   fflush(stdout);
   2623   SetConsoleTextAttribute(stdout_handle,
   2624                           GetColorAttribute(color) | FOREGROUND_INTENSITY);
   2625   vprintf(fmt, args);
   2626 
   2627   fflush(stdout);
   2628   // Restores the text color.
   2629   SetConsoleTextAttribute(stdout_handle, old_color_attrs);
   2630 #else
   2631   printf("\033[0;3%sm", GetAnsiColorCode(color));
   2632   vprintf(fmt, args);
   2633   printf("\033[m");  // Resets the terminal to default.
   2634 #endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
   2635   va_end(args);
   2636 }
   2637 
   2638 void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
   2639   const char* const type_param = test_info.type_param();
   2640   const char* const value_param = test_info.value_param();
   2641 
   2642   if (type_param != NULL || value_param != NULL) {
   2643     printf(", where ");
   2644     if (type_param != NULL) {
   2645       printf("TypeParam = %s", type_param);
   2646       if (value_param != NULL)
   2647         printf(" and ");
   2648     }
   2649     if (value_param != NULL) {
   2650       printf("GetParam() = %s", value_param);
   2651     }
   2652   }
   2653 }
   2654 
   2655 // This class implements the TestEventListener interface.
   2656 //
   2657 // Class PrettyUnitTestResultPrinter is copyable.
   2658 class PrettyUnitTestResultPrinter : public TestEventListener {
   2659  public:
   2660   PrettyUnitTestResultPrinter() {}
   2661   static void PrintTestName(const char * test_case, const char * test) {
   2662     printf("%s.%s", test_case, test);
   2663   }
   2664 
   2665   // The following methods override what's in the TestEventListener class.
   2666   virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
   2667   virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration);
   2668   virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
   2669   virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
   2670   virtual void OnTestCaseStart(const TestCase& test_case);
   2671   virtual void OnTestStart(const TestInfo& test_info);
   2672   virtual void OnTestPartResult(const TestPartResult& result);
   2673   virtual void OnTestEnd(const TestInfo& test_info);
   2674   virtual void OnTestCaseEnd(const TestCase& test_case);
   2675   virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
   2676   virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
   2677   virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
   2678   virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
   2679 
   2680  private:
   2681   static void PrintFailedTests(const UnitTest& unit_test);
   2682 
   2683   internal::String test_case_name_;
   2684 };
   2685 
   2686   // Fired before each iteration of tests starts.
   2687 void PrettyUnitTestResultPrinter::OnTestIterationStart(
   2688     const UnitTest& unit_test, int iteration) {
   2689   if (GTEST_FLAG(repeat) != 1)
   2690     printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
   2691 
   2692   const char* const filter = GTEST_FLAG(filter).c_str();
   2693 
   2694   // Prints the filter if it's not *.  This reminds the user that some
   2695   // tests may be skipped.
   2696   if (!internal::String::CStringEquals(filter, kUniversalFilter)) {
   2697     ColoredPrintf(COLOR_YELLOW,
   2698                   "Note: %s filter = %s\n", GTEST_NAME_, filter);
   2699   }
   2700 
   2701   if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
   2702     const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
   2703     ColoredPrintf(COLOR_YELLOW,
   2704                   "Note: This is test shard %d of %s.\n",
   2705                   static_cast<int>(shard_index) + 1,
   2706                   internal::posix::GetEnv(kTestTotalShards));
   2707   }
   2708 
   2709   if (GTEST_FLAG(shuffle)) {
   2710     ColoredPrintf(COLOR_YELLOW,
   2711                   "Note: Randomizing tests' orders with a seed of %d .\n",
   2712                   unit_test.random_seed());
   2713   }
   2714 
   2715   ColoredPrintf(COLOR_GREEN,  "[==========] ");
   2716   printf("Running %s from %s.\n",
   2717          FormatTestCount(unit_test.test_to_run_count()).c_str(),
   2718          FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str());
   2719   fflush(stdout);
   2720 }
   2721 
   2722 void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
   2723     const UnitTest& /*unit_test*/) {
   2724   ColoredPrintf(COLOR_GREEN,  "[----------] ");
   2725   printf("Global test environment set-up.\n");
   2726   fflush(stdout);
   2727 }
   2728 
   2729 void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
   2730   test_case_name_ = test_case.name();
   2731   const internal::String counts =
   2732       FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
   2733   ColoredPrintf(COLOR_GREEN, "[----------] ");
   2734   printf("%s from %s", counts.c_str(), test_case_name_.c_str());
   2735   if (test_case.type_param() == NULL) {
   2736     printf("\n");
   2737   } else {
   2738     printf(", where TypeParam = %s\n", test_case.type_param());
   2739   }
   2740   fflush(stdout);
   2741 }
   2742 
   2743 void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
   2744   ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
   2745   PrintTestName(test_case_name_.c_str(), test_info.name());
   2746   printf("\n");
   2747   fflush(stdout);
   2748 }
   2749 
   2750 // Called after an assertion failure.
   2751 void PrettyUnitTestResultPrinter::OnTestPartResult(
   2752     const TestPartResult& result) {
   2753   // If the test part succeeded, we don't need to do anything.
   2754   if (result.type() == TestPartResult::kSuccess)
   2755     return;
   2756 
   2757   // Print failure message from the assertion (e.g. expected this and got that).
   2758   PrintTestPartResult(result);
   2759   fflush(stdout);
   2760 }
   2761 
   2762 void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
   2763   if (test_info.result()->Passed()) {
   2764     ColoredPrintf(COLOR_GREEN, "[       OK ] ");
   2765   } else {
   2766     ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
   2767   }
   2768   PrintTestName(test_case_name_.c_str(), test_info.name());
   2769   if (test_info.result()->Failed())
   2770     PrintFullTestCommentIfPresent(test_info);
   2771 
   2772   if (GTEST_FLAG(print_time)) {
   2773     printf(" (%s ms)\n", internal::StreamableToString(
   2774            test_info.result()->elapsed_time()).c_str());
   2775   } else {
   2776     printf("\n");
   2777   }
   2778   fflush(stdout);
   2779 }
   2780 
   2781 void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
   2782   if (!GTEST_FLAG(print_time)) return;
   2783 
   2784   test_case_name_ = test_case.name();
   2785   const internal::String counts =
   2786       FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
   2787   ColoredPrintf(COLOR_GREEN, "[----------] ");
   2788   printf("%s from %s (%s ms total)\n\n",
   2789          counts.c_str(), test_case_name_.c_str(),
   2790          internal::StreamableToString(test_case.elapsed_time()).c_str());
   2791   fflush(stdout);
   2792 }
   2793 
   2794 void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
   2795     const UnitTest& /*unit_test*/) {
   2796   ColoredPrintf(COLOR_GREEN,  "[----------] ");
   2797   printf("Global test environment tear-down\n");
   2798   fflush(stdout);
   2799 }
   2800 
   2801 // Internal helper for printing the list of failed tests.
   2802 void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
   2803   const int failed_test_count = unit_test.failed_test_count();
   2804   if (failed_test_count == 0) {
   2805     return;
   2806   }
   2807 
   2808   for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
   2809     const TestCase& test_case = *unit_test.GetTestCase(i);
   2810     if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
   2811       continue;
   2812     }
   2813     for (int j = 0; j < test_case.total_test_count(); ++j) {
   2814       const TestInfo& test_info = *test_case.GetTestInfo(j);
   2815       if (!test_info.should_run() || test_info.result()->Passed()) {
   2816         continue;
   2817       }
   2818       ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
   2819       printf("%s.%s", test_case.name(), test_info.name());
   2820       PrintFullTestCommentIfPresent(test_info);
   2821       printf("\n");
   2822     }
   2823   }
   2824 }
   2825 
   2826 void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
   2827                                                      int /*iteration*/) {
   2828   ColoredPrintf(COLOR_GREEN,  "[==========] ");
   2829   printf("%s from %s ran.",
   2830          FormatTestCount(unit_test.test_to_run_count()).c_str(),
   2831          FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str());
   2832   if (GTEST_FLAG(print_time)) {
   2833     printf(" (%s ms total)",
   2834            internal::StreamableToString(unit_test.elapsed_time()).c_str());
   2835   }
   2836   printf("\n");
   2837   ColoredPrintf(COLOR_GREEN,  "[  PASSED  ] ");
   2838   printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
   2839 
   2840   int num_failures = unit_test.failed_test_count();
   2841   if (!unit_test.Passed()) {
   2842     const int failed_test_count = unit_test.failed_test_count();
   2843     ColoredPrintf(COLOR_RED,  "[  FAILED  ] ");
   2844     printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
   2845     PrintFailedTests(unit_test);
   2846     printf("\n%2d FAILED %s\n", num_failures,
   2847                         num_failures == 1 ? "TEST" : "TESTS");
   2848   }
   2849 
   2850   int num_disabled = unit_test.disabled_test_count();
   2851   if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
   2852     if (!num_failures) {
   2853       printf("\n");  // Add a spacer if no FAILURE banner is displayed.
   2854     }
   2855     ColoredPrintf(COLOR_YELLOW,
   2856                   "  YOU HAVE %d DISABLED %s\n\n",
   2857                   num_disabled,
   2858                   num_disabled == 1 ? "TEST" : "TESTS");
   2859   }
   2860   // Ensure that Google Test output is printed before, e.g., heapchecker output.
   2861   fflush(stdout);
   2862 }
   2863 
   2864 // End PrettyUnitTestResultPrinter
   2865 
   2866 // class TestEventRepeater
   2867 //
   2868 // This class forwards events to other event listeners.
   2869 class TestEventRepeater : public TestEventListener {
   2870  public:
   2871   TestEventRepeater() : forwarding_enabled_(true) {}
   2872   virtual ~TestEventRepeater();
   2873   void Append(TestEventListener *listener);
   2874   TestEventListener* Release(TestEventListener* listener);
   2875 
   2876   // Controls whether events will be forwarded to listeners_. Set to false
   2877   // in death test child processes.
   2878   bool forwarding_enabled() const { return forwarding_enabled_; }
   2879   void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }
   2880 
   2881   virtual void OnTestProgramStart(const UnitTest& unit_test);
   2882   virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration);
   2883   virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
   2884   virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test);
   2885   virtual void OnTestCaseStart(const TestCase& test_case);
   2886   virtual void OnTestStart(const TestInfo& test_info);
   2887   virtual void OnTestPartResult(const TestPartResult& result);
   2888   virtual void OnTestEnd(const TestInfo& test_info);
   2889   virtual void OnTestCaseEnd(const TestCase& test_case);
   2890   virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
   2891   virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test);
   2892   virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
   2893   virtual void OnTestProgramEnd(const UnitTest& unit_test);
   2894 
   2895  private:
   2896   // Controls whether events will be forwarded to listeners_. Set to false
   2897   // in death test child processes.
   2898   bool forwarding_enabled_;
   2899   // The list of listeners that receive events.
   2900   std::vector<TestEventListener*> listeners_;
   2901 
   2902   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
   2903 };
   2904 
   2905 TestEventRepeater::~TestEventRepeater() {
   2906   ForEach(listeners_, Delete<TestEventListener>);
   2907 }
   2908 
   2909 void TestEventRepeater::Append(TestEventListener *listener) {
   2910   listeners_.push_back(listener);
   2911 }
   2912 
   2913 // TODO(vladl (at) google.com): Factor the search functionality into Vector::Find.
   2914 TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
   2915   for (size_t i = 0; i < listeners_.size(); ++i) {
   2916     if (listeners_[i] == listener) {
   2917       listeners_.erase(listeners_.begin() + i);
   2918       return listener;
   2919     }
   2920   }
   2921 
   2922   return NULL;
   2923 }
   2924 
   2925 // Since most methods are very similar, use macros to reduce boilerplate.
   2926 // This defines a member that forwards the call to all listeners.
   2927 #define GTEST_REPEATER_METHOD_(Name, Type) \
   2928 void TestEventRepeater::Name(const Type& parameter) { \
   2929   if (forwarding_enabled_) { \
   2930     for (size_t i = 0; i < listeners_.size(); i++) { \
   2931       listeners_[i]->Name(parameter); \
   2932     } \
   2933   } \
   2934 }
   2935 // This defines a member that forwards the call to all listeners in reverse
   2936 // order.
   2937 #define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \
   2938 void TestEventRepeater::Name(const Type& parameter) { \
   2939   if (forwarding_enabled_) { \
   2940     for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \
   2941       listeners_[i]->Name(parameter); \
   2942     } \
   2943   } \
   2944 }
   2945 
   2946 GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
   2947 GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
   2948 GTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase)
   2949 GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
   2950 GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
   2951 GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
   2952 GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
   2953 GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
   2954 GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
   2955 GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase)
   2956 GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
   2957 
   2958 #undef GTEST_REPEATER_METHOD_
   2959 #undef GTEST_REVERSE_REPEATER_METHOD_
   2960 
   2961 void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
   2962                                              int iteration) {
   2963   if (forwarding_enabled_) {
   2964     for (size_t i = 0; i < listeners_.size(); i++) {
   2965       listeners_[i]->OnTestIterationStart(unit_test, iteration);
   2966     }
   2967   }
   2968 }
   2969 
   2970 void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
   2971                                            int iteration) {
   2972   if (forwarding_enabled_) {
   2973     for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) {
   2974       listeners_[i]->OnTestIterationEnd(unit_test, iteration);
   2975     }
   2976   }
   2977 }
   2978 
   2979 // End TestEventRepeater
   2980 
   2981 // This class generates an XML output file.
   2982 class XmlUnitTestResultPrinter : public EmptyTestEventListener {
   2983  public:
   2984   explicit XmlUnitTestResultPrinter(const char* output_file);
   2985 
   2986   virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
   2987 
   2988  private:
   2989   // Is c a whitespace character that is normalized to a space character
   2990   // when it appears in an XML attribute value?
   2991   static bool IsNormalizableWhitespace(char c) {
   2992     return c == 0x9 || c == 0xA || c == 0xD;
   2993   }
   2994 
   2995   // May c appear in a well-formed XML document?
   2996   static bool IsValidXmlCharacter(char c) {
   2997     return IsNormalizableWhitespace(c) || c >= 0x20;
   2998   }
   2999 
   3000   // Returns an XML-escaped copy of the input string str.  If
   3001   // is_attribute is true, the text is meant to appear as an attribute
   3002   // value, and normalizable whitespace is preserved by replacing it
   3003   // with character references.
   3004   static String EscapeXml(const char* str, bool is_attribute);
   3005 
   3006   // Returns the given string with all characters invalid in XML removed.
   3007   static string RemoveInvalidXmlCharacters(const string& str);
   3008 
   3009   // Convenience wrapper around EscapeXml when str is an attribute value.
   3010   static String EscapeXmlAttribute(const char* str) {
   3011     return EscapeXml(str, true);
   3012   }
   3013 
   3014   // Convenience wrapper around EscapeXml when str is not an attribute value.
   3015   static String EscapeXmlText(const char* str) { return EscapeXml(str, false); }
   3016 
   3017   // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
   3018   static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
   3019 
   3020   // Streams an XML representation of a TestInfo object.
   3021   static void OutputXmlTestInfo(::std::ostream* stream,
   3022                                 const char* test_case_name,
   3023                                 const TestInfo& test_info);
   3024 
   3025   // Prints an XML representation of a TestCase object
   3026   static void PrintXmlTestCase(FILE* out, const TestCase& test_case);
   3027 
   3028   // Prints an XML summary of unit_test to output stream out.
   3029   static void PrintXmlUnitTest(FILE* out, const UnitTest& unit_test);
   3030 
   3031   // Produces a string representing the test properties in a result as space
   3032   // delimited XML attributes based on the property key="value" pairs.
   3033   // When the String is not empty, it includes a space at the beginning,
   3034   // to delimit this attribute from prior attributes.
   3035   static String TestPropertiesAsXmlAttributes(const TestResult& result);
   3036 
   3037   // The output file.
   3038   const String output_file_;
   3039 
   3040   GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
   3041 };
   3042 
   3043 // Creates a new XmlUnitTestResultPrinter.
   3044 XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
   3045     : output_file_(output_file) {
   3046   if (output_file_.c_str() == NULL || output_file_.empty()) {
   3047     fprintf(stderr, "XML output file may not be null\n");
   3048     fflush(stderr);
   3049     exit(EXIT_FAILURE);
   3050   }
   3051 }
   3052 
   3053 // Called after the unit test ends.
   3054 void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
   3055                                                   int /*iteration*/) {
   3056   FILE* xmlout = NULL;
   3057   FilePath output_file(output_file_);
   3058   FilePath output_dir(output_file.RemoveFileName());
   3059 
   3060   if (output_dir.CreateDirectoriesRecursively()) {
   3061     xmlout = posix::FOpen(output_file_.c_str(), "w");
   3062   }
   3063   if (xmlout == NULL) {
   3064     // TODO(wan): report the reason of the failure.
   3065     //
   3066     // We don't do it for now as:
   3067     //
   3068     //   1. There is no urgent need for it.
   3069     //   2. It's a bit involved to make the errno variable thread-safe on
   3070     //      all three operating systems (Linux, Windows, and Mac OS).
   3071     //   3. To interpret the meaning of errno in a thread-safe way,
   3072     //      we need the strerror_r() function, which is not available on
   3073     //      Windows.
   3074     fprintf(stderr,
   3075             "Unable to open file \"%s\"\n",
   3076             output_file_.c_str());
   3077     fflush(stderr);
   3078     exit(EXIT_FAILURE);
   3079   }
   3080   PrintXmlUnitTest(xmlout, unit_test);
   3081   fclose(xmlout);
   3082 }
   3083 
   3084 // Returns an XML-escaped copy of the input string str.  If is_attribute
   3085 // is true, the text is meant to appear as an attribute value, and
   3086 // normalizable whitespace is preserved by replacing it with character
   3087 // references.
   3088 //
   3089 // Invalid XML characters in str, if any, are stripped from the output.
   3090 // It is expected that most, if not all, of the text processed by this
   3091 // module will consist of ordinary English text.
   3092 // If this module is ever modified to produce version 1.1 XML output,
   3093 // most invalid characters can be retained using character references.
   3094 // TODO(wan): It might be nice to have a minimally invasive, human-readable
   3095 // escaping scheme for invalid characters, rather than dropping them.
   3096 String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_attribute) {
   3097   Message m;
   3098 
   3099   if (str != NULL) {
   3100     for (const char* src = str; *src; ++src) {
   3101       switch (*src) {
   3102         case '<':
   3103           m << "&lt;";
   3104           break;
   3105         case '>':
   3106           m << "&gt;";
   3107           break;
   3108         case '&':
   3109           m << "&amp;";
   3110           break;
   3111         case '\'':
   3112           if (is_attribute)
   3113             m << "&apos;";
   3114           else
   3115             m << '\'';
   3116           break;
   3117         case '"':
   3118           if (is_attribute)
   3119             m << "&quot;";
   3120           else
   3121             m << '"';
   3122           break;
   3123         default:
   3124           if (IsValidXmlCharacter(*src)) {
   3125             if (is_attribute && IsNormalizableWhitespace(*src))
   3126               m << String::Format("&#x%02X;", unsigned(*src));
   3127             else
   3128               m << *src;
   3129           }
   3130           break;
   3131       }
   3132     }
   3133   }
   3134 
   3135   return m.GetString();
   3136 }
   3137 
   3138 // Returns the given string with all characters invalid in XML removed.
   3139 // Currently invalid characters are dropped from the string. An
   3140 // alternative is to replace them with certain characters such as . or ?.
   3141 string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const string& str) {
   3142   string output;
   3143   output.reserve(str.size());
   3144   for (string::const_iterator it = str.begin(); it != str.end(); ++it)
   3145     if (IsValidXmlCharacter(*it))
   3146       output.push_back(*it);
   3147 
   3148   return output;
   3149 }
   3150 
   3151 // The following routines generate an XML representation of a UnitTest
   3152 // object.
   3153 //
   3154 // This is how Google Test concepts map to the DTD:
   3155 //
   3156 // <testsuites name="AllTests">        <-- corresponds to a UnitTest object
   3157 //   <testsuite name="testcase-name">  <-- corresponds to a TestCase object
   3158 //     <testcase name="test-name">     <-- corresponds to a TestInfo object
   3159 //       <failure message="...">...</failure>
   3160 //       <failure message="...">...</failure>
   3161 //       <failure message="...">...</failure>
   3162 //                                     <-- individual assertion failures
   3163 //     </testcase>
   3164 //   </testsuite>
   3165 // </testsuites>
   3166 
   3167 // Formats the given time in milliseconds as seconds.
   3168 std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
   3169   ::std::stringstream ss;
   3170   ss << ms/1000.0;
   3171   return ss.str();
   3172 }
   3173 
   3174 // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
   3175 void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
   3176                                                      const char* data) {
   3177   const char* segment = data;
   3178   *stream << "<![CDATA[";
   3179   for (;;) {
   3180     const char* const next_segment = strstr(segment, "]]>");
   3181     if (next_segment != NULL) {
   3182       stream->write(
   3183           segment, static_cast<std::streamsize>(next_segment - segment));
   3184       *stream << "]]>]]&gt;<![CDATA[";
   3185       segment = next_segment + strlen("]]>");
   3186     } else {
   3187       *stream << segment;
   3188       break;
   3189     }
   3190   }
   3191   *stream << "]]>";
   3192 }
   3193 
   3194 // Prints an XML representation of a TestInfo object.
   3195 // TODO(wan): There is also value in printing properties with the plain printer.
   3196 void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
   3197                                                  const char* test_case_name,
   3198                                                  const TestInfo& test_info) {
   3199   const TestResult& result = *test_info.result();
   3200   *stream << "    <testcase name=\""
   3201           << EscapeXmlAttribute(test_info.name()).c_str() << "\"";
   3202 
   3203   if (test_info.value_param() != NULL) {
   3204     *stream << " value_param=\"" << EscapeXmlAttribute(test_info.value_param())
   3205             << "\"";
   3206   }
   3207   if (test_info.type_param() != NULL) {
   3208     *stream << " type_param=\"" << EscapeXmlAttribute(test_info.type_param())
   3209             << "\"";
   3210   }
   3211 
   3212   *stream << " status=\""
   3213           << (test_info.should_run() ? "run" : "notrun")
   3214           << "\" time=\""
   3215           << FormatTimeInMillisAsSeconds(result.elapsed_time())
   3216           << "\" classname=\"" << EscapeXmlAttribute(test_case_name).c_str()
   3217           << "\"" << TestPropertiesAsXmlAttributes(result).c_str();
   3218 
   3219   int failures = 0;
   3220   for (int i = 0; i < result.total_part_count(); ++i) {
   3221     const TestPartResult& part = result.GetTestPartResult(i);
   3222     if (part.failed()) {
   3223       if (++failures == 1)
   3224         *stream << ">\n";
   3225       *stream << "      <failure message=\""
   3226               << EscapeXmlAttribute(part.summary()).c_str()
   3227               << "\" type=\"\">";
   3228       const string location = internal::FormatCompilerIndependentFileLocation(
   3229           part.file_name(), part.line_number());
   3230       const string message = location + "\n" + part.message();
   3231       OutputXmlCDataSection(stream,
   3232                             RemoveInvalidXmlCharacters(message).c_str());
   3233       *stream << "</failure>\n";
   3234     }
   3235   }
   3236 
   3237   if (failures == 0)
   3238     *stream << " />\n";
   3239   else
   3240     *stream << "    </testcase>\n";
   3241 }
   3242 
   3243 // Prints an XML representation of a TestCase object
   3244 void XmlUnitTestResultPrinter::PrintXmlTestCase(FILE* out,
   3245                                                 const TestCase& test_case) {
   3246   fprintf(out,
   3247           "  <testsuite name=\"%s\" tests=\"%d\" failures=\"%d\" "
   3248           "disabled=\"%d\" ",
   3249           EscapeXmlAttribute(test_case.name()).c_str(),
   3250           test_case.total_test_count(),
   3251           test_case.failed_test_count(),
   3252           test_case.disabled_test_count());
   3253   fprintf(out,
   3254           "errors=\"0\" time=\"%s\">\n",
   3255           FormatTimeInMillisAsSeconds(test_case.elapsed_time()).c_str());
   3256   for (int i = 0; i < test_case.total_test_count(); ++i) {
   3257     ::std::stringstream stream;
   3258     OutputXmlTestInfo(&stream, test_case.name(), *test_case.GetTestInfo(i));
   3259     fprintf(out, "%s", StringStreamToString(&stream).c_str());
   3260   }
   3261   fprintf(out, "  </testsuite>\n");
   3262 }
   3263 
   3264 // Prints an XML summary of unit_test to output stream out.
   3265 void XmlUnitTestResultPrinter::PrintXmlUnitTest(FILE* out,
   3266                                                 const UnitTest& unit_test) {
   3267   fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
   3268   fprintf(out,
   3269           "<testsuites tests=\"%d\" failures=\"%d\" disabled=\"%d\" "
   3270           "errors=\"0\" time=\"%s\" ",
   3271           unit_test.total_test_count(),
   3272           unit_test.failed_test_count(),
   3273           unit_test.disabled_test_count(),
   3274           FormatTimeInMillisAsSeconds(unit_test.elapsed_time()).c_str());
   3275   if (GTEST_FLAG(shuffle)) {
   3276     fprintf(out, "random_seed=\"%d\" ", unit_test.random_seed());
   3277   }
   3278   fprintf(out, "name=\"AllTests\">\n");
   3279   for (int i = 0; i < unit_test.total_test_case_count(); ++i)
   3280     PrintXmlTestCase(out, *unit_test.GetTestCase(i));
   3281   fprintf(out, "</testsuites>\n");
   3282 }
   3283 
   3284 // Produces a string representing the test properties in a result as space
   3285 // delimited XML attributes based on the property key="value" pairs.
   3286 String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
   3287     const TestResult& result) {
   3288   Message attributes;
   3289   for (int i = 0; i < result.test_property_count(); ++i) {
   3290     const TestProperty& property = result.GetTestProperty(i);
   3291     attributes << " " << property.key() << "="
   3292         << "\"" << EscapeXmlAttribute(property.value()) << "\"";
   3293   }
   3294   return attributes.GetString();
   3295 }
   3296 
   3297 // End XmlUnitTestResultPrinter
   3298 
   3299 #if GTEST_CAN_STREAM_RESULTS_
   3300 
   3301 // Streams test results to the given port on the given host machine.
   3302 class StreamingListener : public EmptyTestEventListener {
   3303  public:
   3304   // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
   3305   static string UrlEncode(const char* str);
   3306 
   3307   StreamingListener(const string& host, const string& port)
   3308       : sockfd_(-1), host_name_(host), port_num_(port) {
   3309     MakeConnection();
   3310     Send("gtest_streaming_protocol_version=1.0\n");
   3311   }
   3312 
   3313   virtual ~StreamingListener() {
   3314     if (sockfd_ != -1)
   3315       CloseConnection();
   3316   }
   3317 
   3318   void OnTestProgramStart(const UnitTest& /* unit_test */) {
   3319     Send("event=TestProgramStart\n");
   3320   }
   3321 
   3322   void OnTestProgramEnd(const UnitTest& unit_test) {
   3323     // Note that Google Test current only report elapsed time for each
   3324     // test iteration, not for the entire test program.
   3325     Send(String::Format("event=TestProgramEnd&passed=%d\n",
   3326                         unit_test.Passed()));
   3327 
   3328     // Notify the streaming server to stop.
   3329     CloseConnection();
   3330   }
   3331 
   3332   void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) {
   3333     Send(String::Format("event=TestIterationStart&iteration=%d\n",
   3334                         iteration));
   3335   }
   3336 
   3337   void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) {
   3338     Send(String::Format("event=TestIterationEnd&passed=%d&elapsed_time=%sms\n",
   3339                         unit_test.Passed(),
   3340                         StreamableToString(unit_test.elapsed_time()).c_str()));
   3341   }
   3342 
   3343   void OnTestCaseStart(const TestCase& test_case) {
   3344     Send(String::Format("event=TestCaseStart&name=%s\n", test_case.name()));
   3345   }
   3346 
   3347   void OnTestCaseEnd(const TestCase& test_case) {
   3348     Send(String::Format("event=TestCaseEnd&passed=%d&elapsed_time=%sms\n",
   3349                         test_case.Passed(),
   3350                         StreamableToString(test_case.elapsed_time()).c_str()));
   3351   }
   3352 
   3353   void OnTestStart(const TestInfo& test_info) {
   3354     Send(String::Format("event=TestStart&name=%s\n", test_info.name()));
   3355   }
   3356 
   3357   void OnTestEnd(const TestInfo& test_info) {
   3358     Send(String::Format(
   3359         "event=TestEnd&passed=%d&elapsed_time=%sms\n",
   3360         (test_info.result())->Passed(),
   3361         StreamableToString((test_info.result())->elapsed_time()).c_str()));
   3362   }
   3363 
   3364   void OnTestPartResult(const TestPartResult& test_part_result) {
   3365     const char* file_name = test_part_result.file_name();
   3366     if (file_name == NULL)
   3367       file_name = "";
   3368     Send(String::Format("event=TestPartResult&file=%s&line=%d&message=",
   3369                         UrlEncode(file_name).c_str(),
   3370                         test_part_result.line_number()));
   3371     Send(UrlEncode(test_part_result.message()) + "\n");
   3372   }
   3373 
   3374  private:
   3375   // Creates a client socket and connects to the server.
   3376   void MakeConnection();
   3377 
   3378   // Closes the socket.
   3379   void CloseConnection() {
   3380     GTEST_CHECK_(sockfd_ != -1)
   3381         << "CloseConnection() can be called only when there is a connection.";
   3382 
   3383     close(sockfd_);
   3384     sockfd_ = -1;
   3385   }
   3386 
   3387   // Sends a string to the socket.
   3388   void Send(const string& message) {
   3389     GTEST_CHECK_(sockfd_ != -1)
   3390         << "Send() can be called only when there is a connection.";
   3391 
   3392     const int len = static_cast<int>(message.length());
   3393     if (write(sockfd_, message.c_str(), len) != len) {
   3394       GTEST_LOG_(WARNING)
   3395           << "stream_result_to: failed to stream to "
   3396           << host_name_ << ":" << port_num_;
   3397     }
   3398   }
   3399 
   3400   int sockfd_;   // socket file descriptor
   3401   const string host_name_;
   3402   const string port_num_;
   3403 
   3404   GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
   3405 };  // class StreamingListener
   3406 
   3407 // Checks if str contains '=', '&', '%' or '\n' characters. If yes,
   3408 // replaces them by "%xx" where xx is their hexadecimal value. For
   3409 // example, replaces "=" with "%3D".  This algorithm is O(strlen(str))
   3410 // in both time and space -- important as the input str may contain an
   3411 // arbitrarily long test failure message and stack trace.
   3412 string StreamingListener::UrlEncode(const char* str) {
   3413   string result;
   3414   result.reserve(strlen(str) + 1);
   3415   for (char ch = *str; ch != '\0'; ch = *++str) {
   3416     switch (ch) {
   3417       case '%':
   3418       case '=':
   3419       case '&':
   3420       case '\n':
   3421         result.append(String::Format("%%%02x", static_cast<unsigned char>(ch)));
   3422         break;
   3423       default:
   3424         result.push_back(ch);
   3425         break;
   3426     }
   3427   }
   3428   return result;
   3429 }
   3430 
   3431 void StreamingListener::MakeConnection() {
   3432   GTEST_CHECK_(sockfd_ == -1)
   3433       << "MakeConnection() can't be called when there is already a connection.";
   3434 
   3435   addrinfo hints;
   3436   memset(&hints, 0, sizeof(hints));
   3437   hints.ai_family = AF_UNSPEC;    // To allow both IPv4 and IPv6 addresses.
   3438   hints.ai_socktype = SOCK_STREAM;
   3439   addrinfo* servinfo = NULL;
   3440 
   3441   // Use the getaddrinfo() to get a linked list of IP addresses for
   3442   // the given host name.
   3443   const int error_num = getaddrinfo(
   3444       host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
   3445   if (error_num != 0) {
   3446     GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
   3447                         << gai_strerror(error_num);
   3448   }
   3449 
   3450   // Loop through all the results and connect to the first we can.
   3451   for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL;
   3452        cur_addr = cur_addr->ai_next) {
   3453     sockfd_ = socket(
   3454         cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
   3455     if (sockfd_ != -1) {
   3456       // Connect the client socket to the server socket.
   3457       if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
   3458         close(sockfd_);
   3459         sockfd_ = -1;
   3460       }
   3461     }
   3462   }
   3463 
   3464   freeaddrinfo(servinfo);  // all done with this structure
   3465 
   3466   if (sockfd_ == -1) {
   3467     GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
   3468                         << host_name_ << ":" << port_num_;
   3469   }
   3470 }
   3471 
   3472 // End of class Streaming Listener
   3473 #endif  // GTEST_CAN_STREAM_RESULTS__
   3474 
   3475 // Class ScopedTrace
   3476 
   3477 // Pushes the given source file location and message onto a per-thread
   3478 // trace stack maintained by Google Test.
   3479 // L < UnitTest::mutex_
   3480 ScopedTrace::ScopedTrace(const char* file, int line, const Message& message) {
   3481   TraceInfo trace;
   3482   trace.file = file;
   3483   trace.line = line;
   3484   trace.message = message.GetString();
   3485 
   3486   UnitTest::GetInstance()->PushGTestTrace(trace);
   3487 }
   3488 
   3489 // Pops the info pushed by the c'tor.
   3490 // L < UnitTest::mutex_
   3491 ScopedTrace::~ScopedTrace() {
   3492   UnitTest::GetInstance()->PopGTestTrace();
   3493 }
   3494 
   3495 
   3496 // class OsStackTraceGetter
   3497 
   3498 // Returns the current OS stack trace as a String.  Parameters:
   3499 //
   3500 //   max_depth  - the maximum number of stack frames to be included
   3501 //                in the trace.
   3502 //   skip_count - the number of top frames to be skipped; doesn't count
   3503 //                against max_depth.
   3504 //
   3505 // L < mutex_
   3506 // We use "L < mutex_" to denote that the function may acquire mutex_.
   3507 String OsStackTraceGetter::CurrentStackTrace(int, int) {
   3508   return String("");
   3509 }
   3510 
   3511 // L < mutex_
   3512 void OsStackTraceGetter::UponLeavingGTest() {
   3513 }
   3514 
   3515 const char* const
   3516 OsStackTraceGetter::kElidedFramesMarker =
   3517     "... " GTEST_NAME_ " internal frames ...";
   3518 
   3519 }  // namespace internal
   3520 
   3521 // class TestEventListeners
   3522 
   3523 TestEventListeners::TestEventListeners()
   3524     : repeater_(new internal::TestEventRepeater()),
   3525       default_result_printer_(NULL),
   3526       default_xml_generator_(NULL) {
   3527 }
   3528 
   3529 TestEventListeners::~TestEventListeners() { delete repeater_; }
   3530 
   3531 // Returns the standard listener responsible for the default console
   3532 // output.  Can be removed from the listeners list to shut down default
   3533 // console output.  Note that removing this object from the listener list
   3534 // with Release transfers its ownership to the user.
   3535 void TestEventListeners::Append(TestEventListener* listener) {
   3536   repeater_->Append(listener);
   3537 }
   3538 
   3539 // Removes the given event listener from the list and returns it.  It then
   3540 // becomes the caller's responsibility to delete the listener. Returns
   3541 // NULL if the listener is not found in the list.
   3542 TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
   3543   if (listener == default_result_printer_)
   3544     default_result_printer_ = NULL;
   3545   else if (listener == default_xml_generator_)
   3546     default_xml_generator_ = NULL;
   3547   return repeater_->Release(listener);
   3548 }
   3549 
   3550 // Returns repeater that broadcasts the TestEventListener events to all
   3551 // subscribers.
   3552 TestEventListener* TestEventListeners::repeater() { return repeater_; }
   3553 
   3554 // Sets the default_result_printer attribute to the provided listener.
   3555 // The listener is also added to the listener list and previous
   3556 // default_result_printer is removed from it and deleted. The listener can
   3557 // also be NULL in which case it will not be added to the list. Does
   3558 // nothing if the previous and the current listener objects are the same.
   3559 void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
   3560   if (default_result_printer_ != listener) {
   3561     // It is an error to pass this method a listener that is already in the
   3562     // list.
   3563     delete Release(default_result_printer_);
   3564     default_result_printer_ = listener;
   3565     if (listener != NULL)
   3566       Append(listener);
   3567   }
   3568 }
   3569 
   3570 // Sets the default_xml_generator attribute to the provided listener.  The
   3571 // listener is also added to the listener list and previous
   3572 // default_xml_generator is removed from it and deleted. The listener can
   3573 // also be NULL in which case it will not be added to the list. Does
   3574 // nothing if the previous and the current listener objects are the same.
   3575 void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
   3576   if (default_xml_generator_ != listener) {
   3577     // It is an error to pass this method a listener that is already in the
   3578     // list.
   3579     delete Release(default_xml_generator_);
   3580     default_xml_generator_ = listener;
   3581     if (listener != NULL)
   3582       Append(listener);
   3583   }
   3584 }
   3585 
   3586 // Controls whether events will be forwarded by the repeater to the
   3587 // listeners in the list.
   3588 bool TestEventListeners::EventForwardingEnabled() const {
   3589   return repeater_->forwarding_enabled();
   3590 }
   3591 
   3592 void TestEventListeners::SuppressEventForwarding() {
   3593   repeater_->set_forwarding_enabled(false);
   3594 }
   3595 
   3596 // class UnitTest
   3597 
   3598 // Gets the singleton UnitTest object.  The first time this method is
   3599 // called, a UnitTest object is constructed and returned.  Consecutive
   3600 // calls will return the same object.
   3601 //
   3602 // We don't protect this under mutex_ as a user is not supposed to
   3603 // call this before main() starts, from which point on the return
   3604 // value will never change.
   3605 UnitTest * UnitTest::GetInstance() {
   3606   // When compiled with MSVC 7.1 in optimized mode, destroying the
   3607   // UnitTest object upon exiting the program messes up the exit code,
   3608   // causing successful tests to appear failed.  We have to use a
   3609   // different implementation in this case to bypass the compiler bug.
   3610   // This implementation makes the compiler happy, at the cost of
   3611   // leaking the UnitTest object.
   3612 
   3613   // CodeGear C++Builder insists on a public destructor for the
   3614   // default implementation.  Use this implementation to keep good OO
   3615   // design with private destructor.
   3616 
   3617 #if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
   3618   static UnitTest* const instance = new UnitTest;
   3619   return instance;
   3620 #else
   3621   static UnitTest instance;
   3622   return &instance;
   3623 #endif  // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
   3624 }
   3625 
   3626 // Gets the number of successful test cases.
   3627 int UnitTest::successful_test_case_count() const {
   3628   return impl()->successful_test_case_count();
   3629 }
   3630 
   3631 // Gets the number of failed test cases.
   3632 int UnitTest::failed_test_case_count() const {
   3633   return impl()->failed_test_case_count();
   3634 }
   3635 
   3636 // Gets the number of all test cases.
   3637 int UnitTest::total_test_case_count() const {
   3638   return impl()->total_test_case_count();
   3639 }
   3640 
   3641 // Gets the number of all test cases that contain at least one test
   3642 // that should run.
   3643 int UnitTest::test_case_to_run_count() const {
   3644   return impl()->test_case_to_run_count();
   3645 }
   3646 
   3647 // Gets the number of successful tests.
   3648 int UnitTest::successful_test_count() const {
   3649   return impl()->successful_test_count();
   3650 }
   3651 
   3652 // Gets the number of failed tests.
   3653 int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
   3654 
   3655 // Gets the number of disabled tests.
   3656 int UnitTest::disabled_test_count() const {
   3657   return impl()->disabled_test_count();
   3658 }
   3659 
   3660 // Gets the number of all tests.
   3661 int UnitTest::total_test_count() const { return impl()->total_test_count(); }
   3662 
   3663 // Gets the number of tests that should run.
   3664 int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
   3665 
   3666 // Gets the elapsed time, in milliseconds.
   3667 internal::TimeInMillis UnitTest::elapsed_time() const {
   3668   return impl()->elapsed_time();
   3669 }
   3670 
   3671 // Returns true iff the unit test passed (i.e. all test cases passed).
   3672 bool UnitTest::Passed() const { return impl()->Passed(); }
   3673 
   3674 // Returns true iff the unit test failed (i.e. some test case failed
   3675 // or something outside of all tests failed).
   3676 bool UnitTest::Failed() const { return impl()->Failed(); }
   3677 
   3678 // Gets the i-th test case among all the test cases. i can range from 0 to
   3679 // total_test_case_count() - 1. If i is not in that range, returns NULL.
   3680 const TestCase* UnitTest::GetTestCase(int i) const {
   3681   return impl()->GetTestCase(i);
   3682 }
   3683 
   3684 // Gets the i-th test case among all the test cases. i can range from 0 to
   3685 // total_test_case_count() - 1. If i is not in that range, returns NULL.
   3686 TestCase* UnitTest::GetMutableTestCase(int i) {
   3687   return impl()->GetMutableTestCase(i);
   3688 }
   3689 
   3690 // Returns the list of event listeners that can be used to track events
   3691 // inside Google Test.
   3692 TestEventListeners& UnitTest::listeners() {
   3693   return *impl()->listeners();
   3694 }
   3695 
   3696 // Registers and returns a global test environment.  When a test
   3697 // program is run, all global test environments will be set-up in the
   3698 // order they were registered.  After all tests in the program have
   3699 // finished, all global test environments will be torn-down in the
   3700 // *reverse* order they were registered.
   3701 //
   3702 // The UnitTest object takes ownership of the given environment.
   3703 //
   3704 // We don't protect this under mutex_, as we only support calling it
   3705 // from the main thread.
   3706 Environment* UnitTest::AddEnvironment(Environment* env) {
   3707   if (env == NULL) {
   3708     return NULL;
   3709   }
   3710 
   3711   impl_->environments().push_back(env);
   3712   return env;
   3713 }
   3714 
   3715 // Adds a TestPartResult to the current TestResult object.  All Google Test
   3716 // assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
   3717 // this to report their results.  The user code should use the
   3718 // assertion macros instead of calling this directly.
   3719 // L < mutex_
   3720 void UnitTest::AddTestPartResult(TestPartResult::Type result_type,
   3721                                  const char* file_name,
   3722                                  int line_number,
   3723                                  const internal::String& message,
   3724                                  const internal::String& os_stack_trace) {
   3725   Message msg;
   3726   msg << message;
   3727 
   3728   internal::MutexLock lock(&mutex_);
   3729   if (impl_->gtest_trace_stack().size() > 0) {
   3730     msg << "\n" << GTEST_NAME_ << " trace:";
   3731 
   3732     for (int i = static_cast<int>(impl_->gtest_trace_stack().size());
   3733          i > 0; --i) {
   3734       const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
   3735       msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
   3736           << " " << trace.message;
   3737     }
   3738   }
   3739 
   3740   if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) {
   3741     msg << internal::kStackTraceMarker << os_stack_trace;
   3742   }
   3743 
   3744   const TestPartResult result =
   3745     TestPartResult(result_type, file_name, line_number,
   3746                    msg.GetString().c_str());
   3747   impl_->GetTestPartResultReporterForCurrentThread()->
   3748       ReportTestPartResult(result);
   3749 
   3750   if (result_type != TestPartResult::kSuccess) {
   3751     // gtest_break_on_failure takes precedence over
   3752     // gtest_throw_on_failure.  This allows a user to set the latter
   3753     // in the code (perhaps in order to use Google Test assertions
   3754     // with another testing framework) and specify the former on the
   3755     // command line for debugging.
   3756     if (GTEST_FLAG(break_on_failure)) {
   3757 #if GTEST_OS_WINDOWS
   3758       // Using DebugBreak on Windows allows gtest to still break into a debugger
   3759       // when a failure happens and both the --gtest_break_on_failure and
   3760       // the --gtest_catch_exceptions flags are specified.
   3761       DebugBreak();
   3762 #else
   3763       abort();
   3764 #endif  // GTEST_OS_WINDOWS
   3765     } else if (GTEST_FLAG(throw_on_failure)) {
   3766 #if GTEST_HAS_EXCEPTIONS
   3767       throw GoogleTestFailureException(result);
   3768 #else
   3769       // We cannot call abort() as it generates a pop-up in debug mode
   3770       // that cannot be suppressed in VC 7.1 or below.
   3771       exit(1);
   3772 #endif
   3773     }
   3774   }
   3775 }
   3776 
   3777 // Creates and adds a property to the current TestResult. If a property matching
   3778 // the supplied value already exists, updates its value instead.
   3779 void UnitTest::RecordPropertyForCurrentTest(const char* key,
   3780                                             const char* value) {
   3781   const TestProperty test_property(key, value);
   3782   impl_->current_test_result()->RecordProperty(test_property);
   3783 }
   3784 
   3785 // Runs all tests in this UnitTest object and prints the result.
   3786 // Returns 0 if successful, or 1 otherwise.
   3787 //
   3788 // We don't protect this under mutex_, as we only support calling it
   3789 // from the main thread.
   3790 int UnitTest::Run() {
   3791   // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
   3792   // used for the duration of the program.
   3793   impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
   3794 
   3795 #if GTEST_HAS_SEH
   3796   const bool in_death_test_child_process =
   3797       internal::GTEST_FLAG(internal_run_death_test).length() > 0;
   3798 
   3799   // Either the user wants Google Test to catch exceptions thrown by the
   3800   // tests or this is executing in the context of death test child
   3801   // process. In either case the user does not want to see pop-up dialogs
   3802   // about crashes - they are expected.
   3803   if (impl()->catch_exceptions() || in_death_test_child_process) {
   3804 
   3805 # if !GTEST_OS_WINDOWS_MOBILE
   3806     // SetErrorMode doesn't exist on CE.
   3807     SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
   3808                  SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
   3809 # endif  // !GTEST_OS_WINDOWS_MOBILE
   3810 
   3811 # if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
   3812     // Death test children can be terminated with _abort().  On Windows,
   3813     // _abort() can show a dialog with a warning message.  This forces the
   3814     // abort message to go to stderr instead.
   3815     _set_error_mode(_OUT_TO_STDERR);
   3816 # endif
   3817 
   3818 # if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
   3819     // In the debug version, Visual Studio pops up a separate dialog
   3820     // offering a choice to debug the aborted program. We need to suppress
   3821     // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
   3822     // executed. Google Test will notify the user of any unexpected
   3823     // failure via stderr.
   3824     //
   3825     // VC++ doesn't define _set_abort_behavior() prior to the version 8.0.
   3826     // Users of prior VC versions shall suffer the agony and pain of
   3827     // clicking through the countless debug dialogs.
   3828     // TODO(vladl (at) google.com): find a way to suppress the abort dialog() in the
   3829     // debug mode when compiled with VC 7.1 or lower.
   3830     if (!GTEST_FLAG(break_on_failure))
   3831       _set_abort_behavior(
   3832           0x0,                                    // Clear the following flags:
   3833           _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
   3834 # endif
   3835 
   3836   }
   3837 #endif  // GTEST_HAS_SEH
   3838 
   3839   return internal::HandleExceptionsInMethodIfSupported(
   3840       impl(),
   3841       &internal::UnitTestImpl::RunAllTests,
   3842       "auxiliary test code (environments or event listeners)") ? 0 : 1;
   3843 }
   3844 
   3845 // Returns the working directory when the first TEST() or TEST_F() was
   3846 // executed.
   3847 const char* UnitTest::original_working_dir() const {
   3848   return impl_->original_working_dir_.c_str();
   3849 }
   3850 
   3851 // Returns the TestCase object for the test that's currently running,
   3852 // or NULL if no test is running.
   3853 // L < mutex_
   3854 const TestCase* UnitTest::current_test_case() const {
   3855   internal::MutexLock lock(&mutex_);
   3856   return impl_->current_test_case();
   3857 }
   3858 
   3859 // Returns the TestInfo object for the test that's currently running,
   3860 // or NULL if no test is running.
   3861 // L < mutex_
   3862 const TestInfo* UnitTest::current_test_info() const {
   3863   internal::MutexLock lock(&mutex_);
   3864   return impl_->current_test_info();
   3865 }
   3866 
   3867 // Returns the random seed used at the start of the current test run.
   3868 int UnitTest::random_seed() const { return impl_->random_seed(); }
   3869 
   3870 #if GTEST_HAS_PARAM_TEST
   3871 // Returns ParameterizedTestCaseRegistry object used to keep track of
   3872 // value-parameterized tests and instantiate and register them.
   3873 // L < mutex_
   3874 internal::ParameterizedTestCaseRegistry&
   3875     UnitTest::parameterized_test_registry() {
   3876   return impl_->parameterized_test_registry();
   3877 }
   3878 #endif  // GTEST_HAS_PARAM_TEST
   3879 
   3880 // Creates an empty UnitTest.
   3881 UnitTest::UnitTest() {
   3882   impl_ = new internal::UnitTestImpl(this);
   3883 }
   3884 
   3885 // Destructor of UnitTest.
   3886 UnitTest::~UnitTest() {
   3887   delete impl_;
   3888 }
   3889 
   3890 // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
   3891 // Google Test trace stack.
   3892 // L < mutex_
   3893 void UnitTest::PushGTestTrace(const internal::TraceInfo& trace) {
   3894   internal::MutexLock lock(&mutex_);
   3895   impl_->gtest_trace_stack().push_back(trace);
   3896 }
   3897 
   3898 // Pops a trace from the per-thread Google Test trace stack.
   3899 // L < mutex_
   3900 void UnitTest::PopGTestTrace() {
   3901   internal::MutexLock lock(&mutex_);
   3902   impl_->gtest_trace_stack().pop_back();
   3903 }
   3904 
   3905 namespace internal {
   3906 
   3907 UnitTestImpl::UnitTestImpl(UnitTest* parent)
   3908     : parent_(parent),
   3909 #ifdef _MSC_VER
   3910 # pragma warning(push)                    // Saves the current warning state.
   3911 # pragma warning(disable:4355)            // Temporarily disables warning 4355
   3912                                          // (using this in initializer).
   3913       default_global_test_part_result_reporter_(this),
   3914       default_per_thread_test_part_result_reporter_(this),
   3915 # pragma warning(pop)                     // Restores the warning state again.
   3916 #else
   3917       default_global_test_part_result_reporter_(this),
   3918       default_per_thread_test_part_result_reporter_(this),
   3919 #endif  // _MSC_VER
   3920       global_test_part_result_repoter_(
   3921           &default_global_test_part_result_reporter_),
   3922       per_thread_test_part_result_reporter_(
   3923           &default_per_thread_test_part_result_reporter_),
   3924 #if GTEST_HAS_PARAM_TEST
   3925       parameterized_test_registry_(),
   3926       parameterized_tests_registered_(false),
   3927 #endif  // GTEST_HAS_PARAM_TEST
   3928       last_death_test_case_(-1),
   3929       current_test_case_(NULL),
   3930       current_test_info_(NULL),
   3931       ad_hoc_test_result_(),
   3932       os_stack_trace_getter_(NULL),
   3933       post_flag_parse_init_performed_(false),
   3934       random_seed_(0),  // Will be overridden by the flag before first use.
   3935       random_(0),  // Will be reseeded before first use.
   3936       elapsed_time_(0),
   3937 #if GTEST_HAS_DEATH_TEST
   3938       internal_run_death_test_flag_(NULL),
   3939       death_test_factory_(new DefaultDeathTestFactory),
   3940 #endif
   3941       // Will be overridden by the flag before first use.
   3942       catch_exceptions_(false) {
   3943   listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
   3944 }
   3945 
   3946 UnitTestImpl::~UnitTestImpl() {
   3947   // Deletes every TestCase.
   3948   ForEach(test_cases_, internal::Delete<TestCase>);
   3949 
   3950   // Deletes every Environment.
   3951   ForEach(environments_, internal::Delete<Environment>);
   3952 
   3953   delete os_stack_trace_getter_;
   3954 }
   3955 
   3956 #if GTEST_HAS_DEATH_TEST
   3957 // Disables event forwarding if the control is currently in a death test
   3958 // subprocess. Must not be called before InitGoogleTest.
   3959 void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
   3960   if (internal_run_death_test_flag_.get() != NULL)
   3961     listeners()->SuppressEventForwarding();
   3962 }
   3963 #endif  // GTEST_HAS_DEATH_TEST
   3964 
   3965 // Initializes event listeners performing XML output as specified by
   3966 // UnitTestOptions. Must not be called before InitGoogleTest.
   3967 void UnitTestImpl::ConfigureXmlOutput() {
   3968   const String& output_format = UnitTestOptions::GetOutputFormat();
   3969   if (output_format == "xml") {
   3970     listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
   3971         UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
   3972   } else if (output_format != "") {
   3973     printf("WARNING: unrecognized output format \"%s\" ignored.\n",
   3974            output_format.c_str());
   3975     fflush(stdout);
   3976   }
   3977 }
   3978 
   3979 #if GTEST_CAN_STREAM_RESULTS_
   3980 // Initializes event listeners for streaming test results in String form.
   3981 // Must not be called before InitGoogleTest.
   3982 void UnitTestImpl::ConfigureStreamingOutput() {
   3983   const string& target = GTEST_FLAG(stream_result_to);
   3984   if (!target.empty()) {
   3985     const size_t pos = target.find(':');
   3986     if (pos != string::npos) {
   3987       listeners()->Append(new StreamingListener(target.substr(0, pos),
   3988                                                 target.substr(pos+1)));
   3989     } else {
   3990       printf("WARNING: unrecognized streaming target \"%s\" ignored.\n",
   3991              target.c_str());
   3992       fflush(stdout);
   3993     }
   3994   }
   3995 }
   3996 #endif  // GTEST_CAN_STREAM_RESULTS_
   3997 
   3998 // Performs initialization dependent upon flag values obtained in
   3999 // ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
   4000 // ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
   4001 // this function is also called from RunAllTests.  Since this function can be
   4002 // called more than once, it has to be idempotent.
   4003 void UnitTestImpl::PostFlagParsingInit() {
   4004   // Ensures that this function does not execute more than once.
   4005   if (!post_flag_parse_init_performed_) {
   4006     post_flag_parse_init_performed_ = true;
   4007 
   4008 #if GTEST_HAS_DEATH_TEST
   4009     InitDeathTestSubprocessControlInfo();
   4010     SuppressTestEventsIfInSubprocess();
   4011 #endif  // GTEST_HAS_DEATH_TEST
   4012 
   4013     // Registers parameterized tests. This makes parameterized tests
   4014     // available to the UnitTest reflection API without running
   4015     // RUN_ALL_TESTS.
   4016     RegisterParameterizedTests();
   4017 
   4018     // Configures listeners for XML output. This makes it possible for users
   4019     // to shut down the default XML output before invoking RUN_ALL_TESTS.
   4020     ConfigureXmlOutput();
   4021 
   4022 #if GTEST_CAN_STREAM_RESULTS_
   4023     // Configures listeners for streaming test results to the specified server.
   4024     ConfigureStreamingOutput();
   4025 #endif  // GTEST_CAN_STREAM_RESULTS_
   4026   }
   4027 }
   4028 
   4029 // A predicate that checks the name of a TestCase against a known
   4030 // value.
   4031 //
   4032 // This is used for implementation of the UnitTest class only.  We put
   4033 // it in the anonymous namespace to prevent polluting the outer
   4034 // namespace.
   4035 //
   4036 // TestCaseNameIs is copyable.
   4037 class TestCaseNameIs {
   4038  public:
   4039   // Constructor.
   4040   explicit TestCaseNameIs(const String& name)
   4041       : name_(name) {}
   4042 
   4043   // Returns true iff the name of test_case matches name_.
   4044   bool operator()(const TestCase* test_case) const {
   4045     return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0;
   4046   }
   4047 
   4048  private:
   4049   String name_;
   4050 };
   4051 
   4052 // Finds and returns a TestCase with the given name.  If one doesn't
   4053 // exist, creates one and returns it.  It's the CALLER'S
   4054 // RESPONSIBILITY to ensure that this function is only called WHEN THE
   4055 // TESTS ARE NOT SHUFFLED.
   4056 //
   4057 // Arguments:
   4058 //
   4059 //   test_case_name: name of the test case
   4060 //   type_param:     the name of the test case's type parameter, or NULL if
   4061 //                   this is not a typed or a type-parameterized test case.
   4062 //   set_up_tc:      pointer to the function that sets up the test case
   4063 //   tear_down_tc:   pointer to the function that tears down the test case
   4064 TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
   4065                                     const char* type_param,
   4066                                     Test::SetUpTestCaseFunc set_up_tc,
   4067                                     Test::TearDownTestCaseFunc tear_down_tc) {
   4068   // Can we find a TestCase with the given name?
   4069   const std::vector<TestCase*>::const_iterator test_case =
   4070       std::find_if(test_cases_.begin(), test_cases_.end(),
   4071                    TestCaseNameIs(test_case_name));
   4072 
   4073   if (test_case != test_cases_.end())
   4074     return *test_case;
   4075 
   4076   // No.  Let's create one.
   4077   TestCase* const new_test_case =
   4078       new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc);
   4079 
   4080   // Is this a death test case?
   4081   if (internal::UnitTestOptions::MatchesFilter(String(test_case_name),
   4082                                                kDeathTestCaseFilter)) {
   4083     // Yes.  Inserts the test case after the last death test case
   4084     // defined so far.  This only works when the test cases haven't
   4085     // been shuffled.  Otherwise we may end up running a death test
   4086     // after a non-death test.
   4087     ++last_death_test_case_;
   4088     test_cases_.insert(test_cases_.begin() + last_death_test_case_,
   4089                        new_test_case);
   4090   } else {
   4091     // No.  Appends to the end of the list.
   4092     test_cases_.push_back(new_test_case);
   4093   }
   4094 
   4095   test_case_indices_.push_back(static_cast<int>(test_case_indices_.size()));
   4096   return new_test_case;
   4097 }
   4098 
   4099 // Helpers for setting up / tearing down the given environment.  They
   4100 // are for use in the ForEach() function.
   4101 static void SetUpEnvironment(Environment* env) { env->SetUp(); }
   4102 static void TearDownEnvironment(Environment* env) { env->TearDown(); }
   4103 
   4104 // Runs all tests in this UnitTest object, prints the result, and
   4105 // returns true if all tests are successful.  If any exception is
   4106 // thrown during a test, the test is considered to be failed, but the
   4107 // rest of the tests will still be run.
   4108 //
   4109 // When parameterized tests are enabled, it expands and registers
   4110 // parameterized tests first in RegisterParameterizedTests().
   4111 // All other functions called from RunAllTests() may safely assume that
   4112 // parameterized tests are ready to be counted and run.
   4113 bool UnitTestImpl::RunAllTests() {
   4114   // Makes sure InitGoogleTest() was called.
   4115   if (!GTestIsInitialized()) {
   4116     printf("%s",
   4117            "\nThis test program did NOT call ::testing::InitGoogleTest "
   4118            "before calling RUN_ALL_TESTS().  Please fix it.\n");
   4119     return false;
   4120   }
   4121 
   4122   // Do not run any test if the --help flag was specified.
   4123   if (g_help_flag)
   4124     return true;
   4125 
   4126   // Repeats the call to the post-flag parsing initialization in case the
   4127   // user didn't call InitGoogleTest.
   4128   PostFlagParsingInit();
   4129 
   4130   // Even if sharding is not on, test runners may want to use the
   4131   // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
   4132   // protocol.
   4133   internal::WriteToShardStatusFileIfNeeded();
   4134 
   4135   // True iff we are in a subprocess for running a thread-safe-style
   4136   // death test.
   4137   bool in_subprocess_for_death_test = false;
   4138 
   4139 #if GTEST_HAS_DEATH_TEST
   4140   in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL);
   4141 #endif  // GTEST_HAS_DEATH_TEST
   4142 
   4143   const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
   4144                                         in_subprocess_for_death_test);
   4145 
   4146   // Compares the full test names with the filter to decide which
   4147   // tests to run.
   4148   const bool has_tests_to_run = FilterTests(should_shard
   4149                                               ? HONOR_SHARDING_PROTOCOL
   4150                                               : IGNORE_SHARDING_PROTOCOL) > 0;
   4151 
   4152   // Lists the tests and exits if the --gtest_list_tests flag was specified.
   4153   if (GTEST_FLAG(list_tests)) {
   4154     // This must be called *after* FilterTests() has been called.
   4155     ListTestsMatchingFilter();
   4156     return true;
   4157   }
   4158 
   4159   random_seed_ = GTEST_FLAG(shuffle) ?
   4160       GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
   4161 
   4162   // True iff at least one test has failed.
   4163   bool failed = false;
   4164 
   4165   TestEventListener* repeater = listeners()->repeater();
   4166 
   4167   repeater->OnTestProgramStart(*parent_);
   4168 
   4169   // How many times to repeat the tests?  We don't want to repeat them
   4170   // when we are inside the subprocess of a death test.
   4171   const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
   4172   // Repeats forever if the repeat count is negative.
   4173   const bool forever = repeat < 0;
   4174   for (int i = 0; forever || i != repeat; i++) {
   4175     // We want to preserve failures generated by ad-hoc test
   4176     // assertions executed before RUN_ALL_TESTS().
   4177     ClearNonAdHocTestResult();
   4178 
   4179     const TimeInMillis start = GetTimeInMillis();
   4180 
   4181     // Shuffles test cases and tests if requested.
   4182     if (has_tests_to_run && GTEST_FLAG(shuffle)) {
   4183       random()->Reseed(random_seed_);
   4184       // This should be done before calling OnTestIterationStart(),
   4185       // such that a test event listener can see the actual test order
   4186       // in the event.
   4187       ShuffleTests();
   4188     }
   4189 
   4190     // Tells the unit test event listeners that the tests are about to start.
   4191     repeater->OnTestIterationStart(*parent_, i);
   4192 
   4193     // Runs each test case if there is at least one test to run.
   4194     if (has_tests_to_run) {
   4195       // Sets up all environments beforehand.
   4196       repeater->OnEnvironmentsSetUpStart(*parent_);
   4197       ForEach(environments_, SetUpEnvironment);
   4198       repeater->OnEnvironmentsSetUpEnd(*parent_);
   4199 
   4200       // Runs the tests only if there was no fatal failure during global
   4201       // set-up.
   4202       if (!Test::HasFatalFailure()) {
   4203         for (int test_index = 0; test_index < total_test_case_count();
   4204              test_index++) {
   4205           GetMutableTestCase(test_index)->Run();
   4206         }
   4207       }
   4208 
   4209       // Tears down all environments in reverse order afterwards.
   4210       repeater->OnEnvironmentsTearDownStart(*parent_);
   4211       std::for_each(environments_.rbegin(), environments_.rend(),
   4212                     TearDownEnvironment);
   4213       repeater->OnEnvironmentsTearDownEnd(*parent_);
   4214     }
   4215 
   4216     elapsed_time_ = GetTimeInMillis() - start;
   4217 
   4218     // Tells the unit test event listener that the tests have just finished.
   4219     repeater->OnTestIterationEnd(*parent_, i);
   4220 
   4221     // Gets the result and clears it.
   4222     if (!Passed()) {
   4223       failed = true;
   4224     }
   4225 
   4226     // Restores the original test order after the iteration.  This
   4227     // allows the user to quickly repro a failure that happens in the
   4228     // N-th iteration without repeating the first (N - 1) iterations.
   4229     // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
   4230     // case the user somehow changes the value of the flag somewhere
   4231     // (it's always safe to unshuffle the tests).
   4232     UnshuffleTests();
   4233 
   4234     if (GTEST_FLAG(shuffle)) {
   4235       // Picks a new random seed for each iteration.
   4236       random_seed_ = GetNextRandomSeed(random_seed_);
   4237     }
   4238   }
   4239 
   4240   repeater->OnTestProgramEnd(*parent_);
   4241 
   4242   return !failed;
   4243 }
   4244 
   4245 // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
   4246 // if the variable is present. If a file already exists at this location, this
   4247 // function will write over it. If the variable is present, but the file cannot
   4248 // be created, prints an error and exits.
   4249 void WriteToShardStatusFileIfNeeded() {
   4250   const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
   4251   if (test_shard_file != NULL) {
   4252     FILE* const file = posix::FOpen(test_shard_file, "w");
   4253     if (file == NULL) {
   4254       ColoredPrintf(COLOR_RED,
   4255                     "Could not write to the test shard status file \"%s\" "
   4256                     "specified by the %s environment variable.\n",
   4257                     test_shard_file, kTestShardStatusFile);
   4258       fflush(stdout);
   4259       exit(EXIT_FAILURE);
   4260     }
   4261     fclose(file);
   4262   }
   4263 }
   4264 
   4265 // Checks whether sharding is enabled by examining the relevant
   4266 // environment variable values. If the variables are present,
   4267 // but inconsistent (i.e., shard_index >= total_shards), prints
   4268 // an error and exits. If in_subprocess_for_death_test, sharding is
   4269 // disabled because it must only be applied to the original test
   4270 // process. Otherwise, we could filter out death tests we intended to execute.
   4271 bool ShouldShard(const char* total_shards_env,
   4272                  const char* shard_index_env,
   4273                  bool in_subprocess_for_death_test) {
   4274   if (in_subprocess_for_death_test) {
   4275     return false;
   4276   }
   4277 
   4278   const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1);
   4279   const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1);
   4280 
   4281   if (total_shards == -1 && shard_index == -1) {
   4282     return false;
   4283   } else if (total_shards == -1 && shard_index != -1) {
   4284     const Message msg = Message()
   4285       << "Invalid environment variables: you have "
   4286       << kTestShardIndex << " = " << shard_index
   4287       << ", but have left " << kTestTotalShards << " unset.\n";
   4288     ColoredPrintf(COLOR_RED, msg.GetString().c_str());
   4289     fflush(stdout);
   4290     exit(EXIT_FAILURE);
   4291   } else if (total_shards != -1 && shard_index == -1) {
   4292     const Message msg = Message()
   4293       << "Invalid environment variables: you have "
   4294       << kTestTotalShards << " = " << total_shards
   4295       << ", but have left " << kTestShardIndex << " unset.\n";
   4296     ColoredPrintf(COLOR_RED, msg.GetString().c_str());
   4297     fflush(stdout);
   4298     exit(EXIT_FAILURE);
   4299   } else if (shard_index < 0 || shard_index >= total_shards) {
   4300     const Message msg = Message()
   4301       << "Invalid environment variables: we require 0 <= "
   4302       << kTestShardIndex << " < " << kTestTotalShards
   4303       << ", but you have " << kTestShardIndex << "=" << shard_index
   4304       << ", " << kTestTotalShards << "=" << total_shards << ".\n";
   4305     ColoredPrintf(COLOR_RED, msg.GetString().c_str());
   4306     fflush(stdout);
   4307     exit(EXIT_FAILURE);
   4308   }
   4309 
   4310   return total_shards > 1;
   4311 }
   4312 
   4313 // Parses the environment variable var as an Int32. If it is unset,
   4314 // returns default_val. If it is not an Int32, prints an error
   4315 // and aborts.
   4316 Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
   4317   const char* str_val = posix::GetEnv(var);
   4318   if (str_val == NULL) {
   4319     return default_val;
   4320   }
   4321 
   4322   Int32 result;
   4323   if (!ParseInt32(Message() << "The value of environment variable " << var,
   4324                   str_val, &result)) {
   4325     exit(EXIT_FAILURE);
   4326   }
   4327   return result;
   4328 }
   4329 
   4330 // Given the total number of shards, the shard index, and the test id,
   4331 // returns true iff the test should be run on this shard. The test id is
   4332 // some arbitrary but unique non-negative integer assigned to each test
   4333 // method. Assumes that 0 <= shard_index < total_shards.
   4334 bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
   4335   return (test_id % total_shards) == shard_index;
   4336 }
   4337 
   4338 // Compares the name of each test with the user-specified filter to
   4339 // decide whether the test should be run, then records the result in
   4340 // each TestCase and TestInfo object.
   4341 // If shard_tests == true, further filters tests based on sharding
   4342 // variables in the environment - see
   4343 // http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide.
   4344 // Returns the number of tests that should run.
   4345 int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
   4346   const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
   4347       Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
   4348   const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
   4349       Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
   4350 
   4351   // num_runnable_tests are the number of tests that will
   4352   // run across all shards (i.e., match filter and are not disabled).
   4353   // num_selected_tests are the number of tests to be run on
   4354   // this shard.
   4355   int num_runnable_tests = 0;
   4356   int num_selected_tests = 0;
   4357   for (size_t i = 0; i < test_cases_.size(); i++) {
   4358     TestCase* const test_case = test_cases_[i];
   4359     const String &test_case_name = test_case->name();
   4360     test_case->set_should_run(false);
   4361 
   4362     for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
   4363       TestInfo* const test_info = test_case->test_info_list()[j];
   4364       const String test_name(test_info->name());
   4365       // A test is disabled if test case name or test name matches
   4366       // kDisableTestFilter.
   4367       const bool is_disabled =
   4368           internal::UnitTestOptions::MatchesFilter(test_case_name,
   4369                                                    kDisableTestFilter) ||
   4370           internal::UnitTestOptions::MatchesFilter(test_name,
   4371                                                    kDisableTestFilter);
   4372       test_info->is_disabled_ = is_disabled;
   4373 
   4374       const bool matches_filter =
   4375           internal::UnitTestOptions::FilterMatchesTest(test_case_name,
   4376                                                        test_name);
   4377       test_info->matches_filter_ = matches_filter;
   4378 
   4379       const bool is_runnable =
   4380           (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
   4381           matches_filter;
   4382 
   4383       const bool is_selected = is_runnable &&
   4384           (shard_tests == IGNORE_SHARDING_PROTOCOL ||
   4385            ShouldRunTestOnShard(total_shards, shard_index,
   4386                                 num_runnable_tests));
   4387 
   4388       num_runnable_tests += is_runnable;
   4389       num_selected_tests += is_selected;
   4390 
   4391       test_info->should_run_ = is_selected;
   4392       test_case->set_should_run(test_case->should_run() || is_selected);
   4393     }
   4394   }
   4395   return num_selected_tests;
   4396 }
   4397 
   4398 // Prints the names of the tests matching the user-specified filter flag.
   4399 void UnitTestImpl::ListTestsMatchingFilter() {
   4400   for (size_t i = 0; i < test_cases_.size(); i++) {
   4401     const TestCase* const test_case = test_cases_[i];
   4402     bool printed_test_case_name = false;
   4403 
   4404     for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
   4405       const TestInfo* const test_info =
   4406           test_case->test_info_list()[j];
   4407       if (test_info->matches_filter_) {
   4408         if (!printed_test_case_name) {
   4409           printed_test_case_name = true;
   4410           printf("%s.\n", test_case->name());
   4411         }
   4412         printf("  %s\n", test_info->name());
   4413       }
   4414     }
   4415   }
   4416   fflush(stdout);
   4417 }
   4418 
   4419 // Sets the OS stack trace getter.
   4420 //
   4421 // Does nothing if the input and the current OS stack trace getter are
   4422 // the same; otherwise, deletes the old getter and makes the input the
   4423 // current getter.
   4424 void UnitTestImpl::set_os_stack_trace_getter(
   4425     OsStackTraceGetterInterface* getter) {
   4426   if (os_stack_trace_getter_ != getter) {
   4427     delete os_stack_trace_getter_;
   4428     os_stack_trace_getter_ = getter;
   4429   }
   4430 }
   4431 
   4432 // Returns the current OS stack trace getter if it is not NULL;
   4433 // otherwise, creates an OsStackTraceGetter, makes it the current
   4434 // getter, and returns it.
   4435 OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
   4436   if (os_stack_trace_getter_ == NULL) {
   4437     os_stack_trace_getter_ = new OsStackTraceGetter;
   4438   }
   4439 
   4440   return os_stack_trace_getter_;
   4441 }
   4442 
   4443 // Returns the TestResult for the test that's currently running, or
   4444 // the TestResult for the ad hoc test if no test is running.
   4445 TestResult* UnitTestImpl::current_test_result() {
   4446   return current_test_info_ ?
   4447       &(current_test_info_->result_) : &ad_hoc_test_result_;
   4448 }
   4449 
   4450 // Shuffles all test cases, and the tests within each test case,
   4451 // making sure that death tests are still run first.
   4452 void UnitTestImpl::ShuffleTests() {
   4453   // Shuffles the death test cases.
   4454   ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);
   4455 
   4456   // Shuffles the non-death test cases.
   4457   ShuffleRange(random(), last_death_test_case_ + 1,
   4458                static_cast<int>(test_cases_.size()), &test_case_indices_);
   4459 
   4460   // Shuffles the tests inside each test case.
   4461   for (size_t i = 0; i < test_cases_.size(); i++) {
   4462     test_cases_[i]->ShuffleTests(random());
   4463   }
   4464 }
   4465 
   4466 // Restores the test cases and tests to their order before the first shuffle.
   4467 void UnitTestImpl::UnshuffleTests() {
   4468   for (size_t i = 0; i < test_cases_.size(); i++) {
   4469     // Unshuffles the tests in each test case.
   4470     test_cases_[i]->UnshuffleTests();
   4471     // Resets the index of each test case.
   4472     test_case_indices_[i] = static_cast<int>(i);
   4473   }
   4474 }
   4475 
   4476 // Returns the current OS stack trace as a String.
   4477 //
   4478 // The maximum number of stack frames to be included is specified by
   4479 // the gtest_stack_trace_depth flag.  The skip_count parameter
   4480 // specifies the number of top frames to be skipped, which doesn't
   4481 // count against the number of frames to be included.
   4482 //
   4483 // For example, if Foo() calls Bar(), which in turn calls
   4484 // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
   4485 // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
   4486 String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
   4487                                        int skip_count) {
   4488   // We pass skip_count + 1 to skip this wrapper function in addition
   4489   // to what the user really wants to skip.
   4490   return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
   4491 }
   4492 
   4493 // Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to
   4494 // suppress unreachable code warnings.
   4495 namespace {
   4496 class ClassUniqueToAlwaysTrue {};
   4497 }
   4498 
   4499 bool IsTrue(bool condition) { return condition; }
   4500 
   4501 bool AlwaysTrue() {
   4502 #if GTEST_HAS_EXCEPTIONS
   4503   // This condition is always false so AlwaysTrue() never actually throws,
   4504   // but it makes the compiler think that it may throw.
   4505   if (IsTrue(false))
   4506     throw ClassUniqueToAlwaysTrue();
   4507 #endif  // GTEST_HAS_EXCEPTIONS
   4508   return true;
   4509 }
   4510 
   4511 // If *pstr starts with the given prefix, modifies *pstr to be right
   4512 // past the prefix and returns true; otherwise leaves *pstr unchanged
   4513 // and returns false.  None of pstr, *pstr, and prefix can be NULL.
   4514 bool SkipPrefix(const char* prefix, const char** pstr) {
   4515   const size_t prefix_len = strlen(prefix);
   4516   if (strncmp(*pstr, prefix, prefix_len) == 0) {
   4517     *pstr += prefix_len;
   4518     return true;
   4519   }
   4520   return false;
   4521 }
   4522 
   4523 // Parses a string as a command line flag.  The string should have
   4524 // the format "--flag=value".  When def_optional is true, the "=value"
   4525 // part can be omitted.
   4526 //
   4527 // Returns the value of the flag, or NULL if the parsing failed.
   4528 const char* ParseFlagValue(const char* str,
   4529                            const char* flag,
   4530                            bool def_optional) {
   4531   // str and flag must not be NULL.
   4532   if (str == NULL || flag == NULL) return NULL;
   4533 
   4534   // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
   4535   const String flag_str = String::Format("--%s%s", GTEST_FLAG_PREFIX_, flag);
   4536   const size_t flag_len = flag_str.length();
   4537   if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
   4538 
   4539   // Skips the flag name.
   4540   const char* flag_end = str + flag_len;
   4541 
   4542   // When def_optional is true, it's OK to not have a "=value" part.
   4543   if (def_optional && (flag_end[0] == '\0')) {
   4544     return flag_end;
   4545   }
   4546 
   4547   // If def_optional is true and there are more characters after the
   4548   // flag name, or if def_optional is false, there must be a '=' after
   4549   // the flag name.
   4550   if (flag_end[0] != '=') return NULL;
   4551 
   4552   // Returns the string after "=".
   4553   return flag_end + 1;
   4554 }
   4555 
   4556 // Parses a string for a bool flag, in the form of either
   4557 // "--flag=value" or "--flag".
   4558 //
   4559 // In the former case, the value is taken as true as long as it does
   4560 // not start with '0', 'f', or 'F'.
   4561 //
   4562 // In the latter case, the value is taken as true.
   4563 //
   4564 // On success, stores the value of the flag in *value, and returns
   4565 // true.  On failure, returns false without changing *value.
   4566 bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
   4567   // Gets the value of the flag as a string.
   4568   const char* const value_str = ParseFlagValue(str, flag, true);
   4569 
   4570   // Aborts if the parsing failed.
   4571   if (value_str == NULL) return false;
   4572 
   4573   // Converts the string value to a bool.
   4574   *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
   4575   return true;
   4576 }
   4577 
   4578 // Parses a string for an Int32 flag, in the form of
   4579 // "--flag=value".
   4580 //
   4581 // On success, stores the value of the flag in *value, and returns
   4582 // true.  On failure, returns false without changing *value.
   4583 bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
   4584   // Gets the value of the flag as a string.
   4585   const char* const value_str = ParseFlagValue(str, flag, false);
   4586 
   4587   // Aborts if the parsing failed.
   4588   if (value_str == NULL) return false;
   4589 
   4590   // Sets *value to the value of the flag.
   4591   return ParseInt32(Message() << "The value of flag --" << flag,
   4592                     value_str, value);
   4593 }
   4594 
   4595 // Parses a string for a string flag, in the form of
   4596 // "--flag=value".
   4597 //
   4598 // On success, stores the value of the flag in *value, and returns
   4599 // true.  On failure, returns false without changing *value.
   4600 bool ParseStringFlag(const char* str, const char* flag, String* value) {
   4601   // Gets the value of the flag as a string.
   4602   const char* const value_str = ParseFlagValue(str, flag, false);
   4603 
   4604   // Aborts if the parsing failed.
   4605   if (value_str == NULL) return false;
   4606 
   4607   // Sets *value to the value of the flag.
   4608   *value = value_str;
   4609   return true;
   4610 }
   4611 
   4612 // Determines whether a string has a prefix that Google Test uses for its
   4613 // flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.
   4614 // If Google Test detects that a command line flag has its prefix but is not
   4615 // recognized, it will print its help message. Flags starting with
   4616 // GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
   4617 // internal flags and do not trigger the help message.
   4618 static bool HasGoogleTestFlagPrefix(const char* str) {
   4619   return (SkipPrefix("--", &str) ||
   4620           SkipPrefix("-", &str) ||
   4621           SkipPrefix("/", &str)) &&
   4622          !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
   4623          (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
   4624           SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
   4625 }
   4626 
   4627 // Prints a string containing code-encoded text.  The following escape
   4628 // sequences can be used in the string to control the text color:
   4629 //
   4630 //   @@    prints a single '@' character.
   4631 //   @R    changes the color to red.
   4632 //   @G    changes the color to green.
   4633 //   @Y    changes the color to yellow.
   4634 //   @D    changes to the default terminal text color.
   4635 //
   4636 // TODO(wan (at) google.com): Write tests for this once we add stdout
   4637 // capturing to Google Test.
   4638 static void PrintColorEncoded(const char* str) {
   4639   GTestColor color = COLOR_DEFAULT;  // The current color.
   4640 
   4641   // Conceptually, we split the string into segments divided by escape
   4642   // sequences.  Then we print one segment at a time.  At the end of
   4643   // each iteration, the str pointer advances to the beginning of the
   4644   // next segment.
   4645   for (;;) {
   4646     const char* p = strchr(str, '@');
   4647     if (p == NULL) {
   4648       ColoredPrintf(color, "%s", str);
   4649       return;
   4650     }
   4651 
   4652     ColoredPrintf(color, "%s", String(str, p - str).c_str());
   4653 
   4654     const char ch = p[1];
   4655     str = p + 2;
   4656     if (ch == '@') {
   4657       ColoredPrintf(color, "@");
   4658     } else if (ch == 'D') {
   4659       color = COLOR_DEFAULT;
   4660     } else if (ch == 'R') {
   4661       color = COLOR_RED;
   4662     } else if (ch == 'G') {
   4663       color = COLOR_GREEN;
   4664     } else if (ch == 'Y') {
   4665       color = COLOR_YELLOW;
   4666     } else {
   4667       --str;
   4668     }
   4669   }
   4670 }
   4671 
   4672 static const char kColorEncodedHelpMessage[] =
   4673 "This program contains tests written using " GTEST_NAME_ ". You can use the\n"
   4674 "following command line flags to control its behavior:\n"
   4675 "\n"
   4676 "Test Selection:\n"
   4677 "  @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n"
   4678 "      List the names of all tests instead of running them. The name of\n"
   4679 "      TEST(Foo, Bar) is \"Foo.Bar\".\n"
   4680 "  @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS"
   4681     "[@G-@YNEGATIVE_PATTERNS]@D\n"
   4682 "      Run only the tests whose name matches one of the positive patterns but\n"
   4683 "      none of the negative patterns. '?' matches any single character; '*'\n"
   4684 "      matches any substring; ':' separates two patterns.\n"
   4685 "  @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n"
   4686 "      Run all disabled tests too.\n"
   4687 "\n"
   4688 "Test Execution:\n"
   4689 "  @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n"
   4690 "      Run the tests repeatedly; use a negative count to repeat forever.\n"
   4691 "  @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n"
   4692 "      Randomize tests' orders on every iteration.\n"
   4693 "  @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n"
   4694 "      Random number seed to use for shuffling test orders (between 1 and\n"
   4695 "      99999, or 0 to use a seed based on the current time).\n"
   4696 "\n"
   4697 "Test Output:\n"
   4698 "  @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
   4699 "      Enable/disable colored output. The default is @Gauto@D.\n"
   4700 "  -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n"
   4701 "      Don't print the elapsed time of each test.\n"
   4702 "  @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G"
   4703     GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n"
   4704 "      Generate an XML report in the given directory or with the given file\n"
   4705 "      name. @YFILE_PATH@D defaults to @Gtest_details.xml@D.\n"
   4706 #if GTEST_CAN_STREAM_RESULTS_
   4707 "  @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n"
   4708 "      Stream test results to the given server.\n"
   4709 #endif  // GTEST_CAN_STREAM_RESULTS_
   4710 "\n"
   4711 "Assertion Behavior:\n"
   4712 #if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
   4713 "  @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
   4714 "      Set the default death test style.\n"
   4715 #endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
   4716 "  @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n"
   4717 "      Turn assertion failures into debugger break-points.\n"
   4718 "  @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n"
   4719 "      Turn assertion failures into C++ exceptions.\n"
   4720 "  @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n"
   4721 "      Do not report exceptions as test failures. Instead, allow them\n"
   4722 "      to crash the program or throw a pop-up (on Windows).\n"
   4723 "\n"
   4724 "Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set "
   4725     "the corresponding\n"
   4726 "environment variable of a flag (all letters in upper-case). For example, to\n"
   4727 "disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_
   4728     "color=no@D or set\n"
   4729 "the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n"
   4730 "\n"
   4731 "For more information, please read the " GTEST_NAME_ " documentation at\n"
   4732 "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n"
   4733 "(not one in your own code or tests), please report it to\n"
   4734 "@G<" GTEST_DEV_EMAIL_ ">@D.\n";
   4735 
   4736 // Parses the command line for Google Test flags, without initializing
   4737 // other parts of Google Test.  The type parameter CharType can be
   4738 // instantiated to either char or wchar_t.
   4739 template <typename CharType>
   4740 void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
   4741   for (int i = 1; i < *argc; i++) {
   4742     const String arg_string = StreamableToString(argv[i]);
   4743     const char* const arg = arg_string.c_str();
   4744 
   4745     using internal::ParseBoolFlag;
   4746     using internal::ParseInt32Flag;
   4747     using internal::ParseStringFlag;
   4748 
   4749     // Do we see a Google Test flag?
   4750     if (ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
   4751                       &GTEST_FLAG(also_run_disabled_tests)) ||
   4752         ParseBoolFlag(arg, kBreakOnFailureFlag,
   4753                       &GTEST_FLAG(break_on_failure)) ||
   4754         ParseBoolFlag(arg, kCatchExceptionsFlag,
   4755                       &GTEST_FLAG(catch_exceptions)) ||
   4756         ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
   4757         ParseStringFlag(arg, kDeathTestStyleFlag,
   4758                         &GTEST_FLAG(death_test_style)) ||
   4759         ParseBoolFlag(arg, kDeathTestUseFork,
   4760                       &GTEST_FLAG(death_test_use_fork)) ||
   4761         ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
   4762         ParseStringFlag(arg, kInternalRunDeathTestFlag,
   4763                         &GTEST_FLAG(internal_run_death_test)) ||
   4764         ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
   4765         ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
   4766         ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
   4767         ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
   4768         ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
   4769         ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
   4770         ParseInt32Flag(arg, kStackTraceDepthFlag,
   4771                        &GTEST_FLAG(stack_trace_depth)) ||
   4772         ParseStringFlag(arg, kStreamResultToFlag,
   4773                         &GTEST_FLAG(stream_result_to)) ||
   4774         ParseBoolFlag(arg, kThrowOnFailureFlag,
   4775                       &GTEST_FLAG(throw_on_failure))
   4776         ) {
   4777       // Yes.  Shift the remainder of the argv list left by one.  Note
   4778       // that argv has (*argc + 1) elements, the last one always being
   4779       // NULL.  The following loop moves the trailing NULL element as
   4780       // well.
   4781       for (int j = i; j != *argc; j++) {
   4782         argv[j] = argv[j + 1];
   4783       }
   4784 
   4785       // Decrements the argument count.
   4786       (*argc)--;
   4787 
   4788       // We also need to decrement the iterator as we just removed
   4789       // an element.
   4790       i--;
   4791     } else if (arg_string == "--help" || arg_string == "-h" ||
   4792                arg_string == "-?" || arg_string == "/?" ||
   4793                HasGoogleTestFlagPrefix(arg)) {
   4794       // Both help flag and unrecognized Google Test flags (excluding
   4795       // internal ones) trigger help display.
   4796       g_help_flag = true;
   4797     }
   4798   }
   4799 
   4800   if (g_help_flag) {
   4801     // We print the help here instead of in RUN_ALL_TESTS(), as the
   4802     // latter may not be called at all if the user is using Google
   4803     // Test with another testing framework.
   4804     PrintColorEncoded(kColorEncodedHelpMessage);
   4805   }
   4806 }
   4807 
   4808 // Parses the command line for Google Test flags, without initializing
   4809 // other parts of Google Test.
   4810 void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
   4811   ParseGoogleTestFlagsOnlyImpl(argc, argv);
   4812 }
   4813 void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
   4814   ParseGoogleTestFlagsOnlyImpl(argc, argv);
   4815 }
   4816 
   4817 // The internal implementation of InitGoogleTest().
   4818 //
   4819 // The type parameter CharType can be instantiated to either char or
   4820 // wchar_t.
   4821 template <typename CharType>
   4822 void InitGoogleTestImpl(int* argc, CharType** argv) {
   4823   g_init_gtest_count++;
   4824 
   4825   // We don't want to run the initialization code twice.
   4826   if (g_init_gtest_count != 1) return;
   4827 
   4828   if (*argc <= 0) return;
   4829 
   4830   internal::g_executable_path = internal::StreamableToString(argv[0]);
   4831 
   4832 #if GTEST_HAS_DEATH_TEST
   4833 
   4834   g_argvs.clear();
   4835   for (int i = 0; i != *argc; i++) {
   4836     g_argvs.push_back(StreamableToString(argv[i]));
   4837   }
   4838 
   4839 #endif  // GTEST_HAS_DEATH_TEST
   4840 
   4841   ParseGoogleTestFlagsOnly(argc, argv);
   4842   GetUnitTestImpl()->PostFlagParsingInit();
   4843 }
   4844 
   4845 }  // namespace internal
   4846 
   4847 // Initializes Google Test.  This must be called before calling
   4848 // RUN_ALL_TESTS().  In particular, it parses a command line for the
   4849 // flags that Google Test recognizes.  Whenever a Google Test flag is
   4850 // seen, it is removed from argv, and *argc is decremented.
   4851 //
   4852 // No value is returned.  Instead, the Google Test flag variables are
   4853 // updated.
   4854 //
   4855 // Calling the function for the second time has no user-visible effect.
   4856 void InitGoogleTest(int* argc, char** argv) {
   4857   internal::InitGoogleTestImpl(argc, argv);
   4858 }
   4859 
   4860 // This overloaded version can be used in Windows programs compiled in
   4861 // UNICODE mode.
   4862 void InitGoogleTest(int* argc, wchar_t** argv) {
   4863   internal::InitGoogleTestImpl(argc, argv);
   4864 }
   4865 
   4866 // Pin the vtables to this file.
   4867 Environment::~Environment() {}
   4868 TestPartResultReporterInterface::~TestPartResultReporterInterface() {}
   4869 TestEventListener::~TestEventListener() {}
   4870 void EmptyTestEventListener::anchor() {}
   4871 namespace internal {
   4872 OsStackTraceGetterInterface::~OsStackTraceGetterInterface() {}
   4873 ParameterizedTestCaseInfoBase::~ParameterizedTestCaseInfoBase() {}
   4874 }
   4875 
   4876 }  // namespace testing
   4877