Subversion Repositories NedoOS

 

 

 

 

 

 

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \

 

 

namespace testing {

 

 

 

 

GTEST_DECLARE_bool_(also_run_disabled_tests);

 

GTEST_DECLARE_bool_(break_on_failure);

 

GTEST_DECLARE_bool_(catch_exceptions);

 

GTEST_DECLARE_string_(color);

 

GTEST_DECLARE_string_(filter);

 

GTEST_DECLARE_bool_(list_tests);

 

GTEST_DECLARE_string_(output);

 

GTEST_DECLARE_bool_(print_time);

 

GTEST_DECLARE_bool_(print_utf8);

 

GTEST_DECLARE_int32_(random_seed);

 

GTEST_DECLARE_int32_(repeat);

 

GTEST_DECLARE_bool_(show_internal_stack_frames);

 

GTEST_DECLARE_bool_(shuffle);

 

GTEST_DECLARE_int32_(stack_trace_depth);

 

GTEST_DECLARE_bool_(throw_on_failure);

 

GTEST_DECLARE_string_(stream_result_to);

 

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

 

class Test;

class TestCase;

class TestInfo;

class UnitTest;

 

class GTEST_API_ AssertionResult {

 public:

  // Copy constructor.

  // Used in EXPECT_TRUE/FALSE(assertion_result).

  AssertionResult(const AssertionResult& other);

 

  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)

 

  // 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) {}

 

  GTEST_DISABLE_MSC_WARNINGS_POP_()

 

  // 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_;

 

GTEST_API_ AssertionResult AssertionSuccess();

 

GTEST_API_ AssertionResult AssertionFailure();

 

GTEST_API_ AssertionResult AssertionFailure(const Message& msg);

 

}  // namespace testing

 

 

namespace testing {

 

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;

 

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_;

 

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

 

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:

  friend class internal::DefaultDeathTestFactory;

  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);

 

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);

 

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; }

 

 

class GTEST_API_ AssertionException

    : public internal::GoogleTestFailureException {

 public:

  explicit AssertionException(const TestPartResult& result)

      : GoogleTestFailureException(result) {}

 

 

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;

 

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*/) {}

 

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);

 

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);

 

inline Environment* AddGlobalTestEnvironment(Environment* env) {

  return UnitTest::GetInstance()->AddEnvironment(env);

 

GTEST_API_ void InitGoogleTest(int* argc, char** argv);

 

GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);

 

namespace internal {

 

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);

 

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);

 

GTEST_API_ AssertionResult CmpHelperEQ(const char* lhs_expression,

                                       const char* rhs_expression,

                                       BiggestInt lhs,

                                       BiggestInt rhs);

 

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);

  }

 

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);

  }

 

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);

 

 

 

 

GTEST_IMPL_CMP_HELPER_(NE, !=);

GTEST_IMPL_CMP_HELPER_(LE, <=);

GTEST_IMPL_CMP_HELPER_(LT, <);

GTEST_IMPL_CMP_HELPER_(GE, >=);

GTEST_IMPL_CMP_HELPER_(GT, >);

 

 

GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,

                                          const char* s2_expression,

                                          const char* s1,

                                          const char* s2);

 

GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression,

                                              const char* s2_expression,

                                              const char* s1,

                                              const char* s2);

 

GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,

                                          const char* s2_expression,

                                          const char* s1,

                                          const char* s2);

 

GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,

                                              const char* s2_expression,

                                              const char* s1,

                                              const char* s2);

 

 

GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,

                                          const char* s2_expression,

                                          const wchar_t* s1,

                                          const wchar_t* s2);

 

GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,

                                          const char* s2_expression,

                                          const wchar_t* s1,

                                          const wchar_t* s2);

 

}  // namespace internal

 

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);

 

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);

 

namespace internal {

 

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);

 

GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,

                                                const char* expr2,

                                                const char* abs_error_expr,

                                                double val1,

                                                double val2,

                                                double abs_error);

 

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

 

 

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;

 

 

template <typename T>

class TestWithParam : public Test, public WithParamInterface<T> {