//   actual_expression:   "bar"//   expected_value:      "5"//   actual_value:        "6"//// The ignoring_case parameter is true iff the assertion is a// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will// be inserted into the message.AssertionResult EqFailure(const char* expected_expression,                          const char* actual_expression,                          const String& expected_value,                          const String& actual_value,                          bool ignoring_case);// This template class represents an IEEE floating-point number// (either single-precision or double-precision, depending on the// template parameters).//// The purpose of this class is to do more sophisticated number// comparison.  (Due to round-off error, etc, it's very unlikely that// two floating-points will be equal exactly.  Hence a naive// comparison by the == operation often doesn't work.)//// Format of IEEE floating-point:////   The most-significant bit being the leftmost, an IEEE//   floating-point looks like////     sign_bit exponent_bits fraction_bits////   Here, sign_bit is a single bit that designates the sign of the//   number.////   For float, there are 8 exponent bits and 23 fraction bits.////   For double, there are 11 exponent bits and 52 fraction bits.////   More details can be found at//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.//// Template parameter:////   RawType: the raw floating-point type (either float or double)template <typename RawType>class FloatingPoint { public:  // Defines the unsigned integer type that has the same size as the  // floating point number.  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;  // Constants.  // # of bits in a number.  static const size_t kBitCount = 8*sizeof(RawType);  // # of fraction bits in a number.  static const size_t kFractionBitCount =    std::numeric_limits<RawType>::digits - 1;  // # of exponent bits in a number.  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;  // The mask for the sign bit.  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);  // The mask for the fraction bits.  static const Bits kFractionBitMask =    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);  // The mask for the exponent bits.  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);  // How many ULP's (Units in the Last Place) we want to tolerate when  // comparing two numbers.  The larger the value, the more error we  // allow.  A 0 value means that two numbers must be exactly the same  // to be considered equal.  //  // The maximum error of a single floating-point operation is 0.5  // units in the last place.  On Intel CPU's, all floating-point  // calculations are done with 80-bit precision, while double has 64  // bits.  Therefore, 4 should be enough for ordinary use.  //  // See the following article for more details on ULP:  // http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm.  static const size_t kMaxUlps = 4;  // Constructs a FloatingPoint from a raw floating-point number.  //  // On an Intel CPU, passing a non-normalized NAN (Not a Number)  // around may change its bits, although the new value is guaranteed  // to be also a NAN.  Therefore, don't expect this constructor to  // preserve the bits in x when x is a NAN.  explicit FloatingPoint(const RawType& x) : value_(x) {}  // Static methods  // Reinterprets a bit pattern as a floating-point number.  //  // This function is needed to test the AlmostEquals() method.  static RawType ReinterpretBits(const Bits bits) {    FloatingPoint fp(0);    fp.bits_ = bits;    return fp.value_;  }  // Returns the floating-point number that represent positive infinity.  static RawType Infinity() {    return ReinterpretBits(kExponentBitMask);  }  // Non-static methods  // Returns the bits that represents this number.  const Bits &bits() const { return bits_; }  // Returns the exponent bits of this number.  Bits exponent_bits() const { return kExponentBitMask & bits_; }  // Returns the fraction bits of this number.  Bits fraction_bits() const { return kFractionBitMask & bits_; }  // Returns the sign bit of this number.  Bits sign_bit() const { return kSignBitMask & bits_; }  // Returns true iff this is NAN (not a number).  bool is_nan() const {    // It's a NAN if the exponent bits are all ones and the fraction    // bits are not entirely zeros.    return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);  }  // Returns true iff this number is at most kMaxUlps ULP's away from  // rhs.  In particular, this function:  //  //   - returns false if either number is (or both are) NAN.  //   - treats really large numbers as almost equal to infinity.  //   - thinks +0.0 and -0.0 are 0 DLP's apart.  bool AlmostEquals(const FloatingPoint& rhs) const {    // The IEEE standard says that any comparison operation involving    // a NAN must return false.    if (is_nan() || rhs.is_nan()) return false;    return DistanceBetweenSignAndMagnitudeNumbers(bits_, rhs.bits_) <= kMaxUlps;  } private:  // Converts an integer from the sign-and-magnitude representation to  // the biased representation.  More precisely, let N be 2 to the  // power of (kBitCount - 1), an integer x is represented by the  // unsigned number x + N.  //  // For instance,  //  //   -N + 1 (the most negative number representable using  //          sign-and-magnitude) is represented by 1;  //   0      is represented by N; and  //   N - 1  (the biggest number representable using  //          sign-and-magnitude) is represented by 2N - 1.  //  // Read http://en.wikipedia.org/wiki/Signed_number_representations  // for more details on signed number representations.  static Bits SignAndMagnitudeToBiased(const Bits &sam) {    if (kSignBitMask & sam) {      // sam represents a negative number.      return ~sam + 1;    } else {      // sam represents a positive number.      return kSignBitMask | sam;    }  }  // Given two numbers in the sign-and-magnitude representation,  // returns the distance between them as an unsigned number.  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,                                                     const Bits &sam2) {    const Bits biased1 = SignAndMagnitudeToBiased(sam1);    const Bits biased2 = SignAndMagnitudeToBiased(sam2);    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);  }  union {    RawType value_;  // The raw floating-point number.    Bits bits_;      // The bits that represent the number.  };};// Typedefs the instances of the FloatingPoint template class that we// care to use.typedef FloatingPoint<float> Float;typedef FloatingPoint<double> Double;// In order to catch the mistake of putting tests that use different// test fixture classes in the same test case, we need to assign// unique IDs to fixture classes and compare them.  The TypeId type is// used to hold such IDs.  The user should treat TypeId as an opaque// type: the only operation allowed on TypeId values is to compare// them for equality using the == operator.typedef const void* TypeId;template <typename T>class TypeIdHelper { public:  // dummy_ must not have a const type.  Otherwise an overly eager  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge  // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".  static bool dummy_;};template <typename T>bool TypeIdHelper<T>::dummy_ = false;// GetTypeId<T>() returns the ID of type T.  Different values will be// returned for different types.  Calling the function twice with the// same type argument is guaranteed to return the same ID.template <typename T>TypeId GetTypeId() {  // The compiler is required to allocate a different  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate  // the template.  Therefore, the address of dummy_ is guaranteed to  // be unique.  return &(TypeIdHelper<T>::dummy_);}// Returns the type ID of ::testing::Test.  Always call this instead// of GetTypeId< ::testing::Test>() to get the type ID of// ::testing::Test, as the latter may give the wrong result due to a// suspected linker bug when compiling Google Test as a Mac OS X// framework.TypeId GetTestTypeId();// Defines the abstract factory interface that creates instances// of a Test object.class TestFactoryBase { public:  virtual ~TestFactoryBase() {}  // Creates a test instance to run. The instance is both created and destroyed  // within TestInfoImpl::Run()  virtual Test* CreateTest() = 0; protected:  TestFactoryBase() {} private:  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);};// This class provides implementation of TeastFactoryBase interface.// It is used in TEST and TEST_F macros.template <class TestClass>class TestFactoryImpl : public TestFactoryBase { public:  virtual Test* CreateTest() { return new TestClass; }};#ifdef GTEST_OS_WINDOWS// Predicate-formatters for implementing the HRESULT checking macros// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}// We pass a long instead of HRESULT to avoid causing an// include dependency for the HRESULT type.AssertionResult IsHRESULTSuccess(const char* expr, long hr);  // NOLINTAssertionResult IsHRESULTFailure(const char* expr, long hr);  // NOLINT#endif  // GTEST_OS_WINDOWS// Formats a source file path and a line number as they would appear// in a compiler error message.inline String FormatFileLocation(const char* file, int line) {  const char* const file_name = file == NULL ? "unknown file" : file;  if (line < 0) {    return String::Format("%s:", file_name);  }#ifdef _MSC_VER  return String::Format("%s(%d):", file_name, line);#else  return String::Format("%s:%d:", file_name, line);#endif  // _MSC_VER}// Types of SetUpTestCase() and TearDownTestCase() functions.typedef void (*SetUpTestCaseFunc)();typedef void (*TearDownTestCaseFunc)();// Creates a new TestInfo object and registers it with Google Test;// returns the created object.//// Arguments:////   test_case_name:   name of the test case//   name:             name of the test//   test_case_comment: a comment on the test case that will be included in//                      the test output