LCOV - code coverage report
Current view: top level - usr/src/gtest/src - gtest.cc (source / functions) Hit Total Coverage
Test: clean.info Lines: 624 1626 38.4 %
Date: 2013-05-24 Functions: 152 333 45.6 %
Branches: 344 2775 12.4 %

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

Generated by: LCOV version 1.9