// 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.

//

// Author: wan@google.com (Zhanyong Wan)

//

// The Google C++ Testing 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.

#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"

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

// 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 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 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.

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

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

  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() : "";

  }

  // TODO(vladl@google.com): 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);

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

  // 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.

  // TODO(russr): 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; }

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

    // For now, the XML report includes all tests matching the filter.

    // In the future, we may trim tests that are excluded because of

    // sharding.

    return matches_filter_;

  }

  // 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.

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