gtest.h
Go to the documentation of this file.
00001 // Copyright 2005, Google Inc.
00002 // All rights reserved.
00003 //
00004 // Redistribution and use in source and binary forms, with or without
00005 // modification, are permitted provided that the following conditions are
00006 // met:
00007 //
00008 //     * Redistributions of source code must retain the above copyright
00009 // notice, this list of conditions and the following disclaimer.
00010 //     * Redistributions in binary form must reproduce the above
00011 // copyright notice, this list of conditions and the following disclaimer
00012 // in the documentation and/or other materials provided with the
00013 // distribution.
00014 //     * Neither the name of Google Inc. nor the names of its
00015 // contributors may be used to endorse or promote products derived from
00016 // this software without specific prior written permission.
00017 //
00018 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00019 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00020 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00021 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00022 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00023 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00024 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00025 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00026 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00027 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00028 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00029 //
00030 // Author: wan@google.com (Zhanyong Wan)
00031 //
00032 // The Google C++ Testing Framework (Google Test)
00033 //
00034 // This header file defines the public API for Google Test.  It should be
00035 // included by any test program that uses Google Test.
00036 //
00037 // IMPORTANT NOTE: Due to limitation of the C++ language, we have to
00038 // leave some internal implementation details in this header file.
00039 // They are clearly marked by comments like this:
00040 //
00041 //   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
00042 //
00043 // Such code is NOT meant to be used by a user directly, and is subject
00044 // to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
00045 // program!
00046 //
00047 // Acknowledgment: Google Test borrowed the idea of automatic test
00048 // registration from Barthelemy Dagenais' (barthelemy@prologique.com)
00049 // easyUnit framework.
00050 
00051 #ifndef GTEST_INCLUDE_GTEST_GTEST_H_
00052 #define GTEST_INCLUDE_GTEST_GTEST_H_
00053 
00054 #include <limits>
00055 #include <ostream>
00056 #include <vector>
00057 
00058 #include "gtest/internal/gtest-internal.h"
00059 #include "gtest/internal/gtest-string.h"
00060 #include "gtest/gtest-death-test.h"
00061 #include "gtest/gtest-message.h"
00062 #include "gtest/gtest-param-test.h"
00063 #include "gtest/gtest-printers.h"
00064 #include "gtest/gtest_prod.h"
00065 #include "gtest/gtest-test-part.h"
00066 #include "gtest/gtest-typed-test.h"
00067 
00068 // Depending on the platform, different string classes are available.
00069 // On Linux, in addition to ::std::string, Google also makes use of
00070 // class ::string, which has the same interface as ::std::string, but
00071 // has a different implementation.
00072 //
00073 // The user can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
00074 // ::string is available AND is a distinct type to ::std::string, or
00075 // define it to 0 to indicate otherwise.
00076 //
00077 // If the user's ::std::string and ::string are the same class due to
00078 // aliasing, he should define GTEST_HAS_GLOBAL_STRING to 0.
00079 //
00080 // If the user doesn't define GTEST_HAS_GLOBAL_STRING, it is defined
00081 // heuristically.
00082 
00083 namespace testing {
00084 
00085 // Declares the flags.
00086 
00087 // This flag temporary enables the disabled tests.
00088 GTEST_DECLARE_bool_(also_run_disabled_tests);
00089 
00090 // This flag brings the debugger on an assertion failure.
00091 GTEST_DECLARE_bool_(break_on_failure);
00092 
00093 // This flag controls whether Google Test catches all test-thrown exceptions
00094 // and logs them as failures.
00095 GTEST_DECLARE_bool_(catch_exceptions);
00096 
00097 // This flag enables using colors in terminal output. Available values are
00098 // "yes" to enable colors, "no" (disable colors), or "auto" (the default)
00099 // to let Google Test decide.
00100 GTEST_DECLARE_string_(color);
00101 
00102 // This flag sets up the filter to select by name using a glob pattern
00103 // the tests to run. If the filter is not given all tests are executed.
00104 GTEST_DECLARE_string_(filter);
00105 
00106 // This flag causes the Google Test to list tests. None of the tests listed
00107 // are actually run if the flag is provided.
00108 GTEST_DECLARE_bool_(list_tests);
00109 
00110 // This flag controls whether Google Test emits a detailed XML report to a file
00111 // in addition to its normal textual output.
00112 GTEST_DECLARE_string_(output);
00113 
00114 // This flags control whether Google Test prints the elapsed time for each
00115 // test.
00116 GTEST_DECLARE_bool_(print_time);
00117 
00118 // This flag specifies the random number seed.
00119 GTEST_DECLARE_int32_(random_seed);
00120 
00121 // This flag sets how many times the tests are repeated. The default value
00122 // is 1. If the value is -1 the tests are repeating forever.
00123 GTEST_DECLARE_int32_(repeat);
00124 
00125 // This flag controls whether Google Test includes Google Test internal
00126 // stack frames in failure stack traces.
00127 GTEST_DECLARE_bool_(show_internal_stack_frames);
00128 
00129 // When this flag is specified, tests' order is randomized on every iteration.
00130 GTEST_DECLARE_bool_(shuffle);
00131 
00132 // This flag specifies the maximum number of stack frames to be
00133 // printed in a failure message.
00134 GTEST_DECLARE_int32_(stack_trace_depth);
00135 
00136 // When this flag is specified, a failed assertion will throw an
00137 // exception if exceptions are enabled, or exit the program with a
00138 // non-zero code otherwise.
00139 GTEST_DECLARE_bool_(throw_on_failure);
00140 
00141 // When this flag is set with a "host:port" string, on supported
00142 // platforms test results are streamed to the specified port on
00143 // the specified host machine.
00144 GTEST_DECLARE_string_(stream_result_to);
00145 
00146 // The upper limit for valid stack trace depths.
00147 const int kMaxStackTraceDepth = 100;
00148 
00149 namespace internal {
00150 
00151 class AssertHelper;
00152 class DefaultGlobalTestPartResultReporter;
00153 class ExecDeathTest;
00154 class NoExecDeathTest;
00155 class FinalSuccessChecker;
00156 class GTestFlagSaver;
00157 class StreamingListenerTest;
00158 class TestResultAccessor;
00159 class TestEventListenersAccessor;
00160 class TestEventRepeater;
00161 class UnitTestRecordPropertyTestHelper;
00162 class WindowsDeathTest;
00163 class UnitTestImpl* GetUnitTestImpl();
00164 void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
00165                                     const std::string& message);
00166 
00167 }  // namespace internal
00168 
00169 // The friend relationship of some of these classes is cyclic.
00170 // If we don't forward declare them the compiler might confuse the classes
00171 // in friendship clauses with same named classes on the scope.
00172 class Test;
00173 class TestCase;
00174 class TestInfo;
00175 class UnitTest;
00176 
00177 // A class for indicating whether an assertion was successful.  When
00178 // the assertion wasn't successful, the AssertionResult object
00179 // remembers a non-empty message that describes how it failed.
00180 //
00181 // To create an instance of this class, use one of the factory functions
00182 // (AssertionSuccess() and AssertionFailure()).
00183 //
00184 // This class is useful for two purposes:
00185 //   1. Defining predicate functions to be used with Boolean test assertions
00186 //      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
00187 //   2. Defining predicate-format functions to be
00188 //      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
00189 //
00190 // For example, if you define IsEven predicate:
00191 //
00192 //   testing::AssertionResult IsEven(int n) {
00193 //     if ((n % 2) == 0)
00194 //       return testing::AssertionSuccess();
00195 //     else
00196 //       return testing::AssertionFailure() << n << " is odd";
00197 //   }
00198 //
00199 // Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
00200 // will print the message
00201 //
00202 //   Value of: IsEven(Fib(5))
00203 //     Actual: false (5 is odd)
00204 //   Expected: true
00205 //
00206 // instead of a more opaque
00207 //
00208 //   Value of: IsEven(Fib(5))
00209 //     Actual: false
00210 //   Expected: true
00211 //
00212 // in case IsEven is a simple Boolean predicate.
00213 //
00214 // If you expect your predicate to be reused and want to support informative
00215 // messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
00216 // about half as often as positive ones in our tests), supply messages for
00217 // both success and failure cases:
00218 //
00219 //   testing::AssertionResult IsEven(int n) {
00220 //     if ((n % 2) == 0)
00221 //       return testing::AssertionSuccess() << n << " is even";
00222 //     else
00223 //       return testing::AssertionFailure() << n << " is odd";
00224 //   }
00225 //
00226 // Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
00227 //
00228 //   Value of: IsEven(Fib(6))
00229 //     Actual: true (8 is even)
00230 //   Expected: false
00231 //
00232 // NB: Predicates that support negative Boolean assertions have reduced
00233 // performance in positive ones so be careful not to use them in tests
00234 // that have lots (tens of thousands) of positive Boolean assertions.
00235 //
00236 // To use this class with EXPECT_PRED_FORMAT assertions such as:
00237 //
00238 //   // Verifies that Foo() returns an even number.
00239 //   EXPECT_PRED_FORMAT1(IsEven, Foo());
00240 //
00241 // you need to define:
00242 //
00243 //   testing::AssertionResult IsEven(const char* expr, int n) {
00244 //     if ((n % 2) == 0)
00245 //       return testing::AssertionSuccess();
00246 //     else
00247 //       return testing::AssertionFailure()
00248 //         << "Expected: " << expr << " is even\n  Actual: it's " << n;
00249 //   }
00250 //
00251 // If Foo() returns 5, you will see the following message:
00252 //
00253 //   Expected: Foo() is even
00254 //     Actual: it's 5
00255 //
00256 class GTEST_API_ AssertionResult {
00257  public:
00258   // Copy constructor.
00259   // Used in EXPECT_TRUE/FALSE(assertion_result).
00260   AssertionResult(const AssertionResult& other);
00261   // Used in the EXPECT_TRUE/FALSE(bool_expression).
00262   explicit AssertionResult(bool success) : success_(success) {}
00263 
00264   // Returns true iff the assertion succeeded.
00265   operator bool() const { return success_; }  // NOLINT
00266 
00267   // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
00268   AssertionResult operator!() const;
00269 
00270   // Returns the text streamed into this AssertionResult. Test assertions
00271   // use it when they fail (i.e., the predicate's outcome doesn't match the
00272   // assertion's expectation). When nothing has been streamed into the
00273   // object, returns an empty string.
00274   const char* message() const {
00275     return message_.get() != NULL ?  message_->c_str() : "";
00276   }
00277   // TODO(vladl@google.com): Remove this after making sure no clients use it.
00278   // Deprecated; please use message() instead.
00279   const char* failure_message() const { return message(); }
00280 
00281   // Streams a custom failure message into this object.
00282   template <typename T> AssertionResult& operator<<(const T& value) {
00283     AppendMessage(Message() << value);
00284     return *this;
00285   }
00286 
00287   // Allows streaming basic output manipulators such as endl or flush into
00288   // this object.
00289   AssertionResult& operator<<(
00290       ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
00291     AppendMessage(Message() << basic_manipulator);
00292     return *this;
00293   }
00294 
00295  private:
00296   // Appends the contents of message to message_.
00297   void AppendMessage(const Message& a_message) {
00298     if (message_.get() == NULL)
00299       message_.reset(new ::std::string);
00300     message_->append(a_message.GetString().c_str());
00301   }
00302 
00303   // Stores result of the assertion predicate.
00304   bool success_;
00305   // Stores the message describing the condition in case the expectation
00306   // construct is not satisfied with the predicate's outcome.
00307   // Referenced via a pointer to avoid taking too much stack frame space
00308   // with test assertions.
00309   internal::scoped_ptr< ::std::string> message_;
00310 
00311   GTEST_DISALLOW_ASSIGN_(AssertionResult);
00312 };
00313 
00314 // Makes a successful assertion result.
00315 GTEST_API_ AssertionResult AssertionSuccess();
00316 
00317 // Makes a failed assertion result.
00318 GTEST_API_ AssertionResult AssertionFailure();
00319 
00320 // Makes a failed assertion result with the given failure message.
00321 // Deprecated; use AssertionFailure() << msg.
00322 GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
00323 
00324 // The abstract class that all tests inherit from.
00325 //
00326 // In Google Test, a unit test program contains one or many TestCases, and
00327 // each TestCase contains one or many Tests.
00328 //
00329 // When you define a test using the TEST macro, you don't need to
00330 // explicitly derive from Test - the TEST macro automatically does
00331 // this for you.
00332 //
00333 // The only time you derive from Test is when defining a test fixture
00334 // to be used a TEST_F.  For example:
00335 //
00336 //   class FooTest : public testing::Test {
00337 //    protected:
00338 //     virtual void SetUp() { ... }
00339 //     virtual void TearDown() { ... }
00340 //     ...
00341 //   };
00342 //
00343 //   TEST_F(FooTest, Bar) { ... }
00344 //   TEST_F(FooTest, Baz) { ... }
00345 //
00346 // Test is not copyable.
00347 class GTEST_API_ Test {
00348  public:
00349   friend class TestInfo;
00350 
00351   // Defines types for pointers to functions that set up and tear down
00352   // a test case.
00353   typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc;
00354   typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc;
00355 
00356   // The d'tor is virtual as we intend to inherit from Test.
00357   virtual ~Test();
00358 
00359   // Sets up the stuff shared by all tests in this test case.
00360   //
00361   // Google Test will call Foo::SetUpTestCase() before running the first
00362   // test in test case Foo.  Hence a sub-class can define its own
00363   // SetUpTestCase() method to shadow the one defined in the super
00364   // class.
00365   static void SetUpTestCase() {}
00366 
00367   // Tears down the stuff shared by all tests in this test case.
00368   //
00369   // Google Test will call Foo::TearDownTestCase() after running the last
00370   // test in test case Foo.  Hence a sub-class can define its own
00371   // TearDownTestCase() method to shadow the one defined in the super
00372   // class.
00373   static void TearDownTestCase() {}
00374 
00375   // Returns true iff the current test has a fatal failure.
00376   static bool HasFatalFailure();
00377 
00378   // Returns true iff the current test has a non-fatal failure.
00379   static bool HasNonfatalFailure();
00380 
00381   // Returns true iff the current test has a (either fatal or
00382   // non-fatal) failure.
00383   static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
00384 
00385   // Logs a property for the current test, test case, or for the entire
00386   // invocation of the test program when used outside of the context of a
00387   // test case.  Only the last value for a given key is remembered.  These
00388   // are public static so they can be called from utility functions that are
00389   // not members of the test fixture.  Calls to RecordProperty made during
00390   // lifespan of the test (from the moment its constructor starts to the
00391   // moment its destructor finishes) will be output in XML as attributes of
00392   // the <testcase> element.  Properties recorded from fixture's
00393   // SetUpTestCase or TearDownTestCase are logged as attributes of the
00394   // corresponding <testsuite> element.  Calls to RecordProperty made in the
00395   // global context (before or after invocation of RUN_ALL_TESTS and from
00396   // SetUp/TearDown method of Environment objects registered with Google
00397   // Test) will be output as attributes of the <testsuites> element.
00398   static void RecordProperty(const std::string& key, const std::string& value);
00399   static void RecordProperty(const std::string& key, int value);
00400 
00401  protected:
00402   // Creates a Test object.
00403   Test();
00404 
00405   // Sets up the test fixture.
00406   virtual void SetUp();
00407 
00408   // Tears down the test fixture.
00409   virtual void TearDown();
00410 
00411  private:
00412   // Returns true iff the current test has the same fixture class as
00413   // the first test in the current test case.
00414   static bool HasSameFixtureClass();
00415 
00416   // Runs the test after the test fixture has been set up.
00417   //
00418   // A sub-class must implement this to define the test logic.
00419   //
00420   // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
00421   // Instead, use the TEST or TEST_F macro.
00422   virtual void TestBody() = 0;
00423 
00424   // Sets up, executes, and tears down the test.
00425   void Run();
00426 
00427   // Deletes self.  We deliberately pick an unusual name for this
00428   // internal method to avoid clashing with names used in user TESTs.
00429   void DeleteSelf_() { delete this; }
00430 
00431   // Uses a GTestFlagSaver to save and restore all Google Test flags.
00432   const internal::GTestFlagSaver* const gtest_flag_saver_;
00433 
00434   // Often a user mis-spells SetUp() as Setup() and spends a long time
00435   // wondering why it is never called by Google Test.  The declaration of
00436   // the following method is solely for catching such an error at
00437   // compile time:
00438   //
00439   //   - The return type is deliberately chosen to be not void, so it
00440   //   will be a conflict if a user declares void Setup() in his test
00441   //   fixture.
00442   //
00443   //   - This method is private, so it will be another compiler error
00444   //   if a user calls it from his test fixture.
00445   //
00446   // DO NOT OVERRIDE THIS FUNCTION.
00447   //
00448   // If you see an error about overriding the following function or
00449   // about it being private, you have mis-spelled SetUp() as Setup().
00450   struct Setup_should_be_spelled_SetUp {};
00451   virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
00452 
00453   // We disallow copying Tests.
00454   GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
00455 };
00456 
00457 typedef internal::TimeInMillis TimeInMillis;
00458 
00459 // A copyable object representing a user specified test property which can be
00460 // output as a key/value string pair.
00461 //
00462 // Don't inherit from TestProperty as its destructor is not virtual.
00463 class TestProperty {
00464  public:
00465   // C'tor.  TestProperty does NOT have a default constructor.
00466   // Always use this constructor (with parameters) to create a
00467   // TestProperty object.
00468   TestProperty(const std::string& a_key, const std::string& a_value) :
00469     key_(a_key), value_(a_value) {
00470   }
00471 
00472   // Gets the user supplied key.
00473   const char* key() const {
00474     return key_.c_str();
00475   }
00476 
00477   // Gets the user supplied value.
00478   const char* value() const {
00479     return value_.c_str();
00480   }
00481 
00482   // Sets a new value, overriding the one supplied in the constructor.
00483   void SetValue(const std::string& new_value) {
00484     value_ = new_value;
00485   }
00486 
00487  private:
00488   // The key supplied by the user.
00489   std::string key_;
00490   // The value supplied by the user.
00491   std::string value_;
00492 };
00493 
00494 // The result of a single Test.  This includes a list of
00495 // TestPartResults, a list of TestProperties, a count of how many
00496 // death tests there are in the Test, and how much time it took to run
00497 // the Test.
00498 //
00499 // TestResult is not copyable.
00500 class GTEST_API_ TestResult {
00501  public:
00502   // Creates an empty TestResult.
00503   TestResult();
00504 
00505   // D'tor.  Do not inherit from TestResult.
00506   ~TestResult();
00507 
00508   // Gets the number of all test parts.  This is the sum of the number
00509   // of successful test parts and the number of failed test parts.
00510   int total_part_count() const;
00511 
00512   // Returns the number of the test properties.
00513   int test_property_count() const;
00514 
00515   // Returns true iff the test passed (i.e. no test part failed).
00516   bool Passed() const { return !Failed(); }
00517 
00518   // Returns true iff the test failed.
00519   bool Failed() const;
00520 
00521   // Returns true iff the test fatally failed.
00522   bool HasFatalFailure() const;
00523 
00524   // Returns true iff the test has a non-fatal failure.
00525   bool HasNonfatalFailure() const;
00526 
00527   // Returns the elapsed time, in milliseconds.
00528   TimeInMillis elapsed_time() const { return elapsed_time_; }
00529 
00530   // Returns the i-th test part result among all the results. i can range
00531   // from 0 to test_property_count() - 1. If i is not in that range, aborts
00532   // the program.
00533   const TestPartResult& GetTestPartResult(int i) const;
00534 
00535   // Returns the i-th test property. i can range from 0 to
00536   // test_property_count() - 1. If i is not in that range, aborts the
00537   // program.
00538   const TestProperty& GetTestProperty(int i) const;
00539 
00540  private:
00541   friend class TestInfo;
00542   friend class TestCase;
00543   friend class UnitTest;
00544   friend class internal::DefaultGlobalTestPartResultReporter;
00545   friend class internal::ExecDeathTest;
00546   friend class internal::TestResultAccessor;
00547   friend class internal::UnitTestImpl;
00548   friend class internal::WindowsDeathTest;
00549 
00550   // Gets the vector of TestPartResults.
00551   const std::vector<TestPartResult>& test_part_results() const {
00552     return test_part_results_;
00553   }
00554 
00555   // Gets the vector of TestProperties.
00556   const std::vector<TestProperty>& test_properties() const {
00557     return test_properties_;
00558   }
00559 
00560   // Sets the elapsed time.
00561   void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
00562 
00563   // Adds a test property to the list. The property is validated and may add
00564   // a non-fatal failure if invalid (e.g., if it conflicts with reserved
00565   // key names). If a property is already recorded for the same key, the
00566   // value will be updated, rather than storing multiple values for the same
00567   // key.  xml_element specifies the element for which the property is being
00568   // recorded and is used for validation.
00569   void RecordProperty(const std::string& xml_element,
00570                       const TestProperty& test_property);
00571 
00572   // Adds a failure if the key is a reserved attribute of Google Test
00573   // testcase tags.  Returns true if the property is valid.
00574   // TODO(russr): Validate attribute names are legal and human readable.
00575   static bool ValidateTestProperty(const std::string& xml_element,
00576                                    const TestProperty& test_property);
00577 
00578   // Adds a test part result to the list.
00579   void AddTestPartResult(const TestPartResult& test_part_result);
00580 
00581   // Returns the death test count.
00582   int death_test_count() const { return death_test_count_; }
00583 
00584   // Increments the death test count, returning the new count.
00585   int increment_death_test_count() { return ++death_test_count_; }
00586 
00587   // Clears the test part results.
00588   void ClearTestPartResults();
00589 
00590   // Clears the object.
00591   void Clear();
00592 
00593   // Protects mutable state of the property vector and of owned
00594   // properties, whose values may be updated.
00595   internal::Mutex test_properites_mutex_;
00596 
00597   // The vector of TestPartResults
00598   std::vector<TestPartResult> test_part_results_;
00599   // The vector of TestProperties
00600   std::vector<TestProperty> test_properties_;
00601   // Running count of death tests.
00602   int death_test_count_;
00603   // The elapsed time, in milliseconds.
00604   TimeInMillis elapsed_time_;
00605 
00606   // We disallow copying TestResult.
00607   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
00608 };  // class TestResult
00609 
00610 // A TestInfo object stores the following information about a test:
00611 //
00612 //   Test case name
00613 //   Test name
00614 //   Whether the test should be run
00615 //   A function pointer that creates the test object when invoked
00616 //   Test result
00617 //
00618 // The constructor of TestInfo registers itself with the UnitTest
00619 // singleton such that the RUN_ALL_TESTS() macro knows which tests to
00620 // run.
00621 class GTEST_API_ TestInfo {
00622  public:
00623   // Destructs a TestInfo object.  This function is not virtual, so
00624   // don't inherit from TestInfo.
00625   ~TestInfo();
00626 
00627   // Returns the test case name.
00628   const char* test_case_name() const { return test_case_name_.c_str(); }
00629 
00630   // Returns the test name.
00631   const char* name() const { return name_.c_str(); }
00632 
00633   // Returns the name of the parameter type, or NULL if this is not a typed
00634   // or a type-parameterized test.
00635   const char* type_param() const {
00636     if (type_param_.get() != NULL)
00637       return type_param_->c_str();
00638     return NULL;
00639   }
00640 
00641   // Returns the text representation of the value parameter, or NULL if this
00642   // is not a value-parameterized test.
00643   const char* value_param() const {
00644     if (value_param_.get() != NULL)
00645       return value_param_->c_str();
00646     return NULL;
00647   }
00648 
00649   // Returns true if this test should run, that is if the test is not
00650   // disabled (or it is disabled but the also_run_disabled_tests flag has
00651   // been specified) and its full name matches the user-specified filter.
00652   //
00653   // Google Test allows the user to filter the tests by their full names.
00654   // The full name of a test Bar in test case Foo is defined as
00655   // "Foo.Bar".  Only the tests that match the filter will run.
00656   //
00657   // A filter is a colon-separated list of glob (not regex) patterns,
00658   // optionally followed by a '-' and a colon-separated list of
00659   // negative patterns (tests to exclude).  A test is run if it
00660   // matches one of the positive patterns and does not match any of
00661   // the negative patterns.
00662   //
00663   // For example, *A*:Foo.* is a filter that matches any string that
00664   // contains the character 'A' or starts with "Foo.".
00665   bool should_run() const { return should_run_; }
00666 
00667   // Returns true iff this test will appear in the XML report.
00668   bool is_reportable() const {
00669     // For now, the XML report includes all tests matching the filter.
00670     // In the future, we may trim tests that are excluded because of
00671     // sharding.
00672     return matches_filter_;
00673   }
00674 
00675   // Returns the result of the test.
00676   const TestResult* result() const { return &result_; }
00677 
00678  private:
00679 #if GTEST_HAS_DEATH_TEST
00680   friend class internal::DefaultDeathTestFactory;
00681 #endif  // GTEST_HAS_DEATH_TEST
00682   friend class Test;
00683   friend class TestCase;
00684   friend class internal::UnitTestImpl;
00685   friend class internal::StreamingListenerTest;
00686   friend TestInfo* internal::MakeAndRegisterTestInfo(
00687       const char* test_case_name,
00688       const char* name,
00689       const char* type_param,
00690       const char* value_param,
00691       internal::TypeId fixture_class_id,
00692       Test::SetUpTestCaseFunc set_up_tc,
00693       Test::TearDownTestCaseFunc tear_down_tc,
00694       internal::TestFactoryBase* factory);
00695 
00696   // Constructs a TestInfo object. The newly constructed instance assumes
00697   // ownership of the factory object.
00698   TestInfo(const std::string& test_case_name,
00699            const std::string& name,
00700            const char* a_type_param,   // NULL if not a type-parameterized test
00701            const char* a_value_param,  // NULL if not a value-parameterized test
00702            internal::TypeId fixture_class_id,
00703            internal::TestFactoryBase* factory);
00704 
00705   // Increments the number of death tests encountered in this test so
00706   // far.
00707   int increment_death_test_count() {
00708     return result_.increment_death_test_count();
00709   }
00710 
00711   // Creates the test object, runs it, records its result, and then
00712   // deletes it.
00713   void Run();
00714 
00715   static void ClearTestResult(TestInfo* test_info) {
00716     test_info->result_.Clear();
00717   }
00718 
00719   // These fields are immutable properties of the test.
00720   const std::string test_case_name_;     // Test case name
00721   const std::string name_;               // Test name
00722   // Name of the parameter type, or NULL if this is not a typed or a
00723   // type-parameterized test.
00724   const internal::scoped_ptr<const ::std::string> type_param_;
00725   // Text representation of the value parameter, or NULL if this is not a
00726   // value-parameterized test.
00727   const internal::scoped_ptr<const ::std::string> value_param_;
00728   const internal::TypeId fixture_class_id_;   // ID of the test fixture class
00729   bool should_run_;                 // True iff this test should run
00730   bool is_disabled_;                // True iff this test is disabled
00731   bool matches_filter_;             // True if this test matches the
00732                                     // user-specified filter.
00733   internal::TestFactoryBase* const factory_;  // The factory that creates
00734                                               // the test object
00735 
00736   // This field is mutable and needs to be reset before running the
00737   // test for the second time.
00738   TestResult result_;
00739 
00740   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
00741 };
00742 
00743 // A test case, which consists of a vector of TestInfos.
00744 //
00745 // TestCase is not copyable.
00746 class GTEST_API_ TestCase {
00747  public:
00748   // Creates a TestCase with the given name.
00749   //
00750   // TestCase does NOT have a default constructor.  Always use this
00751   // constructor to create a TestCase object.
00752   //
00753   // Arguments:
00754   //
00755   //   name:         name of the test case
00756   //   a_type_param: the name of the test's type parameter, or NULL if
00757   //                 this is not a type-parameterized test.
00758   //   set_up_tc:    pointer to the function that sets up the test case
00759   //   tear_down_tc: pointer to the function that tears down the test case
00760   TestCase(const char* name, const char* a_type_param,
00761            Test::SetUpTestCaseFunc set_up_tc,
00762            Test::TearDownTestCaseFunc tear_down_tc);
00763 
00764   // Destructor of TestCase.
00765   virtual ~TestCase();
00766 
00767   // Gets the name of the TestCase.
00768   const char* name() const { return name_.c_str(); }
00769 
00770   // Returns the name of the parameter type, or NULL if this is not a
00771   // type-parameterized test case.
00772   const char* type_param() const {
00773     if (type_param_.get() != NULL)
00774       return type_param_->c_str();
00775     return NULL;
00776   }
00777 
00778   // Returns true if any test in this test case should run.
00779   bool should_run() const { return should_run_; }
00780 
00781   // Gets the number of successful tests in this test case.
00782   int successful_test_count() const;
00783 
00784   // Gets the number of failed tests in this test case.
00785   int failed_test_count() const;
00786 
00787   // Gets the number of disabled tests that will be reported in the XML report.
00788   int reportable_disabled_test_count() const;
00789 
00790   // Gets the number of disabled tests in this test case.
00791   int disabled_test_count() const;
00792 
00793   // Gets the number of tests to be printed in the XML report.
00794   int reportable_test_count() const;
00795 
00796   // Get the number of tests in this test case that should run.
00797   int test_to_run_count() const;
00798 
00799   // Gets the number of all tests in this test case.
00800   int total_test_count() const;
00801 
00802   // Returns true iff the test case passed.
00803   bool Passed() const { return !Failed(); }
00804 
00805   // Returns true iff the test case failed.
00806   bool Failed() const { return failed_test_count() > 0; }
00807 
00808   // Returns the elapsed time, in milliseconds.
00809   TimeInMillis elapsed_time() const { return elapsed_time_; }
00810 
00811   // Returns the i-th test among all the tests. i can range from 0 to
00812   // total_test_count() - 1. If i is not in that range, returns NULL.
00813   const TestInfo* GetTestInfo(int i) const;
00814 
00815   // Returns the TestResult that holds test properties recorded during
00816   // execution of SetUpTestCase and TearDownTestCase.
00817   const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
00818 
00819  private:
00820   friend class Test;
00821   friend class internal::UnitTestImpl;
00822 
00823   // Gets the (mutable) vector of TestInfos in this TestCase.
00824   std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
00825 
00826   // Gets the (immutable) vector of TestInfos in this TestCase.
00827   const std::vector<TestInfo*>& test_info_list() const {
00828     return test_info_list_;
00829   }
00830 
00831   // Returns the i-th test among all the tests. i can range from 0 to
00832   // total_test_count() - 1. If i is not in that range, returns NULL.
00833   TestInfo* GetMutableTestInfo(int i);
00834 
00835   // Sets the should_run member.
00836   void set_should_run(bool should) { should_run_ = should; }
00837 
00838   // Adds a TestInfo to this test case.  Will delete the TestInfo upon
00839   // destruction of the TestCase object.
00840   void AddTestInfo(TestInfo * test_info);
00841 
00842   // Clears the results of all tests in this test case.
00843   void ClearResult();
00844 
00845   // Clears the results of all tests in the given test case.
00846   static void ClearTestCaseResult(TestCase* test_case) {
00847     test_case->ClearResult();
00848   }
00849 
00850   // Runs every test in this TestCase.
00851   void Run();
00852 
00853   // Runs SetUpTestCase() for this TestCase.  This wrapper is needed
00854   // for catching exceptions thrown from SetUpTestCase().
00855   void RunSetUpTestCase() { (*set_up_tc_)(); }
00856 
00857   // Runs TearDownTestCase() for this TestCase.  This wrapper is
00858   // needed for catching exceptions thrown from TearDownTestCase().
00859   void RunTearDownTestCase() { (*tear_down_tc_)(); }
00860 
00861   // Returns true iff test passed.
00862   static bool TestPassed(const TestInfo* test_info) {
00863     return test_info->should_run() && test_info->result()->Passed();
00864   }
00865 
00866   // Returns true iff test failed.
00867   static bool TestFailed(const TestInfo* test_info) {
00868     return test_info->should_run() && test_info->result()->Failed();
00869   }
00870 
00871   // Returns true iff the test is disabled and will be reported in the XML
00872   // report.
00873   static bool TestReportableDisabled(const TestInfo* test_info) {
00874     return test_info->is_reportable() && test_info->is_disabled_;
00875   }
00876 
00877   // Returns true iff test is disabled.
00878   static bool TestDisabled(const TestInfo* test_info) {
00879     return test_info->is_disabled_;
00880   }
00881 
00882   // Returns true iff this test will appear in the XML report.
00883   static bool TestReportable(const TestInfo* test_info) {
00884     return test_info->is_reportable();
00885   }
00886 
00887   // Returns true if the given test should run.
00888   static bool ShouldRunTest(const TestInfo* test_info) {
00889     return test_info->should_run();
00890   }
00891 
00892   // Shuffles the tests in this test case.
00893   void ShuffleTests(internal::Random* random);
00894 
00895   // Restores the test order to before the first shuffle.
00896   void UnshuffleTests();
00897 
00898   // Name of the test case.
00899   std::string name_;
00900   // Name of the parameter type, or NULL if this is not a typed or a
00901   // type-parameterized test.
00902   const internal::scoped_ptr<const ::std::string> type_param_;
00903   // The vector of TestInfos in their original order.  It owns the
00904   // elements in the vector.
00905   std::vector<TestInfo*> test_info_list_;
00906   // Provides a level of indirection for the test list to allow easy
00907   // shuffling and restoring the test order.  The i-th element in this
00908   // vector is the index of the i-th test in the shuffled test list.
00909   std::vector<int> test_indices_;
00910   // Pointer to the function that sets up the test case.
00911   Test::SetUpTestCaseFunc set_up_tc_;
00912   // Pointer to the function that tears down the test case.
00913   Test::TearDownTestCaseFunc tear_down_tc_;
00914   // True iff any test in this test case should run.
00915   bool should_run_;
00916   // Elapsed time, in milliseconds.
00917   TimeInMillis elapsed_time_;
00918   // Holds test properties recorded during execution of SetUpTestCase and
00919   // TearDownTestCase.
00920   TestResult ad_hoc_test_result_;
00921 
00922   // We disallow copying TestCases.
00923   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
00924 };
00925 
00926 // An Environment object is capable of setting up and tearing down an
00927 // environment.  The user should subclass this to define his own
00928 // environment(s).
00929 //
00930 // An Environment object does the set-up and tear-down in virtual
00931 // methods SetUp() and TearDown() instead of the constructor and the
00932 // destructor, as:
00933 //
00934 //   1. You cannot safely throw from a destructor.  This is a problem
00935 //      as in some cases Google Test is used where exceptions are enabled, and
00936 //      we may want to implement ASSERT_* using exceptions where they are
00937 //      available.
00938 //   2. You cannot use ASSERT_* directly in a constructor or
00939 //      destructor.
00940 class Environment {
00941  public:
00942   // The d'tor is virtual as we need to subclass Environment.
00943   virtual ~Environment() {}
00944 
00945   // Override this to define how to set up the environment.
00946   virtual void SetUp() {}
00947 
00948   // Override this to define how to tear down the environment.
00949   virtual void TearDown() {}
00950  private:
00951   // If you see an error about overriding the following function or
00952   // about it being private, you have mis-spelled SetUp() as Setup().
00953   struct Setup_should_be_spelled_SetUp {};
00954   virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
00955 };
00956 
00957 // The interface for tracing execution of tests. The methods are organized in
00958 // the order the corresponding events are fired.
00959 class TestEventListener {
00960  public:
00961   virtual ~TestEventListener() {}
00962 
00963   // Fired before any test activity starts.
00964   virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
00965 
00966   // Fired before each iteration of tests starts.  There may be more than
00967   // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
00968   // index, starting from 0.
00969   virtual void OnTestIterationStart(const UnitTest& unit_test,
00970                                     int iteration) = 0;
00971 
00972   // Fired before environment set-up for each iteration of tests starts.
00973   virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
00974 
00975   // Fired after environment set-up for each iteration of tests ends.
00976   virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
00977 
00978   // Fired before the test case starts.
00979   virtual void OnTestCaseStart(const TestCase& test_case) = 0;
00980 
00981   // Fired before the test starts.
00982   virtual void OnTestStart(const TestInfo& test_info) = 0;
00983 
00984   // Fired after a failed assertion or a SUCCEED() invocation.
00985   virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;
00986 
00987   // Fired after the test ends.
00988   virtual void OnTestEnd(const TestInfo& test_info) = 0;
00989 
00990   // Fired after the test case ends.
00991   virtual void OnTestCaseEnd(const TestCase& test_case) = 0;
00992 
00993   // Fired before environment tear-down for each iteration of tests starts.
00994   virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
00995 
00996   // Fired after environment tear-down for each iteration of tests ends.
00997   virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
00998 
00999   // Fired after each iteration of tests finishes.
01000   virtual void OnTestIterationEnd(const UnitTest& unit_test,
01001                                   int iteration) = 0;
01002 
01003   // Fired after all test activities have ended.
01004   virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
01005 };
01006 
01007 // The convenience class for users who need to override just one or two
01008 // methods and are not concerned that a possible change to a signature of
01009 // the methods they override will not be caught during the build.  For
01010 // comments about each method please see the definition of TestEventListener
01011 // above.
01012 class EmptyTestEventListener : public TestEventListener {
01013  public:
01014   virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
01015   virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
01016                                     int /*iteration*/) {}
01017   virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {}
01018   virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
01019   virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
01020   virtual void OnTestStart(const TestInfo& /*test_info*/) {}
01021   virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {}
01022   virtual void OnTestEnd(const TestInfo& /*test_info*/) {}
01023   virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
01024   virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {}
01025   virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
01026   virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
01027                                   int /*iteration*/) {}
01028   virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
01029 };
01030 
01031 // TestEventListeners lets users add listeners to track events in Google Test.
01032 class GTEST_API_ TestEventListeners {
01033  public:
01034   TestEventListeners();
01035   ~TestEventListeners();
01036 
01037   // Appends an event listener to the end of the list. Google Test assumes
01038   // the ownership of the listener (i.e. it will delete the listener when
01039   // the test program finishes).
01040   void Append(TestEventListener* listener);
01041 
01042   // Removes the given event listener from the list and returns it.  It then
01043   // becomes the caller's responsibility to delete the listener. Returns
01044   // NULL if the listener is not found in the list.
01045   TestEventListener* Release(TestEventListener* listener);
01046 
01047   // Returns the standard listener responsible for the default console
01048   // output.  Can be removed from the listeners list to shut down default
01049   // console output.  Note that removing this object from the listener list
01050   // with Release transfers its ownership to the caller and makes this
01051   // function return NULL the next time.
01052   TestEventListener* default_result_printer() const {
01053     return default_result_printer_;
01054   }
01055 
01056   // Returns the standard listener responsible for the default XML output
01057   // controlled by the --gtest_output=xml flag.  Can be removed from the
01058   // listeners list by users who want to shut down the default XML output
01059   // controlled by this flag and substitute it with custom one.  Note that
01060   // removing this object from the listener list with Release transfers its
01061   // ownership to the caller and makes this function return NULL the next
01062   // time.
01063   TestEventListener* default_xml_generator() const {
01064     return default_xml_generator_;
01065   }
01066 
01067  private:
01068   friend class TestCase;
01069   friend class TestInfo;
01070   friend class internal::DefaultGlobalTestPartResultReporter;
01071   friend class internal::NoExecDeathTest;
01072   friend class internal::TestEventListenersAccessor;
01073   friend class internal::UnitTestImpl;
01074 
01075   // Returns repeater that broadcasts the TestEventListener events to all
01076   // subscribers.
01077   TestEventListener* repeater();
01078 
01079   // Sets the default_result_printer attribute to the provided listener.
01080   // The listener is also added to the listener list and previous
01081   // default_result_printer is removed from it and deleted. The listener can
01082   // also be NULL in which case it will not be added to the list. Does
01083   // nothing if the previous and the current listener objects are the same.
01084   void SetDefaultResultPrinter(TestEventListener* listener);
01085 
01086   // Sets the default_xml_generator attribute to the provided listener.  The
01087   // listener is also added to the listener list and previous
01088   // default_xml_generator is removed from it and deleted. The listener can
01089   // also be NULL in which case it will not be added to the list. Does
01090   // nothing if the previous and the current listener objects are the same.
01091   void SetDefaultXmlGenerator(TestEventListener* listener);
01092 
01093   // Controls whether events will be forwarded by the repeater to the
01094   // listeners in the list.
01095   bool EventForwardingEnabled() const;
01096   void SuppressEventForwarding();
01097 
01098   // The actual list of listeners.
01099   internal::TestEventRepeater* repeater_;
01100   // Listener responsible for the standard result output.
01101   TestEventListener* default_result_printer_;
01102   // Listener responsible for the creation of the XML output file.
01103   TestEventListener* default_xml_generator_;
01104 
01105   // We disallow copying TestEventListeners.
01106   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
01107 };
01108 
01109 // A UnitTest consists of a vector of TestCases.
01110 //
01111 // This is a singleton class.  The only instance of UnitTest is
01112 // created when UnitTest::GetInstance() is first called.  This
01113 // instance is never deleted.
01114 //
01115 // UnitTest is not copyable.
01116 //
01117 // This class is thread-safe as long as the methods are called
01118 // according to their specification.
01119 class GTEST_API_ UnitTest {
01120  public:
01121   // Gets the singleton UnitTest object.  The first time this method
01122   // is called, a UnitTest object is constructed and returned.
01123   // Consecutive calls will return the same object.
01124   static UnitTest* GetInstance();
01125 
01126   // Runs all tests in this UnitTest object and prints the result.
01127   // Returns 0 if successful, or 1 otherwise.
01128   //
01129   // This method can only be called from the main thread.
01130   //
01131   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01132   int Run() GTEST_MUST_USE_RESULT_;
01133 
01134   // Returns the working directory when the first TEST() or TEST_F()
01135   // was executed.  The UnitTest object owns the string.
01136   const char* original_working_dir() const;
01137 
01138   // Returns the TestCase object for the test that's currently running,
01139   // or NULL if no test is running.
01140   const TestCase* current_test_case() const
01141       GTEST_LOCK_EXCLUDED_(mutex_);
01142 
01143   // Returns the TestInfo object for the test that's currently running,
01144   // or NULL if no test is running.
01145   const TestInfo* current_test_info() const
01146       GTEST_LOCK_EXCLUDED_(mutex_);
01147 
01148   // Returns the random seed used at the start of the current test run.
01149   int random_seed() const;
01150 
01151 #if GTEST_HAS_PARAM_TEST
01152   // Returns the ParameterizedTestCaseRegistry object used to keep track of
01153   // value-parameterized tests and instantiate and register them.
01154   //
01155   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01156   internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
01157       GTEST_LOCK_EXCLUDED_(mutex_);
01158 #endif  // GTEST_HAS_PARAM_TEST
01159 
01160   // Gets the number of successful test cases.
01161   int successful_test_case_count() const;
01162 
01163   // Gets the number of failed test cases.
01164   int failed_test_case_count() const;
01165 
01166   // Gets the number of all test cases.
01167   int total_test_case_count() const;
01168 
01169   // Gets the number of all test cases that contain at least one test
01170   // that should run.
01171   int test_case_to_run_count() const;
01172 
01173   // Gets the number of successful tests.
01174   int successful_test_count() const;
01175 
01176   // Gets the number of failed tests.
01177   int failed_test_count() const;
01178 
01179   // Gets the number of disabled tests that will be reported in the XML report.
01180   int reportable_disabled_test_count() const;
01181 
01182   // Gets the number of disabled tests.
01183   int disabled_test_count() const;
01184 
01185   // Gets the number of tests to be printed in the XML report.
01186   int reportable_test_count() const;
01187 
01188   // Gets the number of all tests.
01189   int total_test_count() const;
01190 
01191   // Gets the number of tests that should run.
01192   int test_to_run_count() const;
01193 
01194   // Gets the time of the test program start, in ms from the start of the
01195   // UNIX epoch.
01196   TimeInMillis start_timestamp() const;
01197 
01198   // Gets the elapsed time, in milliseconds.
01199   TimeInMillis elapsed_time() const;
01200 
01201   // Returns true iff the unit test passed (i.e. all test cases passed).
01202   bool Passed() const;
01203 
01204   // Returns true iff the unit test failed (i.e. some test case failed
01205   // or something outside of all tests failed).
01206   bool Failed() const;
01207 
01208   // Gets the i-th test case among all the test cases. i can range from 0 to
01209   // total_test_case_count() - 1. If i is not in that range, returns NULL.
01210   const TestCase* GetTestCase(int i) const;
01211 
01212   // Returns the TestResult containing information on test failures and
01213   // properties logged outside of individual test cases.
01214   const TestResult& ad_hoc_test_result() const;
01215 
01216   // Returns the list of event listeners that can be used to track events
01217   // inside Google Test.
01218   TestEventListeners& listeners();
01219 
01220  private:
01221   // Registers and returns a global test environment.  When a test
01222   // program is run, all global test environments will be set-up in
01223   // the order they were registered.  After all tests in the program
01224   // have finished, all global test environments will be torn-down in
01225   // the *reverse* order they were registered.
01226   //
01227   // The UnitTest object takes ownership of the given environment.
01228   //
01229   // This method can only be called from the main thread.
01230   Environment* AddEnvironment(Environment* env);
01231 
01232   // Adds a TestPartResult to the current TestResult object.  All
01233   // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
01234   // eventually call this to report their results.  The user code
01235   // should use the assertion macros instead of calling this directly.
01236   void AddTestPartResult(TestPartResult::Type result_type,
01237                          const char* file_name,
01238                          int line_number,
01239                          const std::string& message,
01240                          const std::string& os_stack_trace)
01241       GTEST_LOCK_EXCLUDED_(mutex_);
01242 
01243   // Adds a TestProperty to the current TestResult object when invoked from
01244   // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
01245   // from SetUpTestCase or TearDownTestCase, or to the global property set
01246   // when invoked elsewhere.  If the result already contains a property with
01247   // the same key, the value will be updated.
01248   void RecordProperty(const std::string& key, const std::string& value);
01249 
01250   // Gets the i-th test case among all the test cases. i can range from 0 to
01251   // total_test_case_count() - 1. If i is not in that range, returns NULL.
01252   TestCase* GetMutableTestCase(int i);
01253 
01254   // Accessors for the implementation object.
01255   internal::UnitTestImpl* impl() { return impl_; }
01256   const internal::UnitTestImpl* impl() const { return impl_; }
01257 
01258   // These classes and funcions are friends as they need to access private
01259   // members of UnitTest.
01260   friend class Test;
01261   friend class internal::AssertHelper;
01262   friend class internal::ScopedTrace;
01263   friend class internal::StreamingListenerTest;
01264   friend class internal::UnitTestRecordPropertyTestHelper;
01265   friend Environment* AddGlobalTestEnvironment(Environment* env);
01266   friend internal::UnitTestImpl* internal::GetUnitTestImpl();
01267   friend void internal::ReportFailureInUnknownLocation(
01268       TestPartResult::Type result_type,
01269       const std::string& message);
01270 
01271   // Creates an empty UnitTest.
01272   UnitTest();
01273 
01274   // D'tor
01275   virtual ~UnitTest();
01276 
01277   // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
01278   // Google Test trace stack.
01279   void PushGTestTrace(const internal::TraceInfo& trace)
01280       GTEST_LOCK_EXCLUDED_(mutex_);
01281 
01282   // Pops a trace from the per-thread Google Test trace stack.
01283   void PopGTestTrace()
01284       GTEST_LOCK_EXCLUDED_(mutex_);
01285 
01286   // Protects mutable state in *impl_.  This is mutable as some const
01287   // methods need to lock it too.
01288   mutable internal::Mutex mutex_;
01289 
01290   // Opaque implementation object.  This field is never changed once
01291   // the object is constructed.  We don't mark it as const here, as
01292   // doing so will cause a warning in the constructor of UnitTest.
01293   // Mutable state in *impl_ is protected by mutex_.
01294   internal::UnitTestImpl* impl_;
01295 
01296   // We disallow copying UnitTest.
01297   GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
01298 };
01299 
01300 // A convenient wrapper for adding an environment for the test
01301 // program.
01302 //
01303 // You should call this before RUN_ALL_TESTS() is called, probably in
01304 // main().  If you use gtest_main, you need to call this before main()
01305 // starts for it to take effect.  For example, you can define a global
01306 // variable like this:
01307 //
01308 //   testing::Environment* const foo_env =
01309 //       testing::AddGlobalTestEnvironment(new FooEnvironment);
01310 //
01311 // However, we strongly recommend you to write your own main() and
01312 // call AddGlobalTestEnvironment() there, as relying on initialization
01313 // of global variables makes the code harder to read and may cause
01314 // problems when you register multiple environments from different
01315 // translation units and the environments have dependencies among them
01316 // (remember that the compiler doesn't guarantee the order in which
01317 // global variables from different translation units are initialized).
01318 inline Environment* AddGlobalTestEnvironment(Environment* env) {
01319   return UnitTest::GetInstance()->AddEnvironment(env);
01320 }
01321 
01322 // Initializes Google Test.  This must be called before calling
01323 // RUN_ALL_TESTS().  In particular, it parses a command line for the
01324 // flags that Google Test recognizes.  Whenever a Google Test flag is
01325 // seen, it is removed from argv, and *argc is decremented.
01326 //
01327 // No value is returned.  Instead, the Google Test flag variables are
01328 // updated.
01329 //
01330 // Calling the function for the second time has no user-visible effect.
01331 GTEST_API_ void InitGoogleTest(int* argc, char** argv);
01332 
01333 // This overloaded version can be used in Windows programs compiled in
01334 // UNICODE mode.
01335 GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
01336 
01337 namespace internal {
01338 
01339 // FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
01340 // value of type ToPrint that is an operand of a comparison assertion
01341 // (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
01342 // the comparison, and is used to help determine the best way to
01343 // format the value.  In particular, when the value is a C string
01344 // (char pointer) and the other operand is an STL string object, we
01345 // want to format the C string as a string, since we know it is
01346 // compared by value with the string object.  If the value is a char
01347 // pointer but the other operand is not an STL string object, we don't
01348 // know whether the pointer is supposed to point to a NUL-terminated
01349 // string, and thus want to print it as a pointer to be safe.
01350 //
01351 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01352 
01353 // The default case.
01354 template <typename ToPrint, typename OtherOperand>
01355 class FormatForComparison {
01356  public:
01357   static ::std::string Format(const ToPrint& value) {
01358     return ::testing::PrintToString(value);
01359   }
01360 };
01361 
01362 // Array.
01363 template <typename ToPrint, size_t N, typename OtherOperand>
01364 class FormatForComparison<ToPrint[N], OtherOperand> {
01365  public:
01366   static ::std::string Format(const ToPrint* value) {
01367     return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
01368   }
01369 };
01370 
01371 // By default, print C string as pointers to be safe, as we don't know
01372 // whether they actually point to a NUL-terminated string.
01373 
01374 #define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
01375   template <typename OtherOperand>                                      \
01376   class FormatForComparison<CharType*, OtherOperand> {                  \
01377    public:                                                              \
01378     static ::std::string Format(CharType* value) {                      \
01379       return ::testing::PrintToString(static_cast<const void*>(value)); \
01380     }                                                                   \
01381   }
01382 
01383 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
01384 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
01385 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
01386 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
01387 
01388 #undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
01389 
01390 // If a C string is compared with an STL string object, we know it's meant
01391 // to point to a NUL-terminated string, and thus can print it as a string.
01392 
01393 #define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
01394   template <>                                                           \
01395   class FormatForComparison<CharType*, OtherStringType> {               \
01396    public:                                                              \
01397     static ::std::string Format(CharType* value) {                      \
01398       return ::testing::PrintToString(value);                           \
01399     }                                                                   \
01400   }
01401 
01402 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
01403 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
01404 
01405 #if GTEST_HAS_GLOBAL_STRING
01406 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
01407 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
01408 #endif
01409 
01410 #if GTEST_HAS_GLOBAL_WSTRING
01411 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
01412 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
01413 #endif
01414 
01415 #if GTEST_HAS_STD_WSTRING
01416 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
01417 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
01418 #endif
01419 
01420 #undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
01421 
01422 // Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
01423 // operand to be used in a failure message.  The type (but not value)
01424 // of the other operand may affect the format.  This allows us to
01425 // print a char* as a raw pointer when it is compared against another
01426 // char* or void*, and print it as a C string when it is compared
01427 // against an std::string object, for example.
01428 //
01429 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01430 template <typename T1, typename T2>
01431 std::string FormatForComparisonFailureMessage(
01432     const T1& value, const T2& /* other_operand */) {
01433   return FormatForComparison<T1, T2>::Format(value);
01434 }
01435 
01436 // The helper function for {ASSERT|EXPECT}_EQ.
01437 template <typename T1, typename T2>
01438 AssertionResult CmpHelperEQ(const char* expected_expression,
01439                             const char* actual_expression,
01440                             const T1& expected,
01441                             const T2& actual) {
01442 #ifdef _MSC_VER
01443 # pragma warning(push)          // Saves the current warning state.
01444 # pragma warning(disable:4389)  // Temporarily disables warning on
01445                                 // signed/unsigned mismatch.
01446 #endif
01447 
01448   if (expected == actual) {
01449     return AssertionSuccess();
01450   }
01451 
01452 #ifdef _MSC_VER
01453 # pragma warning(pop)          // Restores the warning state.
01454 #endif
01455 
01456   return EqFailure(expected_expression,
01457                    actual_expression,
01458                    FormatForComparisonFailureMessage(expected, actual),
01459                    FormatForComparisonFailureMessage(actual, expected),
01460                    false);
01461 }
01462 
01463 // With this overloaded version, we allow anonymous enums to be used
01464 // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
01465 // can be implicitly cast to BiggestInt.
01466 GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression,
01467                                        const char* actual_expression,
01468                                        BiggestInt expected,
01469                                        BiggestInt actual);
01470 
01471 // The helper class for {ASSERT|EXPECT}_EQ.  The template argument
01472 // lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
01473 // is a null pointer literal.  The following default implementation is
01474 // for lhs_is_null_literal being false.
01475 template <bool lhs_is_null_literal>
01476 class EqHelper {
01477  public:
01478   // This templatized version is for the general case.
01479   template <typename T1, typename T2>
01480   static AssertionResult Compare(const char* expected_expression,
01481                                  const char* actual_expression,
01482                                  const T1& expected,
01483                                  const T2& actual) {
01484     return CmpHelperEQ(expected_expression, actual_expression, expected,
01485                        actual);
01486   }
01487 
01488   // With this overloaded version, we allow anonymous enums to be used
01489   // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
01490   // enums can be implicitly cast to BiggestInt.
01491   //
01492   // Even though its body looks the same as the above version, we
01493   // cannot merge the two, as it will make anonymous enums unhappy.
01494   static AssertionResult Compare(const char* expected_expression,
01495                                  const char* actual_expression,
01496                                  BiggestInt expected,
01497                                  BiggestInt actual) {
01498     return CmpHelperEQ(expected_expression, actual_expression, expected,
01499                        actual);
01500   }
01501 };
01502 
01503 // This specialization is used when the first argument to ASSERT_EQ()
01504 // is a null pointer literal, like NULL, false, or 0.
01505 template <>
01506 class EqHelper<true> {
01507  public:
01508   // We define two overloaded versions of Compare().  The first
01509   // version will be picked when the second argument to ASSERT_EQ() is
01510   // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
01511   // EXPECT_EQ(false, a_bool).
01512   template <typename T1, typename T2>
01513   static AssertionResult Compare(
01514       const char* expected_expression,
01515       const char* actual_expression,
01516       const T1& expected,
01517       const T2& actual,
01518       // The following line prevents this overload from being considered if T2
01519       // is not a pointer type.  We need this because ASSERT_EQ(NULL, my_ptr)
01520       // expands to Compare("", "", NULL, my_ptr), which requires a conversion
01521       // to match the Secret* in the other overload, which would otherwise make
01522       // this template match better.
01523       typename EnableIf<!is_pointer<T2>::value>::type* = 0) {
01524     return CmpHelperEQ(expected_expression, actual_expression, expected,
01525                        actual);
01526   }
01527 
01528   // This version will be picked when the second argument to ASSERT_EQ() is a
01529   // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
01530   template <typename T>
01531   static AssertionResult Compare(
01532       const char* expected_expression,
01533       const char* actual_expression,
01534       // We used to have a second template parameter instead of Secret*.  That
01535       // template parameter would deduce to 'long', making this a better match
01536       // than the first overload even without the first overload's EnableIf.
01537       // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
01538       // non-pointer argument" (even a deduced integral argument), so the old
01539       // implementation caused warnings in user code.
01540       Secret* /* expected (NULL) */,
01541       T* actual) {
01542     // We already know that 'expected' is a null pointer.
01543     return CmpHelperEQ(expected_expression, actual_expression,
01544                        static_cast<T*>(NULL), actual);
01545   }
01546 };
01547 
01548 // A macro for implementing the helper functions needed to implement
01549 // ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
01550 // of similar code.
01551 //
01552 // For each templatized helper function, we also define an overloaded
01553 // version for BiggestInt in order to reduce code bloat and allow
01554 // anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
01555 // with gcc 4.
01556 //
01557 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01558 #define GTEST_IMPL_CMP_HELPER_(op_name, op)\
01559 template <typename T1, typename T2>\
01560 AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
01561                                    const T1& val1, const T2& val2) {\
01562   if (val1 op val2) {\
01563     return AssertionSuccess();\
01564   } else {\
01565     return AssertionFailure() \
01566         << "Expected: (" << expr1 << ") " #op " (" << expr2\
01567         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
01568         << " vs " << FormatForComparisonFailureMessage(val2, val1);\
01569   }\
01570 }\
01571 GTEST_API_ AssertionResult CmpHelper##op_name(\
01572     const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
01573 
01574 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01575 
01576 // Implements the helper function for {ASSERT|EXPECT}_NE
01577 GTEST_IMPL_CMP_HELPER_(NE, !=);
01578 // Implements the helper function for {ASSERT|EXPECT}_LE
01579 GTEST_IMPL_CMP_HELPER_(LE, <=);
01580 // Implements the helper function for {ASSERT|EXPECT}_LT
01581 GTEST_IMPL_CMP_HELPER_(LT, <);
01582 // Implements the helper function for {ASSERT|EXPECT}_GE
01583 GTEST_IMPL_CMP_HELPER_(GE, >=);
01584 // Implements the helper function for {ASSERT|EXPECT}_GT
01585 GTEST_IMPL_CMP_HELPER_(GT, >);
01586 
01587 #undef GTEST_IMPL_CMP_HELPER_
01588 
01589 // The helper function for {ASSERT|EXPECT}_STREQ.
01590 //
01591 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01592 GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
01593                                           const char* actual_expression,
01594                                           const char* expected,
01595                                           const char* actual);
01596 
01597 // The helper function for {ASSERT|EXPECT}_STRCASEEQ.
01598 //
01599 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01600 GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
01601                                               const char* actual_expression,
01602                                               const char* expected,
01603                                               const char* actual);
01604 
01605 // The helper function for {ASSERT|EXPECT}_STRNE.
01606 //
01607 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01608 GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
01609                                           const char* s2_expression,
01610                                           const char* s1,
01611                                           const char* s2);
01612 
01613 // The helper function for {ASSERT|EXPECT}_STRCASENE.
01614 //
01615 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01616 GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
01617                                               const char* s2_expression,
01618                                               const char* s1,
01619                                               const char* s2);
01620 
01621 
01622 // Helper function for *_STREQ on wide strings.
01623 //
01624 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01625 GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
01626                                           const char* actual_expression,
01627                                           const wchar_t* expected,
01628                                           const wchar_t* actual);
01629 
01630 // Helper function for *_STRNE on wide strings.
01631 //
01632 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01633 GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
01634                                           const char* s2_expression,
01635                                           const wchar_t* s1,
01636                                           const wchar_t* s2);
01637 
01638 }  // namespace internal
01639 
01640 // IsSubstring() and IsNotSubstring() are intended to be used as the
01641 // first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
01642 // themselves.  They check whether needle is a substring of haystack
01643 // (NULL is considered a substring of itself only), and return an
01644 // appropriate error message when they fail.
01645 //
01646 // The {needle,haystack}_expr arguments are the stringified
01647 // expressions that generated the two real arguments.
01648 GTEST_API_ AssertionResult IsSubstring(
01649     const char* needle_expr, const char* haystack_expr,
01650     const char* needle, const char* haystack);
01651 GTEST_API_ AssertionResult IsSubstring(
01652     const char* needle_expr, const char* haystack_expr,
01653     const wchar_t* needle, const wchar_t* haystack);
01654 GTEST_API_ AssertionResult IsNotSubstring(
01655     const char* needle_expr, const char* haystack_expr,
01656     const char* needle, const char* haystack);
01657 GTEST_API_ AssertionResult IsNotSubstring(
01658     const char* needle_expr, const char* haystack_expr,
01659     const wchar_t* needle, const wchar_t* haystack);
01660 GTEST_API_ AssertionResult IsSubstring(
01661     const char* needle_expr, const char* haystack_expr,
01662     const ::std::string& needle, const ::std::string& haystack);
01663 GTEST_API_ AssertionResult IsNotSubstring(
01664     const char* needle_expr, const char* haystack_expr,
01665     const ::std::string& needle, const ::std::string& haystack);
01666 
01667 #if GTEST_HAS_STD_WSTRING
01668 GTEST_API_ AssertionResult IsSubstring(
01669     const char* needle_expr, const char* haystack_expr,
01670     const ::std::wstring& needle, const ::std::wstring& haystack);
01671 GTEST_API_ AssertionResult IsNotSubstring(
01672     const char* needle_expr, const char* haystack_expr,
01673     const ::std::wstring& needle, const ::std::wstring& haystack);
01674 #endif  // GTEST_HAS_STD_WSTRING
01675 
01676 namespace internal {
01677 
01678 // Helper template function for comparing floating-points.
01679 //
01680 // Template parameter:
01681 //
01682 //   RawType: the raw floating-point type (either float or double)
01683 //
01684 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01685 template <typename RawType>
01686 AssertionResult CmpHelperFloatingPointEQ(const char* expected_expression,
01687                                          const char* actual_expression,
01688                                          RawType expected,
01689                                          RawType actual) {
01690   const FloatingPoint<RawType> lhs(expected), rhs(actual);
01691 
01692   if (lhs.AlmostEquals(rhs)) {
01693     return AssertionSuccess();
01694   }
01695 
01696   ::std::stringstream expected_ss;
01697   expected_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
01698               << expected;
01699 
01700   ::std::stringstream actual_ss;
01701   actual_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
01702             << actual;
01703 
01704   return EqFailure(expected_expression,
01705                    actual_expression,
01706                    StringStreamToString(&expected_ss),
01707                    StringStreamToString(&actual_ss),
01708                    false);
01709 }
01710 
01711 // Helper function for implementing ASSERT_NEAR.
01712 //
01713 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
01714 GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
01715                                                 const char* expr2,
01716                                                 const char* abs_error_expr,
01717                                                 double val1,
01718                                                 double val2,
01719                                                 double abs_error);
01720 
01721 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
01722 // A class that enables one to stream messages to assertion macros
01723 class GTEST_API_ AssertHelper {
01724  public:
01725   // Constructor.
01726   AssertHelper(TestPartResult::Type type,
01727                const char* file,
01728                int line,
01729                const char* message);
01730   ~AssertHelper();
01731 
01732   // Message assignment is a semantic trick to enable assertion
01733   // streaming; see the GTEST_MESSAGE_ macro below.
01734   void operator=(const Message& message) const;
01735 
01736  private:
01737   // We put our data in a struct so that the size of the AssertHelper class can
01738   // be as small as possible.  This is important because gcc is incapable of
01739   // re-using stack space even for temporary variables, so every EXPECT_EQ
01740   // reserves stack space for another AssertHelper.
01741   struct AssertHelperData {
01742     AssertHelperData(TestPartResult::Type t,
01743                      const char* srcfile,
01744                      int line_num,
01745                      const char* msg)
01746         : type(t), file(srcfile), line(line_num), message(msg) { }
01747 
01748     TestPartResult::Type const type;
01749     const char* const file;
01750     int const line;
01751     std::string const message;
01752 
01753    private:
01754     GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
01755   };
01756 
01757   AssertHelperData* const data_;
01758 
01759   GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
01760 };
01761 
01762 }  // namespace internal
01763 
01764 #if GTEST_HAS_PARAM_TEST
01765 // The pure interface class that all value-parameterized tests inherit from.
01766 // A value-parameterized class must inherit from both ::testing::Test and
01767 // ::testing::WithParamInterface. In most cases that just means inheriting
01768 // from ::testing::TestWithParam, but more complicated test hierarchies
01769 // may need to inherit from Test and WithParamInterface at different levels.
01770 //
01771 // This interface has support for accessing the test parameter value via
01772 // the GetParam() method.
01773 //
01774 // Use it with one of the parameter generator defining functions, like Range(),
01775 // Values(), ValuesIn(), Bool(), and Combine().
01776 //
01777 // class FooTest : public ::testing::TestWithParam<int> {
01778 //  protected:
01779 //   FooTest() {
01780 //     // Can use GetParam() here.
01781 //   }
01782 //   virtual ~FooTest() {
01783 //     // Can use GetParam() here.
01784 //   }
01785 //   virtual void SetUp() {
01786 //     // Can use GetParam() here.
01787 //   }
01788 //   virtual void TearDown {
01789 //     // Can use GetParam() here.
01790 //   }
01791 // };
01792 // TEST_P(FooTest, DoesBar) {
01793 //   // Can use GetParam() method here.
01794 //   Foo foo;
01795 //   ASSERT_TRUE(foo.DoesBar(GetParam()));
01796 // }
01797 // INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
01798 
01799 template <typename T>
01800 class WithParamInterface {
01801  public:
01802   typedef T ParamType;
01803   virtual ~WithParamInterface() {}
01804 
01805   // The current parameter value. Is also available in the test fixture's
01806   // constructor. This member function is non-static, even though it only
01807   // references static data, to reduce the opportunity for incorrect uses
01808   // like writing 'WithParamInterface<bool>::GetParam()' for a test that
01809   // uses a fixture whose parameter type is int.
01810   const ParamType& GetParam() const {
01811     GTEST_CHECK_(parameter_ != NULL)
01812         << "GetParam() can only be called inside a value-parameterized test "
01813         << "-- did you intend to write TEST_P instead of TEST_F?";
01814     return *parameter_;
01815   }
01816 
01817  private:
01818   // Sets parameter value. The caller is responsible for making sure the value
01819   // remains alive and unchanged throughout the current test.
01820   static void SetParam(const ParamType* parameter) {
01821     parameter_ = parameter;
01822   }
01823 
01824   // Static value used for accessing parameter during a test lifetime.
01825   static const ParamType* parameter_;
01826 
01827   // TestClass must be a subclass of WithParamInterface<T> and Test.
01828   template <class TestClass> friend class internal::ParameterizedTestFactory;
01829 };
01830 
01831 template <typename T>
01832 const T* WithParamInterface<T>::parameter_ = NULL;
01833 
01834 // Most value-parameterized classes can ignore the existence of
01835 // WithParamInterface, and can just inherit from ::testing::TestWithParam.
01836 
01837 template <typename T>
01838 class TestWithParam : public Test, public WithParamInterface<T> {
01839 };
01840 
01841 #endif  // GTEST_HAS_PARAM_TEST
01842 
01843 // Macros for indicating success/failure in test code.
01844 
01845 // ADD_FAILURE unconditionally adds a failure to the current test.
01846 // SUCCEED generates a success - it doesn't automatically make the
01847 // current test successful, as a test is only successful when it has
01848 // no failure.
01849 //
01850 // EXPECT_* verifies that a certain condition is satisfied.  If not,
01851 // it behaves like ADD_FAILURE.  In particular:
01852 //
01853 //   EXPECT_TRUE  verifies that a Boolean condition is true.
01854 //   EXPECT_FALSE verifies that a Boolean condition is false.
01855 //
01856 // FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
01857 // that they will also abort the current function on failure.  People
01858 // usually want the fail-fast behavior of FAIL and ASSERT_*, but those
01859 // writing data-driven tests often find themselves using ADD_FAILURE
01860 // and EXPECT_* more.
01861 
01862 // Generates a nonfatal failure with a generic message.
01863 #define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
01864 
01865 // Generates a nonfatal failure at the given source file location with
01866 // a generic message.
01867 #define ADD_FAILURE_AT(file, line) \
01868   GTEST_MESSAGE_AT_(file, line, "Failed", \
01869                     ::testing::TestPartResult::kNonFatalFailure)
01870 
01871 // Generates a fatal failure with a generic message.
01872 #define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
01873 
01874 // Define this macro to 1 to omit the definition of FAIL(), which is a
01875 // generic name and clashes with some other libraries.
01876 #if !GTEST_DONT_DEFINE_FAIL
01877 # define FAIL() GTEST_FAIL()
01878 #endif
01879 
01880 // Generates a success with a generic message.
01881 #define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
01882 
01883 // Define this macro to 1 to omit the definition of SUCCEED(), which
01884 // is a generic name and clashes with some other libraries.
01885 #if !GTEST_DONT_DEFINE_SUCCEED
01886 # define SUCCEED() GTEST_SUCCEED()
01887 #endif
01888 
01889 // Macros for testing exceptions.
01890 //
01891 //    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
01892 //         Tests that the statement throws the expected exception.
01893 //    * {ASSERT|EXPECT}_NO_THROW(statement):
01894 //         Tests that the statement doesn't throw any exception.
01895 //    * {ASSERT|EXPECT}_ANY_THROW(statement):
01896 //         Tests that the statement throws an exception.
01897 
01898 #define EXPECT_THROW(statement, expected_exception) \
01899   GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
01900 #define EXPECT_NO_THROW(statement) \
01901   GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
01902 #define EXPECT_ANY_THROW(statement) \
01903   GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
01904 #define ASSERT_THROW(statement, expected_exception) \
01905   GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
01906 #define ASSERT_NO_THROW(statement) \
01907   GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
01908 #define ASSERT_ANY_THROW(statement) \
01909   GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
01910 
01911 // Boolean assertions. Condition can be either a Boolean expression or an
01912 // AssertionResult. For more information on how to use AssertionResult with
01913 // these macros see comments on that class.
01914 #define EXPECT_TRUE(condition) \
01915   GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
01916                       GTEST_NONFATAL_FAILURE_)
01917 #define EXPECT_FALSE(condition) \
01918   GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
01919                       GTEST_NONFATAL_FAILURE_)
01920 #define ASSERT_TRUE(condition) \
01921   GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
01922                       GTEST_FATAL_FAILURE_)
01923 #define ASSERT_FALSE(condition) \
01924   GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
01925                       GTEST_FATAL_FAILURE_)
01926 
01927 // Includes the auto-generated header that implements a family of
01928 // generic predicate assertion macros.
01929 #include "gtest/gtest_pred_impl.h"
01930 
01931 // Macros for testing equalities and inequalities.
01932 //
01933 //    * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual
01934 //    * {ASSERT|EXPECT}_NE(v1, v2):           Tests that v1 != v2
01935 //    * {ASSERT|EXPECT}_LT(v1, v2):           Tests that v1 < v2
01936 //    * {ASSERT|EXPECT}_LE(v1, v2):           Tests that v1 <= v2
01937 //    * {ASSERT|EXPECT}_GT(v1, v2):           Tests that v1 > v2
01938 //    * {ASSERT|EXPECT}_GE(v1, v2):           Tests that v1 >= v2
01939 //
01940 // When they are not, Google Test prints both the tested expressions and
01941 // their actual values.  The values must be compatible built-in types,
01942 // or you will get a compiler error.  By "compatible" we mean that the
01943 // values can be compared by the respective operator.
01944 //
01945 // Note:
01946 //
01947 //   1. It is possible to make a user-defined type work with
01948 //   {ASSERT|EXPECT}_??(), but that requires overloading the
01949 //   comparison operators and is thus discouraged by the Google C++
01950 //   Usage Guide.  Therefore, you are advised to use the
01951 //   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
01952 //   equal.
01953 //
01954 //   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
01955 //   pointers (in particular, C strings).  Therefore, if you use it
01956 //   with two C strings, you are testing how their locations in memory
01957 //   are related, not how their content is related.  To compare two C
01958 //   strings by content, use {ASSERT|EXPECT}_STR*().
01959 //
01960 //   3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to
01961 //   {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you
01962 //   what the actual value is when it fails, and similarly for the
01963 //   other comparisons.
01964 //
01965 //   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
01966 //   evaluate their arguments, which is undefined.
01967 //
01968 //   5. These macros evaluate their arguments exactly once.
01969 //
01970 // Examples:
01971 //
01972 //   EXPECT_NE(5, Foo());
01973 //   EXPECT_EQ(NULL, a_pointer);
01974 //   ASSERT_LT(i, array_size);
01975 //   ASSERT_GT(records.size(), 0) << "There is no record left.";
01976 
01977 #define EXPECT_EQ(expected, actual) \
01978   EXPECT_PRED_FORMAT2(::testing::internal:: \
01979                       EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
01980                       expected, actual)
01981 #define EXPECT_NE(expected, actual) \
01982   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual)
01983 #define EXPECT_LE(val1, val2) \
01984   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
01985 #define EXPECT_LT(val1, val2) \
01986   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
01987 #define EXPECT_GE(val1, val2) \
01988   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
01989 #define EXPECT_GT(val1, val2) \
01990   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
01991 
01992 #define GTEST_ASSERT_EQ(expected, actual) \
01993   ASSERT_PRED_FORMAT2(::testing::internal:: \
01994                       EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
01995                       expected, actual)
01996 #define GTEST_ASSERT_NE(val1, val2) \
01997   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
01998 #define GTEST_ASSERT_LE(val1, val2) \
01999   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
02000 #define GTEST_ASSERT_LT(val1, val2) \
02001   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
02002 #define GTEST_ASSERT_GE(val1, val2) \
02003   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
02004 #define GTEST_ASSERT_GT(val1, val2) \
02005   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
02006 
02007 // Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
02008 // ASSERT_XY(), which clashes with some users' own code.
02009 
02010 #if !GTEST_DONT_DEFINE_ASSERT_EQ
02011 # define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
02012 #endif
02013 
02014 #if !GTEST_DONT_DEFINE_ASSERT_NE
02015 # define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
02016 #endif
02017 
02018 #if !GTEST_DONT_DEFINE_ASSERT_LE
02019 # define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
02020 #endif
02021 
02022 #if !GTEST_DONT_DEFINE_ASSERT_LT
02023 # define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
02024 #endif
02025 
02026 #if !GTEST_DONT_DEFINE_ASSERT_GE
02027 # define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
02028 #endif
02029 
02030 #if !GTEST_DONT_DEFINE_ASSERT_GT
02031 # define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
02032 #endif
02033 
02034 // C-string Comparisons.  All tests treat NULL and any non-NULL string
02035 // as different.  Two NULLs are equal.
02036 //
02037 //    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
02038 //    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
02039 //    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
02040 //    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
02041 //
02042 // For wide or narrow string objects, you can use the
02043 // {ASSERT|EXPECT}_??() macros.
02044 //
02045 // Don't depend on the order in which the arguments are evaluated,
02046 // which is undefined.
02047 //
02048 // These macros evaluate their arguments exactly once.
02049 
02050 #define EXPECT_STREQ(expected, actual) \
02051   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
02052 #define EXPECT_STRNE(s1, s2) \
02053   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
02054 #define EXPECT_STRCASEEQ(expected, actual) \
02055   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
02056 #define EXPECT_STRCASENE(s1, s2)\
02057   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
02058 
02059 #define ASSERT_STREQ(expected, actual) \
02060   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
02061 #define ASSERT_STRNE(s1, s2) \
02062   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
02063 #define ASSERT_STRCASEEQ(expected, actual) \
02064   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
02065 #define ASSERT_STRCASENE(s1, s2)\
02066   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
02067 
02068 // Macros for comparing floating-point numbers.
02069 //
02070 //    * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual):
02071 //         Tests that two float values are almost equal.
02072 //    * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual):
02073 //         Tests that two double values are almost equal.
02074 //    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
02075 //         Tests that v1 and v2 are within the given distance to each other.
02076 //
02077 // Google Test uses ULP-based comparison to automatically pick a default
02078 // error bound that is appropriate for the operands.  See the
02079 // FloatingPoint template class in gtest-internal.h if you are
02080 // interested in the implementation details.
02081 
02082 #define EXPECT_FLOAT_EQ(expected, actual)\
02083   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
02084                       expected, actual)
02085 
02086 #define EXPECT_DOUBLE_EQ(expected, actual)\
02087   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
02088                       expected, actual)
02089 
02090 #define ASSERT_FLOAT_EQ(expected, actual)\
02091   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
02092                       expected, actual)
02093 
02094 #define ASSERT_DOUBLE_EQ(expected, actual)\
02095   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
02096                       expected, actual)
02097 
02098 #define EXPECT_NEAR(val1, val2, abs_error)\
02099   EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
02100                       val1, val2, abs_error)
02101 
02102 #define ASSERT_NEAR(val1, val2, abs_error)\
02103   ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
02104                       val1, val2, abs_error)
02105 
02106 // These predicate format functions work on floating-point values, and
02107 // can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
02108 //
02109 //   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
02110 
02111 // Asserts that val1 is less than, or almost equal to, val2.  Fails
02112 // otherwise.  In particular, it fails if either val1 or val2 is NaN.
02113 GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
02114                                    float val1, float val2);
02115 GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
02116                                     double val1, double val2);
02117 
02118 
02119 #if GTEST_OS_WINDOWS
02120 
02121 // Macros that test for HRESULT failure and success, these are only useful
02122 // on Windows, and rely on Windows SDK macros and APIs to compile.
02123 //
02124 //    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
02125 //
02126 // When expr unexpectedly fails or succeeds, Google Test prints the
02127 // expected result and the actual result with both a human-readable
02128 // string representation of the error, if available, as well as the
02129 // hex result code.
02130 # define EXPECT_HRESULT_SUCCEEDED(expr) \
02131     EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
02132 
02133 # define ASSERT_HRESULT_SUCCEEDED(expr) \
02134     ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
02135 
02136 # define EXPECT_HRESULT_FAILED(expr) \
02137     EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
02138 
02139 # define ASSERT_HRESULT_FAILED(expr) \
02140     ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
02141 
02142 #endif  // GTEST_OS_WINDOWS
02143 
02144 // Macros that execute statement and check that it doesn't generate new fatal
02145 // failures in the current thread.
02146 //
02147 //   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
02148 //
02149 // Examples:
02150 //
02151 //   EXPECT_NO_FATAL_FAILURE(Process());
02152 //   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
02153 //
02154 #define ASSERT_NO_FATAL_FAILURE(statement) \
02155     GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
02156 #define EXPECT_NO_FATAL_FAILURE(statement) \
02157     GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
02158 
02159 // Causes a trace (including the source file path, the current line
02160 // number, and the given message) to be included in every test failure
02161 // message generated by code in the current scope.  The effect is
02162 // undone when the control leaves the current scope.
02163 //
02164 // The message argument can be anything streamable to std::ostream.
02165 //
02166 // In the implementation, we include the current line number as part
02167 // of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
02168 // to appear in the same block - as long as they are on different
02169 // lines.
02170 #define SCOPED_TRACE(message) \
02171   ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
02172     __FILE__, __LINE__, ::testing::Message() << (message))
02173 
02174 // Compile-time assertion for type equality.
02175 // StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
02176 // the same type.  The value it returns is not interesting.
02177 //
02178 // Instead of making StaticAssertTypeEq a class template, we make it a
02179 // function template that invokes a helper class template.  This
02180 // prevents a user from misusing StaticAssertTypeEq<T1, T2> by
02181 // defining objects of that type.
02182 //
02183 // CAVEAT:
02184 //
02185 // When used inside a method of a class template,
02186 // StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
02187 // instantiated.  For example, given:
02188 //
02189 //   template <typename T> class Foo {
02190 //    public:
02191 //     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
02192 //   };
02193 //
02194 // the code:
02195 //
02196 //   void Test1() { Foo<bool> foo; }
02197 //
02198 // will NOT generate a compiler error, as Foo<bool>::Bar() is never
02199 // actually instantiated.  Instead, you need:
02200 //
02201 //   void Test2() { Foo<bool> foo; foo.Bar(); }
02202 //
02203 // to cause a compiler error.
02204 template <typename T1, typename T2>
02205 bool StaticAssertTypeEq() {
02206   (void)internal::StaticAssertTypeEqHelper<T1, T2>();
02207   return true;
02208 }
02209 
02210 // Defines a test.
02211 //
02212 // The first parameter is the name of the test case, and the second
02213 // parameter is the name of the test within the test case.
02214 //
02215 // The convention is to end the test case name with "Test".  For
02216 // example, a test case for the Foo class can be named FooTest.
02217 //
02218 // The user should put his test code between braces after using this
02219 // macro.  Example:
02220 //
02221 //   TEST(FooTest, InitializesCorrectly) {
02222 //     Foo foo;
02223 //     EXPECT_TRUE(foo.StatusIsOK());
02224 //   }
02225 
02226 // Note that we call GetTestTypeId() instead of GetTypeId<
02227 // ::testing::Test>() here to get the type ID of testing::Test.  This
02228 // is to work around a suspected linker bug when using Google Test as
02229 // a framework on Mac OS X.  The bug causes GetTypeId<
02230 // ::testing::Test>() to return different values depending on whether
02231 // the call is from the Google Test framework itself or from user test
02232 // code.  GetTestTypeId() is guaranteed to always return the same
02233 // value, as it always calls GetTypeId<>() from the Google Test
02234 // framework.
02235 #define GTEST_TEST(test_case_name, test_name)\
02236   GTEST_TEST_(test_case_name, test_name, \
02237               ::testing::Test, ::testing::internal::GetTestTypeId())
02238 
02239 // Define this macro to 1 to omit the definition of TEST(), which
02240 // is a generic name and clashes with some other libraries.
02241 #if !GTEST_DONT_DEFINE_TEST
02242 # define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name)
02243 #endif
02244 
02245 // Defines a test that uses a test fixture.
02246 //
02247 // The first parameter is the name of the test fixture class, which
02248 // also doubles as the test case name.  The second parameter is the
02249 // name of the test within the test case.
02250 //
02251 // A test fixture class must be declared earlier.  The user should put
02252 // his test code between braces after using this macro.  Example:
02253 //
02254 //   class FooTest : public testing::Test {
02255 //    protected:
02256 //     virtual void SetUp() { b_.AddElement(3); }
02257 //
02258 //     Foo a_;
02259 //     Foo b_;
02260 //   };
02261 //
02262 //   TEST_F(FooTest, InitializesCorrectly) {
02263 //     EXPECT_TRUE(a_.StatusIsOK());
02264 //   }
02265 //
02266 //   TEST_F(FooTest, ReturnsElementCountCorrectly) {
02267 //     EXPECT_EQ(0, a_.size());
02268 //     EXPECT_EQ(1, b_.size());
02269 //   }
02270 
02271 #define TEST_F(test_fixture, test_name)\
02272   GTEST_TEST_(test_fixture, test_name, test_fixture, \
02273               ::testing::internal::GetTypeId<test_fixture>())
02274 
02275 }  // namespace testing
02276 
02277 // Use this function in main() to run all tests.  It returns 0 if all
02278 // tests are successful, or 1 otherwise.
02279 //
02280 // RUN_ALL_TESTS() should be invoked after the command line has been
02281 // parsed by InitGoogleTest().
02282 //
02283 // This function was formerly a macro; thus, it is in the global
02284 // namespace and has an all-caps name.
02285 int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
02286 
02287 inline int RUN_ALL_TESTS() {
02288   return ::testing::UnitTest::GetInstance()->Run();
02289 }
02290 
02291 #endif  // GTEST_INCLUDE_GTEST_GTEST_H_


ros_opcua_impl_freeopcua
Author(s): Denis Štogl
autogenerated on Sat Jun 8 2019 18:24:55