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