"Fossies" - the Fresh Open Source Software Archive

Member "CSSC-1.4.1/unit-tests/googletest/include/gtest/internal/gtest-internal.h" (28 Feb 2016, 44124 Bytes) of package /linux/privat/CSSC-1.4.1.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "gtest-internal.h" see the Fossies "Dox" file reference documentation.

    1 // Copyright 2005, Google Inc.
    2 // All rights reserved.
    3 //
    4 // Redistribution and use in source and binary forms, with or without
    5 // modification, are permitted provided that the following conditions are
    6 // met:
    7 //
    8 //     * Redistributions of source code must retain the above copyright
    9 // notice, this list of conditions and the following disclaimer.
   10 //     * Redistributions in binary form must reproduce the above
   11 // copyright notice, this list of conditions and the following disclaimer
   12 // in the documentation and/or other materials provided with the
   13 // distribution.
   14 //     * Neither the name of Google Inc. nor the names of its
   15 // contributors may be used to endorse or promote products derived from
   16 // this software without specific prior written permission.
   17 //
   18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   29 //
   30 // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
   31 //
   32 // The Google C++ Testing Framework (Google Test)
   33 //
   34 // This header file declares functions and macros used internally by
   35 // Google Test.  They are subject to change without notice.
   36 
   37 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
   38 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
   39 
   40 #include "gtest/internal/gtest-port.h"
   41 
   42 #if GTEST_OS_LINUX
   43 # include <stdlib.h>
   44 # include <sys/types.h>
   45 # include <sys/wait.h>
   46 # include <unistd.h>
   47 #endif  // GTEST_OS_LINUX
   48 
   49 #if GTEST_HAS_EXCEPTIONS
   50 # include <stdexcept>
   51 #endif
   52 
   53 #include <ctype.h>
   54 #include <float.h>
   55 #include <string.h>
   56 #include <iomanip>
   57 #include <limits>
   58 #include <set>
   59 
   60 #include "gtest/gtest-message.h"
   61 #include "gtest/internal/gtest-string.h"
   62 #include "gtest/internal/gtest-filepath.h"
   63 #include "gtest/internal/gtest-type-util.h"
   64 
   65 // Due to C++ preprocessor weirdness, we need double indirection to
   66 // concatenate two tokens when one of them is __LINE__.  Writing
   67 //
   68 //   foo ## __LINE__
   69 //
   70 // will result in the token foo__LINE__, instead of foo followed by
   71 // the current line number.  For more details, see
   72 // http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
   73 #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
   74 #define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
   75 
   76 class ProtocolMessage;
   77 namespace proto2 { class Message; }
   78 
   79 namespace testing {
   80 
   81 // Forward declarations.
   82 
   83 class AssertionResult;                 // Result of an assertion.
   84 class Message;                         // Represents a failure message.
   85 class Test;                            // Represents a test.
   86 class TestInfo;                        // Information about a test.
   87 class TestPartResult;                  // Result of a test part.
   88 class UnitTest;                        // A collection of test cases.
   89 
   90 template <typename T>
   91 ::std::string PrintToString(const T& value);
   92 
   93 namespace internal {
   94 
   95 struct TraceInfo;                      // Information about a trace point.
   96 class ScopedTrace;                     // Implements scoped trace.
   97 class TestInfoImpl;                    // Opaque implementation of TestInfo
   98 class UnitTestImpl;                    // Opaque implementation of UnitTest
   99 
  100 // How many times InitGoogleTest() has been called.
  101 GTEST_API_ extern int g_init_gtest_count;
  102 
  103 // The text used in failure messages to indicate the start of the
  104 // stack trace.
  105 GTEST_API_ extern const char kStackTraceMarker[];
  106 
  107 // Two overloaded helpers for checking at compile time whether an
  108 // expression is a null pointer literal (i.e. NULL or any 0-valued
  109 // compile-time integral constant).  Their return values have
  110 // different sizes, so we can use sizeof() to test which version is
  111 // picked by the compiler.  These helpers have no implementations, as
  112 // we only need their signatures.
  113 //
  114 // Given IsNullLiteralHelper(x), the compiler will pick the first
  115 // version if x can be implicitly converted to Secret*, and pick the
  116 // second version otherwise.  Since Secret is a secret and incomplete
  117 // type, the only expression a user can write that has type Secret* is
  118 // a null pointer literal.  Therefore, we know that x is a null
  119 // pointer literal if and only if the first version is picked by the
  120 // compiler.
  121 char IsNullLiteralHelper(Secret* p);
  122 char (&IsNullLiteralHelper(...))[2];  // NOLINT
  123 
  124 // A compile-time bool constant that is true if and only if x is a
  125 // null pointer literal (i.e. NULL or any 0-valued compile-time
  126 // integral constant).
  127 #ifdef GTEST_ELLIPSIS_NEEDS_POD_
  128 // We lose support for NULL detection where the compiler doesn't like
  129 // passing non-POD classes through ellipsis (...).
  130 # define GTEST_IS_NULL_LITERAL_(x) false
  131 #else
  132 # define GTEST_IS_NULL_LITERAL_(x) \
  133     (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)
  134 #endif  // GTEST_ELLIPSIS_NEEDS_POD_
  135 
  136 // Appends the user-supplied message to the Google-Test-generated message.
  137 GTEST_API_ std::string AppendUserMessage(
  138     const std::string& gtest_msg, const Message& user_msg);
  139 
  140 #if GTEST_HAS_EXCEPTIONS
  141 
  142 // This exception is thrown by (and only by) a failed Google Test
  143 // assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
  144 // are enabled).  We derive it from std::runtime_error, which is for
  145 // errors presumably detectable only at run time.  Since
  146 // std::runtime_error inherits from std::exception, many testing
  147 // frameworks know how to extract and print the message inside it.
  148 class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
  149  public:
  150   explicit GoogleTestFailureException(const TestPartResult& failure);
  151 };
  152 
  153 #endif  // GTEST_HAS_EXCEPTIONS
  154 
  155 // A helper class for creating scoped traces in user programs.
  156 class GTEST_API_ ScopedTrace {
  157  public:
  158   // The c'tor pushes the given source file location and message onto
  159   // a trace stack maintained by Google Test.
  160   ScopedTrace(const char* file, int line, const Message& message);
  161 
  162   // The d'tor pops the info pushed by the c'tor.
  163   //
  164   // Note that the d'tor is not virtual in order to be efficient.
  165   // Don't inherit from ScopedTrace!
  166   ~ScopedTrace();
  167 
  168  private:
  169   GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
  170 } GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
  171                             // c'tor and d'tor.  Therefore it doesn't
  172                             // need to be used otherwise.
  173 
  174 // Constructs and returns the message for an equality assertion
  175 // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
  176 //
  177 // The first four parameters are the expressions used in the assertion
  178 // and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
  179 // where foo is 5 and bar is 6, we have:
  180 //
  181 //   expected_expression: "foo"
  182 //   actual_expression:   "bar"
  183 //   expected_value:      "5"
  184 //   actual_value:        "6"
  185 //
  186 // The ignoring_case parameter is true iff the assertion is a
  187 // *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
  188 // be inserted into the message.
  189 GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
  190                                      const char* actual_expression,
  191                                      const std::string& expected_value,
  192                                      const std::string& actual_value,
  193                                      bool ignoring_case);
  194 
  195 // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
  196 GTEST_API_ std::string GetBoolAssertionFailureMessage(
  197     const AssertionResult& assertion_result,
  198     const char* expression_text,
  199     const char* actual_predicate_value,
  200     const char* expected_predicate_value);
  201 
  202 // This template class represents an IEEE floating-point number
  203 // (either single-precision or double-precision, depending on the
  204 // template parameters).
  205 //
  206 // The purpose of this class is to do more sophisticated number
  207 // comparison.  (Due to round-off error, etc, it's very unlikely that
  208 // two floating-points will be equal exactly.  Hence a naive
  209 // comparison by the == operation often doesn't work.)
  210 //
  211 // Format of IEEE floating-point:
  212 //
  213 //   The most-significant bit being the leftmost, an IEEE
  214 //   floating-point looks like
  215 //
  216 //     sign_bit exponent_bits fraction_bits
  217 //
  218 //   Here, sign_bit is a single bit that designates the sign of the
  219 //   number.
  220 //
  221 //   For float, there are 8 exponent bits and 23 fraction bits.
  222 //
  223 //   For double, there are 11 exponent bits and 52 fraction bits.
  224 //
  225 //   More details can be found at
  226 //   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
  227 //
  228 // Template parameter:
  229 //
  230 //   RawType: the raw floating-point type (either float or double)
  231 template <typename RawType>
  232 class FloatingPoint {
  233  public:
  234   // Defines the unsigned integer type that has the same size as the
  235   // floating point number.
  236   typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
  237 
  238   // Constants.
  239 
  240   // # of bits in a number.
  241   static const size_t kBitCount = 8*sizeof(RawType);
  242 
  243   // # of fraction bits in a number.
  244   static const size_t kFractionBitCount =
  245     std::numeric_limits<RawType>::digits - 1;
  246 
  247   // # of exponent bits in a number.
  248   static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
  249 
  250   // The mask for the sign bit.
  251   static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
  252 
  253   // The mask for the fraction bits.
  254   static const Bits kFractionBitMask =
  255     ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
  256 
  257   // The mask for the exponent bits.
  258   static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
  259 
  260   // How many ULP's (Units in the Last Place) we want to tolerate when
  261   // comparing two numbers.  The larger the value, the more error we
  262   // allow.  A 0 value means that two numbers must be exactly the same
  263   // to be considered equal.
  264   //
  265   // The maximum error of a single floating-point operation is 0.5
  266   // units in the last place.  On Intel CPU's, all floating-point
  267   // calculations are done with 80-bit precision, while double has 64
  268   // bits.  Therefore, 4 should be enough for ordinary use.
  269   //
  270   // See the following article for more details on ULP:
  271   // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
  272   static const size_t kMaxUlps = 4;
  273 
  274   // Constructs a FloatingPoint from a raw floating-point number.
  275   //
  276   // On an Intel CPU, passing a non-normalized NAN (Not a Number)
  277   // around may change its bits, although the new value is guaranteed
  278   // to be also a NAN.  Therefore, don't expect this constructor to
  279   // preserve the bits in x when x is a NAN.
  280   explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
  281 
  282   // Static methods
  283 
  284   // Reinterprets a bit pattern as a floating-point number.
  285   //
  286   // This function is needed to test the AlmostEquals() method.
  287   static RawType ReinterpretBits(const Bits bits) {
  288     FloatingPoint fp(0);
  289     fp.u_.bits_ = bits;
  290     return fp.u_.value_;
  291   }
  292 
  293   // Returns the floating-point number that represent positive infinity.
  294   static RawType Infinity() {
  295     return ReinterpretBits(kExponentBitMask);
  296   }
  297 
  298   // Returns the maximum representable finite floating-point number.
  299   static RawType Max();
  300 
  301   // Non-static methods
  302 
  303   // Returns the bits that represents this number.
  304   const Bits &bits() const { return u_.bits_; }
  305 
  306   // Returns the exponent bits of this number.
  307   Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
  308 
  309   // Returns the fraction bits of this number.
  310   Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
  311 
  312   // Returns the sign bit of this number.
  313   Bits sign_bit() const { return kSignBitMask & u_.bits_; }
  314 
  315   // Returns true iff this is NAN (not a number).
  316   bool is_nan() const {
  317     // It's a NAN if the exponent bits are all ones and the fraction
  318     // bits are not entirely zeros.
  319     return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
  320   }
  321 
  322   // Returns true iff this number is at most kMaxUlps ULP's away from
  323   // rhs.  In particular, this function:
  324   //
  325   //   - returns false if either number is (or both are) NAN.
  326   //   - treats really large numbers as almost equal to infinity.
  327   //   - thinks +0.0 and -0.0 are 0 DLP's apart.
  328   bool AlmostEquals(const FloatingPoint& rhs) const {
  329     // The IEEE standard says that any comparison operation involving
  330     // a NAN must return false.
  331     if (is_nan() || rhs.is_nan()) return false;
  332 
  333     return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
  334         <= kMaxUlps;
  335   }
  336 
  337  private:
  338   // The data type used to store the actual floating-point number.
  339   union FloatingPointUnion {
  340     RawType value_;  // The raw floating-point number.
  341     Bits bits_;      // The bits that represent the number.
  342   };
  343 
  344   // Converts an integer from the sign-and-magnitude representation to
  345   // the biased representation.  More precisely, let N be 2 to the
  346   // power of (kBitCount - 1), an integer x is represented by the
  347   // unsigned number x + N.
  348   //
  349   // For instance,
  350   //
  351   //   -N + 1 (the most negative number representable using
  352   //          sign-and-magnitude) is represented by 1;
  353   //   0      is represented by N; and
  354   //   N - 1  (the biggest number representable using
  355   //          sign-and-magnitude) is represented by 2N - 1.
  356   //
  357   // Read http://en.wikipedia.org/wiki/Signed_number_representations
  358   // for more details on signed number representations.
  359   static Bits SignAndMagnitudeToBiased(const Bits &sam) {
  360     if (kSignBitMask & sam) {
  361       // sam represents a negative number.
  362       return ~sam + 1;
  363     } else {
  364       // sam represents a positive number.
  365       return kSignBitMask | sam;
  366     }
  367   }
  368 
  369   // Given two numbers in the sign-and-magnitude representation,
  370   // returns the distance between them as an unsigned number.
  371   static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
  372                                                      const Bits &sam2) {
  373     const Bits biased1 = SignAndMagnitudeToBiased(sam1);
  374     const Bits biased2 = SignAndMagnitudeToBiased(sam2);
  375     return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
  376   }
  377 
  378   FloatingPointUnion u_;
  379 };
  380 
  381 // We cannot use std::numeric_limits<T>::max() as it clashes with the max()
  382 // macro defined by <windows.h>.
  383 template <>
  384 inline float FloatingPoint<float>::Max() { return FLT_MAX; }
  385 template <>
  386 inline double FloatingPoint<double>::Max() { return DBL_MAX; }
  387 
  388 // Typedefs the instances of the FloatingPoint template class that we
  389 // care to use.
  390 typedef FloatingPoint<float> Float;
  391 typedef FloatingPoint<double> Double;
  392 
  393 // In order to catch the mistake of putting tests that use different
  394 // test fixture classes in the same test case, we need to assign
  395 // unique IDs to fixture classes and compare them.  The TypeId type is
  396 // used to hold such IDs.  The user should treat TypeId as an opaque
  397 // type: the only operation allowed on TypeId values is to compare
  398 // them for equality using the == operator.
  399 typedef const void* TypeId;
  400 
  401 template <typename T>
  402 class TypeIdHelper {
  403  public:
  404   // dummy_ must not have a const type.  Otherwise an overly eager
  405   // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
  406   // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
  407   static bool dummy_;
  408 };
  409 
  410 template <typename T>
  411 bool TypeIdHelper<T>::dummy_ = false;
  412 
  413 // GetTypeId<T>() returns the ID of type T.  Different values will be
  414 // returned for different types.  Calling the function twice with the
  415 // same type argument is guaranteed to return the same ID.
  416 template <typename T>
  417 TypeId GetTypeId() {
  418   // The compiler is required to allocate a different
  419   // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
  420   // the template.  Therefore, the address of dummy_ is guaranteed to
  421   // be unique.
  422   return &(TypeIdHelper<T>::dummy_);
  423 }
  424 
  425 // Returns the type ID of ::testing::Test.  Always call this instead
  426 // of GetTypeId< ::testing::Test>() to get the type ID of
  427 // ::testing::Test, as the latter may give the wrong result due to a
  428 // suspected linker bug when compiling Google Test as a Mac OS X
  429 // framework.
  430 GTEST_API_ TypeId GetTestTypeId();
  431 
  432 // Defines the abstract factory interface that creates instances
  433 // of a Test object.
  434 class TestFactoryBase {
  435  public:
  436   virtual ~TestFactoryBase() {}
  437 
  438   // Creates a test instance to run. The instance is both created and destroyed
  439   // within TestInfoImpl::Run()
  440   virtual Test* CreateTest() = 0;
  441 
  442  protected:
  443   TestFactoryBase() {}
  444 
  445  private:
  446   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
  447 };
  448 
  449 // This class provides implementation of TeastFactoryBase interface.
  450 // It is used in TEST and TEST_F macros.
  451 template <class TestClass>
  452 class TestFactoryImpl : public TestFactoryBase {
  453  public:
  454   virtual Test* CreateTest() { return new TestClass; }
  455 };
  456 
  457 #if GTEST_OS_WINDOWS
  458 
  459 // Predicate-formatters for implementing the HRESULT checking macros
  460 // {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
  461 // We pass a long instead of HRESULT to avoid causing an
  462 // include dependency for the HRESULT type.
  463 GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
  464                                             long hr);  // NOLINT
  465 GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
  466                                             long hr);  // NOLINT
  467 
  468 #endif  // GTEST_OS_WINDOWS
  469 
  470 // Types of SetUpTestCase() and TearDownTestCase() functions.
  471 typedef void (*SetUpTestCaseFunc)();
  472 typedef void (*TearDownTestCaseFunc)();
  473 
  474 // Creates a new TestInfo object and registers it with Google Test;
  475 // returns the created object.
  476 //
  477 // Arguments:
  478 //
  479 //   test_case_name:   name of the test case
  480 //   name:             name of the test
  481 //   type_param        the name of the test's type parameter, or NULL if
  482 //                     this is not a typed or a type-parameterized test.
  483 //   value_param       text representation of the test's value parameter,
  484 //                     or NULL if this is not a type-parameterized test.
  485 //   fixture_class_id: ID of the test fixture class
  486 //   set_up_tc:        pointer to the function that sets up the test case
  487 //   tear_down_tc:     pointer to the function that tears down the test case
  488 //   factory:          pointer to the factory that creates a test object.
  489 //                     The newly created TestInfo instance will assume
  490 //                     ownership of the factory object.
  491 GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
  492     const char* test_case_name,
  493     const char* name,
  494     const char* type_param,
  495     const char* value_param,
  496     TypeId fixture_class_id,
  497     SetUpTestCaseFunc set_up_tc,
  498     TearDownTestCaseFunc tear_down_tc,
  499     TestFactoryBase* factory);
  500 
  501 // If *pstr starts with the given prefix, modifies *pstr to be right
  502 // past the prefix and returns true; otherwise leaves *pstr unchanged
  503 // and returns false.  None of pstr, *pstr, and prefix can be NULL.
  504 GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);
  505 
  506 #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
  507 
  508 // State of the definition of a type-parameterized test case.
  509 class GTEST_API_ TypedTestCasePState {
  510  public:
  511   TypedTestCasePState() : registered_(false) {}
  512 
  513   // Adds the given test name to defined_test_names_ and return true
  514   // if the test case hasn't been registered; otherwise aborts the
  515   // program.
  516   bool AddTestName(const char* file, int line, const char* case_name,
  517                    const char* test_name) {
  518     if (registered_) {
  519       fprintf(stderr, "%s Test %s must be defined before "
  520               "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n",
  521               FormatFileLocation(file, line).c_str(), test_name, case_name);
  522       fflush(stderr);
  523       posix::Abort();
  524     }
  525     defined_test_names_.insert(test_name);
  526     return true;
  527   }
  528 
  529   // Verifies that registered_tests match the test names in
  530   // defined_test_names_; returns registered_tests if successful, or
  531   // aborts the program otherwise.
  532   const char* VerifyRegisteredTestNames(
  533       const char* file, int line, const char* registered_tests);
  534 
  535  private:
  536   bool registered_;
  537   ::std::set<const char*> defined_test_names_;
  538 };
  539 
  540 // Skips to the first non-space char after the first comma in 'str';
  541 // returns NULL if no comma is found in 'str'.
  542 inline const char* SkipComma(const char* str) {
  543   const char* comma = strchr(str, ',');
  544   if (comma == NULL) {
  545     return NULL;
  546   }
  547   while (IsSpace(*(++comma))) {}
  548   return comma;
  549 }
  550 
  551 // Returns the prefix of 'str' before the first comma in it; returns
  552 // the entire string if it contains no comma.
  553 inline std::string GetPrefixUntilComma(const char* str) {
  554   const char* comma = strchr(str, ',');
  555   return comma == NULL ? str : std::string(str, comma);
  556 }
  557 
  558 // TypeParameterizedTest<Fixture, TestSel, Types>::Register()
  559 // registers a list of type-parameterized tests with Google Test.  The
  560 // return value is insignificant - we just need to return something
  561 // such that we can call this function in a namespace scope.
  562 //
  563 // Implementation note: The GTEST_TEMPLATE_ macro declares a template
  564 // template parameter.  It's defined in gtest-type-util.h.
  565 template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
  566 class TypeParameterizedTest {
  567  public:
  568   // 'index' is the index of the test in the type list 'Types'
  569   // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase,
  570   // Types).  Valid values for 'index' are [0, N - 1] where N is the
  571   // length of Types.
  572   static bool Register(const char* prefix, const char* case_name,
  573                        const char* test_names, int index) {
  574     typedef typename Types::Head Type;
  575     typedef Fixture<Type> FixtureClass;
  576     typedef typename GTEST_BIND_(TestSel, Type) TestClass;
  577 
  578     // First, registers the first type-parameterized test in the type
  579     // list.
  580     MakeAndRegisterTestInfo(
  581         (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
  582          + StreamableToString(index)).c_str(),
  583         GetPrefixUntilComma(test_names).c_str(),
  584         GetTypeName<Type>().c_str(),
  585         NULL,  // No value parameter.
  586         GetTypeId<FixtureClass>(),
  587         TestClass::SetUpTestCase,
  588         TestClass::TearDownTestCase,
  589         new TestFactoryImpl<TestClass>);
  590 
  591     // Next, recurses (at compile time) with the tail of the type list.
  592     return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail>
  593         ::Register(prefix, case_name, test_names, index + 1);
  594   }
  595 };
  596 
  597 // The base case for the compile time recursion.
  598 template <GTEST_TEMPLATE_ Fixture, class TestSel>
  599 class TypeParameterizedTest<Fixture, TestSel, Types0> {
  600  public:
  601   static bool Register(const char* /*prefix*/, const char* /*case_name*/,
  602                        const char* /*test_names*/, int /*index*/) {
  603     return true;
  604   }
  605 };
  606 
  607 // TypeParameterizedTestCase<Fixture, Tests, Types>::Register()
  608 // registers *all combinations* of 'Tests' and 'Types' with Google
  609 // Test.  The return value is insignificant - we just need to return
  610 // something such that we can call this function in a namespace scope.
  611 template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
  612 class TypeParameterizedTestCase {
  613  public:
  614   static bool Register(const char* prefix, const char* case_name,
  615                        const char* test_names) {
  616     typedef typename Tests::Head Head;
  617 
  618     // First, register the first test in 'Test' for each type in 'Types'.
  619     TypeParameterizedTest<Fixture, Head, Types>::Register(
  620         prefix, case_name, test_names, 0);
  621 
  622     // Next, recurses (at compile time) with the tail of the test list.
  623     return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types>
  624         ::Register(prefix, case_name, SkipComma(test_names));
  625   }
  626 };
  627 
  628 // The base case for the compile time recursion.
  629 template <GTEST_TEMPLATE_ Fixture, typename Types>
  630 class TypeParameterizedTestCase<Fixture, Templates0, Types> {
  631  public:
  632   static bool Register(const char* /*prefix*/, const char* /*case_name*/,
  633                        const char* /*test_names*/) {
  634     return true;
  635   }
  636 };
  637 
  638 #endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
  639 
  640 // Returns the current OS stack trace as an std::string.
  641 //
  642 // The maximum number of stack frames to be included is specified by
  643 // the gtest_stack_trace_depth flag.  The skip_count parameter
  644 // specifies the number of top frames to be skipped, which doesn't
  645 // count against the number of frames to be included.
  646 //
  647 // For example, if Foo() calls Bar(), which in turn calls
  648 // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
  649 // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
  650 GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
  651     UnitTest* unit_test, int skip_count);
  652 
  653 // Helpers for suppressing warnings on unreachable code or constant
  654 // condition.
  655 
  656 // Always returns true.
  657 GTEST_API_ bool AlwaysTrue();
  658 
  659 // Always returns false.
  660 inline bool AlwaysFalse() { return !AlwaysTrue(); }
  661 
  662 // Helper for suppressing false warning from Clang on a const char*
  663 // variable declared in a conditional expression always being NULL in
  664 // the else branch.
  665 struct GTEST_API_ ConstCharPtr {
  666   ConstCharPtr(const char* str) : value(str) {}
  667   operator bool() const { return true; }
  668   const char* value;
  669 };
  670 
  671 // A simple Linear Congruential Generator for generating random
  672 // numbers with a uniform distribution.  Unlike rand() and srand(), it
  673 // doesn't use global state (and therefore can't interfere with user
  674 // code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
  675 // but it's good enough for our purposes.
  676 class GTEST_API_ Random {
  677  public:
  678   static const UInt32 kMaxRange = 1u << 31;
  679 
  680   explicit Random(UInt32 seed) : state_(seed) {}
  681 
  682   void Reseed(UInt32 seed) { state_ = seed; }
  683 
  684   // Generates a random number from [0, range).  Crashes if 'range' is
  685   // 0 or greater than kMaxRange.
  686   UInt32 Generate(UInt32 range);
  687 
  688  private:
  689   UInt32 state_;
  690   GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
  691 };
  692 
  693 // Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a
  694 // compiler error iff T1 and T2 are different types.
  695 template <typename T1, typename T2>
  696 struct CompileAssertTypesEqual;
  697 
  698 template <typename T>
  699 struct CompileAssertTypesEqual<T, T> {
  700 };
  701 
  702 // Removes the reference from a type if it is a reference type,
  703 // otherwise leaves it unchanged.  This is the same as
  704 // tr1::remove_reference, which is not widely available yet.
  705 template <typename T>
  706 struct RemoveReference { typedef T type; };  // NOLINT
  707 template <typename T>
  708 struct RemoveReference<T&> { typedef T type; };  // NOLINT
  709 
  710 // A handy wrapper around RemoveReference that works when the argument
  711 // T depends on template parameters.
  712 #define GTEST_REMOVE_REFERENCE_(T) \
  713     typename ::testing::internal::RemoveReference<T>::type
  714 
  715 // Removes const from a type if it is a const type, otherwise leaves
  716 // it unchanged.  This is the same as tr1::remove_const, which is not
  717 // widely available yet.
  718 template <typename T>
  719 struct RemoveConst { typedef T type; };  // NOLINT
  720 template <typename T>
  721 struct RemoveConst<const T> { typedef T type; };  // NOLINT
  722 
  723 // MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
  724 // definition to fail to remove the const in 'const int[3]' and 'const
  725 // char[3][4]'.  The following specialization works around the bug.
  726 template <typename T, size_t N>
  727 struct RemoveConst<const T[N]> {
  728   typedef typename RemoveConst<T>::type type[N];
  729 };
  730 
  731 #if defined(_MSC_VER) && _MSC_VER < 1400
  732 // This is the only specialization that allows VC++ 7.1 to remove const in
  733 // 'const int[3] and 'const int[3][4]'.  However, it causes trouble with GCC
  734 // and thus needs to be conditionally compiled.
  735 template <typename T, size_t N>
  736 struct RemoveConst<T[N]> {
  737   typedef typename RemoveConst<T>::type type[N];
  738 };
  739 #endif
  740 
  741 // A handy wrapper around RemoveConst that works when the argument
  742 // T depends on template parameters.
  743 #define GTEST_REMOVE_CONST_(T) \
  744     typename ::testing::internal::RemoveConst<T>::type
  745 
  746 // Turns const U&, U&, const U, and U all into U.
  747 #define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
  748     GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))
  749 
  750 // Adds reference to a type if it is not a reference type,
  751 // otherwise leaves it unchanged.  This is the same as
  752 // tr1::add_reference, which is not widely available yet.
  753 template <typename T>
  754 struct AddReference { typedef T& type; };  // NOLINT
  755 template <typename T>
  756 struct AddReference<T&> { typedef T& type; };  // NOLINT
  757 
  758 // A handy wrapper around AddReference that works when the argument T
  759 // depends on template parameters.
  760 #define GTEST_ADD_REFERENCE_(T) \
  761     typename ::testing::internal::AddReference<T>::type
  762 
  763 // Adds a reference to const on top of T as necessary.  For example,
  764 // it transforms
  765 //
  766 //   char         ==> const char&
  767 //   const char   ==> const char&
  768 //   char&        ==> const char&
  769 //   const char&  ==> const char&
  770 //
  771 // The argument T must depend on some template parameters.
  772 #define GTEST_REFERENCE_TO_CONST_(T) \
  773     GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T))
  774 
  775 // ImplicitlyConvertible<From, To>::value is a compile-time bool
  776 // constant that's true iff type From can be implicitly converted to
  777 // type To.
  778 template <typename From, typename To>
  779 class ImplicitlyConvertible {
  780  private:
  781   // We need the following helper functions only for their types.
  782   // They have no implementations.
  783 
  784   // MakeFrom() is an expression whose type is From.  We cannot simply
  785   // use From(), as the type From may not have a public default
  786   // constructor.
  787   static typename AddReference<From>::type MakeFrom();
  788 
  789   // These two functions are overloaded.  Given an expression
  790   // Helper(x), the compiler will pick the first version if x can be
  791   // implicitly converted to type To; otherwise it will pick the
  792   // second version.
  793   //
  794   // The first version returns a value of size 1, and the second
  795   // version returns a value of size 2.  Therefore, by checking the
  796   // size of Helper(x), which can be done at compile time, we can tell
  797   // which version of Helper() is used, and hence whether x can be
  798   // implicitly converted to type To.
  799   static char Helper(To);
  800   static char (&Helper(...))[2];  // NOLINT
  801 
  802   // We have to put the 'public' section after the 'private' section,
  803   // or MSVC refuses to compile the code.
  804  public:
  805 #if defined(__BORLANDC__)
  806   // C++Builder cannot use member overload resolution during template
  807   // instantiation.  The simplest workaround is to use its C++0x type traits
  808   // functions (C++Builder 2009 and above only).
  809   static const bool value = __is_convertible(From, To);
  810 #else
  811   // MSVC warns about implicitly converting from double to int for
  812   // possible loss of data, so we need to temporarily disable the
  813   // warning.
  814   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244)
  815   static const bool value =
  816       sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
  817   GTEST_DISABLE_MSC_WARNINGS_POP_()
  818 #endif  // __BORLANDC__
  819 };
  820 template <typename From, typename To>
  821 const bool ImplicitlyConvertible<From, To>::value;
  822 
  823 // IsAProtocolMessage<T>::value is a compile-time bool constant that's
  824 // true iff T is type ProtocolMessage, proto2::Message, or a subclass
  825 // of those.
  826 template <typename T>
  827 struct IsAProtocolMessage
  828     : public bool_constant<
  829   ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value ||
  830   ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> {
  831 };
  832 
  833 // When the compiler sees expression IsContainerTest<C>(0), if C is an
  834 // STL-style container class, the first overload of IsContainerTest
  835 // will be viable (since both C::iterator* and C::const_iterator* are
  836 // valid types and NULL can be implicitly converted to them).  It will
  837 // be picked over the second overload as 'int' is a perfect match for
  838 // the type of argument 0.  If C::iterator or C::const_iterator is not
  839 // a valid type, the first overload is not viable, and the second
  840 // overload will be picked.  Therefore, we can determine whether C is
  841 // a container class by checking the type of IsContainerTest<C>(0).
  842 // The value of the expression is insignificant.
  843 //
  844 // Note that we look for both C::iterator and C::const_iterator.  The
  845 // reason is that C++ injects the name of a class as a member of the
  846 // class itself (e.g. you can refer to class iterator as either
  847 // 'iterator' or 'iterator::iterator').  If we look for C::iterator
  848 // only, for example, we would mistakenly think that a class named
  849 // iterator is an STL container.
  850 //
  851 // Also note that the simpler approach of overloading
  852 // IsContainerTest(typename C::const_iterator*) and
  853 // IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
  854 typedef int IsContainer;
  855 template <class C>
  856 IsContainer IsContainerTest(int /* dummy */,
  857                             typename C::iterator* /* it */ = NULL,
  858                             typename C::const_iterator* /* const_it */ = NULL) {
  859   return 0;
  860 }
  861 
  862 typedef char IsNotContainer;
  863 template <class C>
  864 IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
  865 
  866 // EnableIf<condition>::type is void when 'Cond' is true, and
  867 // undefined when 'Cond' is false.  To use SFINAE to make a function
  868 // overload only apply when a particular expression is true, add
  869 // "typename EnableIf<expression>::type* = 0" as the last parameter.
  870 template<bool> struct EnableIf;
  871 template<> struct EnableIf<true> { typedef void type; };  // NOLINT
  872 
  873 // Utilities for native arrays.
  874 
  875 // ArrayEq() compares two k-dimensional native arrays using the
  876 // elements' operator==, where k can be any integer >= 0.  When k is
  877 // 0, ArrayEq() degenerates into comparing a single pair of values.
  878 
  879 template <typename T, typename U>
  880 bool ArrayEq(const T* lhs, size_t size, const U* rhs);
  881 
  882 // This generic version is used when k is 0.
  883 template <typename T, typename U>
  884 inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
  885 
  886 // This overload is used when k >= 1.
  887 template <typename T, typename U, size_t N>
  888 inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
  889   return internal::ArrayEq(lhs, N, rhs);
  890 }
  891 
  892 // This helper reduces code bloat.  If we instead put its logic inside
  893 // the previous ArrayEq() function, arrays with different sizes would
  894 // lead to different copies of the template code.
  895 template <typename T, typename U>
  896 bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
  897   for (size_t i = 0; i != size; i++) {
  898     if (!internal::ArrayEq(lhs[i], rhs[i]))
  899       return false;
  900   }
  901   return true;
  902 }
  903 
  904 // Finds the first element in the iterator range [begin, end) that
  905 // equals elem.  Element may be a native array type itself.
  906 template <typename Iter, typename Element>
  907 Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
  908   for (Iter it = begin; it != end; ++it) {
  909     if (internal::ArrayEq(*it, elem))
  910       return it;
  911   }
  912   return end;
  913 }
  914 
  915 // CopyArray() copies a k-dimensional native array using the elements'
  916 // operator=, where k can be any integer >= 0.  When k is 0,
  917 // CopyArray() degenerates into copying a single value.
  918 
  919 template <typename T, typename U>
  920 void CopyArray(const T* from, size_t size, U* to);
  921 
  922 // This generic version is used when k is 0.
  923 template <typename T, typename U>
  924 inline void CopyArray(const T& from, U* to) { *to = from; }
  925 
  926 // This overload is used when k >= 1.
  927 template <typename T, typename U, size_t N>
  928 inline void CopyArray(const T(&from)[N], U(*to)[N]) {
  929   internal::CopyArray(from, N, *to);
  930 }
  931 
  932 // This helper reduces code bloat.  If we instead put its logic inside
  933 // the previous CopyArray() function, arrays with different sizes
  934 // would lead to different copies of the template code.
  935 template <typename T, typename U>
  936 void CopyArray(const T* from, size_t size, U* to) {
  937   for (size_t i = 0; i != size; i++) {
  938     internal::CopyArray(from[i], to + i);
  939   }
  940 }
  941 
  942 // The relation between an NativeArray object (see below) and the
  943 // native array it represents.
  944 // We use 2 different structs to allow non-copyable types to be used, as long
  945 // as RelationToSourceReference() is passed.
  946 struct RelationToSourceReference {};
  947 struct RelationToSourceCopy {};
  948 
  949 // Adapts a native array to a read-only STL-style container.  Instead
  950 // of the complete STL container concept, this adaptor only implements
  951 // members useful for Google Mock's container matchers.  New members
  952 // should be added as needed.  To simplify the implementation, we only
  953 // support Element being a raw type (i.e. having no top-level const or
  954 // reference modifier).  It's the client's responsibility to satisfy
  955 // this requirement.  Element can be an array type itself (hence
  956 // multi-dimensional arrays are supported).
  957 template <typename Element>
  958 class NativeArray {
  959  public:
  960   // STL-style container typedefs.
  961   typedef Element value_type;
  962   typedef Element* iterator;
  963   typedef const Element* const_iterator;
  964 
  965   // Constructs from a native array. References the source.
  966   NativeArray(const Element* array, size_t count, RelationToSourceReference) {
  967     InitRef(array, count);
  968   }
  969 
  970   // Constructs from a native array. Copies the source.
  971   NativeArray(const Element* array, size_t count, RelationToSourceCopy) {
  972     InitCopy(array, count);
  973   }
  974 
  975   // Copy constructor.
  976   NativeArray(const NativeArray& rhs) {
  977     (this->*rhs.clone_)(rhs.array_, rhs.size_);
  978   }
  979 
  980   ~NativeArray() {
  981     if (clone_ != &NativeArray::InitRef)
  982       delete[] array_;
  983   }
  984 
  985   // STL-style container methods.
  986   size_t size() const { return size_; }
  987   const_iterator begin() const { return array_; }
  988   const_iterator end() const { return array_ + size_; }
  989   bool operator==(const NativeArray& rhs) const {
  990     return size() == rhs.size() &&
  991         ArrayEq(begin(), size(), rhs.begin());
  992   }
  993 
  994  private:
  995   enum {
  996     kCheckTypeIsNotConstOrAReference = StaticAssertTypeEqHelper<
  997         Element, GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>::value,
  998   };
  999 
 1000   // Initializes this object with a copy of the input.
 1001   void InitCopy(const Element* array, size_t a_size) {
 1002     Element* const copy = new Element[a_size];
 1003     CopyArray(array, a_size, copy);
 1004     array_ = copy;
 1005     size_ = a_size;
 1006     clone_ = &NativeArray::InitCopy;
 1007   }
 1008 
 1009   // Initializes this object with a reference of the input.
 1010   void InitRef(const Element* array, size_t a_size) {
 1011     array_ = array;
 1012     size_ = a_size;
 1013     clone_ = &NativeArray::InitRef;
 1014   }
 1015 
 1016   const Element* array_;
 1017   size_t size_;
 1018   void (NativeArray::*clone_)(const Element*, size_t);
 1019 
 1020   GTEST_DISALLOW_ASSIGN_(NativeArray);
 1021 };
 1022 
 1023 }  // namespace internal
 1024 }  // namespace testing
 1025 
 1026 #define GTEST_MESSAGE_AT_(file, line, message, result_type) \
 1027   ::testing::internal::AssertHelper(result_type, file, line, message) \
 1028     = ::testing::Message()
 1029 
 1030 #define GTEST_MESSAGE_(message, result_type) \
 1031   GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
 1032 
 1033 #define GTEST_FATAL_FAILURE_(message) \
 1034   return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
 1035 
 1036 #define GTEST_NONFATAL_FAILURE_(message) \
 1037   GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
 1038 
 1039 #define GTEST_SUCCESS_(message) \
 1040   GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
 1041 
 1042 // Suppresses MSVC warnings 4072 (unreachable code) for the code following
 1043 // statement if it returns or throws (or doesn't return or throw in some
 1044 // situations).
 1045 #define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
 1046   if (::testing::internal::AlwaysTrue()) { statement; }
 1047 
 1048 #define GTEST_TEST_THROW_(statement, expected_exception, fail) \
 1049   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
 1050   if (::testing::internal::ConstCharPtr gtest_msg = "") { \
 1051     bool gtest_caught_expected = false; \
 1052     try { \
 1053       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
 1054     } \
 1055     catch (expected_exception const&) { \
 1056       gtest_caught_expected = true; \
 1057     } \
 1058     catch (...) { \
 1059       gtest_msg.value = \
 1060           "Expected: " #statement " throws an exception of type " \
 1061           #expected_exception ".\n  Actual: it throws a different type."; \
 1062       goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
 1063     } \
 1064     if (!gtest_caught_expected) { \
 1065       gtest_msg.value = \
 1066           "Expected: " #statement " throws an exception of type " \
 1067           #expected_exception ".\n  Actual: it throws nothing."; \
 1068       goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
 1069     } \
 1070   } else \
 1071     GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
 1072       fail(gtest_msg.value)
 1073 
 1074 #define GTEST_TEST_NO_THROW_(statement, fail) \
 1075   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
 1076   if (::testing::internal::AlwaysTrue()) { \
 1077     try { \
 1078       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
 1079     } \
 1080     catch (...) { \
 1081       goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
 1082     } \
 1083   } else \
 1084     GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
 1085       fail("Expected: " #statement " doesn't throw an exception.\n" \
 1086            "  Actual: it throws.")
 1087 
 1088 #define GTEST_TEST_ANY_THROW_(statement, fail) \
 1089   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
 1090   if (::testing::internal::AlwaysTrue()) { \
 1091     bool gtest_caught_any = false; \
 1092     try { \
 1093       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
 1094     } \
 1095     catch (...) { \
 1096       gtest_caught_any = true; \
 1097     } \
 1098     if (!gtest_caught_any) { \
 1099       goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
 1100     } \
 1101   } else \
 1102     GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
 1103       fail("Expected: " #statement " throws an exception.\n" \
 1104            "  Actual: it doesn't.")
 1105 
 1106 
 1107 // Implements Boolean test assertions such as EXPECT_TRUE. expression can be
 1108 // either a boolean expression or an AssertionResult. text is a textual
 1109 // represenation of expression as it was passed into the EXPECT_TRUE.
 1110 #define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
 1111   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
 1112   if (const ::testing::AssertionResult gtest_ar_ = \
 1113       ::testing::AssertionResult(expression)) \
 1114     ; \
 1115   else \
 1116     fail(::testing::internal::GetBoolAssertionFailureMessage(\
 1117         gtest_ar_, text, #actual, #expected).c_str())
 1118 
 1119 #define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
 1120   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
 1121   if (::testing::internal::AlwaysTrue()) { \
 1122     ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
 1123     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
 1124     if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
 1125       goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
 1126     } \
 1127   } else \
 1128     GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
 1129       fail("Expected: " #statement " doesn't generate new fatal " \
 1130            "failures in the current thread.\n" \
 1131            "  Actual: it does.")
 1132 
 1133 // Expands to the name of the class that implements the given test.
 1134 #define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
 1135   test_case_name##_##test_name##_Test
 1136 
 1137 // Helper macro for defining tests.
 1138 #define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
 1139 class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
 1140  public:\
 1141   GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
 1142  private:\
 1143   virtual void TestBody();\
 1144   static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
 1145   GTEST_DISALLOW_COPY_AND_ASSIGN_(\
 1146       GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
 1147 };\
 1148 \
 1149 ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
 1150   ::test_info_ =\
 1151     ::testing::internal::MakeAndRegisterTestInfo(\
 1152         #test_case_name, #test_name, NULL, NULL, \
 1153         (parent_id), \
 1154         parent_class::SetUpTestCase, \
 1155         parent_class::TearDownTestCase, \
 1156         new ::testing::internal::TestFactoryImpl<\
 1157             GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
 1158 void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
 1159 
 1160 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
 1161