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