1// Copyright 2005, Google Inc. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above 11// copyright notice, this list of conditions and the following disclaimer 12// in the documentation and/or other materials provided with the 13// distribution. 14// * Neither the name of Google Inc. nor the names of its 15// contributors may be used to endorse or promote products derived from 16// this software without specific prior written permission. 17// 18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29// 30// Author: wan@google.com (Zhanyong Wan) 31// 32// The Google C++ Testing Framework (Google Test) 33// 34// This header file defines the public API for Google Test. It should be 35// included by any test program that uses Google Test. 36// 37// IMPORTANT NOTE: Due to limitation of the C++ language, we have to 38// leave some internal implementation details in this header file. 39// They are clearly marked by comments like this: 40// 41// // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 42// 43// Such code is NOT meant to be used by a user directly, and is subject 44// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user 45// program! 46// 47// Acknowledgment: Google Test borrowed the idea of automatic test 48// registration from Barthelemy Dagenais' (barthelemy@prologique.com) 49// easyUnit framework. 50 51#ifndef GTEST_INCLUDE_GTEST_GTEST_H_ 52#define GTEST_INCLUDE_GTEST_GTEST_H_ 53 54#include <limits> 55#include <ostream> 56#include <vector> 57 58#include "gtest/internal/gtest-internal.h" 59#include "gtest/internal/gtest-string.h" 60#include "gtest/gtest-death-test.h" 61#include "gtest/gtest-message.h" 62#include "gtest/gtest-param-test.h" 63#include "gtest/gtest-printers.h" 64#include "gtest/gtest_prod.h" 65#include "gtest/gtest-test-part.h" 66#include "gtest/gtest-typed-test.h" 67 68// Depending on the platform, different string classes are available. 69// On Linux, in addition to ::std::string, Google also makes use of 70// class ::string, which has the same interface as ::std::string, but 71// has a different implementation. 72// 73// You can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that 74// ::string is available AND is a distinct type to ::std::string, or 75// define it to 0 to indicate otherwise. 76// 77// If ::std::string and ::string are the same class on your platform 78// due to aliasing, you should define GTEST_HAS_GLOBAL_STRING to 0. 79// 80// If you do not define GTEST_HAS_GLOBAL_STRING, it is defined 81// heuristically. 82 83namespace testing { 84 85// Declares the flags. 86 87// This flag temporary enables the disabled tests. 88GTEST_DECLARE_bool_(also_run_disabled_tests); 89 90// This flag brings the debugger on an assertion failure. 91GTEST_DECLARE_bool_(break_on_failure); 92 93// This flag controls whether Google Test catches all test-thrown exceptions 94// and logs them as failures. 95GTEST_DECLARE_bool_(catch_exceptions); 96 97// This flag enables using colors in terminal output. Available values are 98// "yes" to enable colors, "no" (disable colors), or "auto" (the default) 99// to let Google Test decide. 100GTEST_DECLARE_string_(color); 101 102// This flag sets up the filter to select by name using a glob pattern 103// the tests to run. If the filter is not given all tests are executed. 104GTEST_DECLARE_string_(filter); 105 106// This flag causes the Google Test to list tests. None of the tests listed 107// are actually run if the flag is provided. 108GTEST_DECLARE_bool_(list_tests); 109 110// This flag controls whether Google Test emits a detailed XML report to a file 111// in addition to its normal textual output. 112GTEST_DECLARE_string_(output); 113 114// This flags control whether Google Test prints the elapsed time for each 115// test. 116GTEST_DECLARE_bool_(print_time); 117 118// This flag specifies the random number seed. 119GTEST_DECLARE_int32_(random_seed); 120 121// This flag sets how many times the tests are repeated. The default value 122// is 1. If the value is -1 the tests are repeating forever. 123GTEST_DECLARE_int32_(repeat); 124 125// This flag controls whether Google Test includes Google Test internal 126// stack frames in failure stack traces. 127GTEST_DECLARE_bool_(show_internal_stack_frames); 128 129// When this flag is specified, tests' order is randomized on every iteration. 130GTEST_DECLARE_bool_(shuffle); 131 132// This flag specifies the maximum number of stack frames to be 133// printed in a failure message. 134GTEST_DECLARE_int32_(stack_trace_depth); 135 136// When this flag is specified, a failed assertion will throw an 137// exception if exceptions are enabled, or exit the program with a 138// non-zero code otherwise. 139GTEST_DECLARE_bool_(throw_on_failure); 140 141// When this flag is set with a "host:port" string, on supported 142// platforms test results are streamed to the specified port on 143// the specified host machine. 144GTEST_DECLARE_string_(stream_result_to); 145 146// The upper limit for valid stack trace depths. 147const int kMaxStackTraceDepth = 100; 148 149namespace internal { 150 151class AssertHelper; 152class DefaultGlobalTestPartResultReporter; 153class ExecDeathTest; 154class NoExecDeathTest; 155class FinalSuccessChecker; 156class GTestFlagSaver; 157class StreamingListenerTest; 158class TestResultAccessor; 159class TestEventListenersAccessor; 160class TestEventRepeater; 161class UnitTestRecordPropertyTestHelper; 162class WindowsDeathTest; 163class UnitTestImpl* GetUnitTestImpl(); 164void ReportFailureInUnknownLocation(TestPartResult::Type result_type, 165 const std::string& message); 166 167} // namespace internal 168 169// The friend relationship of some of these classes is cyclic. 170// If we don't forward declare them the compiler might confuse the classes 171// in friendship clauses with same named classes on the scope. 172class Test; 173class TestCase; 174class TestInfo; 175class UnitTest; 176 177// A class for indicating whether an assertion was successful. When 178// the assertion wasn't successful, the AssertionResult object 179// remembers a non-empty message that describes how it failed. 180// 181// To create an instance of this class, use one of the factory functions 182// (AssertionSuccess() and AssertionFailure()). 183// 184// This class is useful for two purposes: 185// 1. Defining predicate functions to be used with Boolean test assertions 186// EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts 187// 2. Defining predicate-format functions to be 188// used with predicate assertions (ASSERT_PRED_FORMAT*, etc). 189// 190// For example, if you define IsEven predicate: 191// 192// testing::AssertionResult IsEven(int n) { 193// if ((n % 2) == 0) 194// return testing::AssertionSuccess(); 195// else 196// return testing::AssertionFailure() << n << " is odd"; 197// } 198// 199// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5))) 200// will print the message 201// 202// Value of: IsEven(Fib(5)) 203// Actual: false (5 is odd) 204// Expected: true 205// 206// instead of a more opaque 207// 208// Value of: IsEven(Fib(5)) 209// Actual: false 210// Expected: true 211// 212// in case IsEven is a simple Boolean predicate. 213// 214// If you expect your predicate to be reused and want to support informative 215// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up 216// about half as often as positive ones in our tests), supply messages for 217// both success and failure cases: 218// 219// testing::AssertionResult IsEven(int n) { 220// if ((n % 2) == 0) 221// return testing::AssertionSuccess() << n << " is even"; 222// else 223// return testing::AssertionFailure() << n << " is odd"; 224// } 225// 226// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print 227// 228// Value of: IsEven(Fib(6)) 229// Actual: true (8 is even) 230// Expected: false 231// 232// NB: Predicates that support negative Boolean assertions have reduced 233// performance in positive ones so be careful not to use them in tests 234// that have lots (tens of thousands) of positive Boolean assertions. 235// 236// To use this class with EXPECT_PRED_FORMAT assertions such as: 237// 238// // Verifies that Foo() returns an even number. 239// EXPECT_PRED_FORMAT1(IsEven, Foo()); 240// 241// you need to define: 242// 243// testing::AssertionResult IsEven(const char* expr, int n) { 244// if ((n % 2) == 0) 245// return testing::AssertionSuccess(); 246// else 247// return testing::AssertionFailure() 248// << "Expected: " << expr << " is even\n Actual: it's " << n; 249// } 250// 251// If Foo() returns 5, you will see the following message: 252// 253// Expected: Foo() is even 254// Actual: it's 5 255// 256class GTEST_API_ AssertionResult { 257 public: 258 // Copy constructor. 259 // Used in EXPECT_TRUE/FALSE(assertion_result). 260 AssertionResult(const AssertionResult& other); 261 262 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */) 263 264 // Used in the EXPECT_TRUE/FALSE(bool_expression). 265 // 266 // T must be contextually convertible to bool. 267 // 268 // The second parameter prevents this overload from being considered if 269 // the argument is implicitly convertible to AssertionResult. In that case 270 // we want AssertionResult's copy constructor to be used. 271 template <typename T> 272 explicit AssertionResult( 273 const T& success, 274 typename internal::EnableIf< 275 !internal::ImplicitlyConvertible<T, AssertionResult>::value>::type* 276 /*enabler*/ = NULL) 277 : success_(success) {} 278 279 GTEST_DISABLE_MSC_WARNINGS_POP_() 280 281 // Assignment operator. 282 AssertionResult& operator=(AssertionResult other) { 283 swap(other); 284 return *this; 285 } 286 287 // Returns true iff the assertion succeeded. 288 operator bool() const { return success_; } // NOLINT 289 290 // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. 291 AssertionResult operator!() const; 292 293 // Returns the text streamed into this AssertionResult. Test assertions 294 // use it when they fail (i.e., the predicate's outcome doesn't match the 295 // assertion's expectation). When nothing has been streamed into the 296 // object, returns an empty string. 297 const char* message() const { 298 return message_.get() != NULL ? message_->c_str() : ""; 299 } 300 // TODO(vladl@google.com): Remove this after making sure no clients use it. 301 // Deprecated; please use message() instead. 302 const char* failure_message() const { return message(); } 303 304 // Streams a custom failure message into this object. 305 template <typename T> AssertionResult& operator<<(const T& value) { 306 AppendMessage(Message() << value); 307 return *this; 308 } 309 310 // Allows streaming basic output manipulators such as endl or flush into 311 // this object. 312 AssertionResult& operator<<( 313 ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) { 314 AppendMessage(Message() << basic_manipulator); 315 return *this; 316 } 317 318 private: 319 // Appends the contents of message to message_. 320 void AppendMessage(const Message& a_message) { 321 if (message_.get() == NULL) 322 message_.reset(new ::std::string); 323 message_->append(a_message.GetString().c_str()); 324 } 325 326 // Swap the contents of this AssertionResult with other. 327 void swap(AssertionResult& other); 328 329 // Stores result of the assertion predicate. 330 bool success_; 331 // Stores the message describing the condition in case the expectation 332 // construct is not satisfied with the predicate's outcome. 333 // Referenced via a pointer to avoid taking too much stack frame space 334 // with test assertions. 335 internal::scoped_ptr< ::std::string> message_; 336}; 337 338// Makes a successful assertion result. 339GTEST_API_ AssertionResult AssertionSuccess(); 340 341// Makes a failed assertion result. 342GTEST_API_ AssertionResult AssertionFailure(); 343 344// Makes a failed assertion result with the given failure message. 345// Deprecated; use AssertionFailure() << msg. 346GTEST_API_ AssertionResult AssertionFailure(const Message& msg); 347 348// The abstract class that all tests inherit from. 349// 350// In Google Test, a unit test program contains one or many TestCases, and 351// each TestCase contains one or many Tests. 352// 353// When you define a test using the TEST macro, you don't need to 354// explicitly derive from Test - the TEST macro automatically does 355// this for you. 356// 357// The only time you derive from Test is when defining a test fixture 358// to be used a TEST_F. For example: 359// 360// class FooTest : public testing::Test { 361// protected: 362// void SetUp() override { ... } 363// void TearDown() override { ... } 364// ... 365// }; 366// 367// TEST_F(FooTest, Bar) { ... } 368// TEST_F(FooTest, Baz) { ... } 369// 370// Test is not copyable. 371class GTEST_API_ Test { 372 public: 373 friend class TestInfo; 374 375 // Defines types for pointers to functions that set up and tear down 376 // a test case. 377 typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc; 378 typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc; 379 380 // The d'tor is virtual as we intend to inherit from Test. 381 virtual ~Test(); 382 383 // Sets up the stuff shared by all tests in this test case. 384 // 385 // Google Test will call Foo::SetUpTestCase() before running the first 386 // test in test case Foo. Hence a sub-class can define its own 387 // SetUpTestCase() method to shadow the one defined in the super 388 // class. 389 static void SetUpTestCase() {} 390 391 // Tears down the stuff shared by all tests in this test case. 392 // 393 // Google Test will call Foo::TearDownTestCase() after running the last 394 // test in test case Foo. Hence a sub-class can define its own 395 // TearDownTestCase() method to shadow the one defined in the super 396 // class. 397 static void TearDownTestCase() {} 398 399 // Returns true iff the current test has a fatal failure. 400 static bool HasFatalFailure(); 401 402 // Returns true iff the current test has a non-fatal failure. 403 static bool HasNonfatalFailure(); 404 405 // Returns true iff the current test has a (either fatal or 406 // non-fatal) failure. 407 static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); } 408 409 // Logs a property for the current test, test case, or for the entire 410 // invocation of the test program when used outside of the context of a 411 // test case. Only the last value for a given key is remembered. These 412 // are public static so they can be called from utility functions that are 413 // not members of the test fixture. Calls to RecordProperty made during 414 // lifespan of the test (from the moment its constructor starts to the 415 // moment its destructor finishes) will be output in XML as attributes of 416 // the <testcase> element. Properties recorded from fixture's 417 // SetUpTestCase or TearDownTestCase are logged as attributes of the 418 // corresponding <testsuite> element. Calls to RecordProperty made in the 419 // global context (before or after invocation of RUN_ALL_TESTS and from 420 // SetUp/TearDown method of Environment objects registered with Google 421 // Test) will be output as attributes of the <testsuites> element. 422 static void RecordProperty(const std::string& key, const std::string& value); 423 static void RecordProperty(const std::string& key, int value); 424 425 protected: 426 // Creates a Test object. 427 Test(); 428 429 // Sets up the test fixture. 430 virtual void SetUp(); 431 432 // Tears down the test fixture. 433 virtual void TearDown(); 434 435 private: 436 // Returns true iff the current test has the same fixture class as 437 // the first test in the current test case. 438 static bool HasSameFixtureClass(); 439 440 // Runs the test after the test fixture has been set up. 441 // 442 // A sub-class must implement this to define the test logic. 443 // 444 // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM. 445 // Instead, use the TEST or TEST_F macro. 446 virtual void TestBody() = 0; 447 448 // Sets up, executes, and tears down the test. 449 void Run(); 450 451 // Deletes self. We deliberately pick an unusual name for this 452 // internal method to avoid clashing with names used in user TESTs. 453 void DeleteSelf_() { delete this; } 454 455 const internal::scoped_ptr< GTEST_FLAG_SAVER_ > gtest_flag_saver_; 456 457 // Often a user misspells SetUp() as Setup() and spends a long time 458 // wondering why it is never called by Google Test. The declaration of 459 // the following method is solely for catching such an error at 460 // compile time: 461 // 462 // - The return type is deliberately chosen to be not void, so it 463 // will be a conflict if void Setup() is declared in the user's 464 // test fixture. 465 // 466 // - This method is private, so it will be another compiler error 467 // if the method is called from the user's test fixture. 468 // 469 // DO NOT OVERRIDE THIS FUNCTION. 470 // 471 // If you see an error about overriding the following function or 472 // about it being private, you have mis-spelled SetUp() as Setup(). 473 struct Setup_should_be_spelled_SetUp {}; 474 virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } 475 476 // We disallow copying Tests. 477 GTEST_DISALLOW_COPY_AND_ASSIGN_(Test); 478}; 479 480typedef internal::TimeInMillis TimeInMillis; 481 482// A copyable object representing a user specified test property which can be 483// output as a key/value string pair. 484// 485// Don't inherit from TestProperty as its destructor is not virtual. 486class TestProperty { 487 public: 488 // C'tor. TestProperty does NOT have a default constructor. 489 // Always use this constructor (with parameters) to create a 490 // TestProperty object. 491 TestProperty(const std::string& a_key, const std::string& a_value) : 492 key_(a_key), value_(a_value) { 493 } 494 495 // Gets the user supplied key. 496 const char* key() const { 497 return key_.c_str(); 498 } 499 500 // Gets the user supplied value. 501 const char* value() const { 502 return value_.c_str(); 503 } 504 505 // Sets a new value, overriding the one supplied in the constructor. 506 void SetValue(const std::string& new_value) { 507 value_ = new_value; 508 } 509 510 private: 511 // The key supplied by the user. 512 std::string key_; 513 // The value supplied by the user. 514 std::string value_; 515}; 516 517// The result of a single Test. This includes a list of 518// TestPartResults, a list of TestProperties, a count of how many 519// death tests there are in the Test, and how much time it took to run 520// the Test. 521// 522// TestResult is not copyable. 523class GTEST_API_ TestResult { 524 public: 525 // Creates an empty TestResult. 526 TestResult(); 527 528 // D'tor. Do not inherit from TestResult. 529 ~TestResult(); 530 531 // Gets the number of all test parts. This is the sum of the number 532 // of successful test parts and the number of failed test parts. 533 int total_part_count() const; 534 535 // Returns the number of the test properties. 536 int test_property_count() const; 537 538 // Returns true iff the test passed (i.e. no test part failed). 539 bool Passed() const { return !Failed(); } 540 541 // Returns true iff the test failed. 542 bool Failed() const; 543 544 // Returns true iff the test fatally failed. 545 bool HasFatalFailure() const; 546 547 // Returns true iff the test has a non-fatal failure. 548 bool HasNonfatalFailure() const; 549 550 // Returns the elapsed time, in milliseconds. 551 TimeInMillis elapsed_time() const { return elapsed_time_; } 552 553 // Returns the i-th test part result among all the results. i can range 554 // from 0 to test_property_count() - 1. If i is not in that range, aborts 555 // the program. 556 const TestPartResult& GetTestPartResult(int i) const; 557 558 // Returns the i-th test property. i can range from 0 to 559 // test_property_count() - 1. If i is not in that range, aborts the 560 // program. 561 const TestProperty& GetTestProperty(int i) const; 562 563 private: 564 friend class TestInfo; 565 friend class TestCase; 566 friend class UnitTest; 567 friend class internal::DefaultGlobalTestPartResultReporter; 568 friend class internal::ExecDeathTest; 569 friend class internal::TestResultAccessor; 570 friend class internal::UnitTestImpl; 571 friend class internal::WindowsDeathTest; 572 573 // Gets the vector of TestPartResults. 574 const std::vector<TestPartResult>& test_part_results() const { 575 return test_part_results_; 576 } 577 578 // Gets the vector of TestProperties. 579 const std::vector<TestProperty>& test_properties() const { 580 return test_properties_; 581 } 582 583 // Sets the elapsed time. 584 void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; } 585 586 // Adds a test property to the list. The property is validated and may add 587 // a non-fatal failure if invalid (e.g., if it conflicts with reserved 588 // key names). If a property is already recorded for the same key, the 589 // value will be updated, rather than storing multiple values for the same 590 // key. xml_element specifies the element for which the property is being 591 // recorded and is used for validation. 592 void RecordProperty(const std::string& xml_element, 593 const TestProperty& test_property); 594 595 // Adds a failure if the key is a reserved attribute of Google Test 596 // testcase tags. Returns true if the property is valid. 597 // TODO(russr): Validate attribute names are legal and human readable. 598 static bool ValidateTestProperty(const std::string& xml_element, 599 const TestProperty& test_property); 600 601 // Adds a test part result to the list. 602 void AddTestPartResult(const TestPartResult& test_part_result); 603 604 // Returns the death test count. 605 int death_test_count() const { return death_test_count_; } 606 607 // Increments the death test count, returning the new count. 608 int increment_death_test_count() { return ++death_test_count_; } 609 610 // Clears the test part results. 611 void ClearTestPartResults(); 612 613 // Clears the object. 614 void Clear(); 615 616 // Protects mutable state of the property vector and of owned 617 // properties, whose values may be updated. 618 internal::Mutex test_properites_mutex_; 619 620 // The vector of TestPartResults 621 std::vector<TestPartResult> test_part_results_; 622 // The vector of TestProperties 623 std::vector<TestProperty> test_properties_; 624 // Running count of death tests. 625 int death_test_count_; 626 // The elapsed time, in milliseconds. 627 TimeInMillis elapsed_time_; 628 629 // We disallow copying TestResult. 630 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult); 631}; // class TestResult 632 633// A TestInfo object stores the following information about a test: 634// 635// Test case name 636// Test name 637// Whether the test should be run 638// A function pointer that creates the test object when invoked 639// Test result 640// 641// The constructor of TestInfo registers itself with the UnitTest 642// singleton such that the RUN_ALL_TESTS() macro knows which tests to 643// run. 644class GTEST_API_ TestInfo { 645 public: 646 // Destructs a TestInfo object. This function is not virtual, so 647 // don't inherit from TestInfo. 648 ~TestInfo(); 649 650 // Returns the test case name. 651 const char* test_case_name() const { return test_case_name_.c_str(); } 652 653 // Returns the test name. 654 const char* name() const { return name_.c_str(); } 655 656 // Returns the name of the parameter type, or NULL if this is not a typed 657 // or a type-parameterized test. 658 const char* type_param() const { 659 if (type_param_.get() != NULL) 660 return type_param_->c_str(); 661 return NULL; 662 } 663 664 // Returns the text representation of the value parameter, or NULL if this 665 // is not a value-parameterized test. 666 const char* value_param() const { 667 if (value_param_.get() != NULL) 668 return value_param_->c_str(); 669 return NULL; 670 } 671 672 // Returns the file name where this test is defined. 673 const char* file() const { return location_.file.c_str(); } 674 675 // Returns the line where this test is defined. 676 int line() const { return location_.line; } 677 678 // Returns true if this test should run, that is if the test is not 679 // disabled (or it is disabled but the also_run_disabled_tests flag has 680 // been specified) and its full name matches the user-specified filter. 681 // 682 // Google Test allows the user to filter the tests by their full names. 683 // The full name of a test Bar in test case Foo is defined as 684 // "Foo.Bar". Only the tests that match the filter will run. 685 // 686 // A filter is a colon-separated list of glob (not regex) patterns, 687 // optionally followed by a '-' and a colon-separated list of 688 // negative patterns (tests to exclude). A test is run if it 689 // matches one of the positive patterns and does not match any of 690 // the negative patterns. 691 // 692 // For example, *A*:Foo.* is a filter that matches any string that 693 // contains the character 'A' or starts with "Foo.". 694 bool should_run() const { return should_run_; } 695 696 // Returns true iff this test will appear in the XML report. 697 bool is_reportable() const { 698 // For now, the XML report includes all tests matching the filter. 699 // In the future, we may trim tests that are excluded because of 700 // sharding. 701 return matches_filter_; 702 } 703 704 // Returns the result of the test. 705 const TestResult* result() const { return &result_; } 706 707 private: 708#if GTEST_HAS_DEATH_TEST 709 friend class internal::DefaultDeathTestFactory; 710#endif // GTEST_HAS_DEATH_TEST 711 friend class Test; 712 friend class TestCase; 713 friend class internal::UnitTestImpl; 714 friend class internal::StreamingListenerTest; 715 friend TestInfo* internal::MakeAndRegisterTestInfo( 716 const char* test_case_name, 717 const char* name, 718 const char* type_param, 719 const char* value_param, 720 internal::CodeLocation code_location, 721 internal::TypeId fixture_class_id, 722 Test::SetUpTestCaseFunc set_up_tc, 723 Test::TearDownTestCaseFunc tear_down_tc, 724 internal::TestFactoryBase* factory); 725 726 // Constructs a TestInfo object. The newly constructed instance assumes 727 // ownership of the factory object. 728 TestInfo(const std::string& test_case_name, 729 const std::string& name, 730 const char* a_type_param, // NULL if not a type-parameterized test 731 const char* a_value_param, // NULL if not a value-parameterized test 732 internal::CodeLocation a_code_location, 733 internal::TypeId fixture_class_id, 734 internal::TestFactoryBase* factory); 735 736 // Increments the number of death tests encountered in this test so 737 // far. 738 int increment_death_test_count() { 739 return result_.increment_death_test_count(); 740 } 741 742 // Creates the test object, runs it, records its result, and then 743 // deletes it. 744 void Run(); 745 746 static void ClearTestResult(TestInfo* test_info) { 747 test_info->result_.Clear(); 748 } 749 750 // These fields are immutable properties of the test. 751 const std::string test_case_name_; // Test case name 752 const std::string name_; // Test name 753 // Name of the parameter type, or NULL if this is not a typed or a 754 // type-parameterized test. 755 const internal::scoped_ptr<const ::std::string> type_param_; 756 // Text representation of the value parameter, or NULL if this is not a 757 // value-parameterized test. 758 const internal::scoped_ptr<const ::std::string> value_param_; 759 internal::CodeLocation location_; 760 const internal::TypeId fixture_class_id_; // ID of the test fixture class 761 bool should_run_; // True iff this test should run 762 bool is_disabled_; // True iff this test is disabled 763 bool matches_filter_; // True if this test matches the 764 // user-specified filter. 765 internal::TestFactoryBase* const factory_; // The factory that creates 766 // the test object 767 768 // This field is mutable and needs to be reset before running the 769 // test for the second time. 770 TestResult result_; 771 772 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo); 773}; 774 775// A test case, which consists of a vector of TestInfos. 776// 777// TestCase is not copyable. 778class GTEST_API_ TestCase { 779 public: 780 // Creates a TestCase with the given name. 781 // 782 // TestCase does NOT have a default constructor. Always use this 783 // constructor to create a TestCase object. 784 // 785 // Arguments: 786 // 787 // name: name of the test case 788 // a_type_param: the name of the test's type parameter, or NULL if 789 // this is not a type-parameterized test. 790 // set_up_tc: pointer to the function that sets up the test case 791 // tear_down_tc: pointer to the function that tears down the test case 792 TestCase(const char* name, const char* a_type_param, 793 Test::SetUpTestCaseFunc set_up_tc, 794 Test::TearDownTestCaseFunc tear_down_tc); 795 796 // Destructor of TestCase. 797 virtual ~TestCase(); 798 799 // Gets the name of the TestCase. 800 const char* name() const { return name_.c_str(); } 801 802 // Returns the name of the parameter type, or NULL if this is not a 803 // type-parameterized test case. 804 const char* type_param() const { 805 if (type_param_.get() != NULL) 806 return type_param_->c_str(); 807 return NULL; 808 } 809 810 // Returns true if any test in this test case should run. 811 bool should_run() const { return should_run_; } 812 813 // Gets the number of successful tests in this test case. 814 int successful_test_count() const; 815 816 // Gets the number of failed tests in this test case. 817 int failed_test_count() const; 818 819 // Gets the number of disabled tests that will be reported in the XML report. 820 int reportable_disabled_test_count() const; 821 822 // Gets the number of disabled tests in this test case. 823 int disabled_test_count() const; 824 825 // Gets the number of tests to be printed in the XML report. 826 int reportable_test_count() const; 827 828 // Get the number of tests in this test case that should run. 829 int test_to_run_count() const; 830 831 // Gets the number of all tests in this test case. 832 int total_test_count() const; 833 834 // Returns true iff the test case passed. 835 bool Passed() const { return !Failed(); } 836 837 // Returns true iff the test case failed. 838 bool Failed() const { return failed_test_count() > 0; } 839 840 // Returns the elapsed time, in milliseconds. 841 TimeInMillis elapsed_time() const { return elapsed_time_; } 842 843 // Returns the i-th test among all the tests. i can range from 0 to 844 // total_test_count() - 1. If i is not in that range, returns NULL. 845 const TestInfo* GetTestInfo(int i) const; 846 847 // Returns the TestResult that holds test properties recorded during 848 // execution of SetUpTestCase and TearDownTestCase. 849 const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; } 850 851 private: 852 friend class Test; 853 friend class internal::UnitTestImpl; 854 855 // Gets the (mutable) vector of TestInfos in this TestCase. 856 std::vector<TestInfo*>& test_info_list() { return test_info_list_; } 857 858 // Gets the (immutable) vector of TestInfos in this TestCase. 859 const std::vector<TestInfo*>& test_info_list() const { 860 return test_info_list_; 861 } 862 863 // Returns the i-th test among all the tests. i can range from 0 to 864 // total_test_count() - 1. If i is not in that range, returns NULL. 865 TestInfo* GetMutableTestInfo(int i); 866 867 // Sets the should_run member. 868 void set_should_run(bool should) { should_run_ = should; } 869 870 // Adds a TestInfo to this test case. Will delete the TestInfo upon 871 // destruction of the TestCase object. 872 void AddTestInfo(TestInfo * test_info); 873 874 // Clears the results of all tests in this test case. 875 void ClearResult(); 876 877 // Clears the results of all tests in the given test case. 878 static void ClearTestCaseResult(TestCase* test_case) { 879 test_case->ClearResult(); 880 } 881 882 // Runs every test in this TestCase. 883 void Run(); 884 885 // Runs SetUpTestCase() for this TestCase. This wrapper is needed 886 // for catching exceptions thrown from SetUpTestCase(). 887 void RunSetUpTestCase() { (*set_up_tc_)(); } 888 889 // Runs TearDownTestCase() for this TestCase. This wrapper is 890 // needed for catching exceptions thrown from TearDownTestCase(). 891 void RunTearDownTestCase() { (*tear_down_tc_)(); } 892 893 // Returns true iff test passed. 894 static bool TestPassed(const TestInfo* test_info) { 895 return test_info->should_run() && test_info->result()->Passed(); 896 } 897 898 // Returns true iff test failed. 899 static bool TestFailed(const TestInfo* test_info) { 900 return test_info->should_run() && test_info->result()->Failed(); 901 } 902 903 // Returns true iff the test is disabled and will be reported in the XML 904 // report. 905 static bool TestReportableDisabled(const TestInfo* test_info) { 906 return test_info->is_reportable() && test_info->is_disabled_; 907 } 908 909 // Returns true iff test is disabled. 910 static bool TestDisabled(const TestInfo* test_info) { 911 return test_info->is_disabled_; 912 } 913 914 // Returns true iff this test will appear in the XML report. 915 static bool TestReportable(const TestInfo* test_info) { 916 return test_info->is_reportable(); 917 } 918 919 // Returns true if the given test should run. 920 static bool ShouldRunTest(const TestInfo* test_info) { 921 return test_info->should_run(); 922 } 923 924 // Shuffles the tests in this test case. 925 void ShuffleTests(internal::Random* random); 926 927 // Restores the test order to before the first shuffle. 928 void UnshuffleTests(); 929 930 // Name of the test case. 931 std::string name_; 932 // Name of the parameter type, or NULL if this is not a typed or a 933 // type-parameterized test. 934 const internal::scoped_ptr<const ::std::string> type_param_; 935 // The vector of TestInfos in their original order. It owns the 936 // elements in the vector. 937 std::vector<TestInfo*> test_info_list_; 938 // Provides a level of indirection for the test list to allow easy 939 // shuffling and restoring the test order. The i-th element in this 940 // vector is the index of the i-th test in the shuffled test list. 941 std::vector<int> test_indices_; 942 // Pointer to the function that sets up the test case. 943 Test::SetUpTestCaseFunc set_up_tc_; 944 // Pointer to the function that tears down the test case. 945 Test::TearDownTestCaseFunc tear_down_tc_; 946 // True iff any test in this test case should run. 947 bool should_run_; 948 // Elapsed time, in milliseconds. 949 TimeInMillis elapsed_time_; 950 // Holds test properties recorded during execution of SetUpTestCase and 951 // TearDownTestCase. 952 TestResult ad_hoc_test_result_; 953 954 // We disallow copying TestCases. 955 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase); 956}; 957 958// An Environment object is capable of setting up and tearing down an 959// environment. You should subclass this to define your own 960// environment(s). 961// 962// An Environment object does the set-up and tear-down in virtual 963// methods SetUp() and TearDown() instead of the constructor and the 964// destructor, as: 965// 966// 1. You cannot safely throw from a destructor. This is a problem 967// as in some cases Google Test is used where exceptions are enabled, and 968// we may want to implement ASSERT_* using exceptions where they are 969// available. 970// 2. You cannot use ASSERT_* directly in a constructor or 971// destructor. 972class Environment { 973 public: 974 // The d'tor is virtual as we need to subclass Environment. 975 virtual ~Environment() {} 976 977 // Override this to define how to set up the environment. 978 virtual void SetUp() {} 979 980 // Override this to define how to tear down the environment. 981 virtual void TearDown() {} 982 private: 983 // If you see an error about overriding the following function or 984 // about it being private, you have mis-spelled SetUp() as Setup(). 985 struct Setup_should_be_spelled_SetUp {}; 986 virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } 987}; 988 989// The interface for tracing execution of tests. The methods are organized in 990// the order the corresponding events are fired. 991class TestEventListener { 992 public: 993 virtual ~TestEventListener() {} 994 995 // Fired before any test activity starts. 996 virtual void OnTestProgramStart(const UnitTest& unit_test) = 0; 997 998 // Fired before each iteration of tests starts. There may be more than 999 // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration 1000 // index, starting from 0. 1001 virtual void OnTestIterationStart(const UnitTest& unit_test, 1002 int iteration) = 0; 1003 1004 // Fired before environment set-up for each iteration of tests starts. 1005 virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0; 1006 1007 // Fired after environment set-up for each iteration of tests ends. 1008 virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0; 1009 1010 // Fired before the test case starts. 1011 virtual void OnTestCaseStart(const TestCase& test_case) = 0; 1012 1013 // Fired before the test starts. 1014 virtual void OnTestStart(const TestInfo& test_info) = 0; 1015 1016 // Fired after a failed assertion or a SUCCEED() invocation. 1017 virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0; 1018 1019 // Fired after the test ends. 1020 virtual void OnTestEnd(const TestInfo& test_info) = 0; 1021 1022 // Fired after the test case ends. 1023 virtual void OnTestCaseEnd(const TestCase& test_case) = 0; 1024 1025 // Fired before environment tear-down for each iteration of tests starts. 1026 virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0; 1027 1028 // Fired after environment tear-down for each iteration of tests ends. 1029 virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0; 1030 1031 // Fired after each iteration of tests finishes. 1032 virtual void OnTestIterationEnd(const UnitTest& unit_test, 1033 int iteration) = 0; 1034 1035 // Fired after all test activities have ended. 1036 virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0; 1037}; 1038 1039// The convenience class for users who need to override just one or two 1040// methods and are not concerned that a possible change to a signature of 1041// the methods they override will not be caught during the build. For 1042// comments about each method please see the definition of TestEventListener 1043// above. 1044class EmptyTestEventListener : public TestEventListener { 1045 public: 1046 virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} 1047 virtual void OnTestIterationStart(const UnitTest& /*unit_test*/, 1048 int /*iteration*/) {} 1049 virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {} 1050 virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} 1051 virtual void OnTestCaseStart(const TestCase& /*test_case*/) {} 1052 virtual void OnTestStart(const TestInfo& /*test_info*/) {} 1053 virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {} 1054 virtual void OnTestEnd(const TestInfo& /*test_info*/) {} 1055 virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {} 1056 virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {} 1057 virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} 1058 virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/, 1059 int /*iteration*/) {} 1060 virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} 1061}; 1062 1063// TestEventListeners lets users add listeners to track events in Google Test. 1064class GTEST_API_ TestEventListeners { 1065 public: 1066 TestEventListeners(); 1067 ~TestEventListeners(); 1068 1069 // Appends an event listener to the end of the list. Google Test assumes 1070 // the ownership of the listener (i.e. it will delete the listener when 1071 // the test program finishes). 1072 void Append(TestEventListener* listener); 1073 1074 // Removes the given event listener from the list and returns it. It then 1075 // becomes the caller's responsibility to delete the listener. Returns 1076 // NULL if the listener is not found in the list. 1077 TestEventListener* Release(TestEventListener* listener); 1078 1079 // Returns the standard listener responsible for the default console 1080 // output. Can be removed from the listeners list to shut down default 1081 // console output. Note that removing this object from the listener list 1082 // with Release transfers its ownership to the caller and makes this 1083 // function return NULL the next time. 1084 TestEventListener* default_result_printer() const { 1085 return default_result_printer_; 1086 } 1087 1088 // Returns the standard listener responsible for the default XML output 1089 // controlled by the --gtest_output=xml flag. Can be removed from the 1090 // listeners list by users who want to shut down the default XML output 1091 // controlled by this flag and substitute it with custom one. Note that 1092 // removing this object from the listener list with Release transfers its 1093 // ownership to the caller and makes this function return NULL the next 1094 // time. 1095 TestEventListener* default_xml_generator() const { 1096 return default_xml_generator_; 1097 } 1098 1099 private: 1100 friend class TestCase; 1101 friend class TestInfo; 1102 friend class internal::DefaultGlobalTestPartResultReporter; 1103 friend class internal::NoExecDeathTest; 1104 friend class internal::TestEventListenersAccessor; 1105 friend class internal::UnitTestImpl; 1106 1107 // Returns repeater that broadcasts the TestEventListener events to all 1108 // subscribers. 1109 TestEventListener* repeater(); 1110 1111 // Sets the default_result_printer attribute to the provided listener. 1112 // The listener is also added to the listener list and previous 1113 // default_result_printer is removed from it and deleted. The listener can 1114 // also be NULL in which case it will not be added to the list. Does 1115 // nothing if the previous and the current listener objects are the same. 1116 void SetDefaultResultPrinter(TestEventListener* listener); 1117 1118 // Sets the default_xml_generator attribute to the provided listener. The 1119 // listener is also added to the listener list and previous 1120 // default_xml_generator is removed from it and deleted. The listener can 1121 // also be NULL in which case it will not be added to the list. Does 1122 // nothing if the previous and the current listener objects are the same. 1123 void SetDefaultXmlGenerator(TestEventListener* listener); 1124 1125 // Controls whether events will be forwarded by the repeater to the 1126 // listeners in the list. 1127 bool EventForwardingEnabled() const; 1128 void SuppressEventForwarding(); 1129 1130 // The actual list of listeners. 1131 internal::TestEventRepeater* repeater_; 1132 // Listener responsible for the standard result output. 1133 TestEventListener* default_result_printer_; 1134 // Listener responsible for the creation of the XML output file. 1135 TestEventListener* default_xml_generator_; 1136 1137 // We disallow copying TestEventListeners. 1138 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners); 1139}; 1140 1141// A UnitTest consists of a vector of TestCases. 1142// 1143// This is a singleton class. The only instance of UnitTest is 1144// created when UnitTest::GetInstance() is first called. This 1145// instance is never deleted. 1146// 1147// UnitTest is not copyable. 1148// 1149// This class is thread-safe as long as the methods are called 1150// according to their specification. 1151class GTEST_API_ UnitTest { 1152 public: 1153 // Gets the singleton UnitTest object. The first time this method 1154 // is called, a UnitTest object is constructed and returned. 1155 // Consecutive calls will return the same object. 1156 static UnitTest* GetInstance(); 1157 1158 // Runs all tests in this UnitTest object and prints the result. 1159 // Returns 0 if successful, or 1 otherwise. 1160 // 1161 // This method can only be called from the main thread. 1162 // 1163 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1164 int Run() GTEST_MUST_USE_RESULT_; 1165 1166 // Returns the working directory when the first TEST() or TEST_F() 1167 // was executed. The UnitTest object owns the string. 1168 const char* original_working_dir() const; 1169 1170 // Returns the TestCase object for the test that's currently running, 1171 // or NULL if no test is running. 1172 const TestCase* current_test_case() const 1173 GTEST_LOCK_EXCLUDED_(mutex_); 1174 1175 // Returns the TestInfo object for the test that's currently running, 1176 // or NULL if no test is running. 1177 const TestInfo* current_test_info() const 1178 GTEST_LOCK_EXCLUDED_(mutex_); 1179 1180 // Returns the random seed used at the start of the current test run. 1181 int random_seed() const; 1182 1183#if GTEST_HAS_PARAM_TEST 1184 // Returns the ParameterizedTestCaseRegistry object used to keep track of 1185 // value-parameterized tests and instantiate and register them. 1186 // 1187 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1188 internal::ParameterizedTestCaseRegistry& parameterized_test_registry() 1189 GTEST_LOCK_EXCLUDED_(mutex_); 1190#endif // GTEST_HAS_PARAM_TEST 1191 1192 // Gets the number of successful test cases. 1193 int successful_test_case_count() const; 1194 1195 // Gets the number of failed test cases. 1196 int failed_test_case_count() const; 1197 1198 // Gets the number of all test cases. 1199 int total_test_case_count() const; 1200 1201 // Gets the number of all test cases that contain at least one test 1202 // that should run. 1203 int test_case_to_run_count() const; 1204 1205 // Gets the number of successful tests. 1206 int successful_test_count() const; 1207 1208 // Gets the number of failed tests. 1209 int failed_test_count() const; 1210 1211 // Gets the number of disabled tests that will be reported in the XML report. 1212 int reportable_disabled_test_count() const; 1213 1214 // Gets the number of disabled tests. 1215 int disabled_test_count() const; 1216 1217 // Gets the number of tests to be printed in the XML report. 1218 int reportable_test_count() const; 1219 1220 // Gets the number of all tests. 1221 int total_test_count() const; 1222 1223 // Gets the number of tests that should run. 1224 int test_to_run_count() const; 1225 1226 // Gets the time of the test program start, in ms from the start of the 1227 // UNIX epoch. 1228 TimeInMillis start_timestamp() const; 1229 1230 // Gets the elapsed time, in milliseconds. 1231 TimeInMillis elapsed_time() const; 1232 1233 // Returns true iff the unit test passed (i.e. all test cases passed). 1234 bool Passed() const; 1235 1236 // Returns true iff the unit test failed (i.e. some test case failed 1237 // or something outside of all tests failed). 1238 bool Failed() const; 1239 1240 // Gets the i-th test case among all the test cases. i can range from 0 to 1241 // total_test_case_count() - 1. If i is not in that range, returns NULL. 1242 const TestCase* GetTestCase(int i) const; 1243 1244 // Returns the TestResult containing information on test failures and 1245 // properties logged outside of individual test cases. 1246 const TestResult& ad_hoc_test_result() const; 1247 1248 // Returns the list of event listeners that can be used to track events 1249 // inside Google Test. 1250 TestEventListeners& listeners(); 1251 1252 private: 1253 // Registers and returns a global test environment. When a test 1254 // program is run, all global test environments will be set-up in 1255 // the order they were registered. After all tests in the program 1256 // have finished, all global test environments will be torn-down in 1257 // the *reverse* order they were registered. 1258 // 1259 // The UnitTest object takes ownership of the given environment. 1260 // 1261 // This method can only be called from the main thread. 1262 Environment* AddEnvironment(Environment* env); 1263 1264 // Adds a TestPartResult to the current TestResult object. All 1265 // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) 1266 // eventually call this to report their results. The user code 1267 // should use the assertion macros instead of calling this directly. 1268 void AddTestPartResult(TestPartResult::Type result_type, 1269 const char* file_name, 1270 int line_number, 1271 const std::string& message, 1272 const std::string& os_stack_trace) 1273 GTEST_LOCK_EXCLUDED_(mutex_); 1274 1275 // Adds a TestProperty to the current TestResult object when invoked from 1276 // inside a test, to current TestCase's ad_hoc_test_result_ when invoked 1277 // from SetUpTestCase or TearDownTestCase, or to the global property set 1278 // when invoked elsewhere. If the result already contains a property with 1279 // the same key, the value will be updated. 1280 void RecordProperty(const std::string& key, const std::string& value); 1281 1282 // Gets the i-th test case among all the test cases. i can range from 0 to 1283 // total_test_case_count() - 1. If i is not in that range, returns NULL. 1284 TestCase* GetMutableTestCase(int i); 1285 1286 // Accessors for the implementation object. 1287 internal::UnitTestImpl* impl() { return impl_; } 1288 const internal::UnitTestImpl* impl() const { return impl_; } 1289 1290 // These classes and funcions are friends as they need to access private 1291 // members of UnitTest. 1292 friend class Test; 1293 friend class internal::AssertHelper; 1294 friend class internal::ScopedTrace; 1295 friend class internal::StreamingListenerTest; 1296 friend class internal::UnitTestRecordPropertyTestHelper; 1297 friend Environment* AddGlobalTestEnvironment(Environment* env); 1298 friend internal::UnitTestImpl* internal::GetUnitTestImpl(); 1299 friend void internal::ReportFailureInUnknownLocation( 1300 TestPartResult::Type result_type, 1301 const std::string& message); 1302 1303 // Creates an empty UnitTest. 1304 UnitTest(); 1305 1306 // D'tor 1307 virtual ~UnitTest(); 1308 1309 // Pushes a trace defined by SCOPED_TRACE() on to the per-thread 1310 // Google Test trace stack. 1311 void PushGTestTrace(const internal::TraceInfo& trace) 1312 GTEST_LOCK_EXCLUDED_(mutex_); 1313 1314 // Pops a trace from the per-thread Google Test trace stack. 1315 void PopGTestTrace() 1316 GTEST_LOCK_EXCLUDED_(mutex_); 1317 1318 // Protects mutable state in *impl_. This is mutable as some const 1319 // methods need to lock it too. 1320 mutable internal::Mutex mutex_; 1321 1322 // Opaque implementation object. This field is never changed once 1323 // the object is constructed. We don't mark it as const here, as 1324 // doing so will cause a warning in the constructor of UnitTest. 1325 // Mutable state in *impl_ is protected by mutex_. 1326 internal::UnitTestImpl* impl_; 1327 1328 // We disallow copying UnitTest. 1329 GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest); 1330}; 1331 1332// A convenient wrapper for adding an environment for the test 1333// program. 1334// 1335// You should call this before RUN_ALL_TESTS() is called, probably in 1336// main(). If you use gtest_main, you need to call this before main() 1337// starts for it to take effect. For example, you can define a global 1338// variable like this: 1339// 1340// testing::Environment* const foo_env = 1341// testing::AddGlobalTestEnvironment(new FooEnvironment); 1342// 1343// However, we strongly recommend you to write your own main() and 1344// call AddGlobalTestEnvironment() there, as relying on initialization 1345// of global variables makes the code harder to read and may cause 1346// problems when you register multiple environments from different 1347// translation units and the environments have dependencies among them 1348// (remember that the compiler doesn't guarantee the order in which 1349// global variables from different translation units are initialized). 1350inline Environment* AddGlobalTestEnvironment(Environment* env) { 1351 return UnitTest::GetInstance()->AddEnvironment(env); 1352} 1353 1354// Initializes Google Test. This must be called before calling 1355// RUN_ALL_TESTS(). In particular, it parses a command line for the 1356// flags that Google Test recognizes. Whenever a Google Test flag is 1357// seen, it is removed from argv, and *argc is decremented. 1358// 1359// No value is returned. Instead, the Google Test flag variables are 1360// updated. 1361// 1362// Calling the function for the second time has no user-visible effect. 1363GTEST_API_ void InitGoogleTest(int* argc, char** argv); 1364 1365// This overloaded version can be used in Windows programs compiled in 1366// UNICODE mode. 1367GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv); 1368 1369namespace internal { 1370 1371// Separate the error generating code from the code path to reduce the stack 1372// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers 1373// when calling EXPECT_* in a tight loop. 1374template <typename T1, typename T2> 1375AssertionResult CmpHelperEQFailure(const char* lhs_expression, 1376 const char* rhs_expression, 1377 const T1& lhs, const T2& rhs) { 1378 return EqFailure(lhs_expression, 1379 rhs_expression, 1380 FormatForComparisonFailureMessage(lhs, rhs), 1381 FormatForComparisonFailureMessage(rhs, lhs), 1382 false); 1383} 1384 1385// The helper function for {ASSERT|EXPECT}_EQ. 1386template <typename T1, typename T2> 1387AssertionResult CmpHelperEQ(const char* lhs_expression, 1388 const char* rhs_expression, 1389 const T1& lhs, 1390 const T2& rhs) { 1391GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) 1392 if (lhs == rhs) { 1393 return AssertionSuccess(); 1394 } 1395GTEST_DISABLE_MSC_WARNINGS_POP_() 1396 1397 return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); 1398} 1399 1400// With this overloaded version, we allow anonymous enums to be used 1401// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums 1402// can be implicitly cast to BiggestInt. 1403GTEST_API_ AssertionResult CmpHelperEQ(const char* lhs_expression, 1404 const char* rhs_expression, 1405 BiggestInt lhs, 1406 BiggestInt rhs); 1407 1408// The helper class for {ASSERT|EXPECT}_EQ. The template argument 1409// lhs_is_null_literal is true iff the first argument to ASSERT_EQ() 1410// is a null pointer literal. The following default implementation is 1411// for lhs_is_null_literal being false. 1412template <bool lhs_is_null_literal> 1413class EqHelper { 1414 public: 1415 // This templatized version is for the general case. 1416 template <typename T1, typename T2> 1417 static AssertionResult Compare(const char* lhs_expression, 1418 const char* rhs_expression, 1419 const T1& lhs, 1420 const T2& rhs) { 1421 return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); 1422 } 1423 1424 // With this overloaded version, we allow anonymous enums to be used 1425 // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous 1426 // enums can be implicitly cast to BiggestInt. 1427 // 1428 // Even though its body looks the same as the above version, we 1429 // cannot merge the two, as it will make anonymous enums unhappy. 1430 static AssertionResult Compare(const char* lhs_expression, 1431 const char* rhs_expression, 1432 BiggestInt lhs, 1433 BiggestInt rhs) { 1434 return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); 1435 } 1436}; 1437 1438// This specialization is used when the first argument to ASSERT_EQ() 1439// is a null pointer literal, like NULL, false, or 0. 1440template <> 1441class EqHelper<true> { 1442 public: 1443 // We define two overloaded versions of Compare(). The first 1444 // version will be picked when the second argument to ASSERT_EQ() is 1445 // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or 1446 // EXPECT_EQ(false, a_bool). 1447 template <typename T1, typename T2> 1448 static AssertionResult Compare( 1449 const char* lhs_expression, 1450 const char* rhs_expression, 1451 const T1& lhs, 1452 const T2& rhs, 1453 // The following line prevents this overload from being considered if T2 1454 // is not a pointer type. We need this because ASSERT_EQ(NULL, my_ptr) 1455 // expands to Compare("", "", NULL, my_ptr), which requires a conversion 1456 // to match the Secret* in the other overload, which would otherwise make 1457 // this template match better. 1458 typename EnableIf<!is_pointer<T2>::value>::type* = 0) { 1459 return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); 1460 } 1461 1462 // This version will be picked when the second argument to ASSERT_EQ() is a 1463 // pointer, e.g. ASSERT_EQ(NULL, a_pointer). 1464 template <typename T> 1465 static AssertionResult Compare( 1466 const char* lhs_expression, 1467 const char* rhs_expression, 1468 // We used to have a second template parameter instead of Secret*. That 1469 // template parameter would deduce to 'long', making this a better match 1470 // than the first overload even without the first overload's EnableIf. 1471 // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to 1472 // non-pointer argument" (even a deduced integral argument), so the old 1473 // implementation caused warnings in user code. 1474 Secret* /* lhs (NULL) */, 1475 T* rhs) { 1476 // We already know that 'lhs' is a null pointer. 1477 return CmpHelperEQ(lhs_expression, rhs_expression, 1478 static_cast<T*>(NULL), rhs); 1479 } 1480}; 1481 1482// Separate the error generating code from the code path to reduce the stack 1483// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers 1484// when calling EXPECT_OP in a tight loop. 1485template <typename T1, typename T2> 1486AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2, 1487 const T1& val1, const T2& val2, 1488 const char* op) { 1489 return AssertionFailure() 1490 << "Expected: (" << expr1 << ") " << op << " (" << expr2 1491 << "), actual: " << FormatForComparisonFailureMessage(val1, val2) 1492 << " vs " << FormatForComparisonFailureMessage(val2, val1); 1493} 1494 1495// A macro for implementing the helper functions needed to implement 1496// ASSERT_?? and EXPECT_??. It is here just to avoid copy-and-paste 1497// of similar code. 1498// 1499// For each templatized helper function, we also define an overloaded 1500// version for BiggestInt in order to reduce code bloat and allow 1501// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled 1502// with gcc 4. 1503// 1504// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1505 1506#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ 1507template <typename T1, typename T2>\ 1508AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ 1509 const T1& val1, const T2& val2) {\ 1510 if (val1 op val2) {\ 1511 return AssertionSuccess();\ 1512 } else {\ 1513 return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\ 1514 }\ 1515}\ 1516GTEST_API_ AssertionResult CmpHelper##op_name(\ 1517 const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2) 1518 1519// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1520 1521// Implements the helper function for {ASSERT|EXPECT}_NE 1522GTEST_IMPL_CMP_HELPER_(NE, !=); 1523// Implements the helper function for {ASSERT|EXPECT}_LE 1524GTEST_IMPL_CMP_HELPER_(LE, <=); 1525// Implements the helper function for {ASSERT|EXPECT}_LT 1526GTEST_IMPL_CMP_HELPER_(LT, <); 1527// Implements the helper function for {ASSERT|EXPECT}_GE 1528GTEST_IMPL_CMP_HELPER_(GE, >=); 1529// Implements the helper function for {ASSERT|EXPECT}_GT 1530GTEST_IMPL_CMP_HELPER_(GT, >); 1531 1532#undef GTEST_IMPL_CMP_HELPER_ 1533 1534// The helper function for {ASSERT|EXPECT}_STREQ. 1535// 1536// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1537GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression, 1538 const char* s2_expression, 1539 const char* s1, 1540 const char* s2); 1541 1542// The helper function for {ASSERT|EXPECT}_STRCASEEQ. 1543// 1544// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1545GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression, 1546 const char* s2_expression, 1547 const char* s1, 1548 const char* s2); 1549 1550// The helper function for {ASSERT|EXPECT}_STRNE. 1551// 1552// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1553GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, 1554 const char* s2_expression, 1555 const char* s1, 1556 const char* s2); 1557 1558// The helper function for {ASSERT|EXPECT}_STRCASENE. 1559// 1560// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1561GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression, 1562 const char* s2_expression, 1563 const char* s1, 1564 const char* s2); 1565 1566 1567// Helper function for *_STREQ on wide strings. 1568// 1569// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1570GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression, 1571 const char* s2_expression, 1572 const wchar_t* s1, 1573 const wchar_t* s2); 1574 1575// Helper function for *_STRNE on wide strings. 1576// 1577// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1578GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, 1579 const char* s2_expression, 1580 const wchar_t* s1, 1581 const wchar_t* s2); 1582 1583} // namespace internal 1584 1585// IsSubstring() and IsNotSubstring() are intended to be used as the 1586// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by 1587// themselves. They check whether needle is a substring of haystack 1588// (NULL is considered a substring of itself only), and return an 1589// appropriate error message when they fail. 1590// 1591// The {needle,haystack}_expr arguments are the stringified 1592// expressions that generated the two real arguments. 1593GTEST_API_ AssertionResult IsSubstring( 1594 const char* needle_expr, const char* haystack_expr, 1595 const char* needle, const char* haystack); 1596GTEST_API_ AssertionResult IsSubstring( 1597 const char* needle_expr, const char* haystack_expr, 1598 const wchar_t* needle, const wchar_t* haystack); 1599GTEST_API_ AssertionResult IsNotSubstring( 1600 const char* needle_expr, const char* haystack_expr, 1601 const char* needle, const char* haystack); 1602GTEST_API_ AssertionResult IsNotSubstring( 1603 const char* needle_expr, const char* haystack_expr, 1604 const wchar_t* needle, const wchar_t* haystack); 1605GTEST_API_ AssertionResult IsSubstring( 1606 const char* needle_expr, const char* haystack_expr, 1607 const ::std::string& needle, const ::std::string& haystack); 1608GTEST_API_ AssertionResult IsNotSubstring( 1609 const char* needle_expr, const char* haystack_expr, 1610 const ::std::string& needle, const ::std::string& haystack); 1611 1612#if GTEST_HAS_STD_WSTRING 1613GTEST_API_ AssertionResult IsSubstring( 1614 const char* needle_expr, const char* haystack_expr, 1615 const ::std::wstring& needle, const ::std::wstring& haystack); 1616GTEST_API_ AssertionResult IsNotSubstring( 1617 const char* needle_expr, const char* haystack_expr, 1618 const ::std::wstring& needle, const ::std::wstring& haystack); 1619#endif // GTEST_HAS_STD_WSTRING 1620 1621namespace internal { 1622 1623// Helper template function for comparing floating-points. 1624// 1625// Template parameter: 1626// 1627// RawType: the raw floating-point type (either float or double) 1628// 1629// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1630template <typename RawType> 1631AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression, 1632 const char* rhs_expression, 1633 RawType lhs_value, 1634 RawType rhs_value) { 1635 const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value); 1636 1637 if (lhs.AlmostEquals(rhs)) { 1638 return AssertionSuccess(); 1639 } 1640 1641 ::std::stringstream lhs_ss; 1642 lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) 1643 << lhs_value; 1644 1645 ::std::stringstream rhs_ss; 1646 rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) 1647 << rhs_value; 1648 1649 return EqFailure(lhs_expression, 1650 rhs_expression, 1651 StringStreamToString(&lhs_ss), 1652 StringStreamToString(&rhs_ss), 1653 false); 1654} 1655 1656// Helper function for implementing ASSERT_NEAR. 1657// 1658// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1659GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1, 1660 const char* expr2, 1661 const char* abs_error_expr, 1662 double val1, 1663 double val2, 1664 double abs_error); 1665 1666// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 1667// A class that enables one to stream messages to assertion macros 1668class GTEST_API_ AssertHelper { 1669 public: 1670 // Constructor. 1671 AssertHelper(TestPartResult::Type type, 1672 const char* file, 1673 int line, 1674 const char* message); 1675 ~AssertHelper(); 1676 1677 // Message assignment is a semantic trick to enable assertion 1678 // streaming; see the GTEST_MESSAGE_ macro below. 1679 void operator=(const Message& message) const; 1680 1681 private: 1682 // We put our data in a struct so that the size of the AssertHelper class can 1683 // be as small as possible. This is important because gcc is incapable of 1684 // re-using stack space even for temporary variables, so every EXPECT_EQ 1685 // reserves stack space for another AssertHelper. 1686 struct AssertHelperData { 1687 AssertHelperData(TestPartResult::Type t, 1688 const char* srcfile, 1689 int line_num, 1690 const char* msg) 1691 : type(t), file(srcfile), line(line_num), message(msg) { } 1692 1693 TestPartResult::Type const type; 1694 const char* const file; 1695 int const line; 1696 std::string const message; 1697 1698 private: 1699 GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData); 1700 }; 1701 1702 AssertHelperData* const data_; 1703 1704 GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper); 1705}; 1706 1707} // namespace internal 1708 1709#if GTEST_HAS_PARAM_TEST 1710// The pure interface class that all value-parameterized tests inherit from. 1711// A value-parameterized class must inherit from both ::testing::Test and 1712// ::testing::WithParamInterface. In most cases that just means inheriting 1713// from ::testing::TestWithParam, but more complicated test hierarchies 1714// may need to inherit from Test and WithParamInterface at different levels. 1715// 1716// This interface has support for accessing the test parameter value via 1717// the GetParam() method. 1718// 1719// Use it with one of the parameter generator defining functions, like Range(), 1720// Values(), ValuesIn(), Bool(), and Combine(). 1721// 1722// class FooTest : public ::testing::TestWithParam<int> { 1723// protected: 1724// FooTest() { 1725// // Can use GetParam() here. 1726// } 1727// virtual ~FooTest() { 1728// // Can use GetParam() here. 1729// } 1730// virtual void SetUp() { 1731// // Can use GetParam() here. 1732// } 1733// virtual void TearDown { 1734// // Can use GetParam() here. 1735// } 1736// }; 1737// TEST_P(FooTest, DoesBar) { 1738// // Can use GetParam() method here. 1739// Foo foo; 1740// ASSERT_TRUE(foo.DoesBar(GetParam())); 1741// } 1742// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10)); 1743 1744template <typename T> 1745class WithParamInterface { 1746 public: 1747 typedef T ParamType; 1748 virtual ~WithParamInterface() {} 1749 1750 // The current parameter value. Is also available in the test fixture's 1751 // constructor. This member function is non-static, even though it only 1752 // references static data, to reduce the opportunity for incorrect uses 1753 // like writing 'WithParamInterface<bool>::GetParam()' for a test that 1754 // uses a fixture whose parameter type is int. 1755 const ParamType& GetParam() const { 1756 GTEST_CHECK_(parameter_ != NULL) 1757 << "GetParam() can only be called inside a value-parameterized test " 1758 << "-- did you intend to write TEST_P instead of TEST_F?"; 1759 return *parameter_; 1760 } 1761 1762 private: 1763 // Sets parameter value. The caller is responsible for making sure the value 1764 // remains alive and unchanged throughout the current test. 1765 static void SetParam(const ParamType* parameter) { 1766 parameter_ = parameter; 1767 } 1768 1769 // Static value used for accessing parameter during a test lifetime. 1770 static const ParamType* parameter_; 1771 1772 // TestClass must be a subclass of WithParamInterface<T> and Test. 1773 template <class TestClass> friend class internal::ParameterizedTestFactory; 1774}; 1775 1776template <typename T> 1777const T* WithParamInterface<T>::parameter_ = NULL; 1778 1779// Most value-parameterized classes can ignore the existence of 1780// WithParamInterface, and can just inherit from ::testing::TestWithParam. 1781 1782template <typename T> 1783class TestWithParam : public Test, public WithParamInterface<T> { 1784}; 1785 1786#endif // GTEST_HAS_PARAM_TEST 1787 1788// Macros for indicating success/failure in test code. 1789 1790// ADD_FAILURE unconditionally adds a failure to the current test. 1791// SUCCEED generates a success - it doesn't automatically make the 1792// current test successful, as a test is only successful when it has 1793// no failure. 1794// 1795// EXPECT_* verifies that a certain condition is satisfied. If not, 1796// it behaves like ADD_FAILURE. In particular: 1797// 1798// EXPECT_TRUE verifies that a Boolean condition is true. 1799// EXPECT_FALSE verifies that a Boolean condition is false. 1800// 1801// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except 1802// that they will also abort the current function on failure. People 1803// usually want the fail-fast behavior of FAIL and ASSERT_*, but those 1804// writing data-driven tests often find themselves using ADD_FAILURE 1805// and EXPECT_* more. 1806 1807// Generates a nonfatal failure with a generic message. 1808#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed") 1809 1810// Generates a nonfatal failure at the given source file location with 1811// a generic message. 1812#define ADD_FAILURE_AT(file, line) \ 1813 GTEST_MESSAGE_AT_(file, line, "Failed", \ 1814 ::testing::TestPartResult::kNonFatalFailure) 1815 1816// Generates a fatal failure with a generic message. 1817#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed") 1818 1819// Define this macro to 1 to omit the definition of FAIL(), which is a 1820// generic name and clashes with some other libraries. 1821#if !GTEST_DONT_DEFINE_FAIL 1822# define FAIL() GTEST_FAIL() 1823#endif 1824 1825// Generates a success with a generic message. 1826#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded") 1827 1828// Define this macro to 1 to omit the definition of SUCCEED(), which 1829// is a generic name and clashes with some other libraries. 1830#if !GTEST_DONT_DEFINE_SUCCEED 1831# define SUCCEED() GTEST_SUCCEED() 1832#endif 1833 1834// Macros for testing exceptions. 1835// 1836// * {ASSERT|EXPECT}_THROW(statement, expected_exception): 1837// Tests that the statement throws the expected exception. 1838// * {ASSERT|EXPECT}_NO_THROW(statement): 1839// Tests that the statement doesn't throw any exception. 1840// * {ASSERT|EXPECT}_ANY_THROW(statement): 1841// Tests that the statement throws an exception. 1842 1843#define EXPECT_THROW(statement, expected_exception) \ 1844 GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_) 1845#define EXPECT_NO_THROW(statement) \ 1846 GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_) 1847#define EXPECT_ANY_THROW(statement) \ 1848 GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_) 1849#define ASSERT_THROW(statement, expected_exception) \ 1850 GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_) 1851#define ASSERT_NO_THROW(statement) \ 1852 GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_) 1853#define ASSERT_ANY_THROW(statement) \ 1854 GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_) 1855 1856// Boolean assertions. Condition can be either a Boolean expression or an 1857// AssertionResult. For more information on how to use AssertionResult with 1858// these macros see comments on that class. 1859#define EXPECT_TRUE(condition) \ 1860 GTEST_TEST_BOOLEAN_((condition), #condition, false, true, \ 1861 GTEST_NONFATAL_FAILURE_) 1862#define EXPECT_FALSE(condition) \ 1863 GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ 1864 GTEST_NONFATAL_FAILURE_) 1865#define ASSERT_TRUE(condition) \ 1866 GTEST_TEST_BOOLEAN_((condition), #condition, false, true, \ 1867 GTEST_FATAL_FAILURE_) 1868#define ASSERT_FALSE(condition) \ 1869 GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ 1870 GTEST_FATAL_FAILURE_) 1871 1872// Includes the auto-generated header that implements a family of 1873// generic predicate assertion macros. 1874#include "gtest/gtest_pred_impl.h" 1875 1876// Macros for testing equalities and inequalities. 1877// 1878// * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2 1879// * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2 1880// * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2 1881// * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2 1882// * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2 1883// * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2 1884// 1885// When they are not, Google Test prints both the tested expressions and 1886// their actual values. The values must be compatible built-in types, 1887// or you will get a compiler error. By "compatible" we mean that the 1888// values can be compared by the respective operator. 1889// 1890// Note: 1891// 1892// 1. It is possible to make a user-defined type work with 1893// {ASSERT|EXPECT}_??(), but that requires overloading the 1894// comparison operators and is thus discouraged by the Google C++ 1895// Usage Guide. Therefore, you are advised to use the 1896// {ASSERT|EXPECT}_TRUE() macro to assert that two objects are 1897// equal. 1898// 1899// 2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on 1900// pointers (in particular, C strings). Therefore, if you use it 1901// with two C strings, you are testing how their locations in memory 1902// are related, not how their content is related. To compare two C 1903// strings by content, use {ASSERT|EXPECT}_STR*(). 1904// 1905// 3. {ASSERT|EXPECT}_EQ(v1, v2) is preferred to 1906// {ASSERT|EXPECT}_TRUE(v1 == v2), as the former tells you 1907// what the actual value is when it fails, and similarly for the 1908// other comparisons. 1909// 1910// 4. Do not depend on the order in which {ASSERT|EXPECT}_??() 1911// evaluate their arguments, which is undefined. 1912// 1913// 5. These macros evaluate their arguments exactly once. 1914// 1915// Examples: 1916// 1917// EXPECT_NE(5, Foo()); 1918// EXPECT_EQ(NULL, a_pointer); 1919// ASSERT_LT(i, array_size); 1920// ASSERT_GT(records.size(), 0) << "There is no record left."; 1921 1922#define EXPECT_EQ(val1, val2) \ 1923 EXPECT_PRED_FORMAT2(::testing::internal:: \ 1924 EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \ 1925 val1, val2) 1926#define EXPECT_NE(val1, val2) \ 1927 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) 1928#define EXPECT_LE(val1, val2) \ 1929 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) 1930#define EXPECT_LT(val1, val2) \ 1931 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) 1932#define EXPECT_GE(val1, val2) \ 1933 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) 1934#define EXPECT_GT(val1, val2) \ 1935 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) 1936 1937#define GTEST_ASSERT_EQ(val1, val2) \ 1938 ASSERT_PRED_FORMAT2(::testing::internal:: \ 1939 EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \ 1940 val1, val2) 1941#define GTEST_ASSERT_NE(val1, val2) \ 1942 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) 1943#define GTEST_ASSERT_LE(val1, val2) \ 1944 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) 1945#define GTEST_ASSERT_LT(val1, val2) \ 1946 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) 1947#define GTEST_ASSERT_GE(val1, val2) \ 1948 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) 1949#define GTEST_ASSERT_GT(val1, val2) \ 1950 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) 1951 1952// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of 1953// ASSERT_XY(), which clashes with some users' own code. 1954 1955#if !GTEST_DONT_DEFINE_ASSERT_EQ 1956# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2) 1957#endif 1958 1959#if !GTEST_DONT_DEFINE_ASSERT_NE 1960# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2) 1961#endif 1962 1963#if !GTEST_DONT_DEFINE_ASSERT_LE 1964# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2) 1965#endif 1966 1967#if !GTEST_DONT_DEFINE_ASSERT_LT 1968# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2) 1969#endif 1970 1971#if !GTEST_DONT_DEFINE_ASSERT_GE 1972# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2) 1973#endif 1974 1975#if !GTEST_DONT_DEFINE_ASSERT_GT 1976# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2) 1977#endif 1978 1979// C-string Comparisons. All tests treat NULL and any non-NULL string 1980// as different. Two NULLs are equal. 1981// 1982// * {ASSERT|EXPECT}_STREQ(s1, s2): Tests that s1 == s2 1983// * {ASSERT|EXPECT}_STRNE(s1, s2): Tests that s1 != s2 1984// * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case 1985// * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case 1986// 1987// For wide or narrow string objects, you can use the 1988// {ASSERT|EXPECT}_??() macros. 1989// 1990// Don't depend on the order in which the arguments are evaluated, 1991// which is undefined. 1992// 1993// These macros evaluate their arguments exactly once. 1994 1995#define EXPECT_STREQ(s1, s2) \ 1996 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2) 1997#define EXPECT_STRNE(s1, s2) \ 1998 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) 1999#define EXPECT_STRCASEEQ(s1, s2) \ 2000 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2) 2001#define EXPECT_STRCASENE(s1, s2)\ 2002 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) 2003 2004#define ASSERT_STREQ(s1, s2) \ 2005 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2) 2006#define ASSERT_STRNE(s1, s2) \ 2007 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) 2008#define ASSERT_STRCASEEQ(s1, s2) \ 2009 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2) 2010#define ASSERT_STRCASENE(s1, s2)\ 2011 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) 2012 2013// Macros for comparing floating-point numbers. 2014// 2015// * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2): 2016// Tests that two float values are almost equal. 2017// * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2): 2018// Tests that two double values are almost equal. 2019// * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error): 2020// Tests that v1 and v2 are within the given distance to each other. 2021// 2022// Google Test uses ULP-based comparison to automatically pick a default 2023// error bound that is appropriate for the operands. See the 2024// FloatingPoint template class in gtest-internal.h if you are 2025// interested in the implementation details. 2026 2027#define EXPECT_FLOAT_EQ(val1, val2)\ 2028 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ 2029 val1, val2) 2030 2031#define EXPECT_DOUBLE_EQ(val1, val2)\ 2032 EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ 2033 val1, val2) 2034 2035#define ASSERT_FLOAT_EQ(val1, val2)\ 2036 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ 2037 val1, val2) 2038 2039#define ASSERT_DOUBLE_EQ(val1, val2)\ 2040 ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ 2041 val1, val2) 2042 2043#define EXPECT_NEAR(val1, val2, abs_error)\ 2044 EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ 2045 val1, val2, abs_error) 2046 2047#define ASSERT_NEAR(val1, val2, abs_error)\ 2048 ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ 2049 val1, val2, abs_error) 2050 2051// These predicate format functions work on floating-point values, and 2052// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g. 2053// 2054// EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0); 2055 2056// Asserts that val1 is less than, or almost equal to, val2. Fails 2057// otherwise. In particular, it fails if either val1 or val2 is NaN. 2058GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2, 2059 float val1, float val2); 2060GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2, 2061 double val1, double val2); 2062 2063 2064#if GTEST_OS_WINDOWS 2065 2066// Macros that test for HRESULT failure and success, these are only useful 2067// on Windows, and rely on Windows SDK macros and APIs to compile. 2068// 2069// * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr) 2070// 2071// When expr unexpectedly fails or succeeds, Google Test prints the 2072// expected result and the actual result with both a human-readable 2073// string representation of the error, if available, as well as the 2074// hex result code. 2075# define EXPECT_HRESULT_SUCCEEDED(expr) \ 2076 EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) 2077 2078# define ASSERT_HRESULT_SUCCEEDED(expr) \ 2079 ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) 2080 2081# define EXPECT_HRESULT_FAILED(expr) \ 2082 EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) 2083 2084# define ASSERT_HRESULT_FAILED(expr) \ 2085 ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) 2086 2087#endif // GTEST_OS_WINDOWS 2088 2089// Macros that execute statement and check that it doesn't generate new fatal 2090// failures in the current thread. 2091// 2092// * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement); 2093// 2094// Examples: 2095// 2096// EXPECT_NO_FATAL_FAILURE(Process()); 2097// ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed"; 2098// 2099#define ASSERT_NO_FATAL_FAILURE(statement) \ 2100 GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_) 2101#define EXPECT_NO_FATAL_FAILURE(statement) \ 2102 GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_) 2103 2104// Causes a trace (including the source file path, the current line 2105// number, and the given message) to be included in every test failure 2106// message generated by code in the current scope. The effect is 2107// undone when the control leaves the current scope. 2108// 2109// The message argument can be anything streamable to std::ostream. 2110// 2111// In the implementation, we include the current line number as part 2112// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s 2113// to appear in the same block - as long as they are on different 2114// lines. 2115#define SCOPED_TRACE(message) \ 2116 ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\ 2117 __FILE__, __LINE__, ::testing::Message() << (message)) 2118 2119// Compile-time assertion for type equality. 2120// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are 2121// the same type. The value it returns is not interesting. 2122// 2123// Instead of making StaticAssertTypeEq a class template, we make it a 2124// function template that invokes a helper class template. This 2125// prevents a user from misusing StaticAssertTypeEq<T1, T2> by 2126// defining objects of that type. 2127// 2128// CAVEAT: 2129// 2130// When used inside a method of a class template, 2131// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is 2132// instantiated. For example, given: 2133// 2134// template <typename T> class Foo { 2135// public: 2136// void Bar() { testing::StaticAssertTypeEq<int, T>(); } 2137// }; 2138// 2139// the code: 2140// 2141// void Test1() { Foo<bool> foo; } 2142// 2143// will NOT generate a compiler error, as Foo<bool>::Bar() is never 2144// actually instantiated. Instead, you need: 2145// 2146// void Test2() { Foo<bool> foo; foo.Bar(); } 2147// 2148// to cause a compiler error. 2149template <typename T1, typename T2> 2150bool StaticAssertTypeEq() { 2151 (void)internal::StaticAssertTypeEqHelper<T1, T2>(); 2152 return true; 2153} 2154 2155// Defines a test. 2156// 2157// The first parameter is the name of the test case, and the second 2158// parameter is the name of the test within the test case. 2159// 2160// The convention is to end the test case name with "Test". For 2161// example, a test case for the Foo class can be named FooTest. 2162// 2163// Test code should appear between braces after an invocation of 2164// this macro. Example: 2165// 2166// TEST(FooTest, InitializesCorrectly) { 2167// Foo foo; 2168// EXPECT_TRUE(foo.StatusIsOK()); 2169// } 2170 2171// Note that we call GetTestTypeId() instead of GetTypeId< 2172// ::testing::Test>() here to get the type ID of testing::Test. This 2173// is to work around a suspected linker bug when using Google Test as 2174// a framework on Mac OS X. The bug causes GetTypeId< 2175// ::testing::Test>() to return different values depending on whether 2176// the call is from the Google Test framework itself or from user test 2177// code. GetTestTypeId() is guaranteed to always return the same 2178// value, as it always calls GetTypeId<>() from the Google Test 2179// framework. 2180#define GTEST_TEST(test_case_name, test_name)\ 2181 GTEST_TEST_(test_case_name, test_name, \ 2182 ::testing::Test, ::testing::internal::GetTestTypeId()) 2183 2184// Define this macro to 1 to omit the definition of TEST(), which 2185// is a generic name and clashes with some other libraries. 2186#if !GTEST_DONT_DEFINE_TEST 2187# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name) 2188#endif 2189 2190// Defines a test that uses a test fixture. 2191// 2192// The first parameter is the name of the test fixture class, which 2193// also doubles as the test case name. The second parameter is the 2194// name of the test within the test case. 2195// 2196// A test fixture class must be declared earlier. The user should put 2197// his test code between braces after using this macro. Example: 2198// 2199// class FooTest : public testing::Test { 2200// protected: 2201// virtual void SetUp() { b_.AddElement(3); } 2202// 2203// Foo a_; 2204// Foo b_; 2205// }; 2206// 2207// TEST_F(FooTest, InitializesCorrectly) { 2208// EXPECT_TRUE(a_.StatusIsOK()); 2209// } 2210// 2211// TEST_F(FooTest, ReturnsElementCountCorrectly) { 2212// EXPECT_EQ(0, a_.size()); 2213// EXPECT_EQ(1, b_.size()); 2214// } 2215 2216#define TEST_F(test_fixture, test_name)\ 2217 GTEST_TEST_(test_fixture, test_name, test_fixture, \ 2218 ::testing::internal::GetTypeId<test_fixture>()) 2219 2220} // namespace testing 2221 2222// Use this function in main() to run all tests. It returns 0 if all 2223// tests are successful, or 1 otherwise. 2224// 2225// RUN_ALL_TESTS() should be invoked after the command line has been 2226// parsed by InitGoogleTest(). 2227// 2228// This function was formerly a macro; thus, it is in the global 2229// namespace and has an all-caps name. 2230int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_; 2231 2232inline int RUN_ALL_TESTS() { 2233 return ::testing::UnitTest::GetInstance()->Run(); 2234} 2235 2236#endif // GTEST_INCLUDE_GTEST_GTEST_H_ 2237