1 // Copyright 2005, Google Inc. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above 11 // copyright notice, this list of conditions and the following disclaimer 12 // in the documentation and/or other materials provided with the 13 // distribution. 14 // * Neither the name of Google Inc. nor the names of its 15 // contributors may be used to endorse or promote products derived from 16 // this software without specific prior written permission. 17 // 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30 // Utility functions and classes used by the Google C++ testing framework. 31 // 32 // Author: wan (at) google.com (Zhanyong Wan) 33 // 34 // This file contains purely Google Test's internal implementation. Please 35 // DO NOT #INCLUDE IT IN A USER PROGRAM. 36 37 #ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_ 38 #define GTEST_SRC_GTEST_INTERNAL_INL_H_ 39 40 // GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is 41 // part of Google Test's implementation; otherwise it's undefined. 42 #if !GTEST_IMPLEMENTATION_ 43 // A user is trying to include this from his code - just say no. 44 # error "gtest-internal-inl.h is part of Google Test's internal implementation." 45 # error "It must not be included except by Google Test itself." 46 #endif // GTEST_IMPLEMENTATION_ 47 48 #ifndef _WIN32_WCE 49 # include <errno.h> 50 #endif // !_WIN32_WCE 51 #include <stddef.h> 52 #include <stdlib.h> // For strtoll/_strtoul64/malloc/free. 53 #include <string.h> // For memmove. 54 55 #include <algorithm> 56 #include <string> 57 #include <vector> 58 59 #include "gtest/internal/gtest-port.h" 60 61 #if GTEST_OS_WINDOWS 62 # include <windows.h> // NOLINT 63 #endif // GTEST_OS_WINDOWS 64 65 #include "gtest/gtest.h" // NOLINT 66 #include "gtest/gtest-spi.h" 67 68 namespace testing { 69 70 // Declares the flags. 71 // 72 // We don't want the users to modify this flag in the code, but want 73 // Google Test's own unit tests to be able to access it. Therefore we 74 // declare it here as opposed to in gtest.h. 75 GTEST_DECLARE_bool_(death_test_use_fork); 76 77 namespace internal { 78 79 // The value of GetTestTypeId() as seen from within the Google Test 80 // library. This is solely for testing GetTestTypeId(). 81 GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest; 82 83 // Names of the flags (needed for parsing Google Test flags). 84 const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests"; 85 const char kBreakOnFailureFlag[] = "break_on_failure"; 86 const char kCatchExceptionsFlag[] = "catch_exceptions"; 87 const char kColorFlag[] = "color"; 88 const char kFilterFlag[] = "filter"; 89 const char kListTestsFlag[] = "list_tests"; 90 const char kOutputFlag[] = "output"; 91 const char kPrintTimeFlag[] = "print_time"; 92 const char kRandomSeedFlag[] = "random_seed"; 93 const char kRepeatFlag[] = "repeat"; 94 const char kShuffleFlag[] = "shuffle"; 95 const char kStackTraceDepthFlag[] = "stack_trace_depth"; 96 const char kStreamResultToFlag[] = "stream_result_to"; 97 const char kThrowOnFailureFlag[] = "throw_on_failure"; 98 99 // A valid random seed must be in [1, kMaxRandomSeed]. 100 const int kMaxRandomSeed = 99999; 101 102 // g_help_flag is true iff the --help flag or an equivalent form is 103 // specified on the command line. 104 GTEST_API_ extern bool g_help_flag; 105 106 // Returns the current time in milliseconds. 107 GTEST_API_ TimeInMillis GetTimeInMillis(); 108 109 // Returns true iff Google Test should use colors in the output. 110 GTEST_API_ bool ShouldUseColor(bool stdout_is_tty); 111 112 // Formats the given time in milliseconds as seconds. 113 GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms); 114 115 // Parses a string for an Int32 flag, in the form of "--flag=value". 116 // 117 // On success, stores the value of the flag in *value, and returns 118 // true. On failure, returns false without changing *value. 119 GTEST_API_ bool ParseInt32Flag( 120 const char* str, const char* flag, Int32* value); 121 122 // Returns a random seed in range [1, kMaxRandomSeed] based on the 123 // given --gtest_random_seed flag value. 124 inline int GetRandomSeedFromFlag(Int32 random_seed_flag) { 125 const unsigned int raw_seed = (random_seed_flag == 0) ? 126 static_cast<unsigned int>(GetTimeInMillis()) : 127 static_cast<unsigned int>(random_seed_flag); 128 129 // Normalizes the actual seed to range [1, kMaxRandomSeed] such that 130 // it's easy to type. 131 const int normalized_seed = 132 static_cast<int>((raw_seed - 1U) % 133 static_cast<unsigned int>(kMaxRandomSeed)) + 1; 134 return normalized_seed; 135 } 136 137 // Returns the first valid random seed after 'seed'. The behavior is 138 // undefined if 'seed' is invalid. The seed after kMaxRandomSeed is 139 // considered to be 1. 140 inline int GetNextRandomSeed(int seed) { 141 GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed) 142 << "Invalid random seed " << seed << " - must be in [1, " 143 << kMaxRandomSeed << "]."; 144 const int next_seed = seed + 1; 145 return (next_seed > kMaxRandomSeed) ? 1 : next_seed; 146 } 147 148 // This class saves the values of all Google Test flags in its c'tor, and 149 // restores them in its d'tor. 150 class GTestFlagSaver { 151 public: 152 // The c'tor. 153 GTestFlagSaver() { 154 color_ = GTEST_FLAG(color); 155 death_test_style_ = GTEST_FLAG(death_test_style); 156 filter_ = GTEST_FLAG(filter); 157 internal_run_death_test_ = GTEST_FLAG(internal_run_death_test); 158 output_ = GTEST_FLAG(output); 159 stream_result_to_ = GTEST_FLAG(stream_result_to); 160 161 random_seed_ = GTEST_FLAG(random_seed); 162 repeat_ = GTEST_FLAG(repeat); 163 stack_trace_depth_ = GTEST_FLAG(stack_trace_depth); 164 165 also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests); 166 break_on_failure_ = GTEST_FLAG(break_on_failure); 167 catch_exceptions_ = GTEST_FLAG(catch_exceptions); 168 death_test_use_fork_ = GTEST_FLAG(death_test_use_fork); 169 list_tests_ = GTEST_FLAG(list_tests); 170 print_time_ = GTEST_FLAG(print_time); 171 shuffle_ = GTEST_FLAG(shuffle); 172 throw_on_failure_ = GTEST_FLAG(throw_on_failure); 173 } 174 175 // The d'tor is not virtual. DO NOT INHERIT FROM THIS CLASS. 176 ~GTestFlagSaver() { 177 GTEST_FLAG(color) = color_; 178 GTEST_FLAG(death_test_style) = death_test_style_; 179 GTEST_FLAG(filter) = filter_; 180 GTEST_FLAG(internal_run_death_test) = internal_run_death_test_; 181 GTEST_FLAG(output) = output_; 182 GTEST_FLAG(stream_result_to) = stream_result_to_; 183 184 GTEST_FLAG(random_seed) = random_seed_; 185 GTEST_FLAG(repeat) = repeat_; 186 GTEST_FLAG(stack_trace_depth) = stack_trace_depth_; 187 188 GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_; 189 GTEST_FLAG(break_on_failure) = break_on_failure_; 190 GTEST_FLAG(catch_exceptions) = catch_exceptions_; 191 GTEST_FLAG(death_test_use_fork) = death_test_use_fork_; 192 GTEST_FLAG(list_tests) = list_tests_; 193 GTEST_FLAG(print_time) = print_time_; 194 GTEST_FLAG(shuffle) = shuffle_; 195 GTEST_FLAG(throw_on_failure) = throw_on_failure_; 196 } 197 private: 198 // Fields for saving the original values of flags. 199 String color_; 200 String death_test_style_; 201 String filter_; 202 String internal_run_death_test_; 203 String output_; 204 String stream_result_to_; 205 internal::Int32 random_seed_; 206 internal::Int32 repeat_; 207 internal::Int32 stack_trace_depth_; 208 bool also_run_disabled_tests_; 209 bool break_on_failure_; 210 bool catch_exceptions_; 211 bool death_test_use_fork_; 212 bool list_tests_; 213 bool print_time_; 214 bool shuffle_; 215 bool throw_on_failure_; 216 } GTEST_ATTRIBUTE_UNUSED_; 217 218 // Converts a Unicode code point to a narrow string in UTF-8 encoding. 219 // code_point parameter is of type UInt32 because wchar_t may not be 220 // wide enough to contain a code point. 221 // The output buffer str must containt at least 32 characters. 222 // The function returns the address of the output buffer. 223 // If the code_point is not a valid Unicode code point 224 // (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output 225 // as '(Invalid Unicode 0xXXXXXXXX)'. 226 GTEST_API_ char* CodePointToUtf8(UInt32 code_point, char* str); 227 228 // Converts a wide string to a narrow string in UTF-8 encoding. 229 // The wide string is assumed to have the following encoding: 230 // UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS) 231 // UTF-32 if sizeof(wchar_t) == 4 (on Linux) 232 // Parameter str points to a null-terminated wide string. 233 // Parameter num_chars may additionally limit the number 234 // of wchar_t characters processed. -1 is used when the entire string 235 // should be processed. 236 // If the string contains code points that are not valid Unicode code points 237 // (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output 238 // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding 239 // and contains invalid UTF-16 surrogate pairs, values in those pairs 240 // will be encoded as individual Unicode characters from Basic Normal Plane. 241 GTEST_API_ String WideStringToUtf8(const wchar_t* str, int num_chars); 242 243 // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file 244 // if the variable is present. If a file already exists at this location, this 245 // function will write over it. If the variable is present, but the file cannot 246 // be created, prints an error and exits. 247 void WriteToShardStatusFileIfNeeded(); 248 249 // Checks whether sharding is enabled by examining the relevant 250 // environment variable values. If the variables are present, 251 // but inconsistent (e.g., shard_index >= total_shards), prints 252 // an error and exits. If in_subprocess_for_death_test, sharding is 253 // disabled because it must only be applied to the original test 254 // process. Otherwise, we could filter out death tests we intended to execute. 255 GTEST_API_ bool ShouldShard(const char* total_shards_str, 256 const char* shard_index_str, 257 bool in_subprocess_for_death_test); 258 259 // Parses the environment variable var as an Int32. If it is unset, 260 // returns default_val. If it is not an Int32, prints an error and 261 // and aborts. 262 GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val); 263 264 // Given the total number of shards, the shard index, and the test id, 265 // returns true iff the test should be run on this shard. The test id is 266 // some arbitrary but unique non-negative integer assigned to each test 267 // method. Assumes that 0 <= shard_index < total_shards. 268 GTEST_API_ bool ShouldRunTestOnShard( 269 int total_shards, int shard_index, int test_id); 270 271 // STL container utilities. 272 273 // Returns the number of elements in the given container that satisfy 274 // the given predicate. 275 template <class Container, typename Predicate> 276 inline int CountIf(const Container& c, Predicate predicate) { 277 // Implemented as an explicit loop since std::count_if() in libCstd on 278 // Solaris has a non-standard signature. 279 int count = 0; 280 for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) { 281 if (predicate(*it)) 282 ++count; 283 } 284 return count; 285 } 286 287 // Applies a function/functor to each element in the container. 288 template <class Container, typename Functor> 289 void ForEach(const Container& c, Functor functor) { 290 std::for_each(c.begin(), c.end(), functor); 291 } 292 293 // Returns the i-th element of the vector, or default_value if i is not 294 // in range [0, v.size()). 295 template <typename E> 296 inline E GetElementOr(const std::vector<E>& v, int i, E default_value) { 297 return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i]; 298 } 299 300 // Performs an in-place shuffle of a range of the vector's elements. 301 // 'begin' and 'end' are element indices as an STL-style range; 302 // i.e. [begin, end) are shuffled, where 'end' == size() means to 303 // shuffle to the end of the vector. 304 template <typename E> 305 void ShuffleRange(internal::Random* random, int begin, int end, 306 std::vector<E>* v) { 307 const int size = static_cast<int>(v->size()); 308 GTEST_CHECK_(0 <= begin && begin <= size) 309 << "Invalid shuffle range start " << begin << ": must be in range [0, " 310 << size << "]."; 311 GTEST_CHECK_(begin <= end && end <= size) 312 << "Invalid shuffle range finish " << end << ": must be in range [" 313 << begin << ", " << size << "]."; 314 315 // Fisher-Yates shuffle, from 316 // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle 317 for (int range_width = end - begin; range_width >= 2; range_width--) { 318 const int last_in_range = begin + range_width - 1; 319 const int selected = begin + random->Generate(range_width); 320 std::swap((*v)[selected], (*v)[last_in_range]); 321 } 322 } 323 324 // Performs an in-place shuffle of the vector's elements. 325 template <typename E> 326 inline void Shuffle(internal::Random* random, std::vector<E>* v) { 327 ShuffleRange(random, 0, static_cast<int>(v->size()), v); 328 } 329 330 // A function for deleting an object. Handy for being used as a 331 // functor. 332 template <typename T> 333 static void Delete(T* x) { 334 delete x; 335 } 336 337 // A predicate that checks the key of a TestProperty against a known key. 338 // 339 // TestPropertyKeyIs is copyable. 340 class TestPropertyKeyIs { 341 public: 342 // Constructor. 343 // 344 // TestPropertyKeyIs has NO default constructor. 345 explicit TestPropertyKeyIs(const char* key) 346 : key_(key) {} 347 348 // Returns true iff the test name of test property matches on key_. 349 bool operator()(const TestProperty& test_property) const { 350 return String(test_property.key()).Compare(key_) == 0; 351 } 352 353 private: 354 String key_; 355 }; 356 357 // Class UnitTestOptions. 358 // 359 // This class contains functions for processing options the user 360 // specifies when running the tests. It has only static members. 361 // 362 // In most cases, the user can specify an option using either an 363 // environment variable or a command line flag. E.g. you can set the 364 // test filter using either GTEST_FILTER or --gtest_filter. If both 365 // the variable and the flag are present, the latter overrides the 366 // former. 367 class GTEST_API_ UnitTestOptions { 368 public: 369 // Functions for processing the gtest_output flag. 370 371 // Returns the output format, or "" for normal printed output. 372 static String GetOutputFormat(); 373 374 // Returns the absolute path of the requested output file, or the 375 // default (test_detail.xml in the original working directory) if 376 // none was explicitly specified. 377 static String GetAbsolutePathToOutputFile(); 378 379 // Functions for processing the gtest_filter flag. 380 381 // Returns true iff the wildcard pattern matches the string. The 382 // first ':' or '\0' character in pattern marks the end of it. 383 // 384 // This recursive algorithm isn't very efficient, but is clear and 385 // works well enough for matching test names, which are short. 386 static bool PatternMatchesString(const char *pattern, const char *str); 387 388 // Returns true iff the user-specified filter matches the test case 389 // name and the test name. 390 static bool FilterMatchesTest(const String &test_case_name, 391 const String &test_name); 392 393 #if GTEST_OS_WINDOWS 394 // Function for supporting the gtest_catch_exception flag. 395 396 // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the 397 // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. 398 // This function is useful as an __except condition. 399 static int GTestShouldProcessSEH(DWORD exception_code); 400 #endif // GTEST_OS_WINDOWS 401 402 // Returns true if "name" matches the ':' separated list of glob-style 403 // filters in "filter". 404 static bool MatchesFilter(const String& name, const char* filter); 405 }; 406 407 // Returns the current application's name, removing directory path if that 408 // is present. Used by UnitTestOptions::GetOutputFile. 409 GTEST_API_ FilePath GetCurrentExecutableName(); 410 411 // The role interface for getting the OS stack trace as a string. 412 class OsStackTraceGetterInterface { 413 public: 414 OsStackTraceGetterInterface() {} 415 virtual ~OsStackTraceGetterInterface(); 416 417 // Returns the current OS stack trace as a String. Parameters: 418 // 419 // max_depth - the maximum number of stack frames to be included 420 // in the trace. 421 // skip_count - the number of top frames to be skipped; doesn't count 422 // against max_depth. 423 virtual String CurrentStackTrace(int max_depth, int skip_count) = 0; 424 425 // UponLeavingGTest() should be called immediately before Google Test calls 426 // user code. It saves some information about the current stack that 427 // CurrentStackTrace() will use to find and hide Google Test stack frames. 428 virtual void UponLeavingGTest() = 0; 429 430 private: 431 GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface); 432 }; 433 434 // A working implementation of the OsStackTraceGetterInterface interface. 435 class OsStackTraceGetter : public OsStackTraceGetterInterface { 436 public: 437 OsStackTraceGetter() : caller_frame_(NULL) {} 438 String CurrentStackTrace(int max_depth, int skip_count) override; 439 void UponLeavingGTest() override; 440 441 // This string is inserted in place of stack frames that are part of 442 // Google Test's implementation. 443 static const char* const kElidedFramesMarker; 444 445 private: 446 Mutex mutex_; // protects all internal state 447 448 // We save the stack frame below the frame that calls user code. 449 // We do this because the address of the frame immediately below 450 // the user code changes between the call to UponLeavingGTest() 451 // and any calls to CurrentStackTrace() from within the user code. 452 void* caller_frame_; 453 454 GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter); 455 }; 456 457 // Information about a Google Test trace point. 458 struct TraceInfo { 459 const char* file; 460 int line; 461 String message; 462 }; 463 464 // This is the default global test part result reporter used in UnitTestImpl. 465 // This class should only be used by UnitTestImpl. 466 class DefaultGlobalTestPartResultReporter 467 : public TestPartResultReporterInterface { 468 public: 469 explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test); 470 // Implements the TestPartResultReporterInterface. Reports the test part 471 // result in the current test. 472 void ReportTestPartResult(const TestPartResult &result) override; 473 474 private: 475 UnitTestImpl* const unit_test_; 476 477 GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter); 478 }; 479 480 // This is the default per thread test part result reporter used in 481 // UnitTestImpl. This class should only be used by UnitTestImpl. 482 class DefaultPerThreadTestPartResultReporter 483 : public TestPartResultReporterInterface { 484 public: 485 explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test); 486 // Implements the TestPartResultReporterInterface. The implementation just 487 // delegates to the current global test part result reporter of *unit_test_. 488 void ReportTestPartResult(const TestPartResult &result) override; 489 490 private: 491 UnitTestImpl* const unit_test_; 492 493 GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter); 494 }; 495 496 // The private implementation of the UnitTest class. We don't protect 497 // the methods under a mutex, as this class is not accessible by a 498 // user and the UnitTest class that delegates work to this class does 499 // proper locking. 500 class GTEST_API_ UnitTestImpl { 501 public: 502 explicit UnitTestImpl(UnitTest* parent); 503 virtual ~UnitTestImpl(); 504 505 // There are two different ways to register your own TestPartResultReporter. 506 // You can register your own repoter to listen either only for test results 507 // from the current thread or for results from all threads. 508 // By default, each per-thread test result repoter just passes a new 509 // TestPartResult to the global test result reporter, which registers the 510 // test part result for the currently running test. 511 512 // Returns the global test part result reporter. 513 TestPartResultReporterInterface* GetGlobalTestPartResultReporter(); 514 515 // Sets the global test part result reporter. 516 void SetGlobalTestPartResultReporter( 517 TestPartResultReporterInterface* reporter); 518 519 // Returns the test part result reporter for the current thread. 520 TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread(); 521 522 // Sets the test part result reporter for the current thread. 523 void SetTestPartResultReporterForCurrentThread( 524 TestPartResultReporterInterface* reporter); 525 526 // Gets the number of successful test cases. 527 int successful_test_case_count() const; 528 529 // Gets the number of failed test cases. 530 int failed_test_case_count() const; 531 532 // Gets the number of all test cases. 533 int total_test_case_count() const; 534 535 // Gets the number of all test cases that contain at least one test 536 // that should run. 537 int test_case_to_run_count() const; 538 539 // Gets the number of successful tests. 540 int successful_test_count() const; 541 542 // Gets the number of failed tests. 543 int failed_test_count() const; 544 545 // Gets the number of disabled tests. 546 int disabled_test_count() const; 547 548 // Gets the number of all tests. 549 int total_test_count() const; 550 551 // Gets the number of tests that should run. 552 int test_to_run_count() const; 553 554 // Gets the elapsed time, in milliseconds. 555 TimeInMillis elapsed_time() const { return elapsed_time_; } 556 557 // Returns true iff the unit test passed (i.e. all test cases passed). 558 bool Passed() const { return !Failed(); } 559 560 // Returns true iff the unit test failed (i.e. some test case failed 561 // or something outside of all tests failed). 562 bool Failed() const { 563 return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed(); 564 } 565 566 // Gets the i-th test case among all the test cases. i can range from 0 to 567 // total_test_case_count() - 1. If i is not in that range, returns NULL. 568 const TestCase* GetTestCase(int i) const { 569 const int index = GetElementOr(test_case_indices_, i, -1); 570 return index < 0 ? NULL : test_cases_[i]; 571 } 572 573 // Gets the i-th test case among all the test cases. i can range from 0 to 574 // total_test_case_count() - 1. If i is not in that range, returns NULL. 575 TestCase* GetMutableTestCase(int i) { 576 const int index = GetElementOr(test_case_indices_, i, -1); 577 return index < 0 ? NULL : test_cases_[index]; 578 } 579 580 // Provides access to the event listener list. 581 TestEventListeners* listeners() { return &listeners_; } 582 583 // Returns the TestResult for the test that's currently running, or 584 // the TestResult for the ad hoc test if no test is running. 585 TestResult* current_test_result(); 586 587 // Returns the TestResult for the ad hoc test. 588 const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; } 589 590 // Sets the OS stack trace getter. 591 // 592 // Does nothing if the input and the current OS stack trace getter 593 // are the same; otherwise, deletes the old getter and makes the 594 // input the current getter. 595 void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter); 596 597 // Returns the current OS stack trace getter if it is not NULL; 598 // otherwise, creates an OsStackTraceGetter, makes it the current 599 // getter, and returns it. 600 OsStackTraceGetterInterface* os_stack_trace_getter(); 601 602 // Returns the current OS stack trace as a String. 603 // 604 // The maximum number of stack frames to be included is specified by 605 // the gtest_stack_trace_depth flag. The skip_count parameter 606 // specifies the number of top frames to be skipped, which doesn't 607 // count against the number of frames to be included. 608 // 609 // For example, if Foo() calls Bar(), which in turn calls 610 // CurrentOsStackTraceExceptTop(1), Foo() will be included in the 611 // trace but Bar() and CurrentOsStackTraceExceptTop() won't. 612 String CurrentOsStackTraceExceptTop(int skip_count); 613 614 // Finds and returns a TestCase with the given name. If one doesn't 615 // exist, creates one and returns it. 616 // 617 // Arguments: 618 // 619 // test_case_name: name of the test case 620 // type_param: the name of the test's type parameter, or NULL if 621 // this is not a typed or a type-parameterized test. 622 // set_up_tc: pointer to the function that sets up the test case 623 // tear_down_tc: pointer to the function that tears down the test case 624 TestCase* GetTestCase(const char* test_case_name, 625 const char* type_param, 626 Test::SetUpTestCaseFunc set_up_tc, 627 Test::TearDownTestCaseFunc tear_down_tc); 628 629 // Adds a TestInfo to the unit test. 630 // 631 // Arguments: 632 // 633 // set_up_tc: pointer to the function that sets up the test case 634 // tear_down_tc: pointer to the function that tears down the test case 635 // test_info: the TestInfo object 636 void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc, 637 Test::TearDownTestCaseFunc tear_down_tc, 638 TestInfo* test_info) { 639 // In order to support thread-safe death tests, we need to 640 // remember the original working directory when the test program 641 // was first invoked. We cannot do this in RUN_ALL_TESTS(), as 642 // the user may have changed the current directory before calling 643 // RUN_ALL_TESTS(). Therefore we capture the current directory in 644 // AddTestInfo(), which is called to register a TEST or TEST_F 645 // before main() is reached. 646 if (original_working_dir_.IsEmpty()) { 647 original_working_dir_.Set(FilePath::GetCurrentDir()); 648 GTEST_CHECK_(!original_working_dir_.IsEmpty()) 649 << "Failed to get the current working directory."; 650 } 651 652 GetTestCase(test_info->test_case_name(), 653 test_info->type_param(), 654 set_up_tc, 655 tear_down_tc)->AddTestInfo(test_info); 656 } 657 658 #if GTEST_HAS_PARAM_TEST 659 // Returns ParameterizedTestCaseRegistry object used to keep track of 660 // value-parameterized tests and instantiate and register them. 661 internal::ParameterizedTestCaseRegistry& parameterized_test_registry() { 662 return parameterized_test_registry_; 663 } 664 #endif // GTEST_HAS_PARAM_TEST 665 666 // Sets the TestCase object for the test that's currently running. 667 void set_current_test_case(TestCase* a_current_test_case) { 668 current_test_case_ = a_current_test_case; 669 } 670 671 // Sets the TestInfo object for the test that's currently running. If 672 // current_test_info is NULL, the assertion results will be stored in 673 // ad_hoc_test_result_. 674 void set_current_test_info(TestInfo* a_current_test_info) { 675 current_test_info_ = a_current_test_info; 676 } 677 678 // Registers all parameterized tests defined using TEST_P and 679 // INSTANTIATE_TEST_CASE_P, creating regular tests for each test/parameter 680 // combination. This method can be called more then once; it has guards 681 // protecting from registering the tests more then once. If 682 // value-parameterized tests are disabled, RegisterParameterizedTests is 683 // present but does nothing. 684 void RegisterParameterizedTests(); 685 686 // Runs all tests in this UnitTest object, prints the result, and 687 // returns true if all tests are successful. If any exception is 688 // thrown during a test, this test is considered to be failed, but 689 // the rest of the tests will still be run. 690 bool RunAllTests(); 691 692 // Clears the results of all tests, except the ad hoc tests. 693 void ClearNonAdHocTestResult() { 694 ForEach(test_cases_, TestCase::ClearTestCaseResult); 695 } 696 697 // Clears the results of ad-hoc test assertions. 698 void ClearAdHocTestResult() { 699 ad_hoc_test_result_.Clear(); 700 } 701 702 enum ReactionToSharding { 703 HONOR_SHARDING_PROTOCOL, 704 IGNORE_SHARDING_PROTOCOL 705 }; 706 707 // Matches the full name of each test against the user-specified 708 // filter to decide whether the test should run, then records the 709 // result in each TestCase and TestInfo object. 710 // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests 711 // based on sharding variables in the environment. 712 // Returns the number of tests that should run. 713 int FilterTests(ReactionToSharding shard_tests); 714 715 // Prints the names of the tests matching the user-specified filter flag. 716 void ListTestsMatchingFilter(); 717 718 const TestCase* current_test_case() const { return current_test_case_; } 719 TestInfo* current_test_info() { return current_test_info_; } 720 const TestInfo* current_test_info() const { return current_test_info_; } 721 722 // Returns the vector of environments that need to be set-up/torn-down 723 // before/after the tests are run. 724 std::vector<Environment*>& environments() { return environments_; } 725 726 // Getters for the per-thread Google Test trace stack. 727 std::vector<TraceInfo>& gtest_trace_stack() { 728 return *(gtest_trace_stack_.pointer()); 729 } 730 const std::vector<TraceInfo>& gtest_trace_stack() const { 731 return gtest_trace_stack_.get(); 732 } 733 734 #if GTEST_HAS_DEATH_TEST 735 void InitDeathTestSubprocessControlInfo() { 736 internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag()); 737 } 738 // Returns a pointer to the parsed --gtest_internal_run_death_test 739 // flag, or NULL if that flag was not specified. 740 // This information is useful only in a death test child process. 741 // Must not be called before a call to InitGoogleTest. 742 const InternalRunDeathTestFlag* internal_run_death_test_flag() const { 743 return internal_run_death_test_flag_.get(); 744 } 745 746 // Returns a pointer to the current death test factory. 747 internal::DeathTestFactory* death_test_factory() { 748 return death_test_factory_.get(); 749 } 750 751 void SuppressTestEventsIfInSubprocess(); 752 753 friend class ReplaceDeathTestFactory; 754 #endif // GTEST_HAS_DEATH_TEST 755 756 // Initializes the event listener performing XML output as specified by 757 // UnitTestOptions. Must not be called before InitGoogleTest. 758 void ConfigureXmlOutput(); 759 760 #if GTEST_CAN_STREAM_RESULTS_ 761 // Initializes the event listener for streaming test results to a socket. 762 // Must not be called before InitGoogleTest. 763 void ConfigureStreamingOutput(); 764 #endif 765 766 // Performs initialization dependent upon flag values obtained in 767 // ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to 768 // ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest 769 // this function is also called from RunAllTests. Since this function can be 770 // called more than once, it has to be idempotent. 771 void PostFlagParsingInit(); 772 773 // Gets the random seed used at the start of the current test iteration. 774 int random_seed() const { return random_seed_; } 775 776 // Gets the random number generator. 777 internal::Random* random() { return &random_; } 778 779 // Shuffles all test cases, and the tests within each test case, 780 // making sure that death tests are still run first. 781 void ShuffleTests(); 782 783 // Restores the test cases and tests to their order before the first shuffle. 784 void UnshuffleTests(); 785 786 // Returns the value of GTEST_FLAG(catch_exceptions) at the moment 787 // UnitTest::Run() starts. 788 bool catch_exceptions() const { return catch_exceptions_; } 789 790 private: 791 friend class ::testing::UnitTest; 792 793 // Used by UnitTest::Run() to capture the state of 794 // GTEST_FLAG(catch_exceptions) at the moment it starts. 795 void set_catch_exceptions(bool value) { catch_exceptions_ = value; } 796 797 // The UnitTest object that owns this implementation object. 798 UnitTest* const parent_; 799 800 // The working directory when the first TEST() or TEST_F() was 801 // executed. 802 internal::FilePath original_working_dir_; 803 804 // The default test part result reporters. 805 DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_; 806 DefaultPerThreadTestPartResultReporter 807 default_per_thread_test_part_result_reporter_; 808 809 // Points to (but doesn't own) the global test part result reporter. 810 TestPartResultReporterInterface* global_test_part_result_repoter_; 811 812 // Protects read and write access to global_test_part_result_reporter_. 813 internal::Mutex global_test_part_result_reporter_mutex_; 814 815 // Points to (but doesn't own) the per-thread test part result reporter. 816 internal::ThreadLocal<TestPartResultReporterInterface*> 817 per_thread_test_part_result_reporter_; 818 819 // The vector of environments that need to be set-up/torn-down 820 // before/after the tests are run. 821 std::vector<Environment*> environments_; 822 823 // The vector of TestCases in their original order. It owns the 824 // elements in the vector. 825 std::vector<TestCase*> test_cases_; 826 827 // Provides a level of indirection for the test case list to allow 828 // easy shuffling and restoring the test case order. The i-th 829 // element of this vector is the index of the i-th test case in the 830 // shuffled order. 831 std::vector<int> test_case_indices_; 832 833 #if GTEST_HAS_PARAM_TEST 834 // ParameterizedTestRegistry object used to register value-parameterized 835 // tests. 836 internal::ParameterizedTestCaseRegistry parameterized_test_registry_; 837 838 // Indicates whether RegisterParameterizedTests() has been called already. 839 bool parameterized_tests_registered_; 840 #endif // GTEST_HAS_PARAM_TEST 841 842 // Index of the last death test case registered. Initially -1. 843 int last_death_test_case_; 844 845 // This points to the TestCase for the currently running test. It 846 // changes as Google Test goes through one test case after another. 847 // When no test is running, this is set to NULL and Google Test 848 // stores assertion results in ad_hoc_test_result_. Initially NULL. 849 TestCase* current_test_case_; 850 851 // This points to the TestInfo for the currently running test. It 852 // changes as Google Test goes through one test after another. When 853 // no test is running, this is set to NULL and Google Test stores 854 // assertion results in ad_hoc_test_result_. Initially NULL. 855 TestInfo* current_test_info_; 856 857 // Normally, a user only writes assertions inside a TEST or TEST_F, 858 // or inside a function called by a TEST or TEST_F. Since Google 859 // Test keeps track of which test is current running, it can 860 // associate such an assertion with the test it belongs to. 861 // 862 // If an assertion is encountered when no TEST or TEST_F is running, 863 // Google Test attributes the assertion result to an imaginary "ad hoc" 864 // test, and records the result in ad_hoc_test_result_. 865 TestResult ad_hoc_test_result_; 866 867 // The list of event listeners that can be used to track events inside 868 // Google Test. 869 TestEventListeners listeners_; 870 871 // The OS stack trace getter. Will be deleted when the UnitTest 872 // object is destructed. By default, an OsStackTraceGetter is used, 873 // but the user can set this field to use a custom getter if that is 874 // desired. 875 OsStackTraceGetterInterface* os_stack_trace_getter_; 876 877 // True iff PostFlagParsingInit() has been called. 878 bool post_flag_parse_init_performed_; 879 880 // The random number seed used at the beginning of the test run. 881 int random_seed_; 882 883 // Our random number generator. 884 internal::Random random_; 885 886 // How long the test took to run, in milliseconds. 887 TimeInMillis elapsed_time_; 888 889 #if GTEST_HAS_DEATH_TEST 890 // The decomposed components of the gtest_internal_run_death_test flag, 891 // parsed when RUN_ALL_TESTS is called. 892 internal::scoped_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_; 893 internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_; 894 #endif // GTEST_HAS_DEATH_TEST 895 896 // A per-thread stack of traces created by the SCOPED_TRACE() macro. 897 internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_; 898 899 // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests() 900 // starts. 901 bool catch_exceptions_; 902 903 GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl); 904 }; // class UnitTestImpl 905 906 // Convenience function for accessing the global UnitTest 907 // implementation object. 908 inline UnitTestImpl* GetUnitTestImpl() { 909 return UnitTest::GetInstance()->impl(); 910 } 911 912 #if GTEST_USES_SIMPLE_RE 913 914 // Internal helper functions for implementing the simple regular 915 // expression matcher. 916 GTEST_API_ bool IsInSet(char ch, const char* str); 917 GTEST_API_ bool IsAsciiDigit(char ch); 918 GTEST_API_ bool IsAsciiPunct(char ch); 919 GTEST_API_ bool IsRepeat(char ch); 920 GTEST_API_ bool IsAsciiWhiteSpace(char ch); 921 GTEST_API_ bool IsAsciiWordChar(char ch); 922 GTEST_API_ bool IsValidEscape(char ch); 923 GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch); 924 GTEST_API_ bool ValidateRegex(const char* regex); 925 GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str); 926 GTEST_API_ bool MatchRepetitionAndRegexAtHead( 927 bool escaped, char ch, char repeat, const char* regex, const char* str); 928 GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str); 929 930 #endif // GTEST_USES_SIMPLE_RE 931 932 // Parses the command line for Google Test flags, without initializing 933 // other parts of Google Test. 934 GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv); 935 GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv); 936 937 #if GTEST_HAS_DEATH_TEST 938 939 // Returns the message describing the last system error, regardless of the 940 // platform. 941 GTEST_API_ String GetLastErrnoDescription(); 942 943 # if GTEST_OS_WINDOWS 944 // Provides leak-safe Windows kernel handle ownership. 945 class AutoHandle { 946 public: 947 AutoHandle() : handle_(INVALID_HANDLE_VALUE) {} 948 explicit AutoHandle(HANDLE handle) : handle_(handle) {} 949 950 ~AutoHandle() { Reset(); } 951 952 HANDLE Get() const { return handle_; } 953 void Reset() { Reset(INVALID_HANDLE_VALUE); } 954 void Reset(HANDLE handle) { 955 if (handle != handle_) { 956 if (handle_ != INVALID_HANDLE_VALUE) 957 ::CloseHandle(handle_); 958 handle_ = handle; 959 } 960 } 961 962 private: 963 HANDLE handle_; 964 965 GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle); 966 }; 967 # endif // GTEST_OS_WINDOWS 968 969 // Attempts to parse a string into a positive integer pointed to by the 970 // number parameter. Returns true if that is possible. 971 // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use 972 // it here. 973 template <typename Integer> 974 bool ParseNaturalNumber(const ::std::string& str, Integer* number) { 975 // Fail fast if the given string does not begin with a digit; 976 // this bypasses strtoXXX's "optional leading whitespace and plus 977 // or minus sign" semantics, which are undesirable here. 978 if (str.empty() || !IsDigit(str[0])) { 979 return false; 980 } 981 errno = 0; 982 983 char* end; 984 // BiggestConvertible is the largest integer type that system-provided 985 // string-to-number conversion routines can return. 986 987 # if GTEST_OS_WINDOWS && !defined(__GNUC__) 988 989 // MSVC and C++ Builder define __int64 instead of the standard long long. 990 typedef unsigned __int64 BiggestConvertible; 991 const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10); 992 993 # else 994 995 typedef unsigned long long BiggestConvertible; // NOLINT 996 const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10); 997 998 # endif // GTEST_OS_WINDOWS && !defined(__GNUC__) 999 1000 const bool parse_success = *end == '\0' && errno == 0; 1001 1002 // TODO(vladl (at) google.com): Convert this to compile time assertion when it is 1003 // available. 1004 GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed)); 1005 1006 const Integer result = static_cast<Integer>(parsed); 1007 if (parse_success && static_cast<BiggestConvertible>(result) == parsed) { 1008 *number = result; 1009 return true; 1010 } 1011 return false; 1012 } 1013 #endif // GTEST_HAS_DEATH_TEST 1014 1015 // TestResult contains some private methods that should be hidden from 1016 // Google Test user but are required for testing. This class allow our tests 1017 // to access them. 1018 // 1019 // This class is supplied only for the purpose of testing Google Test's own 1020 // constructs. Do not use it in user tests, either directly or indirectly. 1021 class TestResultAccessor { 1022 public: 1023 static void RecordProperty(TestResult* test_result, 1024 const TestProperty& property) { 1025 test_result->RecordProperty(property); 1026 } 1027 1028 static void ClearTestPartResults(TestResult* test_result) { 1029 test_result->ClearTestPartResults(); 1030 } 1031 1032 static const std::vector<testing::TestPartResult>& test_part_results( 1033 const TestResult& test_result) { 1034 return test_result.test_part_results(); 1035 } 1036 }; 1037 1038 } // namespace internal 1039 } // namespace testing 1040 1041 #endif // GTEST_SRC_GTEST_INTERNAL_INL_H_ 1042