testing::internal::FloatingEqMatcher< FloatType >::Impl< T > Class Template Reference

#include <gmock-matchers.h>

Inheritance diagram for testing::internal::FloatingEqMatcher< FloatType >::Impl< T >:

Collaboration diagram for testing::internal::FloatingEqMatcher< FloatType >::Impl< T >:

Public Member Functions
	Impl (FloatType expected, bool nan_eq_nan, FloatType max_abs_error)
virtual bool	MatchAndExplain (T value, MatchResultListener *listener) const
virtual void	DescribeTo (::std::ostream *os) const
virtual void	DescribeNegationTo (::std::ostream *os) const
Public Member Functions inherited from testing::MatcherDescriberInterface
virtual	~MatcherDescriberInterface ()

Detailed Description

template<typename FloatType>
template<typename T>
class testing::internal::FloatingEqMatcher< FloatType >::Impl< T >

Definition at line 1914 of file gmock-matchers.h.

Constructor & Destructor Documentation

Impl()

template<typename FloatType>

template<typename T>

testing::internal::FloatingEqMatcher< FloatType >::Impl< T >::Impl ( FloatType expected, bool nan_eq_nan, FloatType max_abs_error )

inline

Definition at line 1916 of file gmock-matchers.h.

        : expected_(expected),
          nan_eq_nan_(nan_eq_nan),
          max_abs_error_(max_abs_error) {}

Member Function Documentation

DescribeNegationTo()

template<typename FloatType>

template<typename T>

virtual void testing::internal::FloatingEqMatcher< FloatType >::Impl< T >::DescribeNegationTo ( ::std::ostream * os ) const

inlinevirtual

Reimplemented from testing::MatcherDescriberInterface.

Definition at line 1977 of file gmock-matchers.h.

                                                          {
      // As before, get original precision.
      const ::std::streamsize old_precision = os->precision(
          ::std::numeric_limits<FloatType>::digits10 + 2);
      if (FloatingPoint<FloatType>(expected_).is_nan()) {
        if (nan_eq_nan_) {
          *os << "isn't NaN";
        } else {
          *os << "is anything";
        }
      } else {
        *os << "isn't approximately " << expected_;
        if (HasMaxAbsError()) {
          *os << " (absolute error > " << max_abs_error_ << ")";
        }
      }
      // Restore original precision.
      os->precision(old_precision);
    }

DescribeTo()

template<typename FloatType>

template<typename T>

virtual void testing::internal::FloatingEqMatcher< FloatType >::Impl< T >::DescribeTo ( ::std::ostream * os ) const

inlinevirtual

Implements testing::MatcherDescriberInterface.

Definition at line 1956 of file gmock-matchers.h.

                                                  {
      // os->precision() returns the previously set precision, which we
      // store to restore the ostream to its original configuration
      // after outputting.
      const ::std::streamsize old_precision = os->precision(
          ::std::numeric_limits<FloatType>::digits10 + 2);
      if (FloatingPoint<FloatType>(expected_).is_nan()) {
        if (nan_eq_nan_) {
          *os << "is NaN";
        } else {
          *os << "never matches";
        }
      } else {
        *os << "is approximately " << expected_;
        if (HasMaxAbsError()) {
          *os << " (absolute error <= " << max_abs_error_ << ")";
        }
      }
      os->precision(old_precision);
    }

MatchAndExplain()

template<typename FloatType>

template<typename T>

virtual bool testing::internal::FloatingEqMatcher< FloatType >::Impl< T >::MatchAndExplain ( T value, MatchResultListener * listener ) const

inlinevirtual

Implements testing::MatcherInterface< T >.

Definition at line 1921 of file gmock-matchers.h.

                                                                      {
      const FloatingPoint<FloatType> actual(value), expected(expected_);
 
      // Compares NaNs first, if nan_eq_nan_ is true.
      if (actual.is_nan() || expected.is_nan()) {
        if (actual.is_nan() && expected.is_nan()) {
          return nan_eq_nan_;
        }
        // One is nan; the other is not nan.
        return false;
      }
      if (HasMaxAbsError()) {
        // We perform an equality check so that inf will match inf, regardless
        // of error bounds.  If the result of value - expected_ would result in
        // overflow or if either value is inf, the default result is infinity,
        // which should only match if max_abs_error_ is also infinity.
        if (value == expected_) {
          return true;
        }
 
        const FloatType diff = value - expected_;
        if (fabs(diff) <= max_abs_error_) {
          return true;
        }
 
        if (listener->IsInterested()) {
          *listener << "which is " << diff << " from " << expected_;
        }
        return false;
      } else {
        return actual.AlmostEquals(expected);
      }
    }

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/external/rapidjson/thirdparty/gtest/googlemock/include/gmock/gmock-matchers.h