a bunch of updates. to be checked on durian. does not build.
[jacinto-ai/caffe-jacinto.git] / src / gtest / gtest-all.cc
1 // Copyright 2008, 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: mheule@google.com (Markus Heule)
31 //
32 // Google C++ Testing Framework (Google Test)
33 //
34 // Sometimes it's desirable to build Google Test by compiling a single file.
35 // This file serves this purpose.
37 // This line ensures that gtest.h can be compiled on its own, even
38 // when it's fused.
39 #include "gtest/gtest.h"
41 // The following lines pull in the real gtest *.cc files.
42 // Copyright 2005, Google Inc.
43 // All rights reserved.
44 //
45 // Redistribution and use in source and binary forms, with or without
46 // modification, are permitted provided that the following conditions are
47 // met:
48 //
49 //     * Redistributions of source code must retain the above copyright
50 // notice, this list of conditions and the following disclaimer.
51 //     * Redistributions in binary form must reproduce the above
52 // copyright notice, this list of conditions and the following disclaimer
53 // in the documentation and/or other materials provided with the
54 // distribution.
55 //     * Neither the name of Google Inc. nor the names of its
56 // contributors may be used to endorse or promote products derived from
57 // this software without specific prior written permission.
58 //
59 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
60 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
61 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
62 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
63 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
64 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
65 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
66 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
67 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
68 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
69 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
70 //
71 // Author: wan@google.com (Zhanyong Wan)
72 //
73 // The Google C++ Testing Framework (Google Test)
75 // Copyright 2007, Google Inc.
76 // All rights reserved.
77 //
78 // Redistribution and use in source and binary forms, with or without
79 // modification, are permitted provided that the following conditions are
80 // met:
81 //
82 //     * Redistributions of source code must retain the above copyright
83 // notice, this list of conditions and the following disclaimer.
84 //     * Redistributions in binary form must reproduce the above
85 // copyright notice, this list of conditions and the following disclaimer
86 // in the documentation and/or other materials provided with the
87 // distribution.
88 //     * Neither the name of Google Inc. nor the names of its
89 // contributors may be used to endorse or promote products derived from
90 // this software without specific prior written permission.
91 //
92 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
93 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
94 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
95 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
96 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
98 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
99 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
100 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
101 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
102 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
103 //
104 // Author: wan@google.com (Zhanyong Wan)
105 //
106 // Utilities for testing Google Test itself and code that uses Google Test
107 // (e.g. frameworks built on top of Google Test).
109 #ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
110 #define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
113 namespace testing {
115 // This helper class can be used to mock out Google Test failure reporting
116 // so that we can test Google Test or code that builds on Google Test.
117 //
118 // An object of this class appends a TestPartResult object to the
119 // TestPartResultArray object given in the constructor whenever a Google Test
120 // failure is reported. It can either intercept only failures that are
121 // generated in the same thread that created this object or it can intercept
122 // all generated failures. The scope of this mock object can be controlled with
123 // the second argument to the two arguments constructor.
124 class GTEST_API_ ScopedFakeTestPartResultReporter
125     : public TestPartResultReporterInterface {
126  public:
127   // The two possible mocking modes of this object.
128   enum InterceptMode {
129     INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
130     INTERCEPT_ALL_THREADS           // Intercepts all failures.
131   };
133   // The c'tor sets this object as the test part result reporter used
134   // by Google Test.  The 'result' parameter specifies where to report the
135   // results. This reporter will only catch failures generated in the current
136   // thread. DEPRECATED
137   explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
139   // Same as above, but you can choose the interception scope of this object.
140   ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
141                                    TestPartResultArray* result);
143   // The d'tor restores the previous test part result reporter.
144   virtual ~ScopedFakeTestPartResultReporter();
146   // Appends the TestPartResult object to the TestPartResultArray
147   // received in the constructor.
148   //
149   // This method is from the TestPartResultReporterInterface
150   // interface.
151   virtual void ReportTestPartResult(const TestPartResult& result);
152  private:
153   void Init();
155   const InterceptMode intercept_mode_;
156   TestPartResultReporterInterface* old_reporter_;
157   TestPartResultArray* const result_;
159   GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
160 };
162 namespace internal {
164 // A helper class for implementing EXPECT_FATAL_FAILURE() and
165 // EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
166 // TestPartResultArray contains exactly one failure that has the given
167 // type and contains the given substring.  If that's not the case, a
168 // non-fatal failure will be generated.
169 class GTEST_API_ SingleFailureChecker {
170  public:
171   // The constructor remembers the arguments.
172   SingleFailureChecker(const TestPartResultArray* results,
173                        TestPartResult::Type type,
174                        const string& substr);
175   ~SingleFailureChecker();
176  private:
177   const TestPartResultArray* const results_;
178   const TestPartResult::Type type_;
179   const string substr_;
181   GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
182 };
184 }  // namespace internal
186 }  // namespace testing
188 // A set of macros for testing Google Test assertions or code that's expected
189 // to generate Google Test fatal failures.  It verifies that the given
190 // statement will cause exactly one fatal Google Test failure with 'substr'
191 // being part of the failure message.
192 //
193 // There are two different versions of this macro. EXPECT_FATAL_FAILURE only
194 // affects and considers failures generated in the current thread and
195 // EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
196 //
197 // The verification of the assertion is done correctly even when the statement
198 // throws an exception or aborts the current function.
199 //
200 // Known restrictions:
201 //   - 'statement' cannot reference local non-static variables or
202 //     non-static members of the current object.
203 //   - 'statement' cannot return a value.
204 //   - You cannot stream a failure message to this macro.
205 //
206 // Note that even though the implementations of the following two
207 // macros are much alike, we cannot refactor them to use a common
208 // helper macro, due to some peculiarity in how the preprocessor
209 // works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
210 // gtest_unittest.cc will fail to compile if we do that.
211 #define EXPECT_FATAL_FAILURE(statement, substr) \
212   do { \
213     class GTestExpectFatalFailureHelper {\
214      public:\
215       static void Execute() { statement; }\
216     };\
217     ::testing::TestPartResultArray gtest_failures;\
218     ::testing::internal::SingleFailureChecker gtest_checker(\
219         &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
220     {\
221       ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
222           ::testing::ScopedFakeTestPartResultReporter:: \
223           INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
224       GTestExpectFatalFailureHelper::Execute();\
225     }\
226   } while (::testing::internal::AlwaysFalse())
228 #define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
229   do { \
230     class GTestExpectFatalFailureHelper {\
231      public:\
232       static void Execute() { statement; }\
233     };\
234     ::testing::TestPartResultArray gtest_failures;\
235     ::testing::internal::SingleFailureChecker gtest_checker(\
236         &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
237     {\
238       ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
239           ::testing::ScopedFakeTestPartResultReporter:: \
240           INTERCEPT_ALL_THREADS, &gtest_failures);\
241       GTestExpectFatalFailureHelper::Execute();\
242     }\
243   } while (::testing::internal::AlwaysFalse())
245 // A macro for testing Google Test assertions or code that's expected to
246 // generate Google Test non-fatal failures.  It asserts that the given
247 // statement will cause exactly one non-fatal Google Test failure with 'substr'
248 // being part of the failure message.
249 //
250 // There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
251 // affects and considers failures generated in the current thread and
252 // EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
253 //
254 // 'statement' is allowed to reference local variables and members of
255 // the current object.
256 //
257 // The verification of the assertion is done correctly even when the statement
258 // throws an exception or aborts the current function.
259 //
260 // Known restrictions:
261 //   - You cannot stream a failure message to this macro.
262 //
263 // Note that even though the implementations of the following two
264 // macros are much alike, we cannot refactor them to use a common
265 // helper macro, due to some peculiarity in how the preprocessor
266 // works.  If we do that, the code won't compile when the user gives
267 // EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
268 // expands to code containing an unprotected comma.  The
269 // AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
270 // catches that.
271 //
272 // For the same reason, we have to write
273 //   if (::testing::internal::AlwaysTrue()) { statement; }
274 // instead of
275 //   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
276 // to avoid an MSVC warning on unreachable code.
277 #define EXPECT_NONFATAL_FAILURE(statement, substr) \
278   do {\
279     ::testing::TestPartResultArray gtest_failures;\
280     ::testing::internal::SingleFailureChecker gtest_checker(\
281         &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
282         (substr));\
283     {\
284       ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
285           ::testing::ScopedFakeTestPartResultReporter:: \
286           INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
287       if (::testing::internal::AlwaysTrue()) { statement; }\
288     }\
289   } while (::testing::internal::AlwaysFalse())
291 #define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
292   do {\
293     ::testing::TestPartResultArray gtest_failures;\
294     ::testing::internal::SingleFailureChecker gtest_checker(\
295         &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
296         (substr));\
297     {\
298       ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
299           ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS,\
300           &gtest_failures);\
301       if (::testing::internal::AlwaysTrue()) { statement; }\
302     }\
303   } while (::testing::internal::AlwaysFalse())
305 #endif  // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
307 #include <ctype.h>
308 #include <math.h>
309 #include <stdarg.h>
310 #include <stdio.h>
311 #include <stdlib.h>
312 #include <wchar.h>
313 #include <wctype.h>
315 #include <algorithm>
316 #include <ostream>  // NOLINT
317 #include <sstream>
318 #include <vector>
320 #if GTEST_OS_LINUX
322 // TODO(kenton@google.com): Use autoconf to detect availability of
323 // gettimeofday().
324 # define GTEST_HAS_GETTIMEOFDAY_ 1
326 # include <fcntl.h>  // NOLINT
327 # include <limits.h>  // NOLINT
328 # include <sched.h>  // NOLINT
329 // Declares vsnprintf().  This header is not available on Windows.
330 # include <strings.h>  // NOLINT
331 # include <sys/mman.h>  // NOLINT
332 # include <sys/time.h>  // NOLINT
333 # include <unistd.h>  // NOLINT
334 # include <string>
336 #elif GTEST_OS_SYMBIAN
337 # define GTEST_HAS_GETTIMEOFDAY_ 1
338 # include <sys/time.h>  // NOLINT
340 #elif GTEST_OS_ZOS
341 # define GTEST_HAS_GETTIMEOFDAY_ 1
342 # include <sys/time.h>  // NOLINT
344 // On z/OS we additionally need strings.h for strcasecmp.
345 # include <strings.h>  // NOLINT
347 #elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.
349 # include <windows.h>  // NOLINT
351 #elif GTEST_OS_WINDOWS  // We are on Windows proper.
353 # include <io.h>  // NOLINT
354 # include <sys/timeb.h>  // NOLINT
355 # include <sys/types.h>  // NOLINT
356 # include <sys/stat.h>  // NOLINT
358 # if GTEST_OS_WINDOWS_MINGW
359 // MinGW has gettimeofday() but not _ftime64().
360 // TODO(kenton@google.com): Use autoconf to detect availability of
361 //   gettimeofday().
362 // TODO(kenton@google.com): There are other ways to get the time on
363 //   Windows, like GetTickCount() or GetSystemTimeAsFileTime().  MinGW
364 //   supports these.  consider using them instead.
365 #  define GTEST_HAS_GETTIMEOFDAY_ 1
366 #  include <sys/time.h>  // NOLINT
367 # endif  // GTEST_OS_WINDOWS_MINGW
369 // cpplint thinks that the header is already included, so we want to
370 // silence it.
371 # include <windows.h>  // NOLINT
373 #else
375 // Assume other platforms have gettimeofday().
376 // TODO(kenton@google.com): Use autoconf to detect availability of
377 //   gettimeofday().
378 # define GTEST_HAS_GETTIMEOFDAY_ 1
380 // cpplint thinks that the header is already included, so we want to
381 // silence it.
382 # include <sys/time.h>  // NOLINT
383 # include <unistd.h>  // NOLINT
385 #endif  // GTEST_OS_LINUX
387 #if GTEST_HAS_EXCEPTIONS
388 # include <stdexcept>
389 #endif
391 #if GTEST_CAN_STREAM_RESULTS_
392 # include <arpa/inet.h>  // NOLINT
393 # include <netdb.h>  // NOLINT
394 #endif
396 // Indicates that this translation unit is part of Google Test's
397 // implementation.  It must come before gtest-internal-inl.h is
398 // included, or there will be a compiler error.  This trick is to
399 // prevent a user from accidentally including gtest-internal-inl.h in
400 // his code.
401 #define GTEST_IMPLEMENTATION_ 1
402 // Copyright 2005, Google Inc.
403 // All rights reserved.
404 //
405 // Redistribution and use in source and binary forms, with or without
406 // modification, are permitted provided that the following conditions are
407 // met:
408 //
409 //     * Redistributions of source code must retain the above copyright
410 // notice, this list of conditions and the following disclaimer.
411 //     * Redistributions in binary form must reproduce the above
412 // copyright notice, this list of conditions and the following disclaimer
413 // in the documentation and/or other materials provided with the
414 // distribution.
415 //     * Neither the name of Google Inc. nor the names of its
416 // contributors may be used to endorse or promote products derived from
417 // this software without specific prior written permission.
418 //
419 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
420 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
421 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
422 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
423 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
424 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
425 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
426 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
427 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
428 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
429 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
431 // Utility functions and classes used by the Google C++ testing framework.
432 //
433 // Author: wan@google.com (Zhanyong Wan)
434 //
435 // This file contains purely Google Test's internal implementation.  Please
436 // DO NOT #INCLUDE IT IN A USER PROGRAM.
438 #ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_
439 #define GTEST_SRC_GTEST_INTERNAL_INL_H_
441 // GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is
442 // part of Google Test's implementation; otherwise it's undefined.
443 #if !GTEST_IMPLEMENTATION_
444 // A user is trying to include this from his code - just say no.
445 # error "gtest-internal-inl.h is part of Google Test's internal implementation."
446 # error "It must not be included except by Google Test itself."
447 #endif  // GTEST_IMPLEMENTATION_
449 #ifndef _WIN32_WCE
450 # include <errno.h>
451 #endif  // !_WIN32_WCE
452 #include <stddef.h>
453 #include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
454 #include <string.h>  // For memmove.
456 #include <algorithm>
457 #include <string>
458 #include <vector>
461 #if GTEST_OS_WINDOWS
462 # include <windows.h>  // NOLINT
463 #endif  // GTEST_OS_WINDOWS
466 namespace testing {
468 // Declares the flags.
469 //
470 // We don't want the users to modify this flag in the code, but want
471 // Google Test's own unit tests to be able to access it. Therefore we
472 // declare it here as opposed to in gtest.h.
473 GTEST_DECLARE_bool_(death_test_use_fork);
475 namespace internal {
477 // The value of GetTestTypeId() as seen from within the Google Test
478 // library.  This is solely for testing GetTestTypeId().
479 GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;
481 // Names of the flags (needed for parsing Google Test flags).
482 const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
483 const char kBreakOnFailureFlag[] = "break_on_failure";
484 const char kCatchExceptionsFlag[] = "catch_exceptions";
485 const char kColorFlag[] = "color";
486 const char kFilterFlag[] = "filter";
487 const char kListTestsFlag[] = "list_tests";
488 const char kOutputFlag[] = "output";
489 const char kPrintTimeFlag[] = "print_time";
490 const char kRandomSeedFlag[] = "random_seed";
491 const char kRepeatFlag[] = "repeat";
492 const char kShuffleFlag[] = "shuffle";
493 const char kStackTraceDepthFlag[] = "stack_trace_depth";
494 const char kStreamResultToFlag[] = "stream_result_to";
495 const char kThrowOnFailureFlag[] = "throw_on_failure";
497 // A valid random seed must be in [1, kMaxRandomSeed].
498 const int kMaxRandomSeed = 99999;
500 // g_help_flag is true iff the --help flag or an equivalent form is
501 // specified on the command line.
502 GTEST_API_ extern bool g_help_flag;
504 // Returns the current time in milliseconds.
505 GTEST_API_ TimeInMillis GetTimeInMillis();
507 // Returns true iff Google Test should use colors in the output.
508 GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
510 // Formats the given time in milliseconds as seconds.
511 GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
513 // Parses a string for an Int32 flag, in the form of "--flag=value".
514 //
515 // On success, stores the value of the flag in *value, and returns
516 // true.  On failure, returns false without changing *value.
517 GTEST_API_ bool ParseInt32Flag(
518     const char* str, const char* flag, Int32* value);
520 // Returns a random seed in range [1, kMaxRandomSeed] based on the
521 // given --gtest_random_seed flag value.
522 inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
523   const unsigned int raw_seed = (random_seed_flag == 0) ?
524       static_cast<unsigned int>(GetTimeInMillis()) :
525       static_cast<unsigned int>(random_seed_flag);
527   // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
528   // it's easy to type.
529   const int normalized_seed =
530       static_cast<int>((raw_seed - 1U) %
531                        static_cast<unsigned int>(kMaxRandomSeed)) + 1;
532   return normalized_seed;
535 // Returns the first valid random seed after 'seed'.  The behavior is
536 // undefined if 'seed' is invalid.  The seed after kMaxRandomSeed is
537 // considered to be 1.
538 inline int GetNextRandomSeed(int seed) {
539   GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
540       << "Invalid random seed " << seed << " - must be in [1, "
541       << kMaxRandomSeed << "].";
542   const int next_seed = seed + 1;
543   return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
546 // This class saves the values of all Google Test flags in its c'tor, and
547 // restores them in its d'tor.
548 class GTestFlagSaver {
549  public:
550   // The c'tor.
551   GTestFlagSaver() {
552     also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
553     break_on_failure_ = GTEST_FLAG(break_on_failure);
554     catch_exceptions_ = GTEST_FLAG(catch_exceptions);
555     color_ = GTEST_FLAG(color);
556     death_test_style_ = GTEST_FLAG(death_test_style);
557     death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
558     filter_ = GTEST_FLAG(filter);
559     internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
560     list_tests_ = GTEST_FLAG(list_tests);
561     output_ = GTEST_FLAG(output);
562     print_time_ = GTEST_FLAG(print_time);
563     random_seed_ = GTEST_FLAG(random_seed);
564     repeat_ = GTEST_FLAG(repeat);
565     shuffle_ = GTEST_FLAG(shuffle);
566     stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
567     stream_result_to_ = GTEST_FLAG(stream_result_to);
568     throw_on_failure_ = GTEST_FLAG(throw_on_failure);
569   }
571   // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
572   ~GTestFlagSaver() {
573     GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
574     GTEST_FLAG(break_on_failure) = break_on_failure_;
575     GTEST_FLAG(catch_exceptions) = catch_exceptions_;
576     GTEST_FLAG(color) = color_;
577     GTEST_FLAG(death_test_style) = death_test_style_;
578     GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
579     GTEST_FLAG(filter) = filter_;
580     GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
581     GTEST_FLAG(list_tests) = list_tests_;
582     GTEST_FLAG(output) = output_;
583     GTEST_FLAG(print_time) = print_time_;
584     GTEST_FLAG(random_seed) = random_seed_;
585     GTEST_FLAG(repeat) = repeat_;
586     GTEST_FLAG(shuffle) = shuffle_;
587     GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
588     GTEST_FLAG(stream_result_to) = stream_result_to_;
589     GTEST_FLAG(throw_on_failure) = throw_on_failure_;
590   }
591  private:
592   // Fields for saving the original values of flags.
593   bool also_run_disabled_tests_;
594   bool break_on_failure_;
595   bool catch_exceptions_;
596   String color_;
597   String death_test_style_;
598   bool death_test_use_fork_;
599   String filter_;
600   String internal_run_death_test_;
601   bool list_tests_;
602   String output_;
603   bool print_time_;
604   bool pretty_;
605   internal::Int32 random_seed_;
606   internal::Int32 repeat_;
607   bool shuffle_;
608   internal::Int32 stack_trace_depth_;
609   String stream_result_to_;
610   bool throw_on_failure_;
611 } GTEST_ATTRIBUTE_UNUSED_;
613 // Converts a Unicode code point to a narrow string in UTF-8 encoding.
614 // code_point parameter is of type UInt32 because wchar_t may not be
615 // wide enough to contain a code point.
616 // The output buffer str must containt at least 32 characters.
617 // The function returns the address of the output buffer.
618 // If the code_point is not a valid Unicode code point
619 // (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output
620 // as '(Invalid Unicode 0xXXXXXXXX)'.
621 GTEST_API_ char* CodePointToUtf8(UInt32 code_point, char* str);
623 // Converts a wide string to a narrow string in UTF-8 encoding.
624 // The wide string is assumed to have the following encoding:
625 //   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS)
626 //   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
627 // Parameter str points to a null-terminated wide string.
628 // Parameter num_chars may additionally limit the number
629 // of wchar_t characters processed. -1 is used when the entire string
630 // should be processed.
631 // If the string contains code points that are not valid Unicode code points
632 // (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
633 // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
634 // and contains invalid UTF-16 surrogate pairs, values in those pairs
635 // will be encoded as individual Unicode characters from Basic Normal Plane.
636 GTEST_API_ String WideStringToUtf8(const wchar_t* str, int num_chars);
638 // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
639 // if the variable is present. If a file already exists at this location, this
640 // function will write over it. If the variable is present, but the file cannot
641 // be created, prints an error and exits.
642 void WriteToShardStatusFileIfNeeded();
644 // Checks whether sharding is enabled by examining the relevant
645 // environment variable values. If the variables are present,
646 // but inconsistent (e.g., shard_index >= total_shards), prints
647 // an error and exits. If in_subprocess_for_death_test, sharding is
648 // disabled because it must only be applied to the original test
649 // process. Otherwise, we could filter out death tests we intended to execute.
650 GTEST_API_ bool ShouldShard(const char* total_shards_str,
651                             const char* shard_index_str,
652                             bool in_subprocess_for_death_test);
654 // Parses the environment variable var as an Int32. If it is unset,
655 // returns default_val. If it is not an Int32, prints an error and
656 // and aborts.
657 GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val);
659 // Given the total number of shards, the shard index, and the test id,
660 // returns true iff the test should be run on this shard. The test id is
661 // some arbitrary but unique non-negative integer assigned to each test
662 // method. Assumes that 0 <= shard_index < total_shards.
663 GTEST_API_ bool ShouldRunTestOnShard(
664     int total_shards, int shard_index, int test_id);
666 // STL container utilities.
668 // Returns the number of elements in the given container that satisfy
669 // the given predicate.
670 template <class Container, typename Predicate>
671 inline int CountIf(const Container& c, Predicate predicate) {
672   // Implemented as an explicit loop since std::count_if() in libCstd on
673   // Solaris has a non-standard signature.
674   int count = 0;
675   for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
676     if (predicate(*it))
677       ++count;
678   }
679   return count;
682 // Applies a function/functor to each element in the container.
683 template <class Container, typename Functor>
684 void ForEach(const Container& c, Functor functor) {
685   std::for_each(c.begin(), c.end(), functor);
688 // Returns the i-th element of the vector, or default_value if i is not
689 // in range [0, v.size()).
690 template <typename E>
691 inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
692   return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i];
695 // Performs an in-place shuffle of a range of the vector's elements.
696 // 'begin' and 'end' are element indices as an STL-style range;
697 // i.e. [begin, end) are shuffled, where 'end' == size() means to
698 // shuffle to the end of the vector.
699 template <typename E>
700 void ShuffleRange(internal::Random* random, int begin, int end,
701                   std::vector<E>* v) {
702   const int size = static_cast<int>(v->size());
703   GTEST_CHECK_(0 <= begin && begin <= size)
704       << "Invalid shuffle range start " << begin << ": must be in range [0, "
705       << size << "].";
706   GTEST_CHECK_(begin <= end && end <= size)
707       << "Invalid shuffle range finish " << end << ": must be in range ["
708       << begin << ", " << size << "].";
710   // Fisher-Yates shuffle, from
711   // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
712   for (int range_width = end - begin; range_width >= 2; range_width--) {
713     const int last_in_range = begin + range_width - 1;
714     const int selected = begin + random->Generate(range_width);
715     std::swap((*v)[selected], (*v)[last_in_range]);
716   }
719 // Performs an in-place shuffle of the vector's elements.
720 template <typename E>
721 inline void Shuffle(internal::Random* random, std::vector<E>* v) {
722   ShuffleRange(random, 0, static_cast<int>(v->size()), v);
725 // A function for deleting an object.  Handy for being used as a
726 // functor.
727 template <typename T>
728 static void Delete(T* x) {
729   delete x;
732 // A predicate that checks the key of a TestProperty against a known key.
733 //
734 // TestPropertyKeyIs is copyable.
735 class TestPropertyKeyIs {
736  public:
737   // Constructor.
738   //
739   // TestPropertyKeyIs has NO default constructor.
740   explicit TestPropertyKeyIs(const char* key)
741       : key_(key) {}
743   // Returns true iff the test name of test property matches on key_.
744   bool operator()(const TestProperty& test_property) const {
745     return String(test_property.key()).Compare(key_) == 0;
746   }
748  private:
749   String key_;
750 };
752 // Class UnitTestOptions.
753 //
754 // This class contains functions for processing options the user
755 // specifies when running the tests.  It has only static members.
756 //
757 // In most cases, the user can specify an option using either an
758 // environment variable or a command line flag.  E.g. you can set the
759 // test filter using either GTEST_FILTER or --gtest_filter.  If both
760 // the variable and the flag are present, the latter overrides the
761 // former.
762 class GTEST_API_ UnitTestOptions {
763  public:
764   // Functions for processing the gtest_output flag.
766   // Returns the output format, or "" for normal printed output.
767   static String GetOutputFormat();
769   // Returns the absolute path of the requested output file, or the
770   // default (test_detail.xml in the original working directory) if
771   // none was explicitly specified.
772   static String GetAbsolutePathToOutputFile();
774   // Functions for processing the gtest_filter flag.
776   // Returns true iff the wildcard pattern matches the string.  The
777   // first ':' or '\0' character in pattern marks the end of it.
778   //
779   // This recursive algorithm isn't very efficient, but is clear and
780   // works well enough for matching test names, which are short.
781   static bool PatternMatchesString(const char *pattern, const char *str);
783   // Returns true iff the user-specified filter matches the test case
784   // name and the test name.
785   static bool FilterMatchesTest(const String &test_case_name,
786                                 const String &test_name);
788 #if GTEST_OS_WINDOWS
789   // Function for supporting the gtest_catch_exception flag.
791   // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
792   // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
793   // This function is useful as an __except condition.
794   static int GTestShouldProcessSEH(DWORD exception_code);
795 #endif  // GTEST_OS_WINDOWS
797   // Returns true if "name" matches the ':' separated list of glob-style
798   // filters in "filter".
799   static bool MatchesFilter(const String& name, const char* filter);
800 };
802 // Returns the current application's name, removing directory path if that
803 // is present.  Used by UnitTestOptions::GetOutputFile.
804 GTEST_API_ FilePath GetCurrentExecutableName();
806 // The role interface for getting the OS stack trace as a string.
807 class OsStackTraceGetterInterface {
808  public:
809   OsStackTraceGetterInterface() {}
810   virtual ~OsStackTraceGetterInterface() {}
812   // Returns the current OS stack trace as a String.  Parameters:
813   //
814   //   max_depth  - the maximum number of stack frames to be included
815   //                in the trace.
816   //   skip_count - the number of top frames to be skipped; doesn't count
817   //                against max_depth.
818   virtual String CurrentStackTrace(int max_depth, int skip_count) = 0;
820   // UponLeavingGTest() should be called immediately before Google Test calls
821   // user code. It saves some information about the current stack that
822   // CurrentStackTrace() will use to find and hide Google Test stack frames.
823   virtual void UponLeavingGTest() = 0;
825  private:
826   GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
827 };
829 // A working implementation of the OsStackTraceGetterInterface interface.
830 class OsStackTraceGetter : public OsStackTraceGetterInterface {
831  public:
832   OsStackTraceGetter() : caller_frame_(NULL) {}
833   virtual String CurrentStackTrace(int max_depth, int skip_count);
834   virtual void UponLeavingGTest();
836   // This string is inserted in place of stack frames that are part of
837   // Google Test's implementation.
838   static const char* const kElidedFramesMarker;
840  private:
841   Mutex mutex_;  // protects all internal state
843   // We save the stack frame below the frame that calls user code.
844   // We do this because the address of the frame immediately below
845   // the user code changes between the call to UponLeavingGTest()
846   // and any calls to CurrentStackTrace() from within the user code.
847   void* caller_frame_;
849   GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
850 };
852 // Information about a Google Test trace point.
853 struct TraceInfo {
854   const char* file;
855   int line;
856   String message;
857 };
859 // This is the default global test part result reporter used in UnitTestImpl.
860 // This class should only be used by UnitTestImpl.
861 class DefaultGlobalTestPartResultReporter
862   : public TestPartResultReporterInterface {
863  public:
864   explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
865   // Implements the TestPartResultReporterInterface. Reports the test part
866   // result in the current test.
867   virtual void ReportTestPartResult(const TestPartResult& result);
869  private:
870   UnitTestImpl* const unit_test_;
872   GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
873 };
875 // This is the default per thread test part result reporter used in
876 // UnitTestImpl. This class should only be used by UnitTestImpl.
877 class DefaultPerThreadTestPartResultReporter
878     : public TestPartResultReporterInterface {
879  public:
880   explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);
881   // Implements the TestPartResultReporterInterface. The implementation just
882   // delegates to the current global test part result reporter of *unit_test_.
883   virtual void ReportTestPartResult(const TestPartResult& result);
885  private:
886   UnitTestImpl* const unit_test_;
888   GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
889 };
891 // The private implementation of the UnitTest class.  We don't protect
892 // the methods under a mutex, as this class is not accessible by a
893 // user and the UnitTest class that delegates work to this class does
894 // proper locking.
895 class GTEST_API_ UnitTestImpl {
896  public:
897   explicit UnitTestImpl(UnitTest* parent);
898   virtual ~UnitTestImpl();
900   // There are two different ways to register your own TestPartResultReporter.
901   // You can register your own repoter to listen either only for test results
902   // from the current thread or for results from all threads.
903   // By default, each per-thread test result repoter just passes a new
904   // TestPartResult to the global test result reporter, which registers the
905   // test part result for the currently running test.
907   // Returns the global test part result reporter.
908   TestPartResultReporterInterface* GetGlobalTestPartResultReporter();
910   // Sets the global test part result reporter.
911   void SetGlobalTestPartResultReporter(
912       TestPartResultReporterInterface* reporter);
914   // Returns the test part result reporter for the current thread.
915   TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread();
917   // Sets the test part result reporter for the current thread.
918   void SetTestPartResultReporterForCurrentThread(
919       TestPartResultReporterInterface* reporter);
921   // Gets the number of successful test cases.
922   int successful_test_case_count() const;
924   // Gets the number of failed test cases.
925   int failed_test_case_count() const;
927   // Gets the number of all test cases.
928   int total_test_case_count() const;
930   // Gets the number of all test cases that contain at least one test
931   // that should run.
932   int test_case_to_run_count() const;
934   // Gets the number of successful tests.
935   int successful_test_count() const;
937   // Gets the number of failed tests.
938   int failed_test_count() const;
940   // Gets the number of disabled tests.
941   int disabled_test_count() const;
943   // Gets the number of all tests.
944   int total_test_count() const;
946   // Gets the number of tests that should run.
947   int test_to_run_count() const;
949   // Gets the elapsed time, in milliseconds.
950   TimeInMillis elapsed_time() const { return elapsed_time_; }
952   // Returns true iff the unit test passed (i.e. all test cases passed).
953   bool Passed() const { return !Failed(); }
955   // Returns true iff the unit test failed (i.e. some test case failed
956   // or something outside of all tests failed).
957   bool Failed() const {
958     return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed();
959   }
961   // Gets the i-th test case among all the test cases. i can range from 0 to
962   // total_test_case_count() - 1. If i is not in that range, returns NULL.
963   const TestCase* GetTestCase(int i) const {
964     const int index = GetElementOr(test_case_indices_, i, -1);
965     return index < 0 ? NULL : test_cases_[i];
966   }
968   // Gets the i-th test case among all the test cases. i can range from 0 to
969   // total_test_case_count() - 1. If i is not in that range, returns NULL.
970   TestCase* GetMutableTestCase(int i) {
971     const int index = GetElementOr(test_case_indices_, i, -1);
972     return index < 0 ? NULL : test_cases_[index];
973   }
975   // Provides access to the event listener list.
976   TestEventListeners* listeners() { return &listeners_; }
978   // Returns the TestResult for the test that's currently running, or
979   // the TestResult for the ad hoc test if no test is running.
980   TestResult* current_test_result();
982   // Returns the TestResult for the ad hoc test.
983   const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }
985   // Sets the OS stack trace getter.
986   //
987   // Does nothing if the input and the current OS stack trace getter
988   // are the same; otherwise, deletes the old getter and makes the
989   // input the current getter.
990   void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);
992   // Returns the current OS stack trace getter if it is not NULL;
993   // otherwise, creates an OsStackTraceGetter, makes it the current
994   // getter, and returns it.
995   OsStackTraceGetterInterface* os_stack_trace_getter();
997   // Returns the current OS stack trace as a String.
998   //
999   // The maximum number of stack frames to be included is specified by
1000   // the gtest_stack_trace_depth flag.  The skip_count parameter
1001   // specifies the number of top frames to be skipped, which doesn't
1002   // count against the number of frames to be included.
1003   //
1004   // For example, if Foo() calls Bar(), which in turn calls
1005   // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
1006   // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
1007   String CurrentOsStackTraceExceptTop(int skip_count);
1009   // Finds and returns a TestCase with the given name.  If one doesn't
1010   // exist, creates one and returns it.
1011   //
1012   // Arguments:
1013   //
1014   //   test_case_name: name of the test case
1015   //   type_param:     the name of the test's type parameter, or NULL if
1016   //                   this is not a typed or a type-parameterized test.
1017   //   set_up_tc:      pointer to the function that sets up the test case
1018   //   tear_down_tc:   pointer to the function that tears down the test case
1019   TestCase* GetTestCase(const char* test_case_name,
1020                         const char* type_param,
1021                         Test::SetUpTestCaseFunc set_up_tc,
1022                         Test::TearDownTestCaseFunc tear_down_tc);
1024   // Adds a TestInfo to the unit test.
1025   //
1026   // Arguments:
1027   //
1028   //   set_up_tc:    pointer to the function that sets up the test case
1029   //   tear_down_tc: pointer to the function that tears down the test case
1030   //   test_info:    the TestInfo object
1031   void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
1032                    Test::TearDownTestCaseFunc tear_down_tc,
1033                    TestInfo* test_info) {
1034     // In order to support thread-safe death tests, we need to
1035     // remember the original working directory when the test program
1036     // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
1037     // the user may have changed the current directory before calling
1038     // RUN_ALL_TESTS().  Therefore we capture the current directory in
1039     // AddTestInfo(), which is called to register a TEST or TEST_F
1040     // before main() is reached.
1041     if (original_working_dir_.IsEmpty()) {
1042       original_working_dir_.Set(FilePath::GetCurrentDir());
1043       GTEST_CHECK_(!original_working_dir_.IsEmpty())
1044           << "Failed to get the current working directory.";
1045     }
1047     GetTestCase(test_info->test_case_name(),
1048                 test_info->type_param(),
1049                 set_up_tc,
1050                 tear_down_tc)->AddTestInfo(test_info);
1051   }
1053 #if GTEST_HAS_PARAM_TEST
1054   // Returns ParameterizedTestCaseRegistry object used to keep track of
1055   // value-parameterized tests and instantiate and register them.
1056   internal::ParameterizedTestCaseRegistry& parameterized_test_registry() {
1057     return parameterized_test_registry_;
1058   }
1059 #endif  // GTEST_HAS_PARAM_TEST
1061   // Sets the TestCase object for the test that's currently running.
1062   void set_current_test_case(TestCase* a_current_test_case) {
1063     current_test_case_ = a_current_test_case;
1064   }
1066   // Sets the TestInfo object for the test that's currently running.  If
1067   // current_test_info is NULL, the assertion results will be stored in
1068   // ad_hoc_test_result_.
1069   void set_current_test_info(TestInfo* a_current_test_info) {
1070     current_test_info_ = a_current_test_info;
1071   }
1073   // Registers all parameterized tests defined using TEST_P and
1074   // INSTANTIATE_TEST_CASE_P, creating regular tests for each test/parameter
1075   // combination. This method can be called more then once; it has guards
1076   // protecting from registering the tests more then once.  If
1077   // value-parameterized tests are disabled, RegisterParameterizedTests is
1078   // present but does nothing.
1079   void RegisterParameterizedTests();
1081   // Runs all tests in this UnitTest object, prints the result, and
1082   // returns true if all tests are successful.  If any exception is
1083   // thrown during a test, this test is considered to be failed, but
1084   // the rest of the tests will still be run.
1085   bool RunAllTests();
1087   // Clears the results of all tests, except the ad hoc tests.
1088   void ClearNonAdHocTestResult() {
1089     ForEach(test_cases_, TestCase::ClearTestCaseResult);
1090   }
1092   // Clears the results of ad-hoc test assertions.
1093   void ClearAdHocTestResult() {
1094     ad_hoc_test_result_.Clear();
1095   }
1097   enum ReactionToSharding {
1098     HONOR_SHARDING_PROTOCOL,
1099     IGNORE_SHARDING_PROTOCOL
1100   };
1102   // Matches the full name of each test against the user-specified
1103   // filter to decide whether the test should run, then records the
1104   // result in each TestCase and TestInfo object.
1105   // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
1106   // based on sharding variables in the environment.
1107   // Returns the number of tests that should run.
1108   int FilterTests(ReactionToSharding shard_tests);
1110   // Prints the names of the tests matching the user-specified filter flag.
1111   void ListTestsMatchingFilter();
1113   const TestCase* current_test_case() const { return current_test_case_; }
1114   TestInfo* current_test_info() { return current_test_info_; }
1115   const TestInfo* current_test_info() const { return current_test_info_; }
1117   // Returns the vector of environments that need to be set-up/torn-down
1118   // before/after the tests are run.
1119   std::vector<Environment*>& environments() { return environments_; }
1121   // Getters for the per-thread Google Test trace stack.
1122   std::vector<TraceInfo>& gtest_trace_stack() {
1123     return *(gtest_trace_stack_.pointer());
1124   }
1125   const std::vector<TraceInfo>& gtest_trace_stack() const {
1126     return gtest_trace_stack_.get();
1127   }
1129 #if GTEST_HAS_DEATH_TEST
1130   void InitDeathTestSubprocessControlInfo() {
1131     internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
1132   }
1133   // Returns a pointer to the parsed --gtest_internal_run_death_test
1134   // flag, or NULL if that flag was not specified.
1135   // This information is useful only in a death test child process.
1136   // Must not be called before a call to InitGoogleTest.
1137   const InternalRunDeathTestFlag* internal_run_death_test_flag() const {
1138     return internal_run_death_test_flag_.get();
1139   }
1141   // Returns a pointer to the current death test factory.
1142   internal::DeathTestFactory* death_test_factory() {
1143     return death_test_factory_.get();
1144   }
1146   void SuppressTestEventsIfInSubprocess();
1148   friend class ReplaceDeathTestFactory;
1149 #endif  // GTEST_HAS_DEATH_TEST
1151   // Initializes the event listener performing XML output as specified by
1152   // UnitTestOptions. Must not be called before InitGoogleTest.
1153   void ConfigureXmlOutput();
1155 #if GTEST_CAN_STREAM_RESULTS_
1156   // Initializes the event listener for streaming test results to a socket.
1157   // Must not be called before InitGoogleTest.
1158   void ConfigureStreamingOutput();
1159 #endif
1161   // Performs initialization dependent upon flag values obtained in
1162   // ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
1163   // ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
1164   // this function is also called from RunAllTests.  Since this function can be
1165   // called more than once, it has to be idempotent.
1166   void PostFlagParsingInit();
1168   // Gets the random seed used at the start of the current test iteration.
1169   int random_seed() const { return random_seed_; }
1171   // Gets the random number generator.
1172   internal::Random* random() { return &random_; }
1174   // Shuffles all test cases, and the tests within each test case,
1175   // making sure that death tests are still run first.
1176   void ShuffleTests();
1178   // Restores the test cases and tests to their order before the first shuffle.
1179   void UnshuffleTests();
1181   // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
1182   // UnitTest::Run() starts.
1183   bool catch_exceptions() const { return catch_exceptions_; }
1185  private:
1186   friend class ::testing::UnitTest;
1188   // Used by UnitTest::Run() to capture the state of
1189   // GTEST_FLAG(catch_exceptions) at the moment it starts.
1190   void set_catch_exceptions(bool value) { catch_exceptions_ = value; }
1192   // The UnitTest object that owns this implementation object.
1193   UnitTest* const parent_;
1195   // The working directory when the first TEST() or TEST_F() was
1196   // executed.
1197   internal::FilePath original_working_dir_;
1199   // The default test part result reporters.
1200   DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_;
1201   DefaultPerThreadTestPartResultReporter
1202       default_per_thread_test_part_result_reporter_;
1204   // Points to (but doesn't own) the global test part result reporter.
1205   TestPartResultReporterInterface* global_test_part_result_repoter_;
1207   // Protects read and write access to global_test_part_result_reporter_.
1208   internal::Mutex global_test_part_result_reporter_mutex_;
1210   // Points to (but doesn't own) the per-thread test part result reporter.
1211   internal::ThreadLocal<TestPartResultReporterInterface*>
1212       per_thread_test_part_result_reporter_;
1214   // The vector of environments that need to be set-up/torn-down
1215   // before/after the tests are run.
1216   std::vector<Environment*> environments_;
1218   // The vector of TestCases in their original order.  It owns the
1219   // elements in the vector.
1220   std::vector<TestCase*> test_cases_;
1222   // Provides a level of indirection for the test case list to allow
1223   // easy shuffling and restoring the test case order.  The i-th
1224   // element of this vector is the index of the i-th test case in the
1225   // shuffled order.
1226   std::vector<int> test_case_indices_;
1228 #if GTEST_HAS_PARAM_TEST
1229   // ParameterizedTestRegistry object used to register value-parameterized
1230   // tests.
1231   internal::ParameterizedTestCaseRegistry parameterized_test_registry_;
1233   // Indicates whether RegisterParameterizedTests() has been called already.
1234   bool parameterized_tests_registered_;
1235 #endif  // GTEST_HAS_PARAM_TEST
1237   // Index of the last death test case registered.  Initially -1.
1238   int last_death_test_case_;
1240   // This points to the TestCase for the currently running test.  It
1241   // changes as Google Test goes through one test case after another.
1242   // When no test is running, this is set to NULL and Google Test
1243   // stores assertion results in ad_hoc_test_result_.  Initially NULL.
1244   TestCase* current_test_case_;
1246   // This points to the TestInfo for the currently running test.  It
1247   // changes as Google Test goes through one test after another.  When
1248   // no test is running, this is set to NULL and Google Test stores
1249   // assertion results in ad_hoc_test_result_.  Initially NULL.
1250   TestInfo* current_test_info_;
1252   // Normally, a user only writes assertions inside a TEST or TEST_F,
1253   // or inside a function called by a TEST or TEST_F.  Since Google
1254   // Test keeps track of which test is current running, it can
1255   // associate such an assertion with the test it belongs to.
1256   //
1257   // If an assertion is encountered when no TEST or TEST_F is running,
1258   // Google Test attributes the assertion result to an imaginary "ad hoc"
1259   // test, and records the result in ad_hoc_test_result_.
1260   TestResult ad_hoc_test_result_;
1262   // The list of event listeners that can be used to track events inside
1263   // Google Test.
1264   TestEventListeners listeners_;
1266   // The OS stack trace getter.  Will be deleted when the UnitTest
1267   // object is destructed.  By default, an OsStackTraceGetter is used,
1268   // but the user can set this field to use a custom getter if that is
1269   // desired.
1270   OsStackTraceGetterInterface* os_stack_trace_getter_;
1272   // True iff PostFlagParsingInit() has been called.
1273   bool post_flag_parse_init_performed_;
1275   // The random number seed used at the beginning of the test run.
1276   int random_seed_;
1278   // Our random number generator.
1279   internal::Random random_;
1281   // How long the test took to run, in milliseconds.
1282   TimeInMillis elapsed_time_;
1284 #if GTEST_HAS_DEATH_TEST
1285   // The decomposed components of the gtest_internal_run_death_test flag,
1286   // parsed when RUN_ALL_TESTS is called.
1287   internal::scoped_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
1288   internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_;
1289 #endif  // GTEST_HAS_DEATH_TEST
1291   // A per-thread stack of traces created by the SCOPED_TRACE() macro.
1292   internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_;
1294   // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests()
1295   // starts.
1296   bool catch_exceptions_;
1298   GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
1299 };  // class UnitTestImpl
1301 // Convenience function for accessing the global UnitTest
1302 // implementation object.
1303 inline UnitTestImpl* GetUnitTestImpl() {
1304   return UnitTest::GetInstance()->impl();
1307 #if GTEST_USES_SIMPLE_RE
1309 // Internal helper functions for implementing the simple regular
1310 // expression matcher.
1311 GTEST_API_ bool IsInSet(char ch, const char* str);
1312 GTEST_API_ bool IsAsciiDigit(char ch);
1313 GTEST_API_ bool IsAsciiPunct(char ch);
1314 GTEST_API_ bool IsRepeat(char ch);
1315 GTEST_API_ bool IsAsciiWhiteSpace(char ch);
1316 GTEST_API_ bool IsAsciiWordChar(char ch);
1317 GTEST_API_ bool IsValidEscape(char ch);
1318 GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
1319 GTEST_API_ bool ValidateRegex(const char* regex);
1320 GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
1321 GTEST_API_ bool MatchRepetitionAndRegexAtHead(
1322     bool escaped, char ch, char repeat, const char* regex, const char* str);
1323 GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
1325 #endif  // GTEST_USES_SIMPLE_RE
1327 // Parses the command line for Google Test flags, without initializing
1328 // other parts of Google Test.
1329 GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
1330 GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
1332 #if GTEST_HAS_DEATH_TEST
1334 // Returns the message describing the last system error, regardless of the
1335 // platform.
1336 GTEST_API_ String GetLastErrnoDescription();
1338 # if GTEST_OS_WINDOWS
1339 // Provides leak-safe Windows kernel handle ownership.
1340 class AutoHandle {
1341  public:
1342   AutoHandle() : handle_(INVALID_HANDLE_VALUE) {}
1343   explicit AutoHandle(HANDLE handle) : handle_(handle) {}
1345   ~AutoHandle() { Reset(); }
1347   HANDLE Get() const { return handle_; }
1348   void Reset() { Reset(INVALID_HANDLE_VALUE); }
1349   void Reset(HANDLE handle) {
1350     if (handle != handle_) {
1351       if (handle_ != INVALID_HANDLE_VALUE)
1352         ::CloseHandle(handle_);
1353       handle_ = handle;
1354     }
1355   }
1357  private:
1358   HANDLE handle_;
1360   GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
1361 };
1362 # endif  // GTEST_OS_WINDOWS
1364 // Attempts to parse a string into a positive integer pointed to by the
1365 // number parameter.  Returns true if that is possible.
1366 // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use
1367 // it here.
1368 template <typename Integer>
1369 bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
1370   // Fail fast if the given string does not begin with a digit;
1371   // this bypasses strtoXXX's "optional leading whitespace and plus
1372   // or minus sign" semantics, which are undesirable here.
1373   if (str.empty() || !IsDigit(str[0])) {
1374     return false;
1375   }
1376   errno = 0;
1378   char* end;
1379   // BiggestConvertible is the largest integer type that system-provided
1380   // string-to-number conversion routines can return.
1382 # if GTEST_OS_WINDOWS && !defined(__GNUC__)
1384   // MSVC and C++ Builder define __int64 instead of the standard long long.
1385   typedef unsigned __int64 BiggestConvertible;
1386   const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10);
1388 # else
1390   typedef unsigned long long BiggestConvertible;  // NOLINT
1391   const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);
1393 # endif  // GTEST_OS_WINDOWS && !defined(__GNUC__)
1395   const bool parse_success = *end == '\0' && errno == 0;
1397   // TODO(vladl@google.com): Convert this to compile time assertion when it is
1398   // available.
1399   GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
1401   const Integer result = static_cast<Integer>(parsed);
1402   if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
1403     *number = result;
1404     return true;
1405   }
1406   return false;
1408 #endif  // GTEST_HAS_DEATH_TEST
1410 // TestResult contains some private methods that should be hidden from
1411 // Google Test user but are required for testing. This class allow our tests
1412 // to access them.
1413 //
1414 // This class is supplied only for the purpose of testing Google Test's own
1415 // constructs. Do not use it in user tests, either directly or indirectly.
1416 class TestResultAccessor {
1417  public:
1418   static void RecordProperty(TestResult* test_result,
1419                              const TestProperty& property) {
1420     test_result->RecordProperty(property);
1421   }
1423   static void ClearTestPartResults(TestResult* test_result) {
1424     test_result->ClearTestPartResults();
1425   }
1427   static const std::vector<testing::TestPartResult>& test_part_results(
1428       const TestResult& test_result) {
1429     return test_result.test_part_results();
1430   }
1431 };
1433 }  // namespace internal
1434 }  // namespace testing
1436 #endif  // GTEST_SRC_GTEST_INTERNAL_INL_H_
1437 #undef GTEST_IMPLEMENTATION_
1439 #if GTEST_OS_WINDOWS
1440 # define vsnprintf _vsnprintf
1441 #endif  // GTEST_OS_WINDOWS
1443 namespace testing {
1445 using internal::CountIf;
1446 using internal::ForEach;
1447 using internal::GetElementOr;
1448 using internal::Shuffle;
1450 // Constants.
1452 // A test whose test case name or test name matches this filter is
1453 // disabled and not run.
1454 static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
1456 // A test case whose name matches this filter is considered a death
1457 // test case and will be run before test cases whose name doesn't
1458 // match this filter.
1459 static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*";
1461 // A test filter that matches everything.
1462 static const char kUniversalFilter[] = "*";
1464 // The default output file for XML output.
1465 static const char kDefaultOutputFile[] = "test_detail.xml";
1467 // The environment variable name for the test shard index.
1468 static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
1469 // The environment variable name for the total number of test shards.
1470 static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
1471 // The environment variable name for the test shard status file.
1472 static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";
1474 namespace internal {
1476 // The text used in failure messages to indicate the start of the
1477 // stack trace.
1478 const char kStackTraceMarker[] = "\nStack trace:\n";
1480 // g_help_flag is true iff the --help flag or an equivalent form is
1481 // specified on the command line.
1482 bool g_help_flag = false;
1484 }  // namespace internal
1486 GTEST_DEFINE_bool_(
1487     also_run_disabled_tests,
1488     internal::BoolFromGTestEnv("also_run_disabled_tests", false),
1489     "Run disabled tests too, in addition to the tests normally being run.");
1491 GTEST_DEFINE_bool_(
1492     break_on_failure,
1493     internal::BoolFromGTestEnv("break_on_failure", false),
1494     "True iff a failed assertion should be a debugger break-point.");
1496 GTEST_DEFINE_bool_(
1497     catch_exceptions,
1498     internal::BoolFromGTestEnv("catch_exceptions", true),
1499     "True iff " GTEST_NAME_
1500     " should catch exceptions and treat them as test failures.");
1502 GTEST_DEFINE_string_(
1503     color,
1504     internal::StringFromGTestEnv("color", "auto"),
1505     "Whether to use colors in the output.  Valid values: yes, no, "
1506     "and auto.  'auto' means to use colors if the output is "
1507     "being sent to a terminal and the TERM environment variable "
1508     "is set to xterm, xterm-color, xterm-256color, linux or cygwin.");
1510 GTEST_DEFINE_string_(
1511     filter,
1512     internal::StringFromGTestEnv("filter", kUniversalFilter),
1513     "A colon-separated list of glob (not regex) patterns "
1514     "for filtering the tests to run, optionally followed by a "
1515     "'-' and a : separated list of negative patterns (tests to "
1516     "exclude).  A test is run if it matches one of the positive "
1517     "patterns and does not match any of the negative patterns.");
1519 GTEST_DEFINE_bool_(list_tests, false,
1520                    "List all tests without running them.");
1522 GTEST_DEFINE_string_(
1523     output,
1524     internal::StringFromGTestEnv("output", ""),
1525     "A format (currently must be \"xml\"), optionally followed "
1526     "by a colon and an output file name or directory. A directory "
1527     "is indicated by a trailing pathname separator. "
1528     "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "
1529     "If a directory is specified, output files will be created "
1530     "within that directory, with file-names based on the test "
1531     "executable's name and, if necessary, made unique by adding "
1532     "digits.");
1534 GTEST_DEFINE_bool_(
1535     print_time,
1536     internal::BoolFromGTestEnv("print_time", true),
1537     "True iff " GTEST_NAME_
1538     " should display elapsed time in text output.");
1540 GTEST_DEFINE_int32_(
1541     random_seed,
1542     internal::Int32FromGTestEnv("random_seed", 0),
1543     "Random number seed to use when shuffling test orders.  Must be in range "
1544     "[1, 99999], or 0 to use a seed based on the current time.");
1546 GTEST_DEFINE_int32_(
1547     repeat,
1548     internal::Int32FromGTestEnv("repeat", 1),
1549     "How many times to repeat each test.  Specify a negative number "
1550     "for repeating forever.  Useful for shaking out flaky tests.");
1552 GTEST_DEFINE_bool_(
1553     show_internal_stack_frames, false,
1554     "True iff " GTEST_NAME_ " should include internal stack frames when "
1555     "printing test failure stack traces.");
1557 GTEST_DEFINE_bool_(
1558     shuffle,
1559     internal::BoolFromGTestEnv("shuffle", false),
1560     "True iff " GTEST_NAME_
1561     " should randomize tests' order on every run.");
1563 GTEST_DEFINE_int32_(
1564     stack_trace_depth,
1565     internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
1566     "The maximum number of stack frames to print when an "
1567     "assertion fails.  The valid range is 0 through 100, inclusive.");
1569 GTEST_DEFINE_string_(
1570     stream_result_to,
1571     internal::StringFromGTestEnv("stream_result_to", ""),
1572     "This flag specifies the host name and the port number on which to stream "
1573     "test results. Example: \"localhost:555\". The flag is effective only on "
1574     "Linux.");
1576 GTEST_DEFINE_bool_(
1577     throw_on_failure,
1578     internal::BoolFromGTestEnv("throw_on_failure", false),
1579     "When this flag is specified, a failed assertion will throw an exception "
1580     "if exceptions are enabled or exit the program with a non-zero code "
1581     "otherwise.");
1583 namespace internal {
1585 // Generates a random number from [0, range), using a Linear
1586 // Congruential Generator (LCG).  Crashes if 'range' is 0 or greater
1587 // than kMaxRange.
1588 UInt32 Random::Generate(UInt32 range) {
1589   // These constants are the same as are used in glibc's rand(3).
1590   state_ = (1103515245U*state_ + 12345U) % kMaxRange;
1592   GTEST_CHECK_(range > 0)
1593       << "Cannot generate a number in the range [0, 0).";
1594   GTEST_CHECK_(range <= kMaxRange)
1595       << "Generation of a number in [0, " << range << ") was requested, "
1596       << "but this can only generate numbers in [0, " << kMaxRange << ").";
1598   // Converting via modulus introduces a bit of downward bias, but
1599   // it's simple, and a linear congruential generator isn't too good
1600   // to begin with.
1601   return state_ % range;
1604 // GTestIsInitialized() returns true iff the user has initialized
1605 // Google Test.  Useful for catching the user mistake of not initializing
1606 // Google Test before calling RUN_ALL_TESTS().
1607 //
1608 // A user must call testing::InitGoogleTest() to initialize Google
1609 // Test.  g_init_gtest_count is set to the number of times
1610 // InitGoogleTest() has been called.  We don't protect this variable
1611 // under a mutex as it is only accessed in the main thread.
1612 int g_init_gtest_count = 0;
1613 static bool GTestIsInitialized() { return g_init_gtest_count != 0; }
1615 // Iterates over a vector of TestCases, keeping a running sum of the
1616 // results of calling a given int-returning method on each.
1617 // Returns the sum.
1618 static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
1619                                int (TestCase::*method)() const) {
1620   int sum = 0;
1621   for (size_t i = 0; i < case_list.size(); i++) {
1622     sum += (case_list[i]->*method)();
1623   }
1624   return sum;
1627 // Returns true iff the test case passed.
1628 static bool TestCasePassed(const TestCase* test_case) {
1629   return test_case->should_run() && test_case->Passed();
1632 // Returns true iff the test case failed.
1633 static bool TestCaseFailed(const TestCase* test_case) {
1634   return test_case->should_run() && test_case->Failed();
1637 // Returns true iff test_case contains at least one test that should
1638 // run.
1639 static bool ShouldRunTestCase(const TestCase* test_case) {
1640   return test_case->should_run();
1643 // AssertHelper constructor.
1644 AssertHelper::AssertHelper(TestPartResult::Type type,
1645                            const char* file,
1646                            int line,
1647                            const char* message)
1648     : data_(new AssertHelperData(type, file, line, message)) {
1651 AssertHelper::~AssertHelper() {
1652   delete data_;
1655 // Message assignment, for assertion streaming support.
1656 void AssertHelper::operator=(const Message& message) const {
1657   UnitTest::GetInstance()->
1658     AddTestPartResult(data_->type, data_->file, data_->line,
1659                       AppendUserMessage(data_->message, message),
1660                       UnitTest::GetInstance()->impl()
1661                       ->CurrentOsStackTraceExceptTop(1)
1662                       // Skips the stack frame for this function itself.
1663                       );  // NOLINT
1666 // Mutex for linked pointers.
1667 GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
1669 // Application pathname gotten in InitGoogleTest.
1670 String g_executable_path;
1672 // Returns the current application's name, removing directory path if that
1673 // is present.
1674 FilePath GetCurrentExecutableName() {
1675   FilePath result;
1677 #if GTEST_OS_WINDOWS
1678   result.Set(FilePath(g_executable_path).RemoveExtension("exe"));
1679 #else
1680   result.Set(FilePath(g_executable_path));
1681 #endif  // GTEST_OS_WINDOWS
1683   return result.RemoveDirectoryName();
1686 // Functions for processing the gtest_output flag.
1688 // Returns the output format, or "" for normal printed output.
1689 String UnitTestOptions::GetOutputFormat() {
1690   const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
1691   if (gtest_output_flag == NULL) return String("");
1693   const char* const colon = strchr(gtest_output_flag, ':');
1694   return (colon == NULL) ?
1695       String(gtest_output_flag) :
1696       String(gtest_output_flag, colon - gtest_output_flag);
1699 // Returns the name of the requested output file, or the default if none
1700 // was explicitly specified.
1701 String UnitTestOptions::GetAbsolutePathToOutputFile() {
1702   const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
1703   if (gtest_output_flag == NULL)
1704     return String("");
1706   const char* const colon = strchr(gtest_output_flag, ':');
1707   if (colon == NULL)
1708     return String(internal::FilePath::ConcatPaths(
1709                internal::FilePath(
1710                    UnitTest::GetInstance()->original_working_dir()),
1711                internal::FilePath(kDefaultOutputFile)).ToString() );
1713   internal::FilePath output_name(colon + 1);
1714   if (!output_name.IsAbsolutePath())
1715     // TODO(wan@google.com): on Windows \some\path is not an absolute
1716     // path (as its meaning depends on the current drive), yet the
1717     // following logic for turning it into an absolute path is wrong.
1718     // Fix it.
1719     output_name = internal::FilePath::ConcatPaths(
1720         internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
1721         internal::FilePath(colon + 1));
1723   if (!output_name.IsDirectory())
1724     return output_name.ToString();
1726   internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
1727       output_name, internal::GetCurrentExecutableName(),
1728       GetOutputFormat().c_str()));
1729   return result.ToString();
1732 // Returns true iff the wildcard pattern matches the string.  The
1733 // first ':' or '\0' character in pattern marks the end of it.
1734 //
1735 // This recursive algorithm isn't very efficient, but is clear and
1736 // works well enough for matching test names, which are short.
1737 bool UnitTestOptions::PatternMatchesString(const char *pattern,
1738                                            const char *str) {
1739   switch (*pattern) {
1740     case '\0':
1741     case ':':  // Either ':' or '\0' marks the end of the pattern.
1742       return *str == '\0';
1743     case '?':  // Matches any single character.
1744       return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
1745     case '*':  // Matches any string (possibly empty) of characters.
1746       return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
1747           PatternMatchesString(pattern + 1, str);
1748     default:  // Non-special character.  Matches itself.
1749       return *pattern == *str &&
1750           PatternMatchesString(pattern + 1, str + 1);
1751   }
1754 bool UnitTestOptions::MatchesFilter(const String& name, const char* filter) {
1755   const char *cur_pattern = filter;
1756   for (;;) {
1757     if (PatternMatchesString(cur_pattern, name.c_str())) {
1758       return true;
1759     }
1761     // Finds the next pattern in the filter.
1762     cur_pattern = strchr(cur_pattern, ':');
1764     // Returns if no more pattern can be found.
1765     if (cur_pattern == NULL) {
1766       return false;
1767     }
1769     // Skips the pattern separater (the ':' character).
1770     cur_pattern++;
1771   }
1774 // TODO(keithray): move String function implementations to gtest-string.cc.
1776 // Returns true iff the user-specified filter matches the test case
1777 // name and the test name.
1778 bool UnitTestOptions::FilterMatchesTest(const String &test_case_name,
1779                                         const String &test_name) {
1780   const String& full_name = String::Format("%s.%s",
1781                                            test_case_name.c_str(),
1782                                            test_name.c_str());
1784   // Split --gtest_filter at '-', if there is one, to separate into
1785   // positive filter and negative filter portions
1786   const char* const p = GTEST_FLAG(filter).c_str();
1787   const char* const dash = strchr(p, '-');
1788   String positive;
1789   String negative;
1790   if (dash == NULL) {
1791     positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
1792     negative = String("");
1793   } else {
1794     positive = String(p, dash - p);  // Everything up to the dash
1795     negative = String(dash+1);       // Everything after the dash
1796     if (positive.empty()) {
1797       // Treat '-test1' as the same as '*-test1'
1798       positive = kUniversalFilter;
1799     }
1800   }
1802   // A filter is a colon-separated list of patterns.  It matches a
1803   // test if any pattern in it matches the test.
1804   return (MatchesFilter(full_name, positive.c_str()) &&
1805           !MatchesFilter(full_name, negative.c_str()));
1808 #if GTEST_HAS_SEH
1809 // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
1810 // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
1811 // This function is useful as an __except condition.
1812 int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
1813   // Google Test should handle a SEH exception if:
1814   //   1. the user wants it to, AND
1815   //   2. this is not a breakpoint exception, AND
1816   //   3. this is not a C++ exception (VC++ implements them via SEH,
1817   //      apparently).
1818   //
1819   // SEH exception code for C++ exceptions.
1820   // (see http://support.microsoft.com/kb/185294 for more information).
1821   const DWORD kCxxExceptionCode = 0xe06d7363;
1823   bool should_handle = true;
1825   if (!GTEST_FLAG(catch_exceptions))
1826     should_handle = false;
1827   else if (exception_code == EXCEPTION_BREAKPOINT)
1828     should_handle = false;
1829   else if (exception_code == kCxxExceptionCode)
1830     should_handle = false;
1832   return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
1834 #endif  // GTEST_HAS_SEH
1836 }  // namespace internal
1838 // The c'tor sets this object as the test part result reporter used by
1839 // Google Test.  The 'result' parameter specifies where to report the
1840 // results. Intercepts only failures from the current thread.
1841 ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
1842     TestPartResultArray* result)
1843     : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
1844       result_(result) {
1845   Init();
1848 // The c'tor sets this object as the test part result reporter used by
1849 // Google Test.  The 'result' parameter specifies where to report the
1850 // results.
1851 ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
1852     InterceptMode intercept_mode, TestPartResultArray* result)
1853     : intercept_mode_(intercept_mode),
1854       result_(result) {
1855   Init();
1858 void ScopedFakeTestPartResultReporter::Init() {
1859   internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
1860   if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
1861     old_reporter_ = impl->GetGlobalTestPartResultReporter();
1862     impl->SetGlobalTestPartResultReporter(this);
1863   } else {
1864     old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
1865     impl->SetTestPartResultReporterForCurrentThread(this);
1866   }
1869 // The d'tor restores the test part result reporter used by Google Test
1870 // before.
1871 ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
1872   internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
1873   if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
1874     impl->SetGlobalTestPartResultReporter(old_reporter_);
1875   } else {
1876     impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
1877   }
1880 // Increments the test part result count and remembers the result.
1881 // This method is from the TestPartResultReporterInterface interface.
1882 void ScopedFakeTestPartResultReporter::ReportTestPartResult(
1883     const TestPartResult& result) {
1884   result_->Append(result);
1887 namespace internal {
1889 // Returns the type ID of ::testing::Test.  We should always call this
1890 // instead of GetTypeId< ::testing::Test>() to get the type ID of
1891 // testing::Test.  This is to work around a suspected linker bug when
1892 // using Google Test as a framework on Mac OS X.  The bug causes
1893 // GetTypeId< ::testing::Test>() to return different values depending
1894 // on whether the call is from the Google Test framework itself or
1895 // from user test code.  GetTestTypeId() is guaranteed to always
1896 // return the same value, as it always calls GetTypeId<>() from the
1897 // gtest.cc, which is within the Google Test framework.
1898 TypeId GetTestTypeId() {
1899   return GetTypeId<Test>();
1902 // The value of GetTestTypeId() as seen from within the Google Test
1903 // library.  This is solely for testing GetTestTypeId().
1904 extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();
1906 // This predicate-formatter checks that 'results' contains a test part
1907 // failure of the given type and that the failure message contains the
1908 // given substring.
1909 AssertionResult HasOneFailure(const char* /* results_expr */,
1910                               const char* /* type_expr */,
1911                               const char* /* substr_expr */,
1912                               const TestPartResultArray& results,
1913                               TestPartResult::Type type,
1914                               const string& substr) {
1915   const String expected(type == TestPartResult::kFatalFailure ?
1916                         "1 fatal failure" :
1917                         "1 non-fatal failure");
1918   Message msg;
1919   if (results.size() != 1) {
1920     msg << "Expected: " << expected << "\n"
1921         << "  Actual: " << results.size() << " failures";
1922     for (int i = 0; i < results.size(); i++) {
1923       msg << "\n" << results.GetTestPartResult(i);
1924     }
1925     return AssertionFailure() << msg;
1926   }
1928   const TestPartResult& r = results.GetTestPartResult(0);
1929   if (r.type() != type) {
1930     return AssertionFailure() << "Expected: " << expected << "\n"
1931                               << "  Actual:\n"
1932                               << r;
1933   }
1935   if (strstr(r.message(), substr.c_str()) == NULL) {
1936     return AssertionFailure() << "Expected: " << expected << " containing \""
1937                               << substr << "\"\n"
1938                               << "  Actual:\n"
1939                               << r;
1940   }
1942   return AssertionSuccess();
1945 // The constructor of SingleFailureChecker remembers where to look up
1946 // test part results, what type of failure we expect, and what
1947 // substring the failure message should contain.
1948 SingleFailureChecker:: SingleFailureChecker(
1949     const TestPartResultArray* results,
1950     TestPartResult::Type type,
1951     const string& substr)
1952     : results_(results),
1953       type_(type),
1954       substr_(substr) {}
1956 // The destructor of SingleFailureChecker verifies that the given
1957 // TestPartResultArray contains exactly one failure that has the given
1958 // type and contains the given substring.  If that's not the case, a
1959 // non-fatal failure will be generated.
1960 SingleFailureChecker::~SingleFailureChecker() {
1961   EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
1964 DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
1965     UnitTestImpl* unit_test) : unit_test_(unit_test) {}
1967 void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
1968     const TestPartResult& result) {
1969   unit_test_->current_test_result()->AddTestPartResult(result);
1970   unit_test_->listeners()->repeater()->OnTestPartResult(result);
1973 DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
1974     UnitTestImpl* unit_test) : unit_test_(unit_test) {}
1976 void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
1977     const TestPartResult& result) {
1978   unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
1981 // Returns the global test part result reporter.
1982 TestPartResultReporterInterface*
1983 UnitTestImpl::GetGlobalTestPartResultReporter() {
1984   internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
1985   return global_test_part_result_repoter_;
1988 // Sets the global test part result reporter.
1989 void UnitTestImpl::SetGlobalTestPartResultReporter(
1990     TestPartResultReporterInterface* reporter) {
1991   internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
1992   global_test_part_result_repoter_ = reporter;
1995 // Returns the test part result reporter for the current thread.
1996 TestPartResultReporterInterface*
1997 UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
1998   return per_thread_test_part_result_reporter_.get();
2001 // Sets the test part result reporter for the current thread.
2002 void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
2003     TestPartResultReporterInterface* reporter) {
2004   per_thread_test_part_result_reporter_.set(reporter);
2007 // Gets the number of successful test cases.
2008 int UnitTestImpl::successful_test_case_count() const {
2009   return CountIf(test_cases_, TestCasePassed);
2012 // Gets the number of failed test cases.
2013 int UnitTestImpl::failed_test_case_count() const {
2014   return CountIf(test_cases_, TestCaseFailed);
2017 // Gets the number of all test cases.
2018 int UnitTestImpl::total_test_case_count() const {
2019   return static_cast<int>(test_cases_.size());
2022 // Gets the number of all test cases that contain at least one test
2023 // that should run.
2024 int UnitTestImpl::test_case_to_run_count() const {
2025   return CountIf(test_cases_, ShouldRunTestCase);
2028 // Gets the number of successful tests.
2029 int UnitTestImpl::successful_test_count() const {
2030   return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count);
2033 // Gets the number of failed tests.
2034 int UnitTestImpl::failed_test_count() const {
2035   return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count);
2038 // Gets the number of disabled tests.
2039 int UnitTestImpl::disabled_test_count() const {
2040   return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count);
2043 // Gets the number of all tests.
2044 int UnitTestImpl::total_test_count() const {
2045   return SumOverTestCaseList(test_cases_, &TestCase::total_test_count);
2048 // Gets the number of tests that should run.
2049 int UnitTestImpl::test_to_run_count() const {
2050   return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count);
2053 // Returns the current OS stack trace as a String.
2054 //
2055 // The maximum number of stack frames to be included is specified by
2056 // the gtest_stack_trace_depth flag.  The skip_count parameter
2057 // specifies the number of top frames to be skipped, which doesn't
2058 // count against the number of frames to be included.
2059 //
2060 // For example, if Foo() calls Bar(), which in turn calls
2061 // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
2062 // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
2063 String UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
2064   (void)skip_count;
2065   return String("");
2068 // Returns the current time in milliseconds.
2069 TimeInMillis GetTimeInMillis() {
2070 #if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)
2071   // Difference between 1970-01-01 and 1601-01-01 in milliseconds.
2072   // http://analogous.blogspot.com/2005/04/epoch.html
2073   const TimeInMillis kJavaEpochToWinFileTimeDelta =
2074     static_cast<TimeInMillis>(116444736UL) * 100000UL;
2075   const DWORD kTenthMicrosInMilliSecond = 10000;
2077   SYSTEMTIME now_systime;
2078   FILETIME now_filetime;
2079   ULARGE_INTEGER now_int64;
2080   // TODO(kenton@google.com): Shouldn't this just use
2081   //   GetSystemTimeAsFileTime()?
2082   GetSystemTime(&now_systime);
2083   if (SystemTimeToFileTime(&now_systime, &now_filetime)) {
2084     now_int64.LowPart = now_filetime.dwLowDateTime;
2085     now_int64.HighPart = now_filetime.dwHighDateTime;
2086     now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) -
2087       kJavaEpochToWinFileTimeDelta;
2088     return now_int64.QuadPart;
2089   }
2090   return 0;
2091 #elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_
2092   __timeb64 now;
2094 # ifdef _MSC_VER
2096   // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996
2097   // (deprecated function) there.
2098   // TODO(kenton@google.com): Use GetTickCount()?  Or use
2099   //   SystemTimeToFileTime()
2100 #  pragma warning(push)          // Saves the current warning state.
2101 #  pragma warning(disable:4996)  // Temporarily disables warning 4996.
2102   _ftime64(&now);
2103 #  pragma warning(pop)           // Restores the warning state.
2104 # else
2106   _ftime64(&now);
2108 # endif  // _MSC_VER
2110   return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
2111 #elif GTEST_HAS_GETTIMEOFDAY_
2112   struct timeval now;
2113   gettimeofday(&now, NULL);
2114   return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000;
2115 #else
2116 # error "Don't know how to get the current time on your system."
2117 #endif
2120 // Utilities
2122 // class String
2124 // Returns the input enclosed in double quotes if it's not NULL;
2125 // otherwise returns "(null)".  For example, "\"Hello\"" is returned
2126 // for input "Hello".
2127 //
2128 // This is useful for printing a C string in the syntax of a literal.
2129 //
2130 // Known issue: escape sequences are not handled yet.
2131 String String::ShowCStringQuoted(const char* c_str) {
2132   return c_str ? String::Format("\"%s\"", c_str) : String("(null)");
2135 // Copies at most length characters from str into a newly-allocated
2136 // piece of memory of size length+1.  The memory is allocated with new[].
2137 // A terminating null byte is written to the memory, and a pointer to it
2138 // is returned.  If str is NULL, NULL is returned.
2139 static char* CloneString(const char* str, size_t length) {
2140   if (str == NULL) {
2141     return NULL;
2142   } else {
2143     char* const clone = new char[length + 1];
2144     posix::StrNCpy(clone, str, length);
2145     clone[length] = '\0';
2146     return clone;
2147   }
2150 // Clones a 0-terminated C string, allocating memory using new.  The
2151 // caller is responsible for deleting[] the return value.  Returns the
2152 // cloned string, or NULL if the input is NULL.
2153 const char * String::CloneCString(const char* c_str) {
2154   return (c_str == NULL) ?
2155                     NULL : CloneString(c_str, strlen(c_str));
2158 #if GTEST_OS_WINDOWS_MOBILE
2159 // Creates a UTF-16 wide string from the given ANSI string, allocating
2160 // memory using new. The caller is responsible for deleting the return
2161 // value using delete[]. Returns the wide string, or NULL if the
2162 // input is NULL.
2163 LPCWSTR String::AnsiToUtf16(const char* ansi) {
2164   if (!ansi) return NULL;
2165   const int length = strlen(ansi);
2166   const int unicode_length =
2167       MultiByteToWideChar(CP_ACP, 0, ansi, length,
2168                           NULL, 0);
2169   WCHAR* unicode = new WCHAR[unicode_length + 1];
2170   MultiByteToWideChar(CP_ACP, 0, ansi, length,
2171                       unicode, unicode_length);
2172   unicode[unicode_length] = 0;
2173   return unicode;
2176 // Creates an ANSI string from the given wide string, allocating
2177 // memory using new. The caller is responsible for deleting the return
2178 // value using delete[]. Returns the ANSI string, or NULL if the
2179 // input is NULL.
2180 const char* String::Utf16ToAnsi(LPCWSTR utf16_str)  {
2181   if (!utf16_str) return NULL;
2182   const int ansi_length =
2183       WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
2184                           NULL, 0, NULL, NULL);
2185   char* ansi = new char[ansi_length + 1];
2186   WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
2187                       ansi, ansi_length, NULL, NULL);
2188   ansi[ansi_length] = 0;
2189   return ansi;
2192 #endif  // GTEST_OS_WINDOWS_MOBILE
2194 // Compares two C strings.  Returns true iff they have the same content.
2195 //
2196 // Unlike strcmp(), this function can handle NULL argument(s).  A NULL
2197 // C string is considered different to any non-NULL C string,
2198 // including the empty string.
2199 bool String::CStringEquals(const char * lhs, const char * rhs) {
2200   if ( lhs == NULL ) return rhs == NULL;
2202   if ( rhs == NULL ) return false;
2204   return strcmp(lhs, rhs) == 0;
2207 #if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
2209 // Converts an array of wide chars to a narrow string using the UTF-8
2210 // encoding, and streams the result to the given Message object.
2211 static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
2212                                      Message* msg) {
2213   // TODO(wan): consider allowing a testing::String object to
2214   // contain '\0'.  This will make it behave more like std::string,
2215   // and will allow ToUtf8String() to return the correct encoding
2216   // for '\0' s.t. we can get rid of the conditional here (and in
2217   // several other places).
2218   for (size_t i = 0; i != length; ) {  // NOLINT
2219     if (wstr[i] != L'\0') {
2220       *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
2221       while (i != length && wstr[i] != L'\0')
2222         i++;
2223     } else {
2224       *msg << '\0';
2225       i++;
2226     }
2227   }
2230 #endif  // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
2232 }  // namespace internal
2234 #if GTEST_HAS_STD_WSTRING
2235 // Converts the given wide string to a narrow string using the UTF-8
2236 // encoding, and streams the result to this Message object.
2237 Message& Message::operator <<(const ::std::wstring& wstr) {
2238   internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
2239   return *this;
2241 #endif  // GTEST_HAS_STD_WSTRING
2243 #if GTEST_HAS_GLOBAL_WSTRING
2244 // Converts the given wide string to a narrow string using the UTF-8
2245 // encoding, and streams the result to this Message object.
2246 Message& Message::operator <<(const ::wstring& wstr) {
2247   internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
2248   return *this;
2250 #endif  // GTEST_HAS_GLOBAL_WSTRING
2252 // AssertionResult constructors.
2253 // Used in EXPECT_TRUE/FALSE(assertion_result).
2254 AssertionResult::AssertionResult(const AssertionResult& other)
2255     : success_(other.success_),
2256       message_(other.message_.get() != NULL ?
2257                new ::std::string(*other.message_) :
2258                static_cast< ::std::string*>(NULL)) {
2261 // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
2262 AssertionResult AssertionResult::operator!() const {
2263   AssertionResult negation(!success_);
2264   if (message_.get() != NULL)
2265     negation << *message_;
2266   return negation;
2269 // Makes a successful assertion result.
2270 AssertionResult AssertionSuccess() {
2271   return AssertionResult(true);
2274 // Makes a failed assertion result.
2275 AssertionResult AssertionFailure() {
2276   return AssertionResult(false);
2279 // Makes a failed assertion result with the given failure message.
2280 // Deprecated; use AssertionFailure() << message.
2281 AssertionResult AssertionFailure(const Message& message) {
2282   return AssertionFailure() << message;
2285 namespace internal {
2287 // Constructs and returns the message for an equality assertion
2288 // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
2289 //
2290 // The first four parameters are the expressions used in the assertion
2291 // and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
2292 // where foo is 5 and bar is 6, we have:
2293 //
2294 //   expected_expression: "foo"
2295 //   actual_expression:   "bar"
2296 //   expected_value:      "5"
2297 //   actual_value:        "6"
2298 //
2299 // The ignoring_case parameter is true iff the assertion is a
2300 // *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
2301 // be inserted into the message.
2302 AssertionResult EqFailure(const char* expected_expression,
2303                           const char* actual_expression,
2304                           const String& expected_value,
2305                           const String& actual_value,
2306                           bool ignoring_case) {
2307   Message msg;
2308   msg << "Value of: " << actual_expression;
2309   if (actual_value != actual_expression) {
2310     msg << "\n  Actual: " << actual_value;
2311   }
2313   msg << "\nExpected: " << expected_expression;
2314   if (ignoring_case) {
2315     msg << " (ignoring case)";
2316   }
2317   if (expected_value != expected_expression) {
2318     msg << "\nWhich is: " << expected_value;
2319   }
2321   return AssertionFailure() << msg;
2324 // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
2325 String GetBoolAssertionFailureMessage(const AssertionResult& assertion_result,
2326                                       const char* expression_text,
2327                                       const char* actual_predicate_value,
2328                                       const char* expected_predicate_value) {
2329   const char* actual_message = assertion_result.message();
2330   Message msg;
2331   msg << "Value of: " << expression_text
2332       << "\n  Actual: " << actual_predicate_value;
2333   if (actual_message[0] != '\0')
2334     msg << " (" << actual_message << ")";
2335   msg << "\nExpected: " << expected_predicate_value;
2336   return msg.GetString();
2339 // Helper function for implementing ASSERT_NEAR.
2340 AssertionResult DoubleNearPredFormat(const char* expr1,
2341                                      const char* expr2,
2342                                      const char* abs_error_expr,
2343                                      double val1,
2344                                      double val2,
2345                                      double abs_error) {
2346   const double diff = fabs(val1 - val2);
2347   if (diff <= abs_error) return AssertionSuccess();
2349   // TODO(wan): do not print the value of an expression if it's
2350   // already a literal.
2351   return AssertionFailure()
2352       << "The difference between " << expr1 << " and " << expr2
2353       << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
2354       << expr1 << " evaluates to " << val1 << ",\n"
2355       << expr2 << " evaluates to " << val2 << ", and\n"
2356       << abs_error_expr << " evaluates to " << abs_error << ".";
2360 // Helper template for implementing FloatLE() and DoubleLE().
2361 template <typename RawType>
2362 AssertionResult FloatingPointLE(const char* expr1,
2363                                 const char* expr2,
2364                                 RawType val1,
2365                                 RawType val2) {
2366   // Returns success if val1 is less than val2,
2367   if (val1 < val2) {
2368     return AssertionSuccess();
2369   }
2371   // or if val1 is almost equal to val2.
2372   const FloatingPoint<RawType> lhs(val1), rhs(val2);
2373   if (lhs.AlmostEquals(rhs)) {
2374     return AssertionSuccess();
2375   }
2377   // Note that the above two checks will both fail if either val1 or
2378   // val2 is NaN, as the IEEE floating-point standard requires that
2379   // any predicate involving a NaN must return false.
2381   ::std::stringstream val1_ss;
2382   val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
2383           << val1;
2385   ::std::stringstream val2_ss;
2386   val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
2387           << val2;
2389   return AssertionFailure()
2390       << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
2391       << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
2392       << StringStreamToString(&val2_ss);
2395 }  // namespace internal
2397 // Asserts that val1 is less than, or almost equal to, val2.  Fails
2398 // otherwise.  In particular, it fails if either val1 or val2 is NaN.
2399 AssertionResult FloatLE(const char* expr1, const char* expr2,
2400                         float val1, float val2) {
2401   return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
2404 // Asserts that val1 is less than, or almost equal to, val2.  Fails
2405 // otherwise.  In particular, it fails if either val1 or val2 is NaN.
2406 AssertionResult DoubleLE(const char* expr1, const char* expr2,
2407                          double val1, double val2) {
2408   return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
2411 namespace internal {
2413 // The helper function for {ASSERT|EXPECT}_EQ with int or enum
2414 // arguments.
2415 AssertionResult CmpHelperEQ(const char* expected_expression,
2416                             const char* actual_expression,
2417                             BiggestInt expected,
2418                             BiggestInt actual) {
2419   if (expected == actual) {
2420     return AssertionSuccess();
2421   }
2423   return EqFailure(expected_expression,
2424                    actual_expression,
2425                    FormatForComparisonFailureMessage(expected, actual),
2426                    FormatForComparisonFailureMessage(actual, expected),
2427                    false);
2430 // A macro for implementing the helper functions needed to implement
2431 // ASSERT_?? and EXPECT_?? with integer or enum arguments.  It is here
2432 // just to avoid copy-and-paste of similar code.
2433 #define GTEST_IMPL_CMP_HELPER_(op_name, op)\
2434 AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
2435                                    BiggestInt val1, BiggestInt val2) {\
2436   if (val1 op val2) {\
2437     return AssertionSuccess();\
2438   } else {\
2439     return AssertionFailure() \
2440         << "Expected: (" << expr1 << ") " #op " (" << expr2\
2441         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
2442         << " vs " << FormatForComparisonFailureMessage(val2, val1);\
2443   }\
2446 // Implements the helper function for {ASSERT|EXPECT}_NE with int or
2447 // enum arguments.
2448 GTEST_IMPL_CMP_HELPER_(NE, !=)
2449 // Implements the helper function for {ASSERT|EXPECT}_LE with int or
2450 // enum arguments.
2451 GTEST_IMPL_CMP_HELPER_(LE, <=)
2452 // Implements the helper function for {ASSERT|EXPECT}_LT with int or
2453 // enum arguments.
2454 GTEST_IMPL_CMP_HELPER_(LT, < )
2455 // Implements the helper function for {ASSERT|EXPECT}_GE with int or
2456 // enum arguments.
2457 GTEST_IMPL_CMP_HELPER_(GE, >=)
2458 // Implements the helper function for {ASSERT|EXPECT}_GT with int or
2459 // enum arguments.
2460 GTEST_IMPL_CMP_HELPER_(GT, > )
2462 #undef GTEST_IMPL_CMP_HELPER_
2464 // The helper function for {ASSERT|EXPECT}_STREQ.
2465 AssertionResult CmpHelperSTREQ(const char* expected_expression,
2466                                const char* actual_expression,
2467                                const char* expected,
2468                                const char* actual) {
2469   if (String::CStringEquals(expected, actual)) {
2470     return AssertionSuccess();
2471   }
2473   return EqFailure(expected_expression,
2474                    actual_expression,
2475                    String::ShowCStringQuoted(expected),
2476                    String::ShowCStringQuoted(actual),
2477                    false);
2480 // The helper function for {ASSERT|EXPECT}_STRCASEEQ.
2481 AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
2482                                    const char* actual_expression,
2483                                    const char* expected,
2484                                    const char* actual) {
2485   if (String::CaseInsensitiveCStringEquals(expected, actual)) {
2486     return AssertionSuccess();
2487   }
2489   return EqFailure(expected_expression,
2490                    actual_expression,
2491                    String::ShowCStringQuoted(expected),
2492                    String::ShowCStringQuoted(actual),
2493                    true);
2496 // The helper function for {ASSERT|EXPECT}_STRNE.
2497 AssertionResult CmpHelperSTRNE(const char* s1_expression,
2498                                const char* s2_expression,
2499                                const char* s1,
2500                                const char* s2) {
2501   if (!String::CStringEquals(s1, s2)) {
2502     return AssertionSuccess();
2503   } else {
2504     return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
2505                               << s2_expression << "), actual: \""
2506                               << s1 << "\" vs \"" << s2 << "\"";
2507   }
2510 // The helper function for {ASSERT|EXPECT}_STRCASENE.
2511 AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
2512                                    const char* s2_expression,
2513                                    const char* s1,
2514                                    const char* s2) {
2515   if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
2516     return AssertionSuccess();
2517   } else {
2518     return AssertionFailure()
2519         << "Expected: (" << s1_expression << ") != ("
2520         << s2_expression << ") (ignoring case), actual: \""
2521         << s1 << "\" vs \"" << s2 << "\"";
2522   }
2525 }  // namespace internal
2527 namespace {
2529 // Helper functions for implementing IsSubString() and IsNotSubstring().
2531 // This group of overloaded functions return true iff needle is a
2532 // substring of haystack.  NULL is considered a substring of itself
2533 // only.
2535 bool IsSubstringPred(const char* needle, const char* haystack) {
2536   if (needle == NULL || haystack == NULL)
2537     return needle == haystack;
2539   return strstr(haystack, needle) != NULL;
2542 bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
2543   if (needle == NULL || haystack == NULL)
2544     return needle == haystack;
2546   return wcsstr(haystack, needle) != NULL;
2549 // StringType here can be either ::std::string or ::std::wstring.
2550 template <typename StringType>
2551 bool IsSubstringPred(const StringType& needle,
2552                      const StringType& haystack) {
2553   return haystack.find(needle) != StringType::npos;
2556 // This function implements either IsSubstring() or IsNotSubstring(),
2557 // depending on the value of the expected_to_be_substring parameter.
2558 // StringType here can be const char*, const wchar_t*, ::std::string,
2559 // or ::std::wstring.
2560 template <typename StringType>
2561 AssertionResult IsSubstringImpl(
2562     bool expected_to_be_substring,
2563     const char* needle_expr, const char* haystack_expr,
2564     const StringType& needle, const StringType& haystack) {
2565   if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
2566     return AssertionSuccess();
2568   const bool is_wide_string = sizeof(needle[0]) > 1;
2569   const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
2570   return AssertionFailure()
2571       << "Value of: " << needle_expr << "\n"
2572       << "  Actual: " << begin_string_quote << needle << "\"\n"
2573       << "Expected: " << (expected_to_be_substring ? "" : "not ")
2574       << "a substring of " << haystack_expr << "\n"
2575       << "Which is: " << begin_string_quote << haystack << "\"";
2578 }  // namespace
2580 // IsSubstring() and IsNotSubstring() check whether needle is a
2581 // substring of haystack (NULL is considered a substring of itself
2582 // only), and return an appropriate error message when they fail.
2584 AssertionResult IsSubstring(
2585     const char* needle_expr, const char* haystack_expr,
2586     const char* needle, const char* haystack) {
2587   return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
2590 AssertionResult IsSubstring(
2591     const char* needle_expr, const char* haystack_expr,
2592     const wchar_t* needle, const wchar_t* haystack) {
2593   return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
2596 AssertionResult IsNotSubstring(
2597     const char* needle_expr, const char* haystack_expr,
2598     const char* needle, const char* haystack) {
2599   return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
2602 AssertionResult IsNotSubstring(
2603     const char* needle_expr, const char* haystack_expr,
2604     const wchar_t* needle, const wchar_t* haystack) {
2605   return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
2608 AssertionResult IsSubstring(
2609     const char* needle_expr, const char* haystack_expr,
2610     const ::std::string& needle, const ::std::string& haystack) {
2611   return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
2614 AssertionResult IsNotSubstring(
2615     const char* needle_expr, const char* haystack_expr,
2616     const ::std::string& needle, const ::std::string& haystack) {
2617   return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
2620 #if GTEST_HAS_STD_WSTRING
2621 AssertionResult IsSubstring(
2622     const char* needle_expr, const char* haystack_expr,
2623     const ::std::wstring& needle, const ::std::wstring& haystack) {
2624   return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
2627 AssertionResult IsNotSubstring(
2628     const char* needle_expr, const char* haystack_expr,
2629     const ::std::wstring& needle, const ::std::wstring& haystack) {
2630   return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
2632 #endif  // GTEST_HAS_STD_WSTRING
2634 namespace internal {
2636 #if GTEST_OS_WINDOWS
2638 namespace {
2640 // Helper function for IsHRESULT{SuccessFailure} predicates
2641 AssertionResult HRESULTFailureHelper(const char* expr,
2642                                      const char* expected,
2643                                      long hr) {  // NOLINT
2644 # if GTEST_OS_WINDOWS_MOBILE
2646   // Windows CE doesn't support FormatMessage.
2647   const char error_text[] = "";
2649 # else
2651   // Looks up the human-readable system message for the HRESULT code
2652   // and since we're not passing any params to FormatMessage, we don't
2653   // want inserts expanded.
2654   const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
2655                        FORMAT_MESSAGE_IGNORE_INSERTS;
2656   const DWORD kBufSize = 4096;  // String::Format can't exceed this length.
2657   // Gets the system's human readable message string for this HRESULT.
2658   char error_text[kBufSize] = { '\0' };
2659   DWORD message_length = ::FormatMessageA(kFlags,
2660                                           0,  // no source, we're asking system
2661                                           hr,  // the error
2662                                           0,  // no line width restrictions
2663                                           error_text,  // output buffer
2664                                           kBufSize,  // buf size
2665                                           NULL);  // no arguments for inserts
2666   // Trims tailing white space (FormatMessage leaves a trailing cr-lf)
2667   for (; message_length && IsSpace(error_text[message_length - 1]);
2668           --message_length) {
2669     error_text[message_length - 1] = '\0';
2670   }
2672 # endif  // GTEST_OS_WINDOWS_MOBILE
2674   const String error_hex(String::Format("0x%08X ", hr));
2675   return ::testing::AssertionFailure()
2676       << "Expected: " << expr << " " << expected << ".\n"
2677       << "  Actual: " << error_hex << error_text << "\n";
2680 }  // namespace
2682 AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
2683   if (SUCCEEDED(hr)) {
2684     return AssertionSuccess();
2685   }
2686   return HRESULTFailureHelper(expr, "succeeds", hr);
2689 AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
2690   if (FAILED(hr)) {
2691     return AssertionSuccess();
2692   }
2693   return HRESULTFailureHelper(expr, "fails", hr);
2696 #endif  // GTEST_OS_WINDOWS
2698 // Utility functions for encoding Unicode text (wide strings) in
2699 // UTF-8.
2701 // A Unicode code-point can have upto 21 bits, and is encoded in UTF-8
2702 // like this:
2703 //
2704 // Code-point length   Encoding
2705 //   0 -  7 bits       0xxxxxxx
2706 //   8 - 11 bits       110xxxxx 10xxxxxx
2707 //  12 - 16 bits       1110xxxx 10xxxxxx 10xxxxxx
2708 //  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
2710 // The maximum code-point a one-byte UTF-8 sequence can represent.
2711 const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) <<  7) - 1;
2713 // The maximum code-point a two-byte UTF-8 sequence can represent.
2714 const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1;
2716 // The maximum code-point a three-byte UTF-8 sequence can represent.
2717 const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1;
2719 // The maximum code-point a four-byte UTF-8 sequence can represent.
2720 const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1;
2722 // Chops off the n lowest bits from a bit pattern.  Returns the n
2723 // lowest bits.  As a side effect, the original bit pattern will be
2724 // shifted to the right by n bits.
2725 inline UInt32 ChopLowBits(UInt32* bits, int n) {
2726   const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1);
2727   *bits >>= n;
2728   return low_bits;
2731 // Converts a Unicode code point to a narrow string in UTF-8 encoding.
2732 // code_point parameter is of type UInt32 because wchar_t may not be
2733 // wide enough to contain a code point.
2734 // The output buffer str must containt at least 32 characters.
2735 // The function returns the address of the output buffer.
2736 // If the code_point is not a valid Unicode code point
2737 // (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output
2738 // as '(Invalid Unicode 0xXXXXXXXX)'.
2739 char* CodePointToUtf8(UInt32 code_point, char* str) {
2740   if (code_point <= kMaxCodePoint1) {
2741     str[1] = '\0';
2742     str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
2743   } else if (code_point <= kMaxCodePoint2) {
2744     str[2] = '\0';
2745     str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
2746     str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
2747   } else if (code_point <= kMaxCodePoint3) {
2748     str[3] = '\0';
2749     str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
2750     str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
2751     str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
2752   } else if (code_point <= kMaxCodePoint4) {
2753     str[4] = '\0';
2754     str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
2755     str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
2756     str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
2757     str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
2758   } else {
2759     // The longest string String::Format can produce when invoked
2760     // with these parameters is 28 character long (not including
2761     // the terminating nul character). We are asking for 32 character
2762     // buffer just in case. This is also enough for strncpy to
2763     // null-terminate the destination string.
2764     posix::StrNCpy(
2765         str, String::Format("(Invalid Unicode 0x%X)", code_point).c_str(), 32);
2766     str[31] = '\0';  // Makes sure no change in the format to strncpy leaves
2767                      // the result unterminated.
2768   }
2769   return str;
2772 // The following two functions only make sense if the the system
2773 // uses UTF-16 for wide string encoding. All supported systems
2774 // with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16.
2776 // Determines if the arguments constitute UTF-16 surrogate pair
2777 // and thus should be combined into a single Unicode code point
2778 // using CreateCodePointFromUtf16SurrogatePair.
2779 inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
2780   return sizeof(wchar_t) == 2 &&
2781       (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
2784 // Creates a Unicode code point from UTF16 surrogate pair.
2785 inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
2786                                                     wchar_t second) {
2787   const UInt32 mask = (1 << 10) - 1;
2788   return (sizeof(wchar_t) == 2) ?
2789       (((first & mask) << 10) | (second & mask)) + 0x10000 :
2790       // This function should not be called when the condition is
2791       // false, but we provide a sensible default in case it is.
2792       static_cast<UInt32>(first);
2795 // Converts a wide string to a narrow string in UTF-8 encoding.
2796 // The wide string is assumed to have the following encoding:
2797 //   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS)
2798 //   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
2799 // Parameter str points to a null-terminated wide string.
2800 // Parameter num_chars may additionally limit the number
2801 // of wchar_t characters processed. -1 is used when the entire string
2802 // should be processed.
2803 // If the string contains code points that are not valid Unicode code points
2804 // (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
2805 // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
2806 // and contains invalid UTF-16 surrogate pairs, values in those pairs
2807 // will be encoded as individual Unicode characters from Basic Normal Plane.
2808 String WideStringToUtf8(const wchar_t* str, int num_chars) {
2809   if (num_chars == -1)
2810     num_chars = static_cast<int>(wcslen(str));
2812   ::std::stringstream stream;
2813   for (int i = 0; i < num_chars; ++i) {
2814     UInt32 unicode_code_point;
2816     if (str[i] == L'\0') {
2817       break;
2818     } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
2819       unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
2820                                                                  str[i + 1]);
2821       i++;
2822     } else {
2823       unicode_code_point = static_cast<UInt32>(str[i]);
2824     }
2826     char buffer[32];  // CodePointToUtf8 requires a buffer this big.
2827     stream << CodePointToUtf8(unicode_code_point, buffer);
2828   }
2829   return StringStreamToString(&stream);
2832 // Converts a wide C string to a String using the UTF-8 encoding.
2833 // NULL will be converted to "(null)".
2834 String String::ShowWideCString(const wchar_t * wide_c_str) {
2835   if (wide_c_str == NULL) return String("(null)");
2837   return String(internal::WideStringToUtf8(wide_c_str, -1).c_str());
2840 // Similar to ShowWideCString(), except that this function encloses
2841 // the converted string in double quotes.
2842 String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
2843   if (wide_c_str == NULL) return String("(null)");
2845   return String::Format("L\"%s\"",
2846                         String::ShowWideCString(wide_c_str).c_str());
2849 // Compares two wide C strings.  Returns true iff they have the same
2850 // content.
2851 //
2852 // Unlike wcscmp(), this function can handle NULL argument(s).  A NULL
2853 // C string is considered different to any non-NULL C string,
2854 // including the empty string.
2855 bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
2856   if (lhs == NULL) return rhs == NULL;
2858   if (rhs == NULL) return false;
2860   return wcscmp(lhs, rhs) == 0;
2863 // Helper function for *_STREQ on wide strings.
2864 AssertionResult CmpHelperSTREQ(const char* expected_expression,
2865                                const char* actual_expression,
2866                                const wchar_t* expected,
2867                                const wchar_t* actual) {
2868   if (String::WideCStringEquals(expected, actual)) {
2869     return AssertionSuccess();
2870   }
2872   return EqFailure(expected_expression,
2873                    actual_expression,
2874                    String::ShowWideCStringQuoted(expected),
2875                    String::ShowWideCStringQuoted(actual),
2876                    false);
2879 // Helper function for *_STRNE on wide strings.
2880 AssertionResult CmpHelperSTRNE(const char* s1_expression,
2881                                const char* s2_expression,
2882                                const wchar_t* s1,
2883                                const wchar_t* s2) {
2884   if (!String::WideCStringEquals(s1, s2)) {
2885     return AssertionSuccess();
2886   }
2888   return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
2889                             << s2_expression << "), actual: "
2890                             << String::ShowWideCStringQuoted(s1)
2891                             << " vs " << String::ShowWideCStringQuoted(s2);
2894 // Compares two C strings, ignoring case.  Returns true iff they have
2895 // the same content.
2896 //
2897 // Unlike strcasecmp(), this function can handle NULL argument(s).  A
2898 // NULL C string is considered different to any non-NULL C string,
2899 // including the empty string.
2900 bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
2901   if (lhs == NULL)
2902     return rhs == NULL;
2903   if (rhs == NULL)
2904     return false;
2905   return posix::StrCaseCmp(lhs, rhs) == 0;
2908   // Compares two wide C strings, ignoring case.  Returns true iff they
2909   // have the same content.
2910   //
2911   // Unlike wcscasecmp(), this function can handle NULL argument(s).
2912   // A NULL C string is considered different to any non-NULL wide C string,
2913   // including the empty string.
2914   // NB: The implementations on different platforms slightly differ.
2915   // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
2916   // environment variable. On GNU platform this method uses wcscasecmp
2917   // which compares according to LC_CTYPE category of the current locale.
2918   // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
2919   // current locale.
2920 bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
2921                                               const wchar_t* rhs) {
2922   if (lhs == NULL) return rhs == NULL;
2924   if (rhs == NULL) return false;
2926 #if GTEST_OS_WINDOWS
2927   return _wcsicmp(lhs, rhs) == 0;
2928 #elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
2929   return wcscasecmp(lhs, rhs) == 0;
2930 #else
2931   // Android, Mac OS X and Cygwin don't define wcscasecmp.
2932   // Other unknown OSes may not define it either.
2933   wint_t left, right;
2934   do {
2935     left = towlower(*lhs++);
2936     right = towlower(*rhs++);
2937   } while (left && left == right);
2938   return left == right;
2939 #endif  // OS selector
2942 // Compares this with another String.
2943 // Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
2944 // if this is greater than rhs.
2945 int String::Compare(const String & rhs) const {
2946   const char* const lhs_c_str = c_str();
2947   const char* const rhs_c_str = rhs.c_str();
2949   if (lhs_c_str == NULL) {
2950     return rhs_c_str == NULL ? 0 : -1;  // NULL < anything except NULL
2951   } else if (rhs_c_str == NULL) {
2952     return 1;
2953   }
2955   const size_t shorter_str_len =
2956       length() <= rhs.length() ? length() : rhs.length();
2957   for (size_t i = 0; i != shorter_str_len; i++) {
2958     if (lhs_c_str[i] < rhs_c_str[i]) {
2959       return -1;
2960     } else if (lhs_c_str[i] > rhs_c_str[i]) {
2961       return 1;
2962     }
2963   }
2964   return (length() < rhs.length()) ? -1 :
2965       (length() > rhs.length()) ? 1 : 0;
2968 // Returns true iff this String ends with the given suffix.  *Any*
2969 // String is considered to end with a NULL or empty suffix.
2970 bool String::EndsWith(const char* suffix) const {
2971   if (suffix == NULL || CStringEquals(suffix, "")) return true;
2973   if (c_str() == NULL) return false;
2975   const size_t this_len = strlen(c_str());
2976   const size_t suffix_len = strlen(suffix);
2977   return (this_len >= suffix_len) &&
2978          CStringEquals(c_str() + this_len - suffix_len, suffix);
2981 // Returns true iff this String ends with the given suffix, ignoring case.
2982 // Any String is considered to end with a NULL or empty suffix.
2983 bool String::EndsWithCaseInsensitive(const char* suffix) const {
2984   if (suffix == NULL || CStringEquals(suffix, "")) return true;
2986   if (c_str() == NULL) return false;
2988   const size_t this_len = strlen(c_str());
2989   const size_t suffix_len = strlen(suffix);
2990   return (this_len >= suffix_len) &&
2991          CaseInsensitiveCStringEquals(c_str() + this_len - suffix_len, suffix);
2994 // Formats a list of arguments to a String, using the same format
2995 // spec string as for printf.
2996 //
2997 // We do not use the StringPrintf class as it is not universally
2998 // available.
2999 //
3000 // The result is limited to 4096 characters (including the tailing 0).
3001 // If 4096 characters are not enough to format the input, or if
3002 // there's an error, "<formatting error or buffer exceeded>" is
3003 // returned.
3004 String String::Format(const char * format, ...) {
3005   va_list args;
3006   va_start(args, format);
3008   char buffer[4096];
3009   const int kBufferSize = sizeof(buffer)/sizeof(buffer[0]);
3011   // MSVC 8 deprecates vsnprintf(), so we want to suppress warning
3012   // 4996 (deprecated function) there.
3013 #ifdef _MSC_VER  // We are using MSVC.
3014 # pragma warning(push)          // Saves the current warning state.
3015 # pragma warning(disable:4996)  // Temporarily disables warning 4996.
3017   const int size = vsnprintf(buffer, kBufferSize, format, args);
3019 # pragma warning(pop)           // Restores the warning state.
3020 #else  // We are not using MSVC.
3021   const int size = vsnprintf(buffer, kBufferSize, format, args);
3022 #endif  // _MSC_VER
3023   va_end(args);
3025   // vsnprintf()'s behavior is not portable.  When the buffer is not
3026   // big enough, it returns a negative value in MSVC, and returns the
3027   // needed buffer size on Linux.  When there is an output error, it
3028   // always returns a negative value.  For simplicity, we lump the two
3029   // error cases together.
3030   if (size < 0 || size >= kBufferSize) {
3031     return String("<formatting error or buffer exceeded>");
3032   } else {
3033     return String(buffer, size);
3034   }
3037 // Converts the buffer in a stringstream to a String, converting NUL
3038 // bytes to "\\0" along the way.
3039 String StringStreamToString(::std::stringstream* ss) {
3040   const ::std::string& str = ss->str();
3041   const char* const start = str.c_str();
3042   const char* const end = start + str.length();
3044   // We need to use a helper stringstream to do this transformation
3045   // because String doesn't support push_back().
3046   ::std::stringstream helper;
3047   for (const char* ch = start; ch != end; ++ch) {
3048     if (*ch == '\0') {
3049       helper << "\\0";  // Replaces NUL with "\\0";
3050     } else {
3051       helper.put(*ch);
3052     }
3053   }
3055   return String(helper.str().c_str());
3058 // Appends the user-supplied message to the Google-Test-generated message.
3059 String AppendUserMessage(const String& gtest_msg,
3060                          const Message& user_msg) {
3061   // Appends the user message if it's non-empty.
3062   const String user_msg_string = user_msg.GetString();
3063   if (user_msg_string.empty()) {
3064     return gtest_msg;
3065   }
3067   Message msg;
3068   msg << gtest_msg << "\n" << user_msg_string;
3070   return msg.GetString();
3073 }  // namespace internal
3075 // class TestResult
3077 // Creates an empty TestResult.
3078 TestResult::TestResult()
3079     : death_test_count_(0),
3080       elapsed_time_(0) {
3083 // D'tor.
3084 TestResult::~TestResult() {
3087 // Returns the i-th test part result among all the results. i can
3088 // range from 0 to total_part_count() - 1. If i is not in that range,
3089 // aborts the program.
3090 const TestPartResult& TestResult::GetTestPartResult(int i) const {
3091   if (i < 0 || i >= total_part_count())
3092     internal::posix::Abort();
3093   return test_part_results_.at(i);
3096 // Returns the i-th test property. i can range from 0 to
3097 // test_property_count() - 1. If i is not in that range, aborts the
3098 // program.
3099 const TestProperty& TestResult::GetTestProperty(int i) const {
3100   if (i < 0 || i >= test_property_count())
3101     internal::posix::Abort();
3102   return test_properties_.at(i);
3105 // Clears the test part results.
3106 void TestResult::ClearTestPartResults() {
3107   test_part_results_.clear();
3110 // Adds a test part result to the list.
3111 void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
3112   test_part_results_.push_back(test_part_result);
3115 // Adds a test property to the list. If a property with the same key as the
3116 // supplied property is already represented, the value of this test_property
3117 // replaces the old value for that key.
3118 void TestResult::RecordProperty(const TestProperty& test_property) {
3119   if (!ValidateTestProperty(test_property)) {
3120     return;
3121   }
3122   internal::MutexLock lock(&test_properites_mutex_);
3123   const std::vector<TestProperty>::iterator property_with_matching_key =
3124       std::find_if(test_properties_.begin(), test_properties_.end(),
3125                    internal::TestPropertyKeyIs(test_property.key()));
3126   if (property_with_matching_key == test_properties_.end()) {
3127     test_properties_.push_back(test_property);
3128     return;
3129   }
3130   property_with_matching_key->SetValue(test_property.value());
3133 // Adds a failure if the key is a reserved attribute of Google Test
3134 // testcase tags.  Returns true if the property is valid.
3135 bool TestResult::ValidateTestProperty(const TestProperty& test_property) {
3136   internal::String key(test_property.key());
3137   if (key == "name" || key == "status" || key == "time" || key == "classname") {
3138     ADD_FAILURE()
3139         << "Reserved key used in RecordProperty(): "
3140         << key
3141         << " ('name', 'status', 'time', and 'classname' are reserved by "
3142         << GTEST_NAME_ << ")";
3143     return false;
3144   }
3145   return true;
3148 // Clears the object.
3149 void TestResult::Clear() {
3150   test_part_results_.clear();
3151   test_properties_.clear();
3152   death_test_count_ = 0;
3153   elapsed_time_ = 0;
3156 // Returns true iff the test failed.
3157 bool TestResult::Failed() const {
3158   for (int i = 0; i < total_part_count(); ++i) {
3159     if (GetTestPartResult(i).failed())
3160       return true;
3161   }
3162   return false;
3165 // Returns true iff the test part fatally failed.
3166 static bool TestPartFatallyFailed(const TestPartResult& result) {
3167   return result.fatally_failed();
3170 // Returns true iff the test fatally failed.
3171 bool TestResult::HasFatalFailure() const {
3172   return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
3175 // Returns true iff the test part non-fatally failed.
3176 static bool TestPartNonfatallyFailed(const TestPartResult& result) {
3177   return result.nonfatally_failed();
3180 // Returns true iff the test has a non-fatal failure.
3181 bool TestResult::HasNonfatalFailure() const {
3182   return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
3185 // Gets the number of all test parts.  This is the sum of the number
3186 // of successful test parts and the number of failed test parts.
3187 int TestResult::total_part_count() const {
3188   return static_cast<int>(test_part_results_.size());
3191 // Returns the number of the test properties.
3192 int TestResult::test_property_count() const {
3193   return static_cast<int>(test_properties_.size());
3196 // class Test
3198 // Creates a Test object.
3200 // The c'tor saves the values of all Google Test flags.
3201 Test::Test()
3202     : gtest_flag_saver_(new internal::GTestFlagSaver) {
3205 // The d'tor restores the values of all Google Test flags.
3206 Test::~Test() {
3207   delete gtest_flag_saver_;
3210 // Sets up the test fixture.
3211 //
3212 // A sub-class may override this.
3213 void Test::SetUp() {
3216 // Tears down the test fixture.
3217 //
3218 // A sub-class may override this.
3219 void Test::TearDown() {
3222 // Allows user supplied key value pairs to be recorded for later output.
3223 void Test::RecordProperty(const char* key, const char* value) {
3224   UnitTest::GetInstance()->RecordPropertyForCurrentTest(key, value);
3227 // Allows user supplied key value pairs to be recorded for later output.
3228 void Test::RecordProperty(const char* key, int value) {
3229   Message value_message;
3230   value_message << value;
3231   RecordProperty(key, value_message.GetString().c_str());
3234 namespace internal {
3236 void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
3237                                     const String& message) {
3238   // This function is a friend of UnitTest and as such has access to
3239   // AddTestPartResult.
3240   UnitTest::GetInstance()->AddTestPartResult(
3241       result_type,
3242       NULL,  // No info about the source file where the exception occurred.
3243       -1,    // We have no info on which line caused the exception.
3244       message,
3245       String());  // No stack trace, either.
3248 }  // namespace internal
3250 // Google Test requires all tests in the same test case to use the same test
3251 // fixture class.  This function checks if the current test has the
3252 // same fixture class as the first test in the current test case.  If
3253 // yes, it returns true; otherwise it generates a Google Test failure and
3254 // returns false.
3255 bool Test::HasSameFixtureClass() {
3256   internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
3257   const TestCase* const test_case = impl->current_test_case();
3259   // Info about the first test in the current test case.
3260   const TestInfo* const first_test_info = test_case->test_info_list()[0];
3261   const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
3262   const char* const first_test_name = first_test_info->name();
3264   // Info about the current test.
3265   const TestInfo* const this_test_info = impl->current_test_info();
3266   const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
3267   const char* const this_test_name = this_test_info->name();
3269   if (this_fixture_id != first_fixture_id) {
3270     // Is the first test defined using TEST?
3271     const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
3272     // Is this test defined using TEST?
3273     const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
3275     if (first_is_TEST || this_is_TEST) {
3276       // The user mixed TEST and TEST_F in this test case - we'll tell
3277       // him/her how to fix it.
3279       // Gets the name of the TEST and the name of the TEST_F.  Note
3280       // that first_is_TEST and this_is_TEST cannot both be true, as
3281       // the fixture IDs are different for the two tests.
3282       const char* const TEST_name =
3283           first_is_TEST ? first_test_name : this_test_name;
3284       const char* const TEST_F_name =
3285           first_is_TEST ? this_test_name : first_test_name;
3287       ADD_FAILURE()
3288           << "All tests in the same test case must use the same test fixture\n"
3289           << "class, so mixing TEST_F and TEST in the same test case is\n"
3290           << "illegal.  In test case " << this_test_info->test_case_name()
3291           << ",\n"
3292           << "test " << TEST_F_name << " is defined using TEST_F but\n"
3293           << "test " << TEST_name << " is defined using TEST.  You probably\n"
3294           << "want to change the TEST to TEST_F or move it to another test\n"
3295           << "case.";
3296     } else {
3297       // The user defined two fixture classes with the same name in
3298       // two namespaces - we'll tell him/her how to fix it.
3299       ADD_FAILURE()
3300           << "All tests in the same test case must use the same test fixture\n"
3301           << "class.  However, in test case "
3302           << this_test_info->test_case_name() << ",\n"
3303           << "you defined test " << first_test_name
3304           << " and test " << this_test_name << "\n"
3305           << "using two different test fixture classes.  This can happen if\n"
3306           << "the two classes are from different namespaces or translation\n"
3307           << "units and have the same name.  You should probably rename one\n"
3308           << "of the classes to put the tests into different test cases.";
3309     }
3310     return false;
3311   }
3313   return true;
3316 #if GTEST_HAS_SEH
3318 // Adds an "exception thrown" fatal failure to the current test.  This
3319 // function returns its result via an output parameter pointer because VC++
3320 // prohibits creation of objects with destructors on stack in functions
3321 // using __try (see error C2712).
3322 static internal::String* FormatSehExceptionMessage(DWORD exception_code,
3323                                                    const char* location) {
3324   Message message;
3325   message << "SEH exception with code 0x" << std::setbase(16) <<
3326     exception_code << std::setbase(10) << " thrown in " << location << ".";
3328   return new internal::String(message.GetString());
3331 #endif  // GTEST_HAS_SEH
3333 #if GTEST_HAS_EXCEPTIONS
3335 // Adds an "exception thrown" fatal failure to the current test.
3336 static internal::String FormatCxxExceptionMessage(const char* description,
3337                                                   const char* location) {
3338   Message message;
3339   if (description != NULL) {
3340     message << "C++ exception with description \"" << description << "\"";
3341   } else {
3342     message << "Unknown C++ exception";
3343   }
3344   message << " thrown in " << location << ".";
3346   return message.GetString();
3349 static internal::String PrintTestPartResultToString(
3350     const TestPartResult& test_part_result);
3352 // A failed Google Test assertion will throw an exception of this type when
3353 // GTEST_FLAG(throw_on_failure) is true (if exceptions are enabled).  We
3354 // derive it from std::runtime_error, which is for errors presumably
3355 // detectable only at run time.  Since std::runtime_error inherits from
3356 // std::exception, many testing frameworks know how to extract and print the
3357 // message inside it.
3358 class GoogleTestFailureException : public ::std::runtime_error {
3359  public:
3360   explicit GoogleTestFailureException(const TestPartResult& failure)
3361       : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
3362 };
3363 #endif  // GTEST_HAS_EXCEPTIONS
3365 namespace internal {
3366 // We put these helper functions in the internal namespace as IBM's xlC
3367 // compiler rejects the code if they were declared static.
3369 // Runs the given method and handles SEH exceptions it throws, when
3370 // SEH is supported; returns the 0-value for type Result in case of an
3371 // SEH exception.  (Microsoft compilers cannot handle SEH and C++
3372 // exceptions in the same function.  Therefore, we provide a separate
3373 // wrapper function for handling SEH exceptions.)
3374 template <class T, typename Result>
3375 Result HandleSehExceptionsInMethodIfSupported(
3376     T* object, Result (T::*method)(), const char* location) {
3377 #if GTEST_HAS_SEH
3378   __try {
3379     return (object->*method)();
3380   } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
3381       GetExceptionCode())) {
3382     // We create the exception message on the heap because VC++ prohibits
3383     // creation of objects with destructors on stack in functions using __try
3384     // (see error C2712).
3385     internal::String* exception_message = FormatSehExceptionMessage(
3386         GetExceptionCode(), location);
3387     internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
3388                                              *exception_message);
3389     delete exception_message;
3390     return static_cast<Result>(0);
3391   }
3392 #else
3393   (void)location;
3394   return (object->*method)();
3395 #endif  // GTEST_HAS_SEH
3398 // Runs the given method and catches and reports C++ and/or SEH-style
3399 // exceptions, if they are supported; returns the 0-value for type
3400 // Result in case of an SEH exception.
3401 template <class T, typename Result>
3402 Result HandleExceptionsInMethodIfSupported(
3403     T* object, Result (T::*method)(), const char* location) {
3404   // NOTE: The user code can affect the way in which Google Test handles
3405   // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
3406   // RUN_ALL_TESTS() starts. It is technically possible to check the flag
3407   // after the exception is caught and either report or re-throw the
3408   // exception based on the flag's value:
3409   //
3410   // try {
3411   //   // Perform the test method.
3412   // } catch (...) {
3413   //   if (GTEST_FLAG(catch_exceptions))
3414   //     // Report the exception as failure.
3415   //   else
3416   //     throw;  // Re-throws the original exception.
3417   // }
3418   //
3419   // However, the purpose of this flag is to allow the program to drop into
3420   // the debugger when the exception is thrown. On most platforms, once the
3421   // control enters the catch block, the exception origin information is
3422   // lost and the debugger will stop the program at the point of the
3423   // re-throw in this function -- instead of at the point of the original
3424   // throw statement in the code under test.  For this reason, we perform
3425   // the check early, sacrificing the ability to affect Google Test's
3426   // exception handling in the method where the exception is thrown.
3427   if (internal::GetUnitTestImpl()->catch_exceptions()) {
3428 #if GTEST_HAS_EXCEPTIONS
3429     try {
3430       return HandleSehExceptionsInMethodIfSupported(object, method, location);
3431     } catch (const GoogleTestFailureException&) {  // NOLINT
3432       // This exception doesn't originate in code under test. It makes no
3433       // sense to report it as a test failure.