include/gmock/gmock-matchers.h

895   explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
905     explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
929   explicit EqMatcher(const Rhs& rhs)
930       : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
937   explicit NeMatcher(const Rhs& rhs)
938       : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
945   explicit LtMatcher(const Rhs& rhs)
946       : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
953   explicit GtMatcher(const Rhs& rhs)
954       : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
961   explicit LeMatcher(const Rhs& rhs)
962       : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
969   explicit GeMatcher(const Rhs& rhs)
970       : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
1090 inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
1091   return String::CaseInsensitiveCStringEquals(lhs, rhs);
1095                                          const wchar_t* rhs) {
1096   return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
2608   bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; }
2699   // Like ContainerEq, we make a copy of rhs in case the elements in
2701   PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs)
2702       : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {
2728     Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)
2731           rhs_(rhs) {}
3570   void operator=(const BoundSecondMatcher& /*rhs*/) {
3750 // and equal to rhs.  A user may need to use this instead of Eq(...)
3762 inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
3814 // equal to rhs, where two NANs are considered unequal.
3815 inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {
3816   return internal::FloatingEqMatcher<double>(rhs, false);
3820 // equal to rhs, including NaN values when rhs is NaN.
3821 inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {
3822   return internal::FloatingEqMatcher<double>(rhs, true);
3826 // rhs, up to the specified max absolute error bound, where two NANs are
3829     double rhs, double max_abs_error) {
3830   return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
3834 // rhs, up to the specified max absolute error bound, including NaN values when
3835 // rhs is NaN.  The max absolute error bound must be non-negative.
3837     double rhs, double max_abs_error) {
3838   return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);
3842 // equal to rhs, where two NANs are considered unequal.
3843 inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
3844   return internal::FloatingEqMatcher<float>(rhs, false);
3848 // equal to rhs, including NaN values when rhs is NaN.
3849 inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
3850   return internal::FloatingEqMatcher<float>(rhs, true);
3854 // rhs, up to the specified max absolute error bound, where two NANs are
3857     float rhs, float max_abs_error) {
3858   return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
3862 // rhs, up to the specified max absolute error bound, including NaN values when
3863 // rhs is NaN.  The max absolute error bound must be non-negative.
3865     float rhs, float max_abs_error) {
3866   return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);
4150     ContainerEq(const Container& rhs) {
4155       internal::ContainerEqMatcher<RawContainer>(rhs));
4179 // same number of elements as in rhs, where its i-th element and rhs's
4187 Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
4190   // rhs is a const int[])..
4193       tuple_matcher, rhs);
4201     const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
4202   return Pointwise(tuple_matcher, std::vector<T>(rhs));
4207 // UnorderedPointwise(pair_matcher, rhs) matches an STL-style
4209 // elements as in rhs, where in some permutation of the container, its
4210 // i-th element and rhs's i-th element (as a pair) satisfy the given
4216 // This is like Pointwise(pair_matcher, rhs), except that the element
4257                    std::initializer_list<T> rhs) {
4258   return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));