Changeset View
Changeset View
Standalone View
Standalone View
google/googletest/dist/googletest/include/gtest/gtest.h
- This file was added.
Property | Old Value | New Value |
---|---|---|
svn:eol-style | null | native \ No newline at end of property |
svn:keywords | null | FreeBSD=%H \ No newline at end of property |
svn:mime-type | null | text/plain \ No newline at end of property |
// Copyright 2005, Google Inc. | |||||
// All rights reserved. | |||||
// | |||||
// Redistribution and use in source and binary forms, with or without | |||||
// modification, are permitted provided that the following conditions are | |||||
// met: | |||||
// | |||||
// * Redistributions of source code must retain the above copyright | |||||
// notice, this list of conditions and the following disclaimer. | |||||
// * Redistributions in binary form must reproduce the above | |||||
// copyright notice, this list of conditions and the following disclaimer | |||||
// in the documentation and/or other materials provided with the | |||||
// distribution. | |||||
// * Neither the name of Google Inc. nor the names of its | |||||
// contributors may be used to endorse or promote products derived from | |||||
// this software without specific prior written permission. | |||||
// | |||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |||||
// | |||||
// The Google C++ Testing and Mocking Framework (Google Test) | |||||
// | |||||
// This header file defines the public API for Google Test. It should be | |||||
// included by any test program that uses Google Test. | |||||
// | |||||
// IMPORTANT NOTE: Due to limitation of the C++ language, we have to | |||||
// leave some internal implementation details in this header file. | |||||
// They are clearly marked by comments like this: | |||||
// | |||||
// // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
// | |||||
// Such code is NOT meant to be used by a user directly, and is subject | |||||
// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user | |||||
// program! | |||||
// | |||||
// Acknowledgment: Google Test borrowed the idea of automatic test | |||||
// registration from Barthelemy Dagenais' (barthelemy@prologique.com) | |||||
// easyUnit framework. | |||||
// GOOGLETEST_CM0001 DO NOT DELETE | |||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_H_ | |||||
#define GTEST_INCLUDE_GTEST_GTEST_H_ | |||||
#include <limits> | |||||
#include <ostream> | |||||
#include <vector> | |||||
#include "gtest/internal/gtest-internal.h" | |||||
#include "gtest/internal/gtest-string.h" | |||||
#include "gtest/gtest-death-test.h" | |||||
#include "gtest/gtest-message.h" | |||||
#include "gtest/gtest-param-test.h" | |||||
#include "gtest/gtest-printers.h" | |||||
#include "gtest/gtest_prod.h" | |||||
#include "gtest/gtest-test-part.h" | |||||
#include "gtest/gtest-typed-test.h" | |||||
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ | |||||
/* class A needs to have dll-interface to be used by clients of class B */) | |||||
// Depending on the platform, different string classes are available. | |||||
// On Linux, in addition to ::std::string, Google also makes use of | |||||
// class ::string, which has the same interface as ::std::string, but | |||||
// has a different implementation. | |||||
// | |||||
// You can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that | |||||
// ::string is available AND is a distinct type to ::std::string, or | |||||
// define it to 0 to indicate otherwise. | |||||
// | |||||
// If ::std::string and ::string are the same class on your platform | |||||
// due to aliasing, you should define GTEST_HAS_GLOBAL_STRING to 0. | |||||
// | |||||
// If you do not define GTEST_HAS_GLOBAL_STRING, it is defined | |||||
// heuristically. | |||||
namespace testing { | |||||
// Silence C4100 (unreferenced formal parameter) and 4805 | |||||
// unsafe mix of type 'const int' and type 'const bool' | |||||
#ifdef _MSC_VER | |||||
# pragma warning(push) | |||||
# pragma warning(disable:4805) | |||||
# pragma warning(disable:4100) | |||||
#endif | |||||
// Declares the flags. | |||||
// This flag temporary enables the disabled tests. | |||||
GTEST_DECLARE_bool_(also_run_disabled_tests); | |||||
// This flag brings the debugger on an assertion failure. | |||||
GTEST_DECLARE_bool_(break_on_failure); | |||||
// This flag controls whether Google Test catches all test-thrown exceptions | |||||
// and logs them as failures. | |||||
GTEST_DECLARE_bool_(catch_exceptions); | |||||
// This flag enables using colors in terminal output. Available values are | |||||
// "yes" to enable colors, "no" (disable colors), or "auto" (the default) | |||||
// to let Google Test decide. | |||||
GTEST_DECLARE_string_(color); | |||||
// This flag sets up the filter to select by name using a glob pattern | |||||
// the tests to run. If the filter is not given all tests are executed. | |||||
GTEST_DECLARE_string_(filter); | |||||
// This flag controls whether Google Test installs a signal handler that dumps | |||||
// debugging information when fatal signals are raised. | |||||
GTEST_DECLARE_bool_(install_failure_signal_handler); | |||||
// This flag causes the Google Test to list tests. None of the tests listed | |||||
// are actually run if the flag is provided. | |||||
GTEST_DECLARE_bool_(list_tests); | |||||
// This flag controls whether Google Test emits a detailed XML report to a file | |||||
// in addition to its normal textual output. | |||||
GTEST_DECLARE_string_(output); | |||||
// This flags control whether Google Test prints the elapsed time for each | |||||
// test. | |||||
GTEST_DECLARE_bool_(print_time); | |||||
// This flags control whether Google Test prints UTF8 characters as text. | |||||
GTEST_DECLARE_bool_(print_utf8); | |||||
// This flag specifies the random number seed. | |||||
GTEST_DECLARE_int32_(random_seed); | |||||
// This flag sets how many times the tests are repeated. The default value | |||||
// is 1. If the value is -1 the tests are repeating forever. | |||||
GTEST_DECLARE_int32_(repeat); | |||||
// This flag controls whether Google Test includes Google Test internal | |||||
// stack frames in failure stack traces. | |||||
GTEST_DECLARE_bool_(show_internal_stack_frames); | |||||
// When this flag is specified, tests' order is randomized on every iteration. | |||||
GTEST_DECLARE_bool_(shuffle); | |||||
// This flag specifies the maximum number of stack frames to be | |||||
// printed in a failure message. | |||||
GTEST_DECLARE_int32_(stack_trace_depth); | |||||
// When this flag is specified, a failed assertion will throw an | |||||
// exception if exceptions are enabled, or exit the program with a | |||||
// non-zero code otherwise. For use with an external test framework. | |||||
GTEST_DECLARE_bool_(throw_on_failure); | |||||
// When this flag is set with a "host:port" string, on supported | |||||
// platforms test results are streamed to the specified port on | |||||
// the specified host machine. | |||||
GTEST_DECLARE_string_(stream_result_to); | |||||
#if GTEST_USE_OWN_FLAGFILE_FLAG_ | |||||
GTEST_DECLARE_string_(flagfile); | |||||
#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ | |||||
// The upper limit for valid stack trace depths. | |||||
const int kMaxStackTraceDepth = 100; | |||||
namespace internal { | |||||
class AssertHelper; | |||||
class DefaultGlobalTestPartResultReporter; | |||||
class ExecDeathTest; | |||||
class NoExecDeathTest; | |||||
class FinalSuccessChecker; | |||||
class GTestFlagSaver; | |||||
class StreamingListenerTest; | |||||
class TestResultAccessor; | |||||
class TestEventListenersAccessor; | |||||
class TestEventRepeater; | |||||
class UnitTestRecordPropertyTestHelper; | |||||
class WindowsDeathTest; | |||||
class FuchsiaDeathTest; | |||||
class UnitTestImpl* GetUnitTestImpl(); | |||||
void ReportFailureInUnknownLocation(TestPartResult::Type result_type, | |||||
const std::string& message); | |||||
} // namespace internal | |||||
// The friend relationship of some of these classes is cyclic. | |||||
// If we don't forward declare them the compiler might confuse the classes | |||||
// in friendship clauses with same named classes on the scope. | |||||
class Test; | |||||
class TestCase; | |||||
class TestInfo; | |||||
class UnitTest; | |||||
// A class for indicating whether an assertion was successful. When | |||||
// the assertion wasn't successful, the AssertionResult object | |||||
// remembers a non-empty message that describes how it failed. | |||||
// | |||||
// To create an instance of this class, use one of the factory functions | |||||
// (AssertionSuccess() and AssertionFailure()). | |||||
// | |||||
// This class is useful for two purposes: | |||||
// 1. Defining predicate functions to be used with Boolean test assertions | |||||
// EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts | |||||
// 2. Defining predicate-format functions to be | |||||
// used with predicate assertions (ASSERT_PRED_FORMAT*, etc). | |||||
// | |||||
// For example, if you define IsEven predicate: | |||||
// | |||||
// testing::AssertionResult IsEven(int n) { | |||||
// if ((n % 2) == 0) | |||||
// return testing::AssertionSuccess(); | |||||
// else | |||||
// return testing::AssertionFailure() << n << " is odd"; | |||||
// } | |||||
// | |||||
// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5))) | |||||
// will print the message | |||||
// | |||||
// Value of: IsEven(Fib(5)) | |||||
// Actual: false (5 is odd) | |||||
// Expected: true | |||||
// | |||||
// instead of a more opaque | |||||
// | |||||
// Value of: IsEven(Fib(5)) | |||||
// Actual: false | |||||
// Expected: true | |||||
// | |||||
// in case IsEven is a simple Boolean predicate. | |||||
// | |||||
// If you expect your predicate to be reused and want to support informative | |||||
// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up | |||||
// about half as often as positive ones in our tests), supply messages for | |||||
// both success and failure cases: | |||||
// | |||||
// testing::AssertionResult IsEven(int n) { | |||||
// if ((n % 2) == 0) | |||||
// return testing::AssertionSuccess() << n << " is even"; | |||||
// else | |||||
// return testing::AssertionFailure() << n << " is odd"; | |||||
// } | |||||
// | |||||
// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print | |||||
// | |||||
// Value of: IsEven(Fib(6)) | |||||
// Actual: true (8 is even) | |||||
// Expected: false | |||||
// | |||||
// NB: Predicates that support negative Boolean assertions have reduced | |||||
// performance in positive ones so be careful not to use them in tests | |||||
// that have lots (tens of thousands) of positive Boolean assertions. | |||||
// | |||||
// To use this class with EXPECT_PRED_FORMAT assertions such as: | |||||
// | |||||
// // Verifies that Foo() returns an even number. | |||||
// EXPECT_PRED_FORMAT1(IsEven, Foo()); | |||||
// | |||||
// you need to define: | |||||
// | |||||
// testing::AssertionResult IsEven(const char* expr, int n) { | |||||
// if ((n % 2) == 0) | |||||
// return testing::AssertionSuccess(); | |||||
// else | |||||
// return testing::AssertionFailure() | |||||
// << "Expected: " << expr << " is even\n Actual: it's " << n; | |||||
// } | |||||
// | |||||
// If Foo() returns 5, you will see the following message: | |||||
// | |||||
// Expected: Foo() is even | |||||
// Actual: it's 5 | |||||
// | |||||
class GTEST_API_ AssertionResult { | |||||
public: | |||||
// Copy constructor. | |||||
// Used in EXPECT_TRUE/FALSE(assertion_result). | |||||
AssertionResult(const AssertionResult& other); | |||||
#if defined(_MSC_VER) && _MSC_VER < 1910 | |||||
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */) | |||||
#endif | |||||
// Used in the EXPECT_TRUE/FALSE(bool_expression). | |||||
// | |||||
// T must be contextually convertible to bool. | |||||
// | |||||
// The second parameter prevents this overload from being considered if | |||||
// the argument is implicitly convertible to AssertionResult. In that case | |||||
// we want AssertionResult's copy constructor to be used. | |||||
template <typename T> | |||||
explicit AssertionResult( | |||||
const T& success, | |||||
typename internal::EnableIf< | |||||
!internal::ImplicitlyConvertible<T, AssertionResult>::value>::type* | |||||
/*enabler*/ = NULL) | |||||
: success_(success) {} | |||||
#if defined(_MSC_VER) && _MSC_VER < 1910 | |||||
GTEST_DISABLE_MSC_WARNINGS_POP_() | |||||
#endif | |||||
// Assignment operator. | |||||
AssertionResult& operator=(AssertionResult other) { | |||||
swap(other); | |||||
return *this; | |||||
} | |||||
// Returns true iff the assertion succeeded. | |||||
operator bool() const { return success_; } // NOLINT | |||||
// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. | |||||
AssertionResult operator!() const; | |||||
// Returns the text streamed into this AssertionResult. Test assertions | |||||
// use it when they fail (i.e., the predicate's outcome doesn't match the | |||||
// assertion's expectation). When nothing has been streamed into the | |||||
// object, returns an empty string. | |||||
const char* message() const { | |||||
return message_.get() != NULL ? message_->c_str() : ""; | |||||
} | |||||
// FIXME: Remove this after making sure no clients use it. | |||||
// Deprecated; please use message() instead. | |||||
const char* failure_message() const { return message(); } | |||||
// Streams a custom failure message into this object. | |||||
template <typename T> AssertionResult& operator<<(const T& value) { | |||||
AppendMessage(Message() << value); | |||||
return *this; | |||||
} | |||||
// Allows streaming basic output manipulators such as endl or flush into | |||||
// this object. | |||||
AssertionResult& operator<<( | |||||
::std::ostream& (*basic_manipulator)(::std::ostream& stream)) { | |||||
AppendMessage(Message() << basic_manipulator); | |||||
return *this; | |||||
} | |||||
private: | |||||
// Appends the contents of message to message_. | |||||
void AppendMessage(const Message& a_message) { | |||||
if (message_.get() == NULL) | |||||
message_.reset(new ::std::string); | |||||
message_->append(a_message.GetString().c_str()); | |||||
} | |||||
// Swap the contents of this AssertionResult with other. | |||||
void swap(AssertionResult& other); | |||||
// Stores result of the assertion predicate. | |||||
bool success_; | |||||
// Stores the message describing the condition in case the expectation | |||||
// construct is not satisfied with the predicate's outcome. | |||||
// Referenced via a pointer to avoid taking too much stack frame space | |||||
// with test assertions. | |||||
internal::scoped_ptr< ::std::string> message_; | |||||
}; | |||||
// Makes a successful assertion result. | |||||
GTEST_API_ AssertionResult AssertionSuccess(); | |||||
// Makes a failed assertion result. | |||||
GTEST_API_ AssertionResult AssertionFailure(); | |||||
// Makes a failed assertion result with the given failure message. | |||||
// Deprecated; use AssertionFailure() << msg. | |||||
GTEST_API_ AssertionResult AssertionFailure(const Message& msg); | |||||
} // namespace testing | |||||
// Includes the auto-generated header that implements a family of generic | |||||
// predicate assertion macros. This include comes late because it relies on | |||||
// APIs declared above. | |||||
#include "gtest/gtest_pred_impl.h" | |||||
namespace testing { | |||||
// The abstract class that all tests inherit from. | |||||
// | |||||
// In Google Test, a unit test program contains one or many TestCases, and | |||||
// each TestCase contains one or many Tests. | |||||
// | |||||
// When you define a test using the TEST macro, you don't need to | |||||
// explicitly derive from Test - the TEST macro automatically does | |||||
// this for you. | |||||
// | |||||
// The only time you derive from Test is when defining a test fixture | |||||
// to be used in a TEST_F. For example: | |||||
// | |||||
// class FooTest : public testing::Test { | |||||
// protected: | |||||
// void SetUp() override { ... } | |||||
// void TearDown() override { ... } | |||||
// ... | |||||
// }; | |||||
// | |||||
// TEST_F(FooTest, Bar) { ... } | |||||
// TEST_F(FooTest, Baz) { ... } | |||||
// | |||||
// Test is not copyable. | |||||
class GTEST_API_ Test { | |||||
public: | |||||
friend class TestInfo; | |||||
// Defines types for pointers to functions that set up and tear down | |||||
// a test case. | |||||
typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc; | |||||
typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc; | |||||
// The d'tor is virtual as we intend to inherit from Test. | |||||
virtual ~Test(); | |||||
// Sets up the stuff shared by all tests in this test case. | |||||
// | |||||
// Google Test will call Foo::SetUpTestCase() before running the first | |||||
// test in test case Foo. Hence a sub-class can define its own | |||||
// SetUpTestCase() method to shadow the one defined in the super | |||||
// class. | |||||
static void SetUpTestCase() {} | |||||
// Tears down the stuff shared by all tests in this test case. | |||||
// | |||||
// Google Test will call Foo::TearDownTestCase() after running the last | |||||
// test in test case Foo. Hence a sub-class can define its own | |||||
// TearDownTestCase() method to shadow the one defined in the super | |||||
// class. | |||||
static void TearDownTestCase() {} | |||||
// Returns true iff the current test has a fatal failure. | |||||
static bool HasFatalFailure(); | |||||
// Returns true iff the current test has a non-fatal failure. | |||||
static bool HasNonfatalFailure(); | |||||
// Returns true iff the current test has a (either fatal or | |||||
// non-fatal) failure. | |||||
static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); } | |||||
// Logs a property for the current test, test case, or for the entire | |||||
// invocation of the test program when used outside of the context of a | |||||
// test case. Only the last value for a given key is remembered. These | |||||
// are public static so they can be called from utility functions that are | |||||
// not members of the test fixture. Calls to RecordProperty made during | |||||
// lifespan of the test (from the moment its constructor starts to the | |||||
// moment its destructor finishes) will be output in XML as attributes of | |||||
// the <testcase> element. Properties recorded from fixture's | |||||
// SetUpTestCase or TearDownTestCase are logged as attributes of the | |||||
// corresponding <testsuite> element. Calls to RecordProperty made in the | |||||
// global context (before or after invocation of RUN_ALL_TESTS and from | |||||
// SetUp/TearDown method of Environment objects registered with Google | |||||
// Test) will be output as attributes of the <testsuites> element. | |||||
static void RecordProperty(const std::string& key, const std::string& value); | |||||
static void RecordProperty(const std::string& key, int value); | |||||
protected: | |||||
// Creates a Test object. | |||||
Test(); | |||||
// Sets up the test fixture. | |||||
virtual void SetUp(); | |||||
// Tears down the test fixture. | |||||
virtual void TearDown(); | |||||
private: | |||||
// Returns true iff the current test has the same fixture class as | |||||
// the first test in the current test case. | |||||
static bool HasSameFixtureClass(); | |||||
// Runs the test after the test fixture has been set up. | |||||
// | |||||
// A sub-class must implement this to define the test logic. | |||||
// | |||||
// DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM. | |||||
// Instead, use the TEST or TEST_F macro. | |||||
virtual void TestBody() = 0; | |||||
// Sets up, executes, and tears down the test. | |||||
void Run(); | |||||
// Deletes self. We deliberately pick an unusual name for this | |||||
// internal method to avoid clashing with names used in user TESTs. | |||||
void DeleteSelf_() { delete this; } | |||||
const internal::scoped_ptr< GTEST_FLAG_SAVER_ > gtest_flag_saver_; | |||||
// Often a user misspells SetUp() as Setup() and spends a long time | |||||
// wondering why it is never called by Google Test. The declaration of | |||||
// the following method is solely for catching such an error at | |||||
// compile time: | |||||
// | |||||
// - The return type is deliberately chosen to be not void, so it | |||||
// will be a conflict if void Setup() is declared in the user's | |||||
// test fixture. | |||||
// | |||||
// - This method is private, so it will be another compiler error | |||||
// if the method is called from the user's test fixture. | |||||
// | |||||
// DO NOT OVERRIDE THIS FUNCTION. | |||||
// | |||||
// If you see an error about overriding the following function or | |||||
// about it being private, you have mis-spelled SetUp() as Setup(). | |||||
struct Setup_should_be_spelled_SetUp {}; | |||||
virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } | |||||
// We disallow copying Tests. | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(Test); | |||||
}; | |||||
typedef internal::TimeInMillis TimeInMillis; | |||||
// A copyable object representing a user specified test property which can be | |||||
// output as a key/value string pair. | |||||
// | |||||
// Don't inherit from TestProperty as its destructor is not virtual. | |||||
class TestProperty { | |||||
public: | |||||
// C'tor. TestProperty does NOT have a default constructor. | |||||
// Always use this constructor (with parameters) to create a | |||||
// TestProperty object. | |||||
TestProperty(const std::string& a_key, const std::string& a_value) : | |||||
key_(a_key), value_(a_value) { | |||||
} | |||||
// Gets the user supplied key. | |||||
const char* key() const { | |||||
return key_.c_str(); | |||||
} | |||||
// Gets the user supplied value. | |||||
const char* value() const { | |||||
return value_.c_str(); | |||||
} | |||||
// Sets a new value, overriding the one supplied in the constructor. | |||||
void SetValue(const std::string& new_value) { | |||||
value_ = new_value; | |||||
} | |||||
private: | |||||
// The key supplied by the user. | |||||
std::string key_; | |||||
// The value supplied by the user. | |||||
std::string value_; | |||||
}; | |||||
// The result of a single Test. This includes a list of | |||||
// TestPartResults, a list of TestProperties, a count of how many | |||||
// death tests there are in the Test, and how much time it took to run | |||||
// the Test. | |||||
// | |||||
// TestResult is not copyable. | |||||
class GTEST_API_ TestResult { | |||||
public: | |||||
// Creates an empty TestResult. | |||||
TestResult(); | |||||
// D'tor. Do not inherit from TestResult. | |||||
~TestResult(); | |||||
// Gets the number of all test parts. This is the sum of the number | |||||
// of successful test parts and the number of failed test parts. | |||||
int total_part_count() const; | |||||
// Returns the number of the test properties. | |||||
int test_property_count() const; | |||||
// Returns true iff the test passed (i.e. no test part failed). | |||||
bool Passed() const { return !Failed(); } | |||||
// Returns true iff the test failed. | |||||
bool Failed() const; | |||||
// Returns true iff the test fatally failed. | |||||
bool HasFatalFailure() const; | |||||
// Returns true iff the test has a non-fatal failure. | |||||
bool HasNonfatalFailure() const; | |||||
// Returns the elapsed time, in milliseconds. | |||||
TimeInMillis elapsed_time() const { return elapsed_time_; } | |||||
// Returns the i-th test part result among all the results. i can range from 0 | |||||
// to total_part_count() - 1. If i is not in that range, aborts the program. | |||||
const TestPartResult& GetTestPartResult(int i) const; | |||||
// Returns the i-th test property. i can range from 0 to | |||||
// test_property_count() - 1. If i is not in that range, aborts the | |||||
// program. | |||||
const TestProperty& GetTestProperty(int i) const; | |||||
private: | |||||
friend class TestInfo; | |||||
friend class TestCase; | |||||
friend class UnitTest; | |||||
friend class internal::DefaultGlobalTestPartResultReporter; | |||||
friend class internal::ExecDeathTest; | |||||
friend class internal::TestResultAccessor; | |||||
friend class internal::UnitTestImpl; | |||||
friend class internal::WindowsDeathTest; | |||||
friend class internal::FuchsiaDeathTest; | |||||
// Gets the vector of TestPartResults. | |||||
const std::vector<TestPartResult>& test_part_results() const { | |||||
return test_part_results_; | |||||
} | |||||
// Gets the vector of TestProperties. | |||||
const std::vector<TestProperty>& test_properties() const { | |||||
return test_properties_; | |||||
} | |||||
// Sets the elapsed time. | |||||
void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; } | |||||
// Adds a test property to the list. The property is validated and may add | |||||
// a non-fatal failure if invalid (e.g., if it conflicts with reserved | |||||
// key names). If a property is already recorded for the same key, the | |||||
// value will be updated, rather than storing multiple values for the same | |||||
// key. xml_element specifies the element for which the property is being | |||||
// recorded and is used for validation. | |||||
void RecordProperty(const std::string& xml_element, | |||||
const TestProperty& test_property); | |||||
// Adds a failure if the key is a reserved attribute of Google Test | |||||
// testcase tags. Returns true if the property is valid. | |||||
// FIXME: Validate attribute names are legal and human readable. | |||||
static bool ValidateTestProperty(const std::string& xml_element, | |||||
const TestProperty& test_property); | |||||
// Adds a test part result to the list. | |||||
void AddTestPartResult(const TestPartResult& test_part_result); | |||||
// Returns the death test count. | |||||
int death_test_count() const { return death_test_count_; } | |||||
// Increments the death test count, returning the new count. | |||||
int increment_death_test_count() { return ++death_test_count_; } | |||||
// Clears the test part results. | |||||
void ClearTestPartResults(); | |||||
// Clears the object. | |||||
void Clear(); | |||||
// Protects mutable state of the property vector and of owned | |||||
// properties, whose values may be updated. | |||||
internal::Mutex test_properites_mutex_; | |||||
// The vector of TestPartResults | |||||
std::vector<TestPartResult> test_part_results_; | |||||
// The vector of TestProperties | |||||
std::vector<TestProperty> test_properties_; | |||||
// Running count of death tests. | |||||
int death_test_count_; | |||||
// The elapsed time, in milliseconds. | |||||
TimeInMillis elapsed_time_; | |||||
// We disallow copying TestResult. | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult); | |||||
}; // class TestResult | |||||
// A TestInfo object stores the following information about a test: | |||||
// | |||||
// Test case name | |||||
// Test name | |||||
// Whether the test should be run | |||||
// A function pointer that creates the test object when invoked | |||||
// Test result | |||||
// | |||||
// The constructor of TestInfo registers itself with the UnitTest | |||||
// singleton such that the RUN_ALL_TESTS() macro knows which tests to | |||||
// run. | |||||
class GTEST_API_ TestInfo { | |||||
public: | |||||
// Destructs a TestInfo object. This function is not virtual, so | |||||
// don't inherit from TestInfo. | |||||
~TestInfo(); | |||||
// Returns the test case name. | |||||
const char* test_case_name() const { return test_case_name_.c_str(); } | |||||
// Returns the test name. | |||||
const char* name() const { return name_.c_str(); } | |||||
// Returns the name of the parameter type, or NULL if this is not a typed | |||||
// or a type-parameterized test. | |||||
const char* type_param() const { | |||||
if (type_param_.get() != NULL) | |||||
return type_param_->c_str(); | |||||
return NULL; | |||||
} | |||||
// Returns the text representation of the value parameter, or NULL if this | |||||
// is not a value-parameterized test. | |||||
const char* value_param() const { | |||||
if (value_param_.get() != NULL) | |||||
return value_param_->c_str(); | |||||
return NULL; | |||||
} | |||||
// Returns the file name where this test is defined. | |||||
const char* file() const { return location_.file.c_str(); } | |||||
// Returns the line where this test is defined. | |||||
int line() const { return location_.line; } | |||||
// Return true if this test should not be run because it's in another shard. | |||||
bool is_in_another_shard() const { return is_in_another_shard_; } | |||||
// Returns true if this test should run, that is if the test is not | |||||
// disabled (or it is disabled but the also_run_disabled_tests flag has | |||||
// been specified) and its full name matches the user-specified filter. | |||||
// | |||||
// Google Test allows the user to filter the tests by their full names. | |||||
// The full name of a test Bar in test case Foo is defined as | |||||
// "Foo.Bar". Only the tests that match the filter will run. | |||||
// | |||||
// A filter is a colon-separated list of glob (not regex) patterns, | |||||
// optionally followed by a '-' and a colon-separated list of | |||||
// negative patterns (tests to exclude). A test is run if it | |||||
// matches one of the positive patterns and does not match any of | |||||
// the negative patterns. | |||||
// | |||||
// For example, *A*:Foo.* is a filter that matches any string that | |||||
// contains the character 'A' or starts with "Foo.". | |||||
bool should_run() const { return should_run_; } | |||||
// Returns true iff this test will appear in the XML report. | |||||
bool is_reportable() const { | |||||
// The XML report includes tests matching the filter, excluding those | |||||
// run in other shards. | |||||
return matches_filter_ && !is_in_another_shard_; | |||||
} | |||||
// Returns the result of the test. | |||||
const TestResult* result() const { return &result_; } | |||||
private: | |||||
#if GTEST_HAS_DEATH_TEST | |||||
friend class internal::DefaultDeathTestFactory; | |||||
#endif // GTEST_HAS_DEATH_TEST | |||||
friend class Test; | |||||
friend class TestCase; | |||||
friend class internal::UnitTestImpl; | |||||
friend class internal::StreamingListenerTest; | |||||
friend TestInfo* internal::MakeAndRegisterTestInfo( | |||||
const char* test_case_name, | |||||
const char* name, | |||||
const char* type_param, | |||||
const char* value_param, | |||||
internal::CodeLocation code_location, | |||||
internal::TypeId fixture_class_id, | |||||
Test::SetUpTestCaseFunc set_up_tc, | |||||
Test::TearDownTestCaseFunc tear_down_tc, | |||||
internal::TestFactoryBase* factory); | |||||
// Constructs a TestInfo object. The newly constructed instance assumes | |||||
// ownership of the factory object. | |||||
TestInfo(const std::string& test_case_name, | |||||
const std::string& name, | |||||
const char* a_type_param, // NULL if not a type-parameterized test | |||||
const char* a_value_param, // NULL if not a value-parameterized test | |||||
internal::CodeLocation a_code_location, | |||||
internal::TypeId fixture_class_id, | |||||
internal::TestFactoryBase* factory); | |||||
// Increments the number of death tests encountered in this test so | |||||
// far. | |||||
int increment_death_test_count() { | |||||
return result_.increment_death_test_count(); | |||||
} | |||||
// Creates the test object, runs it, records its result, and then | |||||
// deletes it. | |||||
void Run(); | |||||
static void ClearTestResult(TestInfo* test_info) { | |||||
test_info->result_.Clear(); | |||||
} | |||||
// These fields are immutable properties of the test. | |||||
const std::string test_case_name_; // Test case name | |||||
const std::string name_; // Test name | |||||
// Name of the parameter type, or NULL if this is not a typed or a | |||||
// type-parameterized test. | |||||
const internal::scoped_ptr<const ::std::string> type_param_; | |||||
// Text representation of the value parameter, or NULL if this is not a | |||||
// value-parameterized test. | |||||
const internal::scoped_ptr<const ::std::string> value_param_; | |||||
internal::CodeLocation location_; | |||||
const internal::TypeId fixture_class_id_; // ID of the test fixture class | |||||
bool should_run_; // True iff this test should run | |||||
bool is_disabled_; // True iff this test is disabled | |||||
bool matches_filter_; // True if this test matches the | |||||
// user-specified filter. | |||||
bool is_in_another_shard_; // Will be run in another shard. | |||||
internal::TestFactoryBase* const factory_; // The factory that creates | |||||
// the test object | |||||
// This field is mutable and needs to be reset before running the | |||||
// test for the second time. | |||||
TestResult result_; | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo); | |||||
}; | |||||
// A test case, which consists of a vector of TestInfos. | |||||
// | |||||
// TestCase is not copyable. | |||||
class GTEST_API_ TestCase { | |||||
public: | |||||
// Creates a TestCase with the given name. | |||||
// | |||||
// TestCase does NOT have a default constructor. Always use this | |||||
// constructor to create a TestCase object. | |||||
// | |||||
// Arguments: | |||||
// | |||||
// name: name of the test case | |||||
// a_type_param: the name of the test's type parameter, or NULL if | |||||
// this is not a type-parameterized test. | |||||
// set_up_tc: pointer to the function that sets up the test case | |||||
// tear_down_tc: pointer to the function that tears down the test case | |||||
TestCase(const char* name, const char* a_type_param, | |||||
Test::SetUpTestCaseFunc set_up_tc, | |||||
Test::TearDownTestCaseFunc tear_down_tc); | |||||
// Destructor of TestCase. | |||||
virtual ~TestCase(); | |||||
// Gets the name of the TestCase. | |||||
const char* name() const { return name_.c_str(); } | |||||
// Returns the name of the parameter type, or NULL if this is not a | |||||
// type-parameterized test case. | |||||
const char* type_param() const { | |||||
if (type_param_.get() != NULL) | |||||
return type_param_->c_str(); | |||||
return NULL; | |||||
} | |||||
// Returns true if any test in this test case should run. | |||||
bool should_run() const { return should_run_; } | |||||
// Gets the number of successful tests in this test case. | |||||
int successful_test_count() const; | |||||
// Gets the number of failed tests in this test case. | |||||
int failed_test_count() const; | |||||
// Gets the number of disabled tests that will be reported in the XML report. | |||||
int reportable_disabled_test_count() const; | |||||
// Gets the number of disabled tests in this test case. | |||||
int disabled_test_count() const; | |||||
// Gets the number of tests to be printed in the XML report. | |||||
int reportable_test_count() const; | |||||
// Get the number of tests in this test case that should run. | |||||
int test_to_run_count() const; | |||||
// Gets the number of all tests in this test case. | |||||
int total_test_count() const; | |||||
// Returns true iff the test case passed. | |||||
bool Passed() const { return !Failed(); } | |||||
// Returns true iff the test case failed. | |||||
bool Failed() const { return failed_test_count() > 0; } | |||||
// Returns the elapsed time, in milliseconds. | |||||
TimeInMillis elapsed_time() const { return elapsed_time_; } | |||||
// Returns the i-th test among all the tests. i can range from 0 to | |||||
// total_test_count() - 1. If i is not in that range, returns NULL. | |||||
const TestInfo* GetTestInfo(int i) const; | |||||
// Returns the TestResult that holds test properties recorded during | |||||
// execution of SetUpTestCase and TearDownTestCase. | |||||
const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; } | |||||
private: | |||||
friend class Test; | |||||
friend class internal::UnitTestImpl; | |||||
// Gets the (mutable) vector of TestInfos in this TestCase. | |||||
std::vector<TestInfo*>& test_info_list() { return test_info_list_; } | |||||
// Gets the (immutable) vector of TestInfos in this TestCase. | |||||
const std::vector<TestInfo*>& test_info_list() const { | |||||
return test_info_list_; | |||||
} | |||||
// Returns the i-th test among all the tests. i can range from 0 to | |||||
// total_test_count() - 1. If i is not in that range, returns NULL. | |||||
TestInfo* GetMutableTestInfo(int i); | |||||
// Sets the should_run member. | |||||
void set_should_run(bool should) { should_run_ = should; } | |||||
// Adds a TestInfo to this test case. Will delete the TestInfo upon | |||||
// destruction of the TestCase object. | |||||
void AddTestInfo(TestInfo * test_info); | |||||
// Clears the results of all tests in this test case. | |||||
void ClearResult(); | |||||
// Clears the results of all tests in the given test case. | |||||
static void ClearTestCaseResult(TestCase* test_case) { | |||||
test_case->ClearResult(); | |||||
} | |||||
// Runs every test in this TestCase. | |||||
void Run(); | |||||
// Runs SetUpTestCase() for this TestCase. This wrapper is needed | |||||
// for catching exceptions thrown from SetUpTestCase(). | |||||
void RunSetUpTestCase() { (*set_up_tc_)(); } | |||||
// Runs TearDownTestCase() for this TestCase. This wrapper is | |||||
// needed for catching exceptions thrown from TearDownTestCase(). | |||||
void RunTearDownTestCase() { (*tear_down_tc_)(); } | |||||
// Returns true iff test passed. | |||||
static bool TestPassed(const TestInfo* test_info) { | |||||
return test_info->should_run() && test_info->result()->Passed(); | |||||
} | |||||
// Returns true iff test failed. | |||||
static bool TestFailed(const TestInfo* test_info) { | |||||
return test_info->should_run() && test_info->result()->Failed(); | |||||
} | |||||
// Returns true iff the test is disabled and will be reported in the XML | |||||
// report. | |||||
static bool TestReportableDisabled(const TestInfo* test_info) { | |||||
return test_info->is_reportable() && test_info->is_disabled_; | |||||
} | |||||
// Returns true iff test is disabled. | |||||
static bool TestDisabled(const TestInfo* test_info) { | |||||
return test_info->is_disabled_; | |||||
} | |||||
// Returns true iff this test will appear in the XML report. | |||||
static bool TestReportable(const TestInfo* test_info) { | |||||
return test_info->is_reportable(); | |||||
} | |||||
// Returns true if the given test should run. | |||||
static bool ShouldRunTest(const TestInfo* test_info) { | |||||
return test_info->should_run(); | |||||
} | |||||
// Shuffles the tests in this test case. | |||||
void ShuffleTests(internal::Random* random); | |||||
// Restores the test order to before the first shuffle. | |||||
void UnshuffleTests(); | |||||
// Name of the test case. | |||||
std::string name_; | |||||
// Name of the parameter type, or NULL if this is not a typed or a | |||||
// type-parameterized test. | |||||
const internal::scoped_ptr<const ::std::string> type_param_; | |||||
// The vector of TestInfos in their original order. It owns the | |||||
// elements in the vector. | |||||
std::vector<TestInfo*> test_info_list_; | |||||
// Provides a level of indirection for the test list to allow easy | |||||
// shuffling and restoring the test order. The i-th element in this | |||||
// vector is the index of the i-th test in the shuffled test list. | |||||
std::vector<int> test_indices_; | |||||
// Pointer to the function that sets up the test case. | |||||
Test::SetUpTestCaseFunc set_up_tc_; | |||||
// Pointer to the function that tears down the test case. | |||||
Test::TearDownTestCaseFunc tear_down_tc_; | |||||
// True iff any test in this test case should run. | |||||
bool should_run_; | |||||
// Elapsed time, in milliseconds. | |||||
TimeInMillis elapsed_time_; | |||||
// Holds test properties recorded during execution of SetUpTestCase and | |||||
// TearDownTestCase. | |||||
TestResult ad_hoc_test_result_; | |||||
// We disallow copying TestCases. | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase); | |||||
}; | |||||
// An Environment object is capable of setting up and tearing down an | |||||
// environment. You should subclass this to define your own | |||||
// environment(s). | |||||
// | |||||
// An Environment object does the set-up and tear-down in virtual | |||||
// methods SetUp() and TearDown() instead of the constructor and the | |||||
// destructor, as: | |||||
// | |||||
// 1. You cannot safely throw from a destructor. This is a problem | |||||
// as in some cases Google Test is used where exceptions are enabled, and | |||||
// we may want to implement ASSERT_* using exceptions where they are | |||||
// available. | |||||
// 2. You cannot use ASSERT_* directly in a constructor or | |||||
// destructor. | |||||
class Environment { | |||||
public: | |||||
// The d'tor is virtual as we need to subclass Environment. | |||||
virtual ~Environment() {} | |||||
// Override this to define how to set up the environment. | |||||
virtual void SetUp() {} | |||||
// Override this to define how to tear down the environment. | |||||
virtual void TearDown() {} | |||||
private: | |||||
// If you see an error about overriding the following function or | |||||
// about it being private, you have mis-spelled SetUp() as Setup(). | |||||
struct Setup_should_be_spelled_SetUp {}; | |||||
virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } | |||||
}; | |||||
#if GTEST_HAS_EXCEPTIONS | |||||
// Exception which can be thrown from TestEventListener::OnTestPartResult. | |||||
class GTEST_API_ AssertionException | |||||
: public internal::GoogleTestFailureException { | |||||
public: | |||||
explicit AssertionException(const TestPartResult& result) | |||||
: GoogleTestFailureException(result) {} | |||||
}; | |||||
#endif // GTEST_HAS_EXCEPTIONS | |||||
// The interface for tracing execution of tests. The methods are organized in | |||||
// the order the corresponding events are fired. | |||||
class TestEventListener { | |||||
public: | |||||
virtual ~TestEventListener() {} | |||||
// Fired before any test activity starts. | |||||
virtual void OnTestProgramStart(const UnitTest& unit_test) = 0; | |||||
// Fired before each iteration of tests starts. There may be more than | |||||
// one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration | |||||
// index, starting from 0. | |||||
virtual void OnTestIterationStart(const UnitTest& unit_test, | |||||
int iteration) = 0; | |||||
// Fired before environment set-up for each iteration of tests starts. | |||||
virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0; | |||||
// Fired after environment set-up for each iteration of tests ends. | |||||
virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0; | |||||
// Fired before the test case starts. | |||||
virtual void OnTestCaseStart(const TestCase& test_case) = 0; | |||||
// Fired before the test starts. | |||||
virtual void OnTestStart(const TestInfo& test_info) = 0; | |||||
// Fired after a failed assertion or a SUCCEED() invocation. | |||||
// If you want to throw an exception from this function to skip to the next | |||||
// TEST, it must be AssertionException defined above, or inherited from it. | |||||
virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0; | |||||
// Fired after the test ends. | |||||
virtual void OnTestEnd(const TestInfo& test_info) = 0; | |||||
// Fired after the test case ends. | |||||
virtual void OnTestCaseEnd(const TestCase& test_case) = 0; | |||||
// Fired before environment tear-down for each iteration of tests starts. | |||||
virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0; | |||||
// Fired after environment tear-down for each iteration of tests ends. | |||||
virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0; | |||||
// Fired after each iteration of tests finishes. | |||||
virtual void OnTestIterationEnd(const UnitTest& unit_test, | |||||
int iteration) = 0; | |||||
// Fired after all test activities have ended. | |||||
virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0; | |||||
}; | |||||
// The convenience class for users who need to override just one or two | |||||
// methods and are not concerned that a possible change to a signature of | |||||
// the methods they override will not be caught during the build. For | |||||
// comments about each method please see the definition of TestEventListener | |||||
// above. | |||||
class EmptyTestEventListener : public TestEventListener { | |||||
public: | |||||
virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} | |||||
virtual void OnTestIterationStart(const UnitTest& /*unit_test*/, | |||||
int /*iteration*/) {} | |||||
virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {} | |||||
virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} | |||||
virtual void OnTestCaseStart(const TestCase& /*test_case*/) {} | |||||
virtual void OnTestStart(const TestInfo& /*test_info*/) {} | |||||
virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {} | |||||
virtual void OnTestEnd(const TestInfo& /*test_info*/) {} | |||||
virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {} | |||||
virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {} | |||||
virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} | |||||
virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/, | |||||
int /*iteration*/) {} | |||||
virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} | |||||
}; | |||||
// TestEventListeners lets users add listeners to track events in Google Test. | |||||
class GTEST_API_ TestEventListeners { | |||||
public: | |||||
TestEventListeners(); | |||||
~TestEventListeners(); | |||||
// Appends an event listener to the end of the list. Google Test assumes | |||||
// the ownership of the listener (i.e. it will delete the listener when | |||||
// the test program finishes). | |||||
void Append(TestEventListener* listener); | |||||
// Removes the given event listener from the list and returns it. It then | |||||
// becomes the caller's responsibility to delete the listener. Returns | |||||
// NULL if the listener is not found in the list. | |||||
TestEventListener* Release(TestEventListener* listener); | |||||
// Returns the standard listener responsible for the default console | |||||
// output. Can be removed from the listeners list to shut down default | |||||
// console output. Note that removing this object from the listener list | |||||
// with Release transfers its ownership to the caller and makes this | |||||
// function return NULL the next time. | |||||
TestEventListener* default_result_printer() const { | |||||
return default_result_printer_; | |||||
} | |||||
// Returns the standard listener responsible for the default XML output | |||||
// controlled by the --gtest_output=xml flag. Can be removed from the | |||||
// listeners list by users who want to shut down the default XML output | |||||
// controlled by this flag and substitute it with custom one. Note that | |||||
// removing this object from the listener list with Release transfers its | |||||
// ownership to the caller and makes this function return NULL the next | |||||
// time. | |||||
TestEventListener* default_xml_generator() const { | |||||
return default_xml_generator_; | |||||
} | |||||
private: | |||||
friend class TestCase; | |||||
friend class TestInfo; | |||||
friend class internal::DefaultGlobalTestPartResultReporter; | |||||
friend class internal::NoExecDeathTest; | |||||
friend class internal::TestEventListenersAccessor; | |||||
friend class internal::UnitTestImpl; | |||||
// Returns repeater that broadcasts the TestEventListener events to all | |||||
// subscribers. | |||||
TestEventListener* repeater(); | |||||
// Sets the default_result_printer attribute to the provided listener. | |||||
// The listener is also added to the listener list and previous | |||||
// default_result_printer is removed from it and deleted. The listener can | |||||
// also be NULL in which case it will not be added to the list. Does | |||||
// nothing if the previous and the current listener objects are the same. | |||||
void SetDefaultResultPrinter(TestEventListener* listener); | |||||
// Sets the default_xml_generator attribute to the provided listener. The | |||||
// listener is also added to the listener list and previous | |||||
// default_xml_generator is removed from it and deleted. The listener can | |||||
// also be NULL in which case it will not be added to the list. Does | |||||
// nothing if the previous and the current listener objects are the same. | |||||
void SetDefaultXmlGenerator(TestEventListener* listener); | |||||
// Controls whether events will be forwarded by the repeater to the | |||||
// listeners in the list. | |||||
bool EventForwardingEnabled() const; | |||||
void SuppressEventForwarding(); | |||||
// The actual list of listeners. | |||||
internal::TestEventRepeater* repeater_; | |||||
// Listener responsible for the standard result output. | |||||
TestEventListener* default_result_printer_; | |||||
// Listener responsible for the creation of the XML output file. | |||||
TestEventListener* default_xml_generator_; | |||||
// We disallow copying TestEventListeners. | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners); | |||||
}; | |||||
// A UnitTest consists of a vector of TestCases. | |||||
// | |||||
// This is a singleton class. The only instance of UnitTest is | |||||
// created when UnitTest::GetInstance() is first called. This | |||||
// instance is never deleted. | |||||
// | |||||
// UnitTest is not copyable. | |||||
// | |||||
// This class is thread-safe as long as the methods are called | |||||
// according to their specification. | |||||
class GTEST_API_ UnitTest { | |||||
public: | |||||
// Gets the singleton UnitTest object. The first time this method | |||||
// is called, a UnitTest object is constructed and returned. | |||||
// Consecutive calls will return the same object. | |||||
static UnitTest* GetInstance(); | |||||
// Runs all tests in this UnitTest object and prints the result. | |||||
// Returns 0 if successful, or 1 otherwise. | |||||
// | |||||
// This method can only be called from the main thread. | |||||
// | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
int Run() GTEST_MUST_USE_RESULT_; | |||||
// Returns the working directory when the first TEST() or TEST_F() | |||||
// was executed. The UnitTest object owns the string. | |||||
const char* original_working_dir() const; | |||||
// Returns the TestCase object for the test that's currently running, | |||||
// or NULL if no test is running. | |||||
const TestCase* current_test_case() const | |||||
GTEST_LOCK_EXCLUDED_(mutex_); | |||||
// Returns the TestInfo object for the test that's currently running, | |||||
// or NULL if no test is running. | |||||
const TestInfo* current_test_info() const | |||||
GTEST_LOCK_EXCLUDED_(mutex_); | |||||
// Returns the random seed used at the start of the current test run. | |||||
int random_seed() const; | |||||
// Returns the ParameterizedTestCaseRegistry object used to keep track of | |||||
// value-parameterized tests and instantiate and register them. | |||||
// | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
internal::ParameterizedTestCaseRegistry& parameterized_test_registry() | |||||
GTEST_LOCK_EXCLUDED_(mutex_); | |||||
// Gets the number of successful test cases. | |||||
int successful_test_case_count() const; | |||||
// Gets the number of failed test cases. | |||||
int failed_test_case_count() const; | |||||
// Gets the number of all test cases. | |||||
int total_test_case_count() const; | |||||
// Gets the number of all test cases that contain at least one test | |||||
// that should run. | |||||
int test_case_to_run_count() const; | |||||
// Gets the number of successful tests. | |||||
int successful_test_count() const; | |||||
// Gets the number of failed tests. | |||||
int failed_test_count() const; | |||||
// Gets the number of disabled tests that will be reported in the XML report. | |||||
int reportable_disabled_test_count() const; | |||||
// Gets the number of disabled tests. | |||||
int disabled_test_count() const; | |||||
// Gets the number of tests to be printed in the XML report. | |||||
int reportable_test_count() const; | |||||
// Gets the number of all tests. | |||||
int total_test_count() const; | |||||
// Gets the number of tests that should run. | |||||
int test_to_run_count() const; | |||||
// Gets the time of the test program start, in ms from the start of the | |||||
// UNIX epoch. | |||||
TimeInMillis start_timestamp() const; | |||||
// Gets the elapsed time, in milliseconds. | |||||
TimeInMillis elapsed_time() const; | |||||
// Returns true iff the unit test passed (i.e. all test cases passed). | |||||
bool Passed() const; | |||||
// Returns true iff the unit test failed (i.e. some test case failed | |||||
// or something outside of all tests failed). | |||||
bool Failed() const; | |||||
// Gets the i-th test case among all the test cases. i can range from 0 to | |||||
// total_test_case_count() - 1. If i is not in that range, returns NULL. | |||||
const TestCase* GetTestCase(int i) const; | |||||
// Returns the TestResult containing information on test failures and | |||||
// properties logged outside of individual test cases. | |||||
const TestResult& ad_hoc_test_result() const; | |||||
// Returns the list of event listeners that can be used to track events | |||||
// inside Google Test. | |||||
TestEventListeners& listeners(); | |||||
private: | |||||
// Registers and returns a global test environment. When a test | |||||
// program is run, all global test environments will be set-up in | |||||
// the order they were registered. After all tests in the program | |||||
// have finished, all global test environments will be torn-down in | |||||
// the *reverse* order they were registered. | |||||
// | |||||
// The UnitTest object takes ownership of the given environment. | |||||
// | |||||
// This method can only be called from the main thread. | |||||
Environment* AddEnvironment(Environment* env); | |||||
// Adds a TestPartResult to the current TestResult object. All | |||||
// Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) | |||||
// eventually call this to report their results. The user code | |||||
// should use the assertion macros instead of calling this directly. | |||||
void AddTestPartResult(TestPartResult::Type result_type, | |||||
const char* file_name, | |||||
int line_number, | |||||
const std::string& message, | |||||
const std::string& os_stack_trace) | |||||
GTEST_LOCK_EXCLUDED_(mutex_); | |||||
// Adds a TestProperty to the current TestResult object when invoked from | |||||
// inside a test, to current TestCase's ad_hoc_test_result_ when invoked | |||||
// from SetUpTestCase or TearDownTestCase, or to the global property set | |||||
// when invoked elsewhere. If the result already contains a property with | |||||
// the same key, the value will be updated. | |||||
void RecordProperty(const std::string& key, const std::string& value); | |||||
// Gets the i-th test case among all the test cases. i can range from 0 to | |||||
// total_test_case_count() - 1. If i is not in that range, returns NULL. | |||||
TestCase* GetMutableTestCase(int i); | |||||
// Accessors for the implementation object. | |||||
internal::UnitTestImpl* impl() { return impl_; } | |||||
const internal::UnitTestImpl* impl() const { return impl_; } | |||||
// These classes and functions are friends as they need to access private | |||||
// members of UnitTest. | |||||
friend class ScopedTrace; | |||||
friend class Test; | |||||
friend class internal::AssertHelper; | |||||
friend class internal::StreamingListenerTest; | |||||
friend class internal::UnitTestRecordPropertyTestHelper; | |||||
friend Environment* AddGlobalTestEnvironment(Environment* env); | |||||
friend internal::UnitTestImpl* internal::GetUnitTestImpl(); | |||||
friend void internal::ReportFailureInUnknownLocation( | |||||
TestPartResult::Type result_type, | |||||
const std::string& message); | |||||
// Creates an empty UnitTest. | |||||
UnitTest(); | |||||
// D'tor | |||||
virtual ~UnitTest(); | |||||
// Pushes a trace defined by SCOPED_TRACE() on to the per-thread | |||||
// Google Test trace stack. | |||||
void PushGTestTrace(const internal::TraceInfo& trace) | |||||
GTEST_LOCK_EXCLUDED_(mutex_); | |||||
// Pops a trace from the per-thread Google Test trace stack. | |||||
void PopGTestTrace() | |||||
GTEST_LOCK_EXCLUDED_(mutex_); | |||||
// Protects mutable state in *impl_. This is mutable as some const | |||||
// methods need to lock it too. | |||||
mutable internal::Mutex mutex_; | |||||
// Opaque implementation object. This field is never changed once | |||||
// the object is constructed. We don't mark it as const here, as | |||||
// doing so will cause a warning in the constructor of UnitTest. | |||||
// Mutable state in *impl_ is protected by mutex_. | |||||
internal::UnitTestImpl* impl_; | |||||
// We disallow copying UnitTest. | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest); | |||||
}; | |||||
// A convenient wrapper for adding an environment for the test | |||||
// program. | |||||
// | |||||
// You should call this before RUN_ALL_TESTS() is called, probably in | |||||
// main(). If you use gtest_main, you need to call this before main() | |||||
// starts for it to take effect. For example, you can define a global | |||||
// variable like this: | |||||
// | |||||
// testing::Environment* const foo_env = | |||||
// testing::AddGlobalTestEnvironment(new FooEnvironment); | |||||
// | |||||
// However, we strongly recommend you to write your own main() and | |||||
// call AddGlobalTestEnvironment() there, as relying on initialization | |||||
// of global variables makes the code harder to read and may cause | |||||
// problems when you register multiple environments from different | |||||
// translation units and the environments have dependencies among them | |||||
// (remember that the compiler doesn't guarantee the order in which | |||||
// global variables from different translation units are initialized). | |||||
inline Environment* AddGlobalTestEnvironment(Environment* env) { | |||||
return UnitTest::GetInstance()->AddEnvironment(env); | |||||
} | |||||
// Initializes Google Test. This must be called before calling | |||||
// RUN_ALL_TESTS(). In particular, it parses a command line for the | |||||
// flags that Google Test recognizes. Whenever a Google Test flag is | |||||
// seen, it is removed from argv, and *argc is decremented. | |||||
// | |||||
// No value is returned. Instead, the Google Test flag variables are | |||||
// updated. | |||||
// | |||||
// Calling the function for the second time has no user-visible effect. | |||||
GTEST_API_ void InitGoogleTest(int* argc, char** argv); | |||||
// This overloaded version can be used in Windows programs compiled in | |||||
// UNICODE mode. | |||||
GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv); | |||||
namespace internal { | |||||
// Separate the error generating code from the code path to reduce the stack | |||||
// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers | |||||
// when calling EXPECT_* in a tight loop. | |||||
template <typename T1, typename T2> | |||||
AssertionResult CmpHelperEQFailure(const char* lhs_expression, | |||||
const char* rhs_expression, | |||||
const T1& lhs, const T2& rhs) { | |||||
return EqFailure(lhs_expression, | |||||
rhs_expression, | |||||
FormatForComparisonFailureMessage(lhs, rhs), | |||||
FormatForComparisonFailureMessage(rhs, lhs), | |||||
false); | |||||
} | |||||
// The helper function for {ASSERT|EXPECT}_EQ. | |||||
template <typename T1, typename T2> | |||||
AssertionResult CmpHelperEQ(const char* lhs_expression, | |||||
const char* rhs_expression, | |||||
const T1& lhs, | |||||
const T2& rhs) { | |||||
if (lhs == rhs) { | |||||
return AssertionSuccess(); | |||||
} | |||||
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); | |||||
} | |||||
// With this overloaded version, we allow anonymous enums to be used | |||||
// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums | |||||
// can be implicitly cast to BiggestInt. | |||||
GTEST_API_ AssertionResult CmpHelperEQ(const char* lhs_expression, | |||||
const char* rhs_expression, | |||||
BiggestInt lhs, | |||||
BiggestInt rhs); | |||||
// The helper class for {ASSERT|EXPECT}_EQ. The template argument | |||||
// lhs_is_null_literal is true iff the first argument to ASSERT_EQ() | |||||
// is a null pointer literal. The following default implementation is | |||||
// for lhs_is_null_literal being false. | |||||
template <bool lhs_is_null_literal> | |||||
class EqHelper { | |||||
public: | |||||
// This templatized version is for the general case. | |||||
template <typename T1, typename T2> | |||||
static AssertionResult Compare(const char* lhs_expression, | |||||
const char* rhs_expression, | |||||
const T1& lhs, | |||||
const T2& rhs) { | |||||
return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); | |||||
} | |||||
// With this overloaded version, we allow anonymous enums to be used | |||||
// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous | |||||
// enums can be implicitly cast to BiggestInt. | |||||
// | |||||
// Even though its body looks the same as the above version, we | |||||
// cannot merge the two, as it will make anonymous enums unhappy. | |||||
static AssertionResult Compare(const char* lhs_expression, | |||||
const char* rhs_expression, | |||||
BiggestInt lhs, | |||||
BiggestInt rhs) { | |||||
return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); | |||||
} | |||||
}; | |||||
// This specialization is used when the first argument to ASSERT_EQ() | |||||
// is a null pointer literal, like NULL, false, or 0. | |||||
template <> | |||||
class EqHelper<true> { | |||||
public: | |||||
// We define two overloaded versions of Compare(). The first | |||||
// version will be picked when the second argument to ASSERT_EQ() is | |||||
// NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or | |||||
// EXPECT_EQ(false, a_bool). | |||||
template <typename T1, typename T2> | |||||
static AssertionResult Compare( | |||||
const char* lhs_expression, | |||||
const char* rhs_expression, | |||||
const T1& lhs, | |||||
const T2& rhs, | |||||
// The following line prevents this overload from being considered if T2 | |||||
// is not a pointer type. We need this because ASSERT_EQ(NULL, my_ptr) | |||||
// expands to Compare("", "", NULL, my_ptr), which requires a conversion | |||||
// to match the Secret* in the other overload, which would otherwise make | |||||
// this template match better. | |||||
typename EnableIf<!is_pointer<T2>::value>::type* = 0) { | |||||
return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); | |||||
} | |||||
// This version will be picked when the second argument to ASSERT_EQ() is a | |||||
// pointer, e.g. ASSERT_EQ(NULL, a_pointer). | |||||
template <typename T> | |||||
static AssertionResult Compare( | |||||
const char* lhs_expression, | |||||
const char* rhs_expression, | |||||
// We used to have a second template parameter instead of Secret*. That | |||||
// template parameter would deduce to 'long', making this a better match | |||||
// than the first overload even without the first overload's EnableIf. | |||||
// Unfortunately, gcc with -Wconversion-null warns when "passing NULL to | |||||
// non-pointer argument" (even a deduced integral argument), so the old | |||||
// implementation caused warnings in user code. | |||||
Secret* /* lhs (NULL) */, | |||||
T* rhs) { | |||||
// We already know that 'lhs' is a null pointer. | |||||
return CmpHelperEQ(lhs_expression, rhs_expression, | |||||
static_cast<T*>(NULL), rhs); | |||||
} | |||||
}; | |||||
// Separate the error generating code from the code path to reduce the stack | |||||
// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers | |||||
// when calling EXPECT_OP in a tight loop. | |||||
template <typename T1, typename T2> | |||||
AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2, | |||||
const T1& val1, const T2& val2, | |||||
const char* op) { | |||||
return AssertionFailure() | |||||
<< "Expected: (" << expr1 << ") " << op << " (" << expr2 | |||||
<< "), actual: " << FormatForComparisonFailureMessage(val1, val2) | |||||
<< " vs " << FormatForComparisonFailureMessage(val2, val1); | |||||
} | |||||
// A macro for implementing the helper functions needed to implement | |||||
// ASSERT_?? and EXPECT_??. It is here just to avoid copy-and-paste | |||||
// of similar code. | |||||
// | |||||
// For each templatized helper function, we also define an overloaded | |||||
// version for BiggestInt in order to reduce code bloat and allow | |||||
// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled | |||||
// with gcc 4. | |||||
// | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ | |||||
template <typename T1, typename T2>\ | |||||
AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ | |||||
const T1& val1, const T2& val2) {\ | |||||
if (val1 op val2) {\ | |||||
return AssertionSuccess();\ | |||||
} else {\ | |||||
return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\ | |||||
}\ | |||||
}\ | |||||
GTEST_API_ AssertionResult CmpHelper##op_name(\ | |||||
const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2) | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
// Implements the helper function for {ASSERT|EXPECT}_NE | |||||
GTEST_IMPL_CMP_HELPER_(NE, !=); | |||||
// Implements the helper function for {ASSERT|EXPECT}_LE | |||||
GTEST_IMPL_CMP_HELPER_(LE, <=); | |||||
// Implements the helper function for {ASSERT|EXPECT}_LT | |||||
GTEST_IMPL_CMP_HELPER_(LT, <); | |||||
// Implements the helper function for {ASSERT|EXPECT}_GE | |||||
GTEST_IMPL_CMP_HELPER_(GE, >=); | |||||
// Implements the helper function for {ASSERT|EXPECT}_GT | |||||
GTEST_IMPL_CMP_HELPER_(GT, >); | |||||
#undef GTEST_IMPL_CMP_HELPER_ | |||||
// The helper function for {ASSERT|EXPECT}_STREQ. | |||||
// | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression, | |||||
const char* s2_expression, | |||||
const char* s1, | |||||
const char* s2); | |||||
// The helper function for {ASSERT|EXPECT}_STRCASEEQ. | |||||
// | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression, | |||||
const char* s2_expression, | |||||
const char* s1, | |||||
const char* s2); | |||||
// The helper function for {ASSERT|EXPECT}_STRNE. | |||||
// | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, | |||||
const char* s2_expression, | |||||
const char* s1, | |||||
const char* s2); | |||||
// The helper function for {ASSERT|EXPECT}_STRCASENE. | |||||
// | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression, | |||||
const char* s2_expression, | |||||
const char* s1, | |||||
const char* s2); | |||||
// Helper function for *_STREQ on wide strings. | |||||
// | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression, | |||||
const char* s2_expression, | |||||
const wchar_t* s1, | |||||
const wchar_t* s2); | |||||
// Helper function for *_STRNE on wide strings. | |||||
// | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, | |||||
const char* s2_expression, | |||||
const wchar_t* s1, | |||||
const wchar_t* s2); | |||||
} // namespace internal | |||||
// IsSubstring() and IsNotSubstring() are intended to be used as the | |||||
// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by | |||||
// themselves. They check whether needle is a substring of haystack | |||||
// (NULL is considered a substring of itself only), and return an | |||||
// appropriate error message when they fail. | |||||
// | |||||
// The {needle,haystack}_expr arguments are the stringified | |||||
// expressions that generated the two real arguments. | |||||
GTEST_API_ AssertionResult IsSubstring( | |||||
const char* needle_expr, const char* haystack_expr, | |||||
const char* needle, const char* haystack); | |||||
GTEST_API_ AssertionResult IsSubstring( | |||||
const char* needle_expr, const char* haystack_expr, | |||||
const wchar_t* needle, const wchar_t* haystack); | |||||
GTEST_API_ AssertionResult IsNotSubstring( | |||||
const char* needle_expr, const char* haystack_expr, | |||||
const char* needle, const char* haystack); | |||||
GTEST_API_ AssertionResult IsNotSubstring( | |||||
const char* needle_expr, const char* haystack_expr, | |||||
const wchar_t* needle, const wchar_t* haystack); | |||||
GTEST_API_ AssertionResult IsSubstring( | |||||
const char* needle_expr, const char* haystack_expr, | |||||
const ::std::string& needle, const ::std::string& haystack); | |||||
GTEST_API_ AssertionResult IsNotSubstring( | |||||
const char* needle_expr, const char* haystack_expr, | |||||
const ::std::string& needle, const ::std::string& haystack); | |||||
#if GTEST_HAS_STD_WSTRING | |||||
GTEST_API_ AssertionResult IsSubstring( | |||||
const char* needle_expr, const char* haystack_expr, | |||||
const ::std::wstring& needle, const ::std::wstring& haystack); | |||||
GTEST_API_ AssertionResult IsNotSubstring( | |||||
const char* needle_expr, const char* haystack_expr, | |||||
const ::std::wstring& needle, const ::std::wstring& haystack); | |||||
#endif // GTEST_HAS_STD_WSTRING | |||||
namespace internal { | |||||
// Helper template function for comparing floating-points. | |||||
// | |||||
// Template parameter: | |||||
// | |||||
// RawType: the raw floating-point type (either float or double) | |||||
// | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
template <typename RawType> | |||||
AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression, | |||||
const char* rhs_expression, | |||||
RawType lhs_value, | |||||
RawType rhs_value) { | |||||
const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value); | |||||
if (lhs.AlmostEquals(rhs)) { | |||||
return AssertionSuccess(); | |||||
} | |||||
::std::stringstream lhs_ss; | |||||
lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) | |||||
<< lhs_value; | |||||
::std::stringstream rhs_ss; | |||||
rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) | |||||
<< rhs_value; | |||||
return EqFailure(lhs_expression, | |||||
rhs_expression, | |||||
StringStreamToString(&lhs_ss), | |||||
StringStreamToString(&rhs_ss), | |||||
false); | |||||
} | |||||
// Helper function for implementing ASSERT_NEAR. | |||||
// | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | |||||
GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1, | |||||
const char* expr2, | |||||
const char* abs_error_expr, | |||||
double val1, | |||||
double val2, | |||||
double abs_error); | |||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. | |||||
// A class that enables one to stream messages to assertion macros | |||||
class GTEST_API_ AssertHelper { | |||||
public: | |||||
// Constructor. | |||||
AssertHelper(TestPartResult::Type type, | |||||
const char* file, | |||||
int line, | |||||
const char* message); | |||||
~AssertHelper(); | |||||
// Message assignment is a semantic trick to enable assertion | |||||
// streaming; see the GTEST_MESSAGE_ macro below. | |||||
void operator=(const Message& message) const; | |||||
private: | |||||
// We put our data in a struct so that the size of the AssertHelper class can | |||||
// be as small as possible. This is important because gcc is incapable of | |||||
// re-using stack space even for temporary variables, so every EXPECT_EQ | |||||
// reserves stack space for another AssertHelper. | |||||
struct AssertHelperData { | |||||
AssertHelperData(TestPartResult::Type t, | |||||
const char* srcfile, | |||||
int line_num, | |||||
const char* msg) | |||||
: type(t), file(srcfile), line(line_num), message(msg) { } | |||||
TestPartResult::Type const type; | |||||
const char* const file; | |||||
int const line; | |||||
std::string const message; | |||||
private: | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData); | |||||
}; | |||||
AssertHelperData* const data_; | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper); | |||||
}; | |||||
} // namespace internal | |||||
// The pure interface class that all value-parameterized tests inherit from. | |||||
// A value-parameterized class must inherit from both ::testing::Test and | |||||
// ::testing::WithParamInterface. In most cases that just means inheriting | |||||
// from ::testing::TestWithParam, but more complicated test hierarchies | |||||
// may need to inherit from Test and WithParamInterface at different levels. | |||||
// | |||||
// This interface has support for accessing the test parameter value via | |||||
// the GetParam() method. | |||||
// | |||||
// Use it with one of the parameter generator defining functions, like Range(), | |||||
// Values(), ValuesIn(), Bool(), and Combine(). | |||||
// | |||||
// class FooTest : public ::testing::TestWithParam<int> { | |||||
// protected: | |||||
// FooTest() { | |||||
// // Can use GetParam() here. | |||||
// } | |||||
// virtual ~FooTest() { | |||||
// // Can use GetParam() here. | |||||
// } | |||||
// virtual void SetUp() { | |||||
// // Can use GetParam() here. | |||||
// } | |||||
// virtual void TearDown { | |||||
// // Can use GetParam() here. | |||||
// } | |||||
// }; | |||||
// TEST_P(FooTest, DoesBar) { | |||||
// // Can use GetParam() method here. | |||||
// Foo foo; | |||||
// ASSERT_TRUE(foo.DoesBar(GetParam())); | |||||
// } | |||||
// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10)); | |||||
template <typename T> | |||||
class WithParamInterface { | |||||
public: | |||||
typedef T ParamType; | |||||
virtual ~WithParamInterface() {} | |||||
// The current parameter value. Is also available in the test fixture's | |||||
// constructor. This member function is non-static, even though it only | |||||
// references static data, to reduce the opportunity for incorrect uses | |||||
// like writing 'WithParamInterface<bool>::GetParam()' for a test that | |||||
// uses a fixture whose parameter type is int. | |||||
const ParamType& GetParam() const { | |||||
GTEST_CHECK_(parameter_ != NULL) | |||||
<< "GetParam() can only be called inside a value-parameterized test " | |||||
<< "-- did you intend to write TEST_P instead of TEST_F?"; | |||||
return *parameter_; | |||||
} | |||||
private: | |||||
// Sets parameter value. The caller is responsible for making sure the value | |||||
// remains alive and unchanged throughout the current test. | |||||
static void SetParam(const ParamType* parameter) { | |||||
parameter_ = parameter; | |||||
} | |||||
// Static value used for accessing parameter during a test lifetime. | |||||
static const ParamType* parameter_; | |||||
// TestClass must be a subclass of WithParamInterface<T> and Test. | |||||
template <class TestClass> friend class internal::ParameterizedTestFactory; | |||||
}; | |||||
template <typename T> | |||||
const T* WithParamInterface<T>::parameter_ = NULL; | |||||
// Most value-parameterized classes can ignore the existence of | |||||
// WithParamInterface, and can just inherit from ::testing::TestWithParam. | |||||
template <typename T> | |||||
class TestWithParam : public Test, public WithParamInterface<T> { | |||||
}; | |||||
// Macros for indicating success/failure in test code. | |||||
// ADD_FAILURE unconditionally adds a failure to the current test. | |||||
// SUCCEED generates a success - it doesn't automatically make the | |||||
// current test successful, as a test is only successful when it has | |||||
// no failure. | |||||
// | |||||
// EXPECT_* verifies that a certain condition is satisfied. If not, | |||||
// it behaves like ADD_FAILURE. In particular: | |||||
// | |||||
// EXPECT_TRUE verifies that a Boolean condition is true. | |||||
// EXPECT_FALSE verifies that a Boolean condition is false. | |||||
// | |||||
// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except | |||||
// that they will also abort the current function on failure. People | |||||
// usually want the fail-fast behavior of FAIL and ASSERT_*, but those | |||||
// writing data-driven tests often find themselves using ADD_FAILURE | |||||
// and EXPECT_* more. | |||||
// Generates a nonfatal failure with a generic message. | |||||
#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed") | |||||
// Generates a nonfatal failure at the given source file location with | |||||
// a generic message. | |||||
#define ADD_FAILURE_AT(file, line) \ | |||||
GTEST_MESSAGE_AT_(file, line, "Failed", \ | |||||
::testing::TestPartResult::kNonFatalFailure) | |||||
// Generates a fatal failure with a generic message. | |||||
#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed") | |||||
// Define this macro to 1 to omit the definition of FAIL(), which is a | |||||
// generic name and clashes with some other libraries. | |||||
#if !GTEST_DONT_DEFINE_FAIL | |||||
# define FAIL() GTEST_FAIL() | |||||
#endif | |||||
// Generates a success with a generic message. | |||||
#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded") | |||||
// Define this macro to 1 to omit the definition of SUCCEED(), which | |||||
// is a generic name and clashes with some other libraries. | |||||
#if !GTEST_DONT_DEFINE_SUCCEED | |||||
# define SUCCEED() GTEST_SUCCEED() | |||||
#endif | |||||
// Macros for testing exceptions. | |||||
// | |||||
// * {ASSERT|EXPECT}_THROW(statement, expected_exception): | |||||
// Tests that the statement throws the expected exception. | |||||
// * {ASSERT|EXPECT}_NO_THROW(statement): | |||||
// Tests that the statement doesn't throw any exception. | |||||
// * {ASSERT|EXPECT}_ANY_THROW(statement): | |||||
// Tests that the statement throws an exception. | |||||
#define EXPECT_THROW(statement, expected_exception) \ | |||||
GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_) | |||||
#define EXPECT_NO_THROW(statement) \ | |||||
GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_) | |||||
#define EXPECT_ANY_THROW(statement) \ | |||||
GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_) | |||||
#define ASSERT_THROW(statement, expected_exception) \ | |||||
GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_) | |||||
#define ASSERT_NO_THROW(statement) \ | |||||
GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_) | |||||
#define ASSERT_ANY_THROW(statement) \ | |||||
GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_) | |||||
// Boolean assertions. Condition can be either a Boolean expression or an | |||||
// AssertionResult. For more information on how to use AssertionResult with | |||||
// these macros see comments on that class. | |||||
#define EXPECT_TRUE(condition) \ | |||||
GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ | |||||
GTEST_NONFATAL_FAILURE_) | |||||
#define EXPECT_FALSE(condition) \ | |||||
GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ | |||||
GTEST_NONFATAL_FAILURE_) | |||||
#define ASSERT_TRUE(condition) \ | |||||
GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ | |||||
GTEST_FATAL_FAILURE_) | |||||
#define ASSERT_FALSE(condition) \ | |||||
GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ | |||||
GTEST_FATAL_FAILURE_) | |||||
// Macros for testing equalities and inequalities. | |||||
// | |||||
// * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2 | |||||
// * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2 | |||||
// * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2 | |||||
// * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2 | |||||
// * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2 | |||||
// * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2 | |||||
// | |||||
// When they are not, Google Test prints both the tested expressions and | |||||
// their actual values. The values must be compatible built-in types, | |||||
// or you will get a compiler error. By "compatible" we mean that the | |||||
// values can be compared by the respective operator. | |||||
// | |||||
// Note: | |||||
// | |||||
// 1. It is possible to make a user-defined type work with | |||||
// {ASSERT|EXPECT}_??(), but that requires overloading the | |||||
// comparison operators and is thus discouraged by the Google C++ | |||||
// Usage Guide. Therefore, you are advised to use the | |||||
// {ASSERT|EXPECT}_TRUE() macro to assert that two objects are | |||||
// equal. | |||||
// | |||||
// 2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on | |||||
// pointers (in particular, C strings). Therefore, if you use it | |||||
// with two C strings, you are testing how their locations in memory | |||||
// are related, not how their content is related. To compare two C | |||||
// strings by content, use {ASSERT|EXPECT}_STR*(). | |||||
// | |||||
// 3. {ASSERT|EXPECT}_EQ(v1, v2) is preferred to | |||||
// {ASSERT|EXPECT}_TRUE(v1 == v2), as the former tells you | |||||
// what the actual value is when it fails, and similarly for the | |||||
// other comparisons. | |||||
// | |||||
// 4. Do not depend on the order in which {ASSERT|EXPECT}_??() | |||||
// evaluate their arguments, which is undefined. | |||||
// | |||||
// 5. These macros evaluate their arguments exactly once. | |||||
// | |||||
// Examples: | |||||
// | |||||
// EXPECT_NE(Foo(), 5); | |||||
// EXPECT_EQ(a_pointer, NULL); | |||||
// ASSERT_LT(i, array_size); | |||||
// ASSERT_GT(records.size(), 0) << "There is no record left."; | |||||
#define EXPECT_EQ(val1, val2) \ | |||||
EXPECT_PRED_FORMAT2(::testing::internal:: \ | |||||
EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \ | |||||
val1, val2) | |||||
#define EXPECT_NE(val1, val2) \ | |||||
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) | |||||
#define EXPECT_LE(val1, val2) \ | |||||
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) | |||||
#define EXPECT_LT(val1, val2) \ | |||||
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) | |||||
#define EXPECT_GE(val1, val2) \ | |||||
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) | |||||
#define EXPECT_GT(val1, val2) \ | |||||
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) | |||||
#define GTEST_ASSERT_EQ(val1, val2) \ | |||||
ASSERT_PRED_FORMAT2(::testing::internal:: \ | |||||
EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \ | |||||
val1, val2) | |||||
#define GTEST_ASSERT_NE(val1, val2) \ | |||||
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) | |||||
#define GTEST_ASSERT_LE(val1, val2) \ | |||||
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) | |||||
#define GTEST_ASSERT_LT(val1, val2) \ | |||||
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) | |||||
#define GTEST_ASSERT_GE(val1, val2) \ | |||||
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) | |||||
#define GTEST_ASSERT_GT(val1, val2) \ | |||||
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) | |||||
// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of | |||||
// ASSERT_XY(), which clashes with some users' own code. | |||||
#if !GTEST_DONT_DEFINE_ASSERT_EQ | |||||
# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2) | |||||
#endif | |||||
#if !GTEST_DONT_DEFINE_ASSERT_NE | |||||
# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2) | |||||
#endif | |||||
#if !GTEST_DONT_DEFINE_ASSERT_LE | |||||
# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2) | |||||
#endif | |||||
#if !GTEST_DONT_DEFINE_ASSERT_LT | |||||
# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2) | |||||
#endif | |||||
#if !GTEST_DONT_DEFINE_ASSERT_GE | |||||
# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2) | |||||
#endif | |||||
#if !GTEST_DONT_DEFINE_ASSERT_GT | |||||
# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2) | |||||
#endif | |||||
// C-string Comparisons. All tests treat NULL and any non-NULL string | |||||
// as different. Two NULLs are equal. | |||||
// | |||||
// * {ASSERT|EXPECT}_STREQ(s1, s2): Tests that s1 == s2 | |||||
// * {ASSERT|EXPECT}_STRNE(s1, s2): Tests that s1 != s2 | |||||
// * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case | |||||
// * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case | |||||
// | |||||
// For wide or narrow string objects, you can use the | |||||
// {ASSERT|EXPECT}_??() macros. | |||||
// | |||||
// Don't depend on the order in which the arguments are evaluated, | |||||
// which is undefined. | |||||
// | |||||
// These macros evaluate their arguments exactly once. | |||||
#define EXPECT_STREQ(s1, s2) \ | |||||
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2) | |||||
#define EXPECT_STRNE(s1, s2) \ | |||||
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) | |||||
#define EXPECT_STRCASEEQ(s1, s2) \ | |||||
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2) | |||||
#define EXPECT_STRCASENE(s1, s2)\ | |||||
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) | |||||
#define ASSERT_STREQ(s1, s2) \ | |||||
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2) | |||||
#define ASSERT_STRNE(s1, s2) \ | |||||
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) | |||||
#define ASSERT_STRCASEEQ(s1, s2) \ | |||||
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2) | |||||
#define ASSERT_STRCASENE(s1, s2)\ | |||||
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) | |||||
// Macros for comparing floating-point numbers. | |||||
// | |||||
// * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2): | |||||
// Tests that two float values are almost equal. | |||||
// * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2): | |||||
// Tests that two double values are almost equal. | |||||
// * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error): | |||||
// Tests that v1 and v2 are within the given distance to each other. | |||||
// | |||||
// Google Test uses ULP-based comparison to automatically pick a default | |||||
// error bound that is appropriate for the operands. See the | |||||
// FloatingPoint template class in gtest-internal.h if you are | |||||
// interested in the implementation details. | |||||
#define EXPECT_FLOAT_EQ(val1, val2)\ | |||||
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ | |||||
val1, val2) | |||||
#define EXPECT_DOUBLE_EQ(val1, val2)\ | |||||
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ | |||||
val1, val2) | |||||
#define ASSERT_FLOAT_EQ(val1, val2)\ | |||||
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ | |||||
val1, val2) | |||||
#define ASSERT_DOUBLE_EQ(val1, val2)\ | |||||
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ | |||||
val1, val2) | |||||
#define EXPECT_NEAR(val1, val2, abs_error)\ | |||||
EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ | |||||
val1, val2, abs_error) | |||||
#define ASSERT_NEAR(val1, val2, abs_error)\ | |||||
ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ | |||||
val1, val2, abs_error) | |||||
// These predicate format functions work on floating-point values, and | |||||
// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g. | |||||
// | |||||
// EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0); | |||||
// Asserts that val1 is less than, or almost equal to, val2. Fails | |||||
// otherwise. In particular, it fails if either val1 or val2 is NaN. | |||||
GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2, | |||||
float val1, float val2); | |||||
GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2, | |||||
double val1, double val2); | |||||
#if GTEST_OS_WINDOWS | |||||
// Macros that test for HRESULT failure and success, these are only useful | |||||
// on Windows, and rely on Windows SDK macros and APIs to compile. | |||||
// | |||||
// * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr) | |||||
// | |||||
// When expr unexpectedly fails or succeeds, Google Test prints the | |||||
// expected result and the actual result with both a human-readable | |||||
// string representation of the error, if available, as well as the | |||||
// hex result code. | |||||
# define EXPECT_HRESULT_SUCCEEDED(expr) \ | |||||
EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) | |||||
# define ASSERT_HRESULT_SUCCEEDED(expr) \ | |||||
ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) | |||||
# define EXPECT_HRESULT_FAILED(expr) \ | |||||
EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) | |||||
# define ASSERT_HRESULT_FAILED(expr) \ | |||||
ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) | |||||
#endif // GTEST_OS_WINDOWS | |||||
// Macros that execute statement and check that it doesn't generate new fatal | |||||
// failures in the current thread. | |||||
// | |||||
// * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement); | |||||
// | |||||
// Examples: | |||||
// | |||||
// EXPECT_NO_FATAL_FAILURE(Process()); | |||||
// ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed"; | |||||
// | |||||
#define ASSERT_NO_FATAL_FAILURE(statement) \ | |||||
GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_) | |||||
#define EXPECT_NO_FATAL_FAILURE(statement) \ | |||||
GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_) | |||||
// Causes a trace (including the given source file path and line number, | |||||
// and the given message) to be included in every test failure message generated | |||||
// by code in the scope of the lifetime of an instance of this class. The effect | |||||
// is undone with the destruction of the instance. | |||||
// | |||||
// The message argument can be anything streamable to std::ostream. | |||||
// | |||||
// Example: | |||||
// testing::ScopedTrace trace("file.cc", 123, "message"); | |||||
// | |||||
class GTEST_API_ ScopedTrace { | |||||
public: | |||||
// The c'tor pushes the given source file location and message onto | |||||
// a trace stack maintained by Google Test. | |||||
// Template version. Uses Message() to convert the values into strings. | |||||
// Slow, but flexible. | |||||
template <typename T> | |||||
ScopedTrace(const char* file, int line, const T& message) { | |||||
PushTrace(file, line, (Message() << message).GetString()); | |||||
} | |||||
// Optimize for some known types. | |||||
ScopedTrace(const char* file, int line, const char* message) { | |||||
PushTrace(file, line, message ? message : "(null)"); | |||||
} | |||||
#if GTEST_HAS_GLOBAL_STRING | |||||
ScopedTrace(const char* file, int line, const ::string& message) { | |||||
PushTrace(file, line, message); | |||||
} | |||||
#endif | |||||
ScopedTrace(const char* file, int line, const std::string& message) { | |||||
PushTrace(file, line, message); | |||||
} | |||||
// The d'tor pops the info pushed by the c'tor. | |||||
// | |||||
// Note that the d'tor is not virtual in order to be efficient. | |||||
// Don't inherit from ScopedTrace! | |||||
~ScopedTrace(); | |||||
private: | |||||
void PushTrace(const char* file, int line, std::string message); | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace); | |||||
} GTEST_ATTRIBUTE_UNUSED_; // A ScopedTrace object does its job in its | |||||
// c'tor and d'tor. Therefore it doesn't | |||||
// need to be used otherwise. | |||||
// Causes a trace (including the source file path, the current line | |||||
// number, and the given message) to be included in every test failure | |||||
// message generated by code in the current scope. The effect is | |||||
// undone when the control leaves the current scope. | |||||
// | |||||
// The message argument can be anything streamable to std::ostream. | |||||
// | |||||
// In the implementation, we include the current line number as part | |||||
// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s | |||||
// to appear in the same block - as long as they are on different | |||||
// lines. | |||||
// | |||||
// Assuming that each thread maintains its own stack of traces. | |||||
// Therefore, a SCOPED_TRACE() would (correctly) only affect the | |||||
// assertions in its own thread. | |||||
#define SCOPED_TRACE(message) \ | |||||
::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\ | |||||
__FILE__, __LINE__, (message)) | |||||
// Compile-time assertion for type equality. | |||||
// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are | |||||
// the same type. The value it returns is not interesting. | |||||
// | |||||
// Instead of making StaticAssertTypeEq a class template, we make it a | |||||
// function template that invokes a helper class template. This | |||||
// prevents a user from misusing StaticAssertTypeEq<T1, T2> by | |||||
// defining objects of that type. | |||||
// | |||||
// CAVEAT: | |||||
// | |||||
// When used inside a method of a class template, | |||||
// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is | |||||
// instantiated. For example, given: | |||||
// | |||||
// template <typename T> class Foo { | |||||
// public: | |||||
// void Bar() { testing::StaticAssertTypeEq<int, T>(); } | |||||
// }; | |||||
// | |||||
// the code: | |||||
// | |||||
// void Test1() { Foo<bool> foo; } | |||||
// | |||||
// will NOT generate a compiler error, as Foo<bool>::Bar() is never | |||||
// actually instantiated. Instead, you need: | |||||
// | |||||
// void Test2() { Foo<bool> foo; foo.Bar(); } | |||||
// | |||||
// to cause a compiler error. | |||||
template <typename T1, typename T2> | |||||
bool StaticAssertTypeEq() { | |||||
(void)internal::StaticAssertTypeEqHelper<T1, T2>(); | |||||
return true; | |||||
} | |||||
// Defines a test. | |||||
// | |||||
// The first parameter is the name of the test case, and the second | |||||
// parameter is the name of the test within the test case. | |||||
// | |||||
// The convention is to end the test case name with "Test". For | |||||
// example, a test case for the Foo class can be named FooTest. | |||||
// | |||||
// Test code should appear between braces after an invocation of | |||||
// this macro. Example: | |||||
// | |||||
// TEST(FooTest, InitializesCorrectly) { | |||||
// Foo foo; | |||||
// EXPECT_TRUE(foo.StatusIsOK()); | |||||
// } | |||||
// Note that we call GetTestTypeId() instead of GetTypeId< | |||||
// ::testing::Test>() here to get the type ID of testing::Test. This | |||||
// is to work around a suspected linker bug when using Google Test as | |||||
// a framework on Mac OS X. The bug causes GetTypeId< | |||||
// ::testing::Test>() to return different values depending on whether | |||||
// the call is from the Google Test framework itself or from user test | |||||
// code. GetTestTypeId() is guaranteed to always return the same | |||||
// value, as it always calls GetTypeId<>() from the Google Test | |||||
// framework. | |||||
#define GTEST_TEST(test_case_name, test_name)\ | |||||
GTEST_TEST_(test_case_name, test_name, \ | |||||
::testing::Test, ::testing::internal::GetTestTypeId()) | |||||
// Define this macro to 1 to omit the definition of TEST(), which | |||||
// is a generic name and clashes with some other libraries. | |||||
#if !GTEST_DONT_DEFINE_TEST | |||||
# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name) | |||||
#endif | |||||
// Defines a test that uses a test fixture. | |||||
// | |||||
// The first parameter is the name of the test fixture class, which | |||||
// also doubles as the test case name. The second parameter is the | |||||
// name of the test within the test case. | |||||
// | |||||
// A test fixture class must be declared earlier. The user should put | |||||
// the test code between braces after using this macro. Example: | |||||
// | |||||
// class FooTest : public testing::Test { | |||||
// protected: | |||||
// virtual void SetUp() { b_.AddElement(3); } | |||||
// | |||||
// Foo a_; | |||||
// Foo b_; | |||||
// }; | |||||
// | |||||
// TEST_F(FooTest, InitializesCorrectly) { | |||||
// EXPECT_TRUE(a_.StatusIsOK()); | |||||
// } | |||||
// | |||||
// TEST_F(FooTest, ReturnsElementCountCorrectly) { | |||||
// EXPECT_EQ(a_.size(), 0); | |||||
// EXPECT_EQ(b_.size(), 1); | |||||
// } | |||||
#define TEST_F(test_fixture, test_name)\ | |||||
GTEST_TEST_(test_fixture, test_name, test_fixture, \ | |||||
::testing::internal::GetTypeId<test_fixture>()) | |||||
// Returns a path to temporary directory. | |||||
// Tries to determine an appropriate directory for the platform. | |||||
GTEST_API_ std::string TempDir(); | |||||
#ifdef _MSC_VER | |||||
# pragma warning(pop) | |||||
#endif | |||||
} // namespace testing | |||||
// Use this function in main() to run all tests. It returns 0 if all | |||||
// tests are successful, or 1 otherwise. | |||||
// | |||||
// RUN_ALL_TESTS() should be invoked after the command line has been | |||||
// parsed by InitGoogleTest(). | |||||
// | |||||
// This function was formerly a macro; thus, it is in the global | |||||
// namespace and has an all-caps name. | |||||
int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_; | |||||
inline int RUN_ALL_TESTS() { | |||||
return ::testing::UnitTest::GetInstance()->Run(); | |||||
} | |||||
GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 | |||||
#endif // GTEST_INCLUDE_GTEST_GTEST_H_ |