Qucs-core  0.0.19
gtest-internal.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 // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
00031 //
00032 // The Google C++ Testing Framework (Google Test)
00033 //
00034 // This header file declares functions and macros used internally by
00035 // Google Test.  They are subject to change without notice.
00036 
00037 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
00038 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
00039 
00040 #include "gtest/internal/gtest-port.h"
00041 
00042 #if GTEST_OS_LINUX
00043 # include <stdlib.h>
00044 # include <sys/types.h>
00045 # include <sys/wait.h>
00046 # include <unistd.h>
00047 #endif  // GTEST_OS_LINUX
00048 
00049 #if GTEST_HAS_EXCEPTIONS
00050 # include <stdexcept>
00051 #endif
00052 
00053 #include <ctype.h>
00054 #include <float.h>
00055 #include <string.h>
00056 #include <iomanip>
00057 #include <limits>
00058 #include <set>
00059 
00060 #include "gtest/gtest-message.h"
00061 #include "gtest/internal/gtest-string.h"
00062 #include "gtest/internal/gtest-filepath.h"
00063 #include "gtest/internal/gtest-type-util.h"
00064 
00065 // Due to C++ preprocessor weirdness, we need double indirection to
00066 // concatenate two tokens when one of them is __LINE__.  Writing
00067 //
00068 //   foo ## __LINE__
00069 //
00070 // will result in the token foo__LINE__, instead of foo followed by
00071 // the current line number.  For more details, see
00072 // http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
00073 #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
00074 #define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
00075 
00076 class ProtocolMessage;
00077 namespace proto2 { class Message; }
00078 
00079 namespace testing {
00080 
00081 // Forward declarations.
00082 
00083 class AssertionResult;                 // Result of an assertion.
00084 class Message;                         // Represents a failure message.
00085 class Test;                            // Represents a test.
00086 class TestInfo;                        // Information about a test.
00087 class TestPartResult;                  // Result of a test part.
00088 class UnitTest;                        // A collection of test cases.
00089 
00090 template <typename T>
00091 ::std::string PrintToString(const T& value);
00092 
00093 namespace internal {
00094 
00095 struct TraceInfo;                      // Information about a trace point.
00096 class ScopedTrace;                     // Implements scoped trace.
00097 class TestInfoImpl;                    // Opaque implementation of TestInfo
00098 class UnitTestImpl;                    // Opaque implementation of UnitTest
00099 
00100 // How many times InitGoogleTest() has been called.
00101 GTEST_API_ extern int g_init_gtest_count;
00102 
00103 // The text used in failure messages to indicate the start of the
00104 // stack trace.
00105 GTEST_API_ extern const char kStackTraceMarker[];
00106 
00107 // Two overloaded helpers for checking at compile time whether an
00108 // expression is a null pointer literal (i.e. NULL or any 0-valued
00109 // compile-time integral constant).  Their return values have
00110 // different sizes, so we can use sizeof() to test which version is
00111 // picked by the compiler.  These helpers have no implementations, as
00112 // we only need their signatures.
00113 //
00114 // Given IsNullLiteralHelper(x), the compiler will pick the first
00115 // version if x can be implicitly converted to Secret*, and pick the
00116 // second version otherwise.  Since Secret is a secret and incomplete
00117 // type, the only expression a user can write that has type Secret* is
00118 // a null pointer literal.  Therefore, we know that x is a null
00119 // pointer literal if and only if the first version is picked by the
00120 // compiler.
00121 char IsNullLiteralHelper(Secret* p);
00122 char (&IsNullLiteralHelper(...))[2];  // NOLINT
00123 
00124 // A compile-time bool constant that is true if and only if x is a
00125 // null pointer literal (i.e. NULL or any 0-valued compile-time
00126 // integral constant).
00127 #ifdef GTEST_ELLIPSIS_NEEDS_POD_
00128 // We lose support for NULL detection where the compiler doesn't like
00129 // passing non-POD classes through ellipsis (...).
00130 # define GTEST_IS_NULL_LITERAL_(x) false
00131 #else
00132 # define GTEST_IS_NULL_LITERAL_(x) \
00133     (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)
00134 #endif  // GTEST_ELLIPSIS_NEEDS_POD_
00135 
00136 // Appends the user-supplied message to the Google-Test-generated message.
00137 GTEST_API_ std::string AppendUserMessage(
00138     const std::string& gtest_msg, const Message& user_msg);
00139 
00140 #if GTEST_HAS_EXCEPTIONS
00141 
00142 // This exception is thrown by (and only by) a failed Google Test
00143 // assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
00144 // are enabled).  We derive it from std::runtime_error, which is for
00145 // errors presumably detectable only at run time.  Since
00146 // std::runtime_error inherits from std::exception, many testing
00147 // frameworks know how to extract and print the message inside it.
00148 class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
00149  public:
00150   explicit GoogleTestFailureException(const TestPartResult& failure);
00151 };
00152 
00153 #endif  // GTEST_HAS_EXCEPTIONS
00154 
00155 // A helper class for creating scoped traces in user programs.
00156 class GTEST_API_ ScopedTrace {
00157  public:
00158   // The c'tor pushes the given source file location and message onto
00159   // a trace stack maintained by Google Test.
00160   ScopedTrace(const char* file, int line, const Message& message);
00161 
00162   // The d'tor pops the info pushed by the c'tor.
00163   //
00164   // Note that the d'tor is not virtual in order to be efficient.
00165   // Don't inherit from ScopedTrace!
00166   ~ScopedTrace();
00167 
00168  private:
00169   GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
00170 } GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
00171                             // c'tor and d'tor.  Therefore it doesn't
00172                             // need to be used otherwise.
00173 
00174 // Constructs and returns the message for an equality assertion
00175 // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
00176 //
00177 // The first four parameters are the expressions used in the assertion
00178 // and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
00179 // where foo is 5 and bar is 6, we have:
00180 //
00181 //   expected_expression: "foo"
00182 //   actual_expression:   "bar"
00183 //   expected_value:      "5"
00184 //   actual_value:        "6"
00185 //
00186 // The ignoring_case parameter is true iff the assertion is a
00187 // *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
00188 // be inserted into the message.
00189 GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
00190                                      const char* actual_expression,
00191                                      const std::string& expected_value,
00192                                      const std::string& actual_value,
00193                                      bool ignoring_case);
00194 
00195 // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
00196 GTEST_API_ std::string GetBoolAssertionFailureMessage(
00197     const AssertionResult& assertion_result,
00198     const char* expression_text,
00199     const char* actual_predicate_value,
00200     const char* expected_predicate_value);
00201 
00202 // This template class represents an IEEE floating-point number
00203 // (either single-precision or double-precision, depending on the
00204 // template parameters).
00205 //
00206 // The purpose of this class is to do more sophisticated number
00207 // comparison.  (Due to round-off error, etc, it's very unlikely that
00208 // two floating-points will be equal exactly.  Hence a naive
00209 // comparison by the == operation often doesn't work.)
00210 //
00211 // Format of IEEE floating-point:
00212 //
00213 //   The most-significant bit being the leftmost, an IEEE
00214 //   floating-point looks like
00215 //
00216 //     sign_bit exponent_bits fraction_bits
00217 //
00218 //   Here, sign_bit is a single bit that designates the sign of the
00219 //   number.
00220 //
00221 //   For float, there are 8 exponent bits and 23 fraction bits.
00222 //
00223 //   For double, there are 11 exponent bits and 52 fraction bits.
00224 //
00225 //   More details can be found at
00226 //   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
00227 //
00228 // Template parameter:
00229 //
00230 //   RawType: the raw floating-point type (either float or double)
00231 template <typename RawType>
00232 class FloatingPoint {
00233  public:
00234   // Defines the unsigned integer type that has the same size as the
00235   // floating point number.
00236   typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
00237 
00238   // Constants.
00239 
00240   // # of bits in a number.
00241   static const size_t kBitCount = 8*sizeof(RawType);
00242 
00243   // # of fraction bits in a number.
00244   static const size_t kFractionBitCount =
00245     std::numeric_limits<RawType>::digits - 1;
00246 
00247   // # of exponent bits in a number.
00248   static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
00249 
00250   // The mask for the sign bit.
00251   static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
00252 
00253   // The mask for the fraction bits.
00254   static const Bits kFractionBitMask =
00255     ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
00256 
00257   // The mask for the exponent bits.
00258   static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
00259 
00260   // How many ULP's (Units in the Last Place) we want to tolerate when
00261   // comparing two numbers.  The larger the value, the more error we
00262   // allow.  A 0 value means that two numbers must be exactly the same
00263   // to be considered equal.
00264   //
00265   // The maximum error of a single floating-point operation is 0.5
00266   // units in the last place.  On Intel CPU's, all floating-point
00267   // calculations are done with 80-bit precision, while double has 64
00268   // bits.  Therefore, 4 should be enough for ordinary use.
00269   //
00270   // See the following article for more details on ULP:
00271   // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
00272   static const size_t kMaxUlps = 4;
00273 
00274   // Constructs a FloatingPoint from a raw floating-point number.
00275   //
00276   // On an Intel CPU, passing a non-normalized NAN (Not a Number)
00277   // around may change its bits, although the new value is guaranteed
00278   // to be also a NAN.  Therefore, don't expect this constructor to
00279   // preserve the bits in x when x is a NAN.
00280   explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
00281 
00282   // Static methods
00283 
00284   // Reinterprets a bit pattern as a floating-point number.
00285   //
00286   // This function is needed to test the AlmostEquals() method.
00287   static RawType ReinterpretBits(const Bits bits) {
00288     FloatingPoint fp(0);
00289     fp.u_.bits_ = bits;
00290     return fp.u_.value_;
00291   }
00292 
00293   // Returns the floating-point number that represent positive infinity.
00294   static RawType Infinity() {
00295     return ReinterpretBits(kExponentBitMask);
00296   }
00297 
00298   // Returns the maximum representable finite floating-point number.
00299   static RawType Max();
00300 
00301   // Non-static methods
00302 
00303   // Returns the bits that represents this number.
00304   const Bits &bits() const { return u_.bits_; }
00305 
00306   // Returns the exponent bits of this number.
00307   Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
00308 
00309   // Returns the fraction bits of this number.
00310   Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
00311 
00312   // Returns the sign bit of this number.
00313   Bits sign_bit() const { return kSignBitMask & u_.bits_; }
00314 
00315   // Returns true iff this is NAN (not a number).
00316   bool is_nan() const {
00317     // It's a NAN if the exponent bits are all ones and the fraction
00318     // bits are not entirely zeros.
00319     return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
00320   }
00321 
00322   // Returns true iff this number is at most kMaxUlps ULP's away from
00323   // rhs.  In particular, this function:
00324   //
00325   //   - returns false if either number is (or both are) NAN.
00326   //   - treats really large numbers as almost equal to infinity.
00327   //   - thinks +0.0 and -0.0 are 0 DLP's apart.
00328   bool AlmostEquals(const FloatingPoint& rhs) const {
00329     // The IEEE standard says that any comparison operation involving
00330     // a NAN must return false.
00331     if (is_nan() || rhs.is_nan()) return false;
00332 
00333     return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
00334         <= kMaxUlps;
00335   }
00336 
00337  private:
00338   // The data type used to store the actual floating-point number.
00339   union FloatingPointUnion {
00340     RawType value_;  // The raw floating-point number.
00341     Bits bits_;      // The bits that represent the number.
00342   };
00343 
00344   // Converts an integer from the sign-and-magnitude representation to
00345   // the biased representation.  More precisely, let N be 2 to the
00346   // power of (kBitCount - 1), an integer x is represented by the
00347   // unsigned number x + N.
00348   //
00349   // For instance,
00350   //
00351   //   -N + 1 (the most negative number representable using
00352   //          sign-and-magnitude) is represented by 1;
00353   //   0      is represented by N; and
00354   //   N - 1  (the biggest number representable using
00355   //          sign-and-magnitude) is represented by 2N - 1.
00356   //
00357   // Read http://en.wikipedia.org/wiki/Signed_number_representations
00358   // for more details on signed number representations.
00359   static Bits SignAndMagnitudeToBiased(const Bits &sam) {
00360     if (kSignBitMask & sam) {
00361       // sam represents a negative number.
00362       return ~sam + 1;
00363     } else {
00364       // sam represents a positive number.
00365       return kSignBitMask | sam;
00366     }
00367   }
00368 
00369   // Given two numbers in the sign-and-magnitude representation,
00370   // returns the distance between them as an unsigned number.
00371   static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
00372                                                      const Bits &sam2) {
00373     const Bits biased1 = SignAndMagnitudeToBiased(sam1);
00374     const Bits biased2 = SignAndMagnitudeToBiased(sam2);
00375     return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
00376   }
00377 
00378   FloatingPointUnion u_;
00379 };
00380 
00381 // We cannot use std::numeric_limits<T>::max() as it clashes with the max()
00382 // macro defined by <windows.h>.
00383 template <>
00384 inline float FloatingPoint<float>::Max() { return FLT_MAX; }
00385 template <>
00386 inline double FloatingPoint<double>::Max() { return DBL_MAX; }
00387 
00388 // Typedefs the instances of the FloatingPoint template class that we
00389 // care to use.
00390 typedef FloatingPoint<float> Float;
00391 typedef FloatingPoint<double> Double;
00392 
00393 // In order to catch the mistake of putting tests that use different
00394 // test fixture classes in the same test case, we need to assign
00395 // unique IDs to fixture classes and compare them.  The TypeId type is
00396 // used to hold such IDs.  The user should treat TypeId as an opaque
00397 // type: the only operation allowed on TypeId values is to compare
00398 // them for equality using the == operator.
00399 typedef const void* TypeId;
00400 
00401 template <typename T>
00402 class TypeIdHelper {
00403  public:
00404   // dummy_ must not have a const type.  Otherwise an overly eager
00405   // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
00406   // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
00407   static bool dummy_;
00408 };
00409 
00410 template <typename T>
00411 bool TypeIdHelper<T>::dummy_ = false;
00412 
00413 // GetTypeId<T>() returns the ID of type T.  Different values will be
00414 // returned for different types.  Calling the function twice with the
00415 // same type argument is guaranteed to return the same ID.
00416 template <typename T>
00417 TypeId GetTypeId() {
00418   // The compiler is required to allocate a different
00419   // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
00420   // the template.  Therefore, the address of dummy_ is guaranteed to
00421   // be unique.
00422   return &(TypeIdHelper<T>::dummy_);
00423 }
00424 
00425 // Returns the type ID of ::testing::Test.  Always call this instead
00426 // of GetTypeId< ::testing::Test>() to get the type ID of
00427 // ::testing::Test, as the latter may give the wrong result due to a
00428 // suspected linker bug when compiling Google Test as a Mac OS X
00429 // framework.
00430 GTEST_API_ TypeId GetTestTypeId();
00431 
00432 // Defines the abstract factory interface that creates instances
00433 // of a Test object.
00434 class TestFactoryBase {
00435  public:
00436   virtual ~TestFactoryBase() {}
00437 
00438   // Creates a test instance to run. The instance is both created and destroyed
00439   // within TestInfoImpl::Run()
00440   virtual Test* CreateTest() = 0;
00441 
00442  protected:
00443   TestFactoryBase() {}
00444 
00445  private:
00446   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
00447 };
00448 
00449 // This class provides implementation of TeastFactoryBase interface.
00450 // It is used in TEST and TEST_F macros.
00451 template <class TestClass>
00452 class TestFactoryImpl : public TestFactoryBase {
00453  public:
00454   virtual Test* CreateTest() { return new TestClass; }
00455 };
00456 
00457 #if GTEST_OS_WINDOWS
00458 
00459 // Predicate-formatters for implementing the HRESULT checking macros
00460 // {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
00461 // We pass a long instead of HRESULT to avoid causing an
00462 // include dependency for the HRESULT type.
00463 GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
00464                                             long hr);  // NOLINT
00465 GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
00466                                             long hr);  // NOLINT
00467 
00468 #endif  // GTEST_OS_WINDOWS
00469 
00470 // Types of SetUpTestCase() and TearDownTestCase() functions.
00471 typedef void (*SetUpTestCaseFunc)();
00472 typedef void (*TearDownTestCaseFunc)();
00473 
00474 // Creates a new TestInfo object and registers it with Google Test;
00475 // returns the created object.
00476 //
00477 // Arguments:
00478 //
00479 //   test_case_name:   name of the test case
00480 //   name:             name of the test
00481 //   type_param        the name of the test's type parameter, or NULL if
00482 //                     this is not a typed or a type-parameterized test.
00483 //   value_param       text representation of the test's value parameter,
00484 //                     or NULL if this is not a type-parameterized test.
00485 //   fixture_class_id: ID of the test fixture class
00486 //   set_up_tc:        pointer to the function that sets up the test case
00487 //   tear_down_tc:     pointer to the function that tears down the test case
00488 //   factory:          pointer to the factory that creates a test object.
00489 //                     The newly created TestInfo instance will assume
00490 //                     ownership of the factory object.
00491 GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
00492     const char* test_case_name,
00493     const char* name,
00494     const char* type_param,
00495     const char* value_param,
00496     TypeId fixture_class_id,
00497     SetUpTestCaseFunc set_up_tc,
00498     TearDownTestCaseFunc tear_down_tc,
00499     TestFactoryBase* factory);
00500 
00501 // If *pstr starts with the given prefix, modifies *pstr to be right
00502 // past the prefix and returns true; otherwise leaves *pstr unchanged
00503 // and returns false.  None of pstr, *pstr, and prefix can be NULL.
00504 GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);
00505 
00506 #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
00507 
00508 // State of the definition of a type-parameterized test case.
00509 class GTEST_API_ TypedTestCasePState {
00510  public:
00511   TypedTestCasePState() : registered_(false) {}
00512 
00513   // Adds the given test name to defined_test_names_ and return true
00514   // if the test case hasn't been registered; otherwise aborts the
00515   // program.
00516   bool AddTestName(const char* file, int line, const char* case_name,
00517                    const char* test_name) {
00518     if (registered_) {
00519       fprintf(stderr, "%s Test %s must be defined before "
00520               "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n",
00521               FormatFileLocation(file, line).c_str(), test_name, case_name);
00522       fflush(stderr);
00523       posix::Abort();
00524     }
00525     defined_test_names_.insert(test_name);
00526     return true;
00527   }
00528 
00529   // Verifies that registered_tests match the test names in
00530   // defined_test_names_; returns registered_tests if successful, or
00531   // aborts the program otherwise.
00532   const char* VerifyRegisteredTestNames(
00533       const char* file, int line, const char* registered_tests);
00534 
00535  private:
00536   bool registered_;
00537   ::std::set<const char*> defined_test_names_;
00538 };
00539 
00540 // Skips to the first non-space char after the first comma in 'str';
00541 // returns NULL if no comma is found in 'str'.
00542 inline const char* SkipComma(const char* str) {
00543   const char* comma = strchr(str, ',');
00544   if (comma == NULL) {
00545     return NULL;
00546   }
00547   while (IsSpace(*(++comma))) {}
00548   return comma;
00549 }
00550 
00551 // Returns the prefix of 'str' before the first comma in it; returns
00552 // the entire string if it contains no comma.
00553 inline std::string GetPrefixUntilComma(const char* str) {
00554   const char* comma = strchr(str, ',');
00555   return comma == NULL ? str : std::string(str, comma);
00556 }
00557 
00558 // TypeParameterizedTest<Fixture, TestSel, Types>::Register()
00559 // registers a list of type-parameterized tests with Google Test.  The
00560 // return value is insignificant - we just need to return something
00561 // such that we can call this function in a namespace scope.
00562 //
00563 // Implementation note: The GTEST_TEMPLATE_ macro declares a template
00564 // template parameter.  It's defined in gtest-type-util.h.
00565 template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
00566 class TypeParameterizedTest {
00567  public:
00568   // 'index' is the index of the test in the type list 'Types'
00569   // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase,
00570   // Types).  Valid values for 'index' are [0, N - 1] where N is the
00571   // length of Types.
00572   static bool Register(const char* prefix, const char* case_name,
00573                        const char* test_names, int index) {
00574     typedef typename Types::Head Type;
00575     typedef Fixture<Type> FixtureClass;
00576     typedef typename GTEST_BIND_(TestSel, Type) TestClass;
00577 
00578     // First, registers the first type-parameterized test in the type
00579     // list.
00580     MakeAndRegisterTestInfo(
00581         (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
00582          + StreamableToString(index)).c_str(),
00583         GetPrefixUntilComma(test_names).c_str(),
00584         GetTypeName<Type>().c_str(),
00585         NULL,  // No value parameter.
00586         GetTypeId<FixtureClass>(),
00587         TestClass::SetUpTestCase,
00588         TestClass::TearDownTestCase,
00589         new TestFactoryImpl<TestClass>);
00590 
00591     // Next, recurses (at compile time) with the tail of the type list.
00592     return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail>
00593         ::Register(prefix, case_name, test_names, index + 1);
00594   }
00595 };
00596 
00597 // The base case for the compile time recursion.
00598 template <GTEST_TEMPLATE_ Fixture, class TestSel>
00599 class TypeParameterizedTest<Fixture, TestSel, Types0> {
00600  public:
00601   static bool Register(const char* /*prefix*/, const char* /*case_name*/,
00602                        const char* /*test_names*/, int /*index*/) {
00603     return true;
00604   }
00605 };
00606 
00607 // TypeParameterizedTestCase<Fixture, Tests, Types>::Register()
00608 // registers *all combinations* of 'Tests' and 'Types' with Google
00609 // Test.  The return value is insignificant - we just need to return
00610 // something such that we can call this function in a namespace scope.
00611 template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
00612 class TypeParameterizedTestCase {
00613  public:
00614   static bool Register(const char* prefix, const char* case_name,
00615                        const char* test_names) {
00616     typedef typename Tests::Head Head;
00617 
00618     // First, register the first test in 'Test' for each type in 'Types'.
00619     TypeParameterizedTest<Fixture, Head, Types>::Register(
00620         prefix, case_name, test_names, 0);
00621 
00622     // Next, recurses (at compile time) with the tail of the test list.
00623     return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types>
00624         ::Register(prefix, case_name, SkipComma(test_names));
00625   }
00626 };
00627 
00628 // The base case for the compile time recursion.
00629 template <GTEST_TEMPLATE_ Fixture, typename Types>
00630 class TypeParameterizedTestCase<Fixture, Templates0, Types> {
00631  public:
00632   static bool Register(const char* /*prefix*/, const char* /*case_name*/,
00633                        const char* /*test_names*/) {
00634     return true;
00635   }
00636 };
00637 
00638 #endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
00639 
00640 // Returns the current OS stack trace as an std::string.
00641 //
00642 // The maximum number of stack frames to be included is specified by
00643 // the gtest_stack_trace_depth flag.  The skip_count parameter
00644 // specifies the number of top frames to be skipped, which doesn't
00645 // count against the number of frames to be included.
00646 //
00647 // For example, if Foo() calls Bar(), which in turn calls
00648 // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
00649 // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
00650 GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
00651     UnitTest* unit_test, int skip_count);
00652 
00653 // Helpers for suppressing warnings on unreachable code or constant
00654 // condition.
00655 
00656 // Always returns true.
00657 GTEST_API_ bool AlwaysTrue();
00658 
00659 // Always returns false.
00660 inline bool AlwaysFalse() { return !AlwaysTrue(); }
00661 
00662 // Helper for suppressing false warning from Clang on a const char*
00663 // variable declared in a conditional expression always being NULL in
00664 // the else branch.
00665 struct GTEST_API_ ConstCharPtr {
00666   ConstCharPtr(const char* str) : value(str) {}
00667   operator bool() const { return true; }
00668   const char* value;
00669 };
00670 
00671 // A simple Linear Congruential Generator for generating random
00672 // numbers with a uniform distribution.  Unlike rand() and srand(), it
00673 // doesn't use global state (and therefore can't interfere with user
00674 // code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
00675 // but it's good enough for our purposes.
00676 class GTEST_API_ Random {
00677  public:
00678   static const UInt32 kMaxRange = 1u << 31;
00679 
00680   explicit Random(UInt32 seed) : state_(seed) {}
00681 
00682   void Reseed(UInt32 seed) { state_ = seed; }
00683 
00684   // Generates a random number from [0, range).  Crashes if 'range' is
00685   // 0 or greater than kMaxRange.
00686   UInt32 Generate(UInt32 range);
00687 
00688  private:
00689   UInt32 state_;
00690   GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
00691 };
00692 
00693 // Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a
00694 // compiler error iff T1 and T2 are different types.
00695 template <typename T1, typename T2>
00696 struct CompileAssertTypesEqual;
00697 
00698 template <typename T>
00699 struct CompileAssertTypesEqual<T, T> {
00700 };
00701 
00702 // Removes the reference from a type if it is a reference type,
00703 // otherwise leaves it unchanged.  This is the same as
00704 // tr1::remove_reference, which is not widely available yet.
00705 template <typename T>
00706 struct RemoveReference { typedef T type; };  // NOLINT
00707 template <typename T>
00708 struct RemoveReference<T&> { typedef T type; };  // NOLINT
00709 
00710 // A handy wrapper around RemoveReference that works when the argument
00711 // T depends on template parameters.
00712 #define GTEST_REMOVE_REFERENCE_(T) \
00713     typename ::testing::internal::RemoveReference<T>::type
00714 
00715 // Removes const from a type if it is a const type, otherwise leaves
00716 // it unchanged.  This is the same as tr1::remove_const, which is not
00717 // widely available yet.
00718 template <typename T>
00719 struct RemoveConst { typedef T type; };  // NOLINT
00720 template <typename T>
00721 struct RemoveConst<const T> { typedef T type; };  // NOLINT
00722 
00723 // MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
00724 // definition to fail to remove the const in 'const int[3]' and 'const
00725 // char[3][4]'.  The following specialization works around the bug.
00726 template <typename T, size_t N>
00727 struct RemoveConst<const T[N]> {
00728   typedef typename RemoveConst<T>::type type[N];
00729 };
00730 
00731 #if defined(_MSC_VER) && _MSC_VER < 1400
00732 // This is the only specialization that allows VC++ 7.1 to remove const in
00733 // 'const int[3] and 'const int[3][4]'.  However, it causes trouble with GCC
00734 // and thus needs to be conditionally compiled.
00735 template <typename T, size_t N>
00736 struct RemoveConst<T[N]> {
00737   typedef typename RemoveConst<T>::type type[N];
00738 };
00739 #endif
00740 
00741 // A handy wrapper around RemoveConst that works when the argument
00742 // T depends on template parameters.
00743 #define GTEST_REMOVE_CONST_(T) \
00744     typename ::testing::internal::RemoveConst<T>::type
00745 
00746 // Turns const U&, U&, const U, and U all into U.
00747 #define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
00748     GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))
00749 
00750 // Adds reference to a type if it is not a reference type,
00751 // otherwise leaves it unchanged.  This is the same as
00752 // tr1::add_reference, which is not widely available yet.
00753 template <typename T>
00754 struct AddReference { typedef T& type; };  // NOLINT
00755 template <typename T>
00756 struct AddReference<T&> { typedef T& type; };  // NOLINT
00757 
00758 // A handy wrapper around AddReference that works when the argument T
00759 // depends on template parameters.
00760 #define GTEST_ADD_REFERENCE_(T) \
00761     typename ::testing::internal::AddReference<T>::type
00762 
00763 // Adds a reference to const on top of T as necessary.  For example,
00764 // it transforms
00765 //
00766 //   char         ==> const char&
00767 //   const char   ==> const char&
00768 //   char&        ==> const char&
00769 //   const char&  ==> const char&
00770 //
00771 // The argument T must depend on some template parameters.
00772 #define GTEST_REFERENCE_TO_CONST_(T) \
00773     GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T))
00774 
00775 // ImplicitlyConvertible<From, To>::value is a compile-time bool
00776 // constant that's true iff type From can be implicitly converted to
00777 // type To.
00778 template <typename From, typename To>
00779 class ImplicitlyConvertible {
00780  private:
00781   // We need the following helper functions only for their types.
00782   // They have no implementations.
00783 
00784   // MakeFrom() is an expression whose type is From.  We cannot simply
00785   // use From(), as the type From may not have a public default
00786   // constructor.
00787   static From MakeFrom();
00788 
00789   // These two functions are overloaded.  Given an expression
00790   // Helper(x), the compiler will pick the first version if x can be
00791   // implicitly converted to type To; otherwise it will pick the
00792   // second version.
00793   //
00794   // The first version returns a value of size 1, and the second
00795   // version returns a value of size 2.  Therefore, by checking the
00796   // size of Helper(x), which can be done at compile time, we can tell
00797   // which version of Helper() is used, and hence whether x can be
00798   // implicitly converted to type To.
00799   static char Helper(To);
00800   static char (&Helper(...))[2];  // NOLINT
00801 
00802   // We have to put the 'public' section after the 'private' section,
00803   // or MSVC refuses to compile the code.
00804  public:
00805   // MSVC warns about implicitly converting from double to int for
00806   // possible loss of data, so we need to temporarily disable the
00807   // warning.
00808 #ifdef _MSC_VER
00809 # pragma warning(push)          // Saves the current warning state.
00810 # pragma warning(disable:4244)  // Temporarily disables warning 4244.
00811 
00812   static const bool value =
00813       sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
00814 # pragma warning(pop)           // Restores the warning state.
00815 #elif defined(__BORLANDC__)
00816   // C++Builder cannot use member overload resolution during template
00817   // instantiation.  The simplest workaround is to use its C++0x type traits
00818   // functions (C++Builder 2009 and above only).
00819   static const bool value = __is_convertible(From, To);
00820 #else
00821   static const bool value =
00822       sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
00823 #endif  // _MSV_VER
00824 };
00825 template <typename From, typename To>
00826 const bool ImplicitlyConvertible<From, To>::value;
00827 
00828 // IsAProtocolMessage<T>::value is a compile-time bool constant that's
00829 // true iff T is type ProtocolMessage, proto2::Message, or a subclass
00830 // of those.
00831 template <typename T>
00832 struct IsAProtocolMessage
00833     : public bool_constant<
00834   ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value ||
00835   ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> {
00836 };
00837 
00838 // When the compiler sees expression IsContainerTest<C>(0), if C is an
00839 // STL-style container class, the first overload of IsContainerTest
00840 // will be viable (since both C::iterator* and C::const_iterator* are
00841 // valid types and NULL can be implicitly converted to them).  It will
00842 // be picked over the second overload as 'int' is a perfect match for
00843 // the type of argument 0.  If C::iterator or C::const_iterator is not
00844 // a valid type, the first overload is not viable, and the second
00845 // overload will be picked.  Therefore, we can determine whether C is
00846 // a container class by checking the type of IsContainerTest<C>(0).
00847 // The value of the expression is insignificant.
00848 //
00849 // Note that we look for both C::iterator and C::const_iterator.  The
00850 // reason is that C++ injects the name of a class as a member of the
00851 // class itself (e.g. you can refer to class iterator as either
00852 // 'iterator' or 'iterator::iterator').  If we look for C::iterator
00853 // only, for example, we would mistakenly think that a class named
00854 // iterator is an STL container.
00855 //
00856 // Also note that the simpler approach of overloading
00857 // IsContainerTest(typename C::const_iterator*) and
00858 // IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
00859 typedef int IsContainer;
00860 template <class C>
00861 IsContainer IsContainerTest(int /* dummy */,
00862                             typename C::iterator* /* it */ = NULL,
00863                             typename C::const_iterator* /* const_it */ = NULL) {
00864   return 0;
00865 }
00866 
00867 typedef char IsNotContainer;
00868 template <class C>
00869 IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
00870 
00871 // EnableIf<condition>::type is void when 'Cond' is true, and
00872 // undefined when 'Cond' is false.  To use SFINAE to make a function
00873 // overload only apply when a particular expression is true, add
00874 // "typename EnableIf<expression>::type* = 0" as the last parameter.
00875 template<bool> struct EnableIf;
00876 template<> struct EnableIf<true> { typedef void type; };  // NOLINT
00877 
00878 // Utilities for native arrays.
00879 
00880 // ArrayEq() compares two k-dimensional native arrays using the
00881 // elements' operator==, where k can be any integer >= 0.  When k is
00882 // 0, ArrayEq() degenerates into comparing a single pair of values.
00883 
00884 template <typename T, typename U>
00885 bool ArrayEq(const T* lhs, size_t size, const U* rhs);
00886 
00887 // This generic version is used when k is 0.
00888 template <typename T, typename U>
00889 inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
00890 
00891 // This overload is used when k >= 1.
00892 template <typename T, typename U, size_t N>
00893 inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
00894   return internal::ArrayEq(lhs, N, rhs);
00895 }
00896 
00897 // This helper reduces code bloat.  If we instead put its logic inside
00898 // the previous ArrayEq() function, arrays with different sizes would
00899 // lead to different copies of the template code.
00900 template <typename T, typename U>
00901 bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
00902   for (size_t i = 0; i != size; i++) {
00903     if (!internal::ArrayEq(lhs[i], rhs[i]))
00904       return false;
00905   }
00906   return true;
00907 }
00908 
00909 // Finds the first element in the iterator range [begin, end) that
00910 // equals elem.  Element may be a native array type itself.
00911 template <typename Iter, typename Element>
00912 Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
00913   for (Iter it = begin; it != end; ++it) {
00914     if (internal::ArrayEq(*it, elem))
00915       return it;
00916   }
00917   return end;
00918 }
00919 
00920 // CopyArray() copies a k-dimensional native array using the elements'
00921 // operator=, where k can be any integer >= 0.  When k is 0,
00922 // CopyArray() degenerates into copying a single value.
00923 
00924 template <typename T, typename U>
00925 void CopyArray(const T* from, size_t size, U* to);
00926 
00927 // This generic version is used when k is 0.
00928 template <typename T, typename U>
00929 inline void CopyArray(const T& from, U* to) { *to = from; }
00930 
00931 // This overload is used when k >= 1.
00932 template <typename T, typename U, size_t N>
00933 inline void CopyArray(const T(&from)[N], U(*to)[N]) {
00934   internal::CopyArray(from, N, *to);
00935 }
00936 
00937 // This helper reduces code bloat.  If we instead put its logic inside
00938 // the previous CopyArray() function, arrays with different sizes
00939 // would lead to different copies of the template code.
00940 template <typename T, typename U>
00941 void CopyArray(const T* from, size_t size, U* to) {
00942   for (size_t i = 0; i != size; i++) {
00943     internal::CopyArray(from[i], to + i);
00944   }
00945 }
00946 
00947 // The relation between an NativeArray object (see below) and the
00948 // native array it represents.
00949 enum RelationToSource {
00950   kReference,  // The NativeArray references the native array.
00951   kCopy        // The NativeArray makes a copy of the native array and
00952                // owns the copy.
00953 };
00954 
00955 // Adapts a native array to a read-only STL-style container.  Instead
00956 // of the complete STL container concept, this adaptor only implements
00957 // members useful for Google Mock's container matchers.  New members
00958 // should be added as needed.  To simplify the implementation, we only
00959 // support Element being a raw type (i.e. having no top-level const or
00960 // reference modifier).  It's the client's responsibility to satisfy
00961 // this requirement.  Element can be an array type itself (hence
00962 // multi-dimensional arrays are supported).
00963 template <typename Element>
00964 class NativeArray {
00965  public:
00966   // STL-style container typedefs.
00967   typedef Element value_type;
00968   typedef Element* iterator;
00969   typedef const Element* const_iterator;
00970 
00971   // Constructs from a native array.
00972   NativeArray(const Element* array, size_t count, RelationToSource relation) {
00973     Init(array, count, relation);
00974   }
00975 
00976   // Copy constructor.
00977   NativeArray(const NativeArray& rhs) {
00978     Init(rhs.array_, rhs.size_, rhs.relation_to_source_);
00979   }
00980 
00981   ~NativeArray() {
00982     // Ensures that the user doesn't instantiate NativeArray with a
00983     // const or reference type.
00984     static_cast<void>(StaticAssertTypeEqHelper<Element,
00985         GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>());
00986     if (relation_to_source_ == kCopy)
00987       delete[] array_;
00988   }
00989 
00990   // STL-style container methods.
00991   size_t size() const { return size_; }
00992   const_iterator begin() const { return array_; }
00993   const_iterator end() const { return array_ + size_; }
00994   bool operator==(const NativeArray& rhs) const {
00995     return size() == rhs.size() &&
00996         ArrayEq(begin(), size(), rhs.begin());
00997   }
00998 
00999  private:
01000   // Initializes this object; makes a copy of the input array if
01001   // 'relation' is kCopy.
01002   void Init(const Element* array, size_t a_size, RelationToSource relation) {
01003     if (relation == kReference) {
01004       array_ = array;
01005     } else {
01006       Element* const copy = new Element[a_size];
01007       CopyArray(array, a_size, copy);
01008       array_ = copy;
01009     }
01010     size_ = a_size;
01011     relation_to_source_ = relation;
01012   }
01013 
01014   const Element* array_;
01015   size_t size_;
01016   RelationToSource relation_to_source_;
01017 
01018   GTEST_DISALLOW_ASSIGN_(NativeArray);
01019 };
01020 
01021 }  // namespace internal
01022 }  // namespace testing
01023 
01024 #define GTEST_MESSAGE_AT_(file, line, message, result_type) \
01025   ::testing::internal::AssertHelper(result_type, file, line, message) \
01026     = ::testing::Message()
01027 
01028 #define GTEST_MESSAGE_(message, result_type) \
01029   GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
01030 
01031 #define GTEST_FATAL_FAILURE_(message) \
01032   return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
01033 
01034 #define GTEST_NONFATAL_FAILURE_(message) \
01035   GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
01036 
01037 #define GTEST_SUCCESS_(message) \
01038   GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
01039 
01040 // Suppresses MSVC warnings 4072 (unreachable code) for the code following
01041 // statement if it returns or throws (or doesn't return or throw in some
01042 // situations).
01043 #define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
01044   if (::testing::internal::AlwaysTrue()) { statement; }
01045 
01046 #define GTEST_TEST_THROW_(statement, expected_exception, fail) \
01047   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
01048   if (::testing::internal::ConstCharPtr gtest_msg = "") { \
01049     bool gtest_caught_expected = false; \
01050     try { \
01051       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
01052     } \
01053     catch (expected_exception const&) { \
01054       gtest_caught_expected = true; \
01055     } \
01056     catch (...) { \
01057       gtest_msg.value = \
01058           "Expected: " #statement " throws an exception of type " \
01059           #expected_exception ".\n  Actual: it throws a different type."; \
01060       goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
01061     } \
01062     if (!gtest_caught_expected) { \
01063       gtest_msg.value = \
01064           "Expected: " #statement " throws an exception of type " \
01065           #expected_exception ".\n  Actual: it throws nothing."; \
01066       goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
01067     } \
01068   } else \
01069     GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
01070       fail(gtest_msg.value)
01071 
01072 #define GTEST_TEST_NO_THROW_(statement, fail) \
01073   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
01074   if (::testing::internal::AlwaysTrue()) { \
01075     try { \
01076       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
01077     } \
01078     catch (...) { \
01079       goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
01080     } \
01081   } else \
01082     GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
01083       fail("Expected: " #statement " doesn't throw an exception.\n" \
01084            "  Actual: it throws.")
01085 
01086 #define GTEST_TEST_ANY_THROW_(statement, fail) \
01087   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
01088   if (::testing::internal::AlwaysTrue()) { \
01089     bool gtest_caught_any = false; \
01090     try { \
01091       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
01092     } \
01093     catch (...) { \
01094       gtest_caught_any = true; \
01095     } \
01096     if (!gtest_caught_any) { \
01097       goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
01098     } \
01099   } else \
01100     GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
01101       fail("Expected: " #statement " throws an exception.\n" \
01102            "  Actual: it doesn't.")
01103 
01104 
01105 // Implements Boolean test assertions such as EXPECT_TRUE. expression can be
01106 // either a boolean expression or an AssertionResult. text is a textual
01107 // represenation of expression as it was passed into the EXPECT_TRUE.
01108 #define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
01109   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
01110   if (const ::testing::AssertionResult gtest_ar_ = \
01111       ::testing::AssertionResult(expression)) \
01112     ; \
01113   else \
01114     fail(::testing::internal::GetBoolAssertionFailureMessage(\
01115         gtest_ar_, text, #actual, #expected).c_str())
01116 
01117 #define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
01118   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
01119   if (::testing::internal::AlwaysTrue()) { \
01120     ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
01121     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
01122     if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
01123       goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
01124     } \
01125   } else \
01126     GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
01127       fail("Expected: " #statement " doesn't generate new fatal " \
01128            "failures in the current thread.\n" \
01129            "  Actual: it does.")
01130 
01131 // Expands to the name of the class that implements the given test.
01132 #define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
01133   test_case_name##_##test_name##_Test
01134 
01135 // Helper macro for defining tests.
01136 #define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
01137 class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
01138  public:\
01139   GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
01140  private:\
01141   virtual void TestBody();\
01142   static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
01143   GTEST_DISALLOW_COPY_AND_ASSIGN_(\
01144       GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
01145 };\
01146 \
01147 ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
01148   ::test_info_ =\
01149     ::testing::internal::MakeAndRegisterTestInfo(\
01150         #test_case_name, #test_name, NULL, NULL, \
01151         (parent_id), \
01152         parent_class::SetUpTestCase, \
01153         parent_class::TearDownTestCase, \
01154         new ::testing::internal::TestFactoryImpl<\
01155             GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
01156 void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
01157 
01158 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_