text: // 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.
  
  #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_H_
  #define GOOGLETEST_INCLUDE_GTEST_GTEST_H_
  
  #include <cstddef>
  #include <limits>
  #include <memory>
  #include <ostream>
  #include <type_traits>
  #include <vector>
  
  #include "gtest/internal/gtest-internal.h"
  #include "gtest/internal/gtest-string.h"
  #include "gtest/gtest-death-test.h"
  #include "gtest/gtest-matchers.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 */)
  
  // 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 controls whether the test runner should continue execution past
  // first failure.
  GTEST_DECLARE_bool_(fail_fast);
  
  // 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 only test failures.
  GTEST_DECLARE_bool_(brief);
  
  // 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 Environments are recreated for each
  // repeat of the tests. The default value is true. If set to false the global
  // test Environment objects are only set up once, for the first iteration, and
  // only torn down once, for the last.
  GTEST_DECLARE_bool_(recreate_environments_when_repeating);
  
  // 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_
  
  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
  
  // 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);
  std::set<std::string>* GetIgnoredParameterizedTestSuites();
  
  }  // 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 TestSuite;
  
  // Old API is still available but deprecated
  #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  using TestCase = TestSuite;
  #endif
  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);
  
  // C4800 is a level 3 warning in Visual Studio 2015 and earlier.
  // This warning is not emitted in Visual Studio 2017.
  // This warning is off by default starting in Visual Studio 2019 but can be
  // enabled with command-line options.
  #if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
    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 std::enable_if<
            !std::is_convertible<T, AssertionResult>::value>::type*
        /*enabler*/
        = nullptr)
        : success_(success) {}
  
  #if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
    GTEST_DISABLE_MSC_WARNINGS_POP_()
  #endif
  
    // Assignment operator.
    AssertionResult& operator=(AssertionResult other) {
      swap(other);
      return *this;
    }
  
    // Returns true if and only if 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() != nullptr ? message_->c_str() : "";
    }
    // 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() == nullptr) 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.
    std::unique_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 TestSuites, and
  // each TestSuite 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;
  
    // 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 suite.
    //
    // Google Test will call Foo::SetUpTestSuite() before running the first
    // test in test suite Foo.  Hence a sub-class can define its own
    // SetUpTestSuite() method to shadow the one defined in the super
    // class.
    static void SetUpTestSuite() {}
  
    // Tears down the stuff shared by all tests in this test suite.
    //
    // Google Test will call Foo::TearDownTestSuite() after running the last
    // test in test suite Foo.  Hence a sub-class can define its own
    // TearDownTestSuite() method to shadow the one defined in the super
    // class.
    static void TearDownTestSuite() {}
  
    // Legacy API is deprecated but still available. Use SetUpTestSuite and
    // TearDownTestSuite instead.
  #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    static void TearDownTestCase() {}
    static void SetUpTestCase() {}
  #endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  
    // Returns true if and only if the current test has a fatal failure.
    static bool HasFatalFailure();
  
    // Returns true if and only if the current test has a non-fatal failure.
    static bool HasNonfatalFailure();
  
    // Returns true if and only if the current test was skipped.
    static bool IsSkipped();
  
    // Returns true if and only if 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 suite, or for the entire
    // invocation of the test program when used outside of the context of a
    // test suite.  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
    // SetUpTestSuite or TearDownTestSuite 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 if and only if the current test has the same fixture class
    // as the first test in the current test suite.
    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 std::unique_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 nullptr; }
  
    // 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 if and only if the test passed (i.e. no test part failed).
    bool Passed() const { return !Skipped() && !Failed(); }
  
    // Returns true if and only if the test was skipped.
    bool Skipped() const;
  
    // Returns true if and only if the test failed.
    bool Failed() const;
  
    // Returns true if and only if the test fatally failed.
    bool HasFatalFailure() const;
  
    // Returns true if and only if the test has a non-fatal failure.
    bool HasNonfatalFailure() const;
  
    // Returns the elapsed time, in milliseconds.
    TimeInMillis elapsed_time() const { return elapsed_time_; }
  
    // Gets the time of the test case start, in ms from the start of the
    // UNIX epoch.
    TimeInMillis start_timestamp() const { return start_timestamp_; }
  
    // 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 TestSuite;
    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 start time.
    void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; }
  
    // 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
    // testsuite 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_properties_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 start time, in milliseconds since UNIX Epoch.
    TimeInMillis start_timestamp_;
    // 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 suite 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 suite name.
    const char* test_suite_name() const { return test_suite_name_.c_str(); }
  
  // Legacy API is deprecated but still available
  #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    const char* test_case_name() const { return test_suite_name(); }
  #endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  
    // 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() != nullptr) return type_param_->c_str();
      return nullptr;
    }
  
    // 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() != nullptr) return value_param_->c_str();
      return nullptr;
    }
  
    // 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 suite 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 if and only if 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 TestSuite;
    friend class internal::UnitTestImpl;
    friend class internal::StreamingListenerTest;
    friend TestInfo* internal::MakeAndRegisterTestInfo(
        const char* test_suite_name, const char* name, const char* type_param,
        const char* value_param, internal::CodeLocation code_location,
        internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc,
        internal::TearDownTestSuiteFunc 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_suite_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();
  
    // Skip and records the test result for this object.
    void Skip();
  
    static void ClearTestResult(TestInfo* test_info) {
      test_info->result_.Clear();
    }
  
    // These fields are immutable properties of the test.
    const std::string test_suite_name_;    // test suite 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 std::unique_ptr<const ::std::string> type_param_;
    // Text representation of the value parameter, or NULL if this is not a
    // value-parameterized test.
    const std::unique_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 if and only if this test should run
    bool is_disabled_;          // True if and only if 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 suite, which consists of a vector of TestInfos.
  //
  // TestSuite is not copyable.
  class GTEST_API_ TestSuite {
   public:
    // Creates a TestSuite with the given name.
    //
    // TestSuite does NOT have a default constructor.  Always use this
    // constructor to create a TestSuite object.
    //
    // Arguments:
    //
    //   name:         name of the test suite
    //   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 suite
    //   tear_down_tc: pointer to the function that tears down the test suite
    TestSuite(const char* name, const char* a_type_param,
              internal::SetUpTestSuiteFunc set_up_tc,
              internal::TearDownTestSuiteFunc tear_down_tc);
  
    // Destructor of TestSuite.
    virtual ~TestSuite();
  
    // Gets the name of the TestSuite.
    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 suite.
    const char* type_param() const {
      if (type_param_.get() != nullptr) return type_param_->c_str();
      return nullptr;
    }
  
    // Returns true if any test in this test suite should run.
    bool should_run() const { return should_run_; }
  
    // Gets the number of successful tests in this test suite.
    int successful_test_count() const;
  
    // Gets the number of skipped tests in this test suite.
    int skipped_test_count() const;
  
    // Gets the number of failed tests in this test suite.
    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 suite.
    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 suite that should run.
    int test_to_run_count() const;
  
    // Gets the number of all tests in this test suite.
    int total_test_count() const;
  
    // Returns true if and only if the test suite passed.
    bool Passed() const { return !Failed(); }
  
    // Returns true if and only if the test suite failed.
    bool Failed() const {
      return failed_test_count() > 0 || ad_hoc_test_result().Failed();
    }
  
    // Returns the elapsed time, in milliseconds.
    TimeInMillis elapsed_time() const { return elapsed_time_; }
  
    // Gets the time of the test suite start, in ms from the start of the
    // UNIX epoch.
    TimeInMillis start_timestamp() const { return start_timestamp_; }
  
    // 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 SetUpTestSuite and TearDownTestSuite.
    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 TestSuite.
    std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
  
    // Gets the (immutable) vector of TestInfos in this TestSuite.
    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 suite.  Will delete the TestInfo upon
    // destruction of the TestSuite object.
    void AddTestInfo(TestInfo * test_info);
  
    // Clears the results of all tests in this test suite.
    void ClearResult();
  
    // Clears the results of all tests in the given test suite.
    static void ClearTestSuiteResult(TestSuite* test_suite) {
      test_suite->ClearResult();
    }
  
    // Runs every test in this TestSuite.
    void Run();
  
    // Skips the execution of tests under this TestSuite
    void Skip();
  
    // Runs SetUpTestSuite() for this TestSuite.  This wrapper is needed
    // for catching exceptions thrown from SetUpTestSuite().
    void RunSetUpTestSuite() {
      if (set_up_tc_ != nullptr) {
        (*set_up_tc_)();
      }
    }
  
    // Runs TearDownTestSuite() for this TestSuite.  This wrapper is
    // needed for catching exceptions thrown from TearDownTestSuite().
    void RunTearDownTestSuite() {
      if (tear_down_tc_ != nullptr) {
        (*tear_down_tc_)();
      }
    }
  
    // Returns true if and only if test passed.
    static bool TestPassed(const TestInfo* test_info) {
      return test_info->should_run() && test_info->result()->Passed();
    }
  
    // Returns true if and only if test skipped.
    static bool TestSkipped(const TestInfo* test_info) {
      return test_info->should_run() && test_info->result()->Skipped();
    }
  
    // Returns true if and only if test failed.
    static bool TestFailed(const TestInfo* test_info) {
      return test_info->should_run() && test_info->result()->Failed();
    }
  
    // Returns true if and only if 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 if and only if test is disabled.
    static bool TestDisabled(const TestInfo* test_info) {
      return test_info->is_disabled_;
    }
  
    // Returns true if and only if 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 suite.
    void ShuffleTests(internal::Random* random);
  
    // Restores the test order to before the first shuffle.
    void UnshuffleTests();
  
    // Name of the test suite.
    std::string name_;
    // Name of the parameter type, or NULL if this is not a typed or a
    // type-parameterized test.
    const std::unique_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 suite.
    internal::SetUpTestSuiteFunc set_up_tc_;
    // Pointer to the function that tears down the test suite.
    internal::TearDownTestSuiteFunc tear_down_tc_;
    // True if and only if any test in this test suite should run.
    bool should_run_;
    // The start time, in milliseconds since UNIX Epoch.
    TimeInMillis start_timestamp_;
    // Elapsed time, in milliseconds.
    TimeInMillis elapsed_time_;
    // Holds test properties recorded during execution of SetUpTestSuite and
    // TearDownTestSuite.
    TestResult ad_hoc_test_result_;
  
    // We disallow copying TestSuites.
    GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite);
  };
  
  // 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 nullptr; }
  };
  
  #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 suite starts.
    virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}
  
    //  Legacy API is deprecated but still available
  #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
  #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  
    // Fired before the test starts.
    virtual void OnTestStart(const TestInfo& test_info) = 0;
  
    // Fired when a test is disabled
    virtual void OnTestDisabled(const TestInfo& /*test_info*/) {}
  
    // 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 suite ends.
    virtual void OnTestSuiteEnd(const TestSuite& /*test_suite*/) {}
  
  //  Legacy API is deprecated but still available
  #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
  #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  
    // 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:
    void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
    void OnTestIterationStart(const UnitTest& /*unit_test*/,
                              int /*iteration*/) override {}
    void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
    void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
    void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
  //  Legacy API is deprecated but still available
  #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    void OnTestCaseStart(const TestCase& /*test_case*/) override {}
  #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  
    void OnTestStart(const TestInfo& /*test_info*/) override {}
    void OnTestDisabled(const TestInfo& /*test_info*/) override {}
    void OnTestPartResult(const TestPartResult& /*test_part_result*/) override {}
    void OnTestEnd(const TestInfo& /*test_info*/) override {}
    void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
  #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
  #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  
    void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
    void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
    void OnTestIterationEnd(const UnitTest& /*unit_test*/,
                            int /*iteration*/) override {}
    void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
  };
  
  // 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 TestSuite;
    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 TestSuites.
  //
  // 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 TestSuite object for the test that's currently running,
    // or NULL if no test is running.
    const TestSuite* current_test_suite() const GTEST_LOCK_EXCLUDED_(mutex_);
  
  // Legacy API is still available but deprecated
  #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    const TestCase* current_test_case() const GTEST_LOCK_EXCLUDED_(mutex_);
  #endif
  
    // 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 ParameterizedTestSuiteRegistry object used to keep track of
    // value-parameterized tests and instantiate and register them.
    //
    // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
    internal::ParameterizedTestSuiteRegistry& parameterized_test_registry()
        GTEST_LOCK_EXCLUDED_(mutex_);
  
    // Gets the number of successful test suites.
    int successful_test_suite_count() const;
  
    // Gets the number of failed test suites.
    int failed_test_suite_count() const;
  
    // Gets the number of all test suites.
    int total_test_suite_count() const;
  
    // Gets the number of all test suites that contain at least one test
    // that should run.
    int test_suite_to_run_count() const;
  
    //  Legacy API is deprecated but still available
  #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    int successful_test_case_count() const;
    int failed_test_case_count() const;
    int total_test_case_count() const;
    int test_case_to_run_count() const;
  #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  
    // Gets the number of successful tests.
    int successful_test_count() const;
  
    // Gets the number of skipped tests.
    int skipped_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 if and only if the unit test passed (i.e. all test suites
    // passed).
    bool Passed() const;
  
    // Returns true if and only if the unit test failed (i.e. some test suite
    // failed or something outside of all tests failed).
    bool Failed() const;
  
    // Gets the i-th test suite among all the test suites. i can range from 0 to
    // total_test_suite_count() - 1. If i is not in that range, returns NULL.
    const TestSuite* GetTestSuite(int i) const;
  
  //  Legacy API is deprecated but still available
  #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    const TestCase* GetTestCase(int i) const;
  #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  
    // Returns the TestResult containing information on test failures and
    // properties logged outside of individual test suites.
    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 TestSuite's ad_hoc_test_result_ when invoked
    // from SetUpTestSuite or TearDownTestSuite, 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 suite among all the test suites. i can range from 0 to
    // total_test_suite_count() - 1. If i is not in that range, returns NULL.
    TestSuite* GetMutableTestSuite(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 std::set<std::string>* internal::GetIgnoredParameterizedTestSuites();
    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);
  
  // This overloaded version can be used on Arduino/embedded platforms where
  // there is no argc/argv.
  GTEST_API_ void InitGoogleTest();
  
  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);
  }
  
  // This block of code defines operator==/!=
  // to block lexical scope lookup.
  // It prevents using invalid operator==/!= defined at namespace scope.
  struct faketype {};
  inline bool operator==(faketype, faketype) { return true; }
  inline bool operator!=(faketype, faketype) { return 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);
  }
  
  class EqHelper {
   public:
    // This templatized version is for the general case.
    template <
        typename T1, typename T2,
        // Disable this overload for cases where one argument is a pointer
        // and the other is the null pointer constant.
        typename std::enable_if<!std::is_integral<T1>::value ||
                                !std::is_pointer<T2>::value>::type* = nullptr>
    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 <typename T>
    static AssertionResult Compare(
        const char* lhs_expression, const char* rhs_expression,
        // Handle cases where '0' is used as a null pointer literal.
        std::nullptr_t /* lhs */, T* rhs) {
      // We already know that 'lhs' is a null pointer.
      return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr),
                         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.
  //
  // 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);\
    }\
  }
  
  // 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.
  //   }
  //   ~FooTest() override {
  //     // Can use GetParam() here.
  //   }
  //   void SetUp() override {
  //     // Can use GetParam() here.
  //   }
  //   void TearDown override {
  //     // Can use GetParam() here.
  //   }
  // };
  // TEST_P(FooTest, DoesBar) {
  //   // Can use GetParam() method here.
  //   Foo foo;
  //   ASSERT_TRUE(foo.DoesBar(GetParam()));
  // }
  // INSTANTIATE_TEST_SUITE_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.
    static const ParamType& GetParam() {
      GTEST_CHECK_(parameter_ != nullptr)
          << "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_ = nullptr;
  
  // 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.
  
  // Skips test in runtime.
  // Skipping test aborts current function.
  // Skipped tests are neither successful nor failed.
  #define GTEST_SKIP() GTEST_SKIP_("")
  
  // 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")
  
  // Like GTEST_FAIL(), but at the given source file location.
  #define GTEST_FAIL_AT(file, line)         \
    GTEST_MESSAGE_AT_(file, line, "Failed", \
                      ::testing::TestPartResult::kFatalFailure)
  
  // 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 GTEST_EXPECT_TRUE(condition) \
    GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                        GTEST_NONFATAL_FAILURE_)
  #define GTEST_EXPECT_FALSE(condition) \
    GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                        GTEST_NONFATAL_FAILURE_)
  #define GTEST_ASSERT_TRUE(condition) \
    GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                        GTEST_FATAL_FAILURE_)
  #define GTEST_ASSERT_FALSE(condition) \
    GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                        GTEST_FATAL_FAILURE_)
  
  // Define these macros to 1 to omit the definition of the corresponding
  // EXPECT or ASSERT, which clashes with some users' own code.
  
  #if !GTEST_DONT_DEFINE_EXPECT_TRUE
  #define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition)
  #endif
  
  #if !GTEST_DONT_DEFINE_EXPECT_FALSE
  #define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition)
  #endif
  
  #if !GTEST_DONT_DEFINE_ASSERT_TRUE
  #define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition)
  #endif
  
  #if !GTEST_DONT_DEFINE_ASSERT_FALSE
  #define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition)
  #endif
  
  // 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::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::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)");
    }
  
    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 if and only if 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>
  constexpr bool StaticAssertTypeEq() noexcept {
    static_assert(std::is_same<T1, T2>::value, "T1 and T2 are not the same type");
    return true;
  }
  
  // Defines a test.
  //
  // The first parameter is the name of the test suite, and the second
  // parameter is the name of the test within the test suite.
  //
  // The convention is to end the test suite name with "Test".  For
  // example, a test suite 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_suite_name, test_name)             \
    GTEST_TEST_(test_suite_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_suite_name, test_name) GTEST_TEST(test_suite_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 suite name.  The second parameter is the
  // name of the test within the test suite.
  //
  // 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:
  //     void SetUp() override { 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 GTEST_TEST_F(test_fixture, test_name)\
    GTEST_TEST_(test_fixture, test_name, test_fixture, \
                ::testing::internal::GetTypeId<test_fixture>())
  #if !GTEST_DONT_DEFINE_TEST_F
  #define TEST_F(test_fixture, test_name) GTEST_TEST_F(test_fixture, test_name)
  #endif
  
  // 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
  
  // Dynamically registers a test with the framework.
  //
  // This is an advanced API only to be used when the `TEST` macros are
  // insufficient. The macros should be preferred when possible, as they avoid
  // most of the complexity of calling this function.
  //
  // The `factory` argument is a factory callable (move-constructible) object or
  // function pointer that creates a new instance of the Test object. It
  // handles ownership to the caller. The signature of the callable is
  // `Fixture*()`, where `Fixture` is the test fixture class for the test. All
  // tests registered with the same `test_suite_name` must return the same
  // fixture type. This is checked at runtime.
  //
  // The framework will infer the fixture class from the factory and will call
  // the `SetUpTestSuite` and `TearDownTestSuite` for it.
  //
  // Must be called before `RUN_ALL_TESTS()` is invoked, otherwise behavior is
  // undefined.
  //
  // Use case example:
  //
  // class MyFixture : public ::testing::Test {
  //  public:
  //   // All of these optional, just like in regular macro usage.
  //   static void SetUpTestSuite() { ... }
  //   static void TearDownTestSuite() { ... }
  //   void SetUp() override { ... }
  //   void TearDown() override { ... }
  // };
  //
  // class MyTest : public MyFixture {
  //  public:
  //   explicit MyTest(int data) : data_(data) {}
  //   void TestBody() override { ... }
  //
  //  private:
  //   int data_;
  // };
  //
  // void RegisterMyTests(const std::vector<int>& values) {
  //   for (int v : values) {
  //     ::testing::RegisterTest(
  //         "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr,
  //         std::to_string(v).c_str(),
  //         __FILE__, __LINE__,
  //         // Important to use the fixture type as the return type here.
  //         [=]() -> MyFixture* { return new MyTest(v); });
  //   }
  // }
  // ...
  // int main(int argc, char** argv) {
  //   std::vector<int> values_to_test = LoadValuesFromConfig();
  //   RegisterMyTests(values_to_test);
  //   ...
  //   return RUN_ALL_TESTS();
  // }
  //
  template <int&... ExplicitParameterBarrier, typename Factory>
  TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
                         const char* type_param, const char* value_param,
                         const char* file, int line, Factory factory) {
    using TestT = typename std::remove_pointer<decltype(factory())>::type;
  
    class FactoryImpl : public internal::TestFactoryBase {
     public:
      explicit FactoryImpl(Factory f) : factory_(std::move(f)) {}
      Test* CreateTest() override { return factory_(); }
  
     private:
      Factory factory_;
    };
  
    return internal::MakeAndRegisterTestInfo(
        test_suite_name, test_name, type_param, value_param,
        internal::CodeLocation(file, line), internal::GetTypeId<TestT>(),
        internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(file, line),
        internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file, line),
        new FactoryImpl{std::move(factory)});
  }
  
  }  // 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  // GOOGLETEST_INCLUDE_GTEST_GTEST_H_
  