Electroneum
Loading...
Searching...
No Matches
gmock-generated-matchers.h File Reference
#include <iterator>
#include <sstream>
#include <string>
#include <vector>
#include "gmock/gmock-matchers.h"
Include dependency graph for gmock-generated-matchers.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 >
class  testing::internal::TupleFields< Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >
class  testing::internal::TupleFields< Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1 >
class  testing::internal::TupleFields< Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1 >
class  testing::internal::TupleFields< Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1 >
class  testing::internal::TupleFields< Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1 >
class  testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1 >
class  testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1 >
class  testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1 >
class  testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1 >
class  testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1 >
class  testing::internal::ArgsMatcherImpl< ArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 >
class  testing::internal::ArgsMatcher< InnerMatcher, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 >
struct  testing::internal::AllOfResult1< M1 >
struct  testing::internal::AllOfResult2< M1, M2 >
struct  testing::internal::AllOfResult3< M1, M2, M3 >
struct  testing::internal::AllOfResult4< M1, M2, M3, M4 >
struct  testing::internal::AllOfResult5< M1, M2, M3, M4, M5 >
struct  testing::internal::AllOfResult6< M1, M2, M3, M4, M5, M6 >
struct  testing::internal::AllOfResult7< M1, M2, M3, M4, M5, M6, M7 >
struct  testing::internal::AllOfResult8< M1, M2, M3, M4, M5, M6, M7, M8 >
struct  testing::internal::AllOfResult9< M1, M2, M3, M4, M5, M6, M7, M8, M9 >
struct  testing::internal::AllOfResult10< M1, M2, M3, M4, M5, M6, M7, M8, M9, M10 >
struct  testing::internal::AnyOfResult1< M1 >
struct  testing::internal::AnyOfResult2< M1, M2 >
struct  testing::internal::AnyOfResult3< M1, M2, M3 >
struct  testing::internal::AnyOfResult4< M1, M2, M3, M4 >
struct  testing::internal::AnyOfResult5< M1, M2, M3, M4, M5 >
struct  testing::internal::AnyOfResult6< M1, M2, M3, M4, M5, M6 >
struct  testing::internal::AnyOfResult7< M1, M2, M3, M4, M5, M6, M7 >
struct  testing::internal::AnyOfResult8< M1, M2, M3, M4, M5, M6, M7, M8 >
struct  testing::internal::AnyOfResult9< M1, M2, M3, M4, M5, M6, M7, M8, M9 >
struct  testing::internal::AnyOfResult10< M1, M2, M3, M4, M5, M6, M7, M8, M9, M10 >

Namespaces

namespace  testing
namespace  testing::internal

Macros

#define GMOCK_FIELD_TYPE_(Tuple, i)
#define MATCHER(name, description)
 << DiffStrings(str, arg);
#define MATCHER_P(name, p0, description)
#define MATCHER_P2(name, p0, p1, description)
#define MATCHER_P3(name, p0, p1, p2, description)
#define MATCHER_P4(name, p0, p1, p2, p3, description)
#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)
#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)
#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)
#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)
#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)
#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)

Functions

template<typename InnerMatcher>
internal::ArgsMatcher< InnerMatcher > testing::Args (const InnerMatcher &matcher)
template<int k1, typename InnerMatcher>
internal::ArgsMatcher< InnerMatcher, k1 > testing::Args (const InnerMatcher &matcher)
template<int k1, int k2, typename InnerMatcher>
internal::ArgsMatcher< InnerMatcher, k1, k2 > testing::Args (const InnerMatcher &matcher)
template<int k1, int k2, int k3, typename InnerMatcher>
internal::ArgsMatcher< InnerMatcher, k1, k2, k3 > testing::Args (const InnerMatcher &matcher)
template<int k1, int k2, int k3, int k4, typename InnerMatcher>
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4 > testing::Args (const InnerMatcher &matcher)
template<int k1, int k2, int k3, int k4, int k5, typename InnerMatcher>
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5 > testing::Args (const InnerMatcher &matcher)
template<int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher>
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6 > testing::Args (const InnerMatcher &matcher)
template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, typename InnerMatcher>
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7 > testing::Args (const InnerMatcher &matcher)
template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, typename InnerMatcher>
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8 > testing::Args (const InnerMatcher &matcher)
template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, int k9, typename InnerMatcher>
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9 > testing::Args (const InnerMatcher &matcher)
template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, int k9, int k10, typename InnerMatcher>
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > testing::Args (const InnerMatcher &matcher)
internal::ElementsAreMatcher< ::testing::tuple<> > testing::ElementsAre ()
template<typename T1>
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type > > testing::ElementsAre (const T1 &e1)
template<typename T1, typename T2>
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type > > testing::ElementsAre (const T1 &e1, const T2 &e2)
template<typename T1, typename T2, typename T3>
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type > > testing::ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3)
template<typename T1, typename T2, typename T3, typename T4>
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type > > testing::ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4)
template<typename T1, typename T2, typename T3, typename T4, typename T5>
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type > > testing::ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5)
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type > > testing::ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6)
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type > > testing::ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7)
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type > > testing::ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8)
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type, typename internal::DecayArray< T9 >::type > > testing::ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8, const T9 &e9)
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type, typename internal::DecayArray< T9 >::type, typename internal::DecayArray< T10 >::type > > testing::ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8, const T9 &e9, const T10 &e10)
internal::UnorderedElementsAreMatcher< ::testing::tuple<> > testing::UnorderedElementsAre ()
template<typename T1>
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type > > testing::UnorderedElementsAre (const T1 &e1)
template<typename T1, typename T2>
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type > > testing::UnorderedElementsAre (const T1 &e1, const T2 &e2)
template<typename T1, typename T2, typename T3>
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type > > testing::UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3)
template<typename T1, typename T2, typename T3, typename T4>
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type > > testing::UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4)
template<typename T1, typename T2, typename T3, typename T4, typename T5>
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type > > testing::UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5)
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type > > testing::UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6)
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type > > testing::UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7)
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type > > testing::UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8)
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type, typename internal::DecayArray< T9 >::type > > testing::UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8, const T9 &e9)
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type, typename internal::DecayArray< T9 >::type, typename internal::DecayArray< T10 >::type > > testing::UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8, const T9 &e9, const T10 &e10)
template<typename M1, typename M2>
internal::AllOfResult2< M1, M2 >::type testing::AllOf (M1 m1, M2 m2)
template<typename M1, typename M2, typename M3>
internal::AllOfResult3< M1, M2, M3 >::type testing::AllOf (M1 m1, M2 m2, M3 m3)
template<typename M1, typename M2, typename M3, typename M4>
internal::AllOfResult4< M1, M2, M3, M4 >::type testing::AllOf (M1 m1, M2 m2, M3 m3, M4 m4)
template<typename M1, typename M2, typename M3, typename M4, typename M5>
internal::AllOfResult5< M1, M2, M3, M4, M5 >::type testing::AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5)
template<typename M1, typename M2, typename M3, typename M4, typename M5, typename M6>
internal::AllOfResult6< M1, M2, M3, M4, M5, M6 >::type testing::AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6)
template<typename M1, typename M2, typename M3, typename M4, typename M5, typename M6, typename M7>
internal::AllOfResult7< M1, M2, M3, M4, M5, M6, M7 >::type testing::AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7)
template<typename M1, typename M2, typename M3, typename M4, typename M5, typename M6, typename M7, typename M8>
internal::AllOfResult8< M1, M2, M3, M4, M5, M6, M7, M8 >::type testing::AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8)
template<typename M1, typename M2, typename M3, typename M4, typename M5, typename M6, typename M7, typename M8, typename M9>
internal::AllOfResult9< M1, M2, M3, M4, M5, M6, M7, M8, M9 >::type testing::AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9)
template<typename M1, typename M2, typename M3, typename M4, typename M5, typename M6, typename M7, typename M8, typename M9, typename M10>
internal::AllOfResult10< M1, M2, M3, M4, M5, M6, M7, M8, M9, M10 >::type testing::AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10)
template<typename M1, typename M2>
internal::AnyOfResult2< M1, M2 >::type testing::AnyOf (M1 m1, M2 m2)
template<typename M1, typename M2, typename M3>
internal::AnyOfResult3< M1, M2, M3 >::type testing::AnyOf (M1 m1, M2 m2, M3 m3)
template<typename M1, typename M2, typename M3, typename M4>
internal::AnyOfResult4< M1, M2, M3, M4 >::type testing::AnyOf (M1 m1, M2 m2, M3 m3, M4 m4)
template<typename M1, typename M2, typename M3, typename M4, typename M5>
internal::AnyOfResult5< M1, M2, M3, M4, M5 >::type testing::AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5)
template<typename M1, typename M2, typename M3, typename M4, typename M5, typename M6>
internal::AnyOfResult6< M1, M2, M3, M4, M5, M6 >::type testing::AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6)
template<typename M1, typename M2, typename M3, typename M4, typename M5, typename M6, typename M7>
internal::AnyOfResult7< M1, M2, M3, M4, M5, M6, M7 >::type testing::AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7)
template<typename M1, typename M2, typename M3, typename M4, typename M5, typename M6, typename M7, typename M8>
internal::AnyOfResult8< M1, M2, M3, M4, M5, M6, M7, M8 >::type testing::AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8)
template<typename M1, typename M2, typename M3, typename M4, typename M5, typename M6, typename M7, typename M8, typename M9>
internal::AnyOfResult9< M1, M2, M3, M4, M5, M6, M7, M8, M9 >::type testing::AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9)
template<typename M1, typename M2, typename M3, typename M4, typename M5, typename M6, typename M7, typename M8, typename M9, typename M10>
internal::AnyOfResult10< M1, M2, M3, M4, M5, M6, M7, M8, M9, M10 >::type testing::AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10)

Macro Definition Documentation

◆ GMOCK_FIELD_TYPE_

#define GMOCK_FIELD_TYPE_ ( Tuple,
i )
Value:
typename ::testing::tuple_element<i, Tuple>::type

Definition at line 51 of file gmock-generated-matchers.h.

51#define GMOCK_FIELD_TYPE_(Tuple, i) \
52 typename ::testing::tuple_element<i, Tuple>::type

◆ MATCHER

#define MATCHER ( name,
description )

<< DiffStrings(str, arg);

Definition at line 1381 of file gmock-generated-matchers.h.

1381#define MATCHER(name, description)\
1382 class name##Matcher {\
1383 public:\
1384 template <typename arg_type>\
1385 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1386 public:\
1387 gmock_Impl()\
1388 {}\
1389 virtual bool MatchAndExplain(\
1390 arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1391 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1392 *gmock_os << FormatDescription(false);\
1393 }\
1394 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1395 *gmock_os << FormatDescription(true);\
1396 }\
1397 private:\
1398 ::testing::internal::string FormatDescription(bool negation) const {\
1399 const ::testing::internal::string gmock_description = (description);\
1400 if (!gmock_description.empty())\
1401 return gmock_description;\
1402 return ::testing::internal::FormatMatcherDescription(\
1403 negation, #name, \
1404 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1405 ::testing::tuple<>()));\
1406 }\
1407 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1408 };\
1409 template <typename arg_type>\
1410 operator ::testing::Matcher<arg_type>() const {\
1411 return ::testing::Matcher<arg_type>(\
1412 new gmock_Impl<arg_type>());\
1413 }\
1414 name##Matcher() {\
1415 }\
1416 private:\
1417 GTEST_DISALLOW_ASSIGN_(name##Matcher);\
1418 };\
1419 inline name##Matcher name() {\
1420 return name##Matcher();\
1421 }\
1422 template <typename arg_type>\
1423 bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
1424 arg_type arg, \
1425 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1426 const

◆ MATCHER_P

#define MATCHER_P ( name,
p0,
description )

Definition at line 1428 of file gmock-generated-matchers.h.

1428#define MATCHER_P(name, p0, description)\
1429 template <typename p0##_type>\
1430 class name##MatcherP {\
1431 public:\
1432 template <typename arg_type>\
1433 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1434 public:\
1435 explicit gmock_Impl(p0##_type gmock_p0)\
1436 : p0(gmock_p0) {}\
1437 virtual bool MatchAndExplain(\
1438 arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1439 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1440 *gmock_os << FormatDescription(false);\
1441 }\
1442 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1443 *gmock_os << FormatDescription(true);\
1444 }\
1445 p0##_type p0;\
1446 private:\
1447 ::testing::internal::string FormatDescription(bool negation) const {\
1448 const ::testing::internal::string gmock_description = (description);\
1449 if (!gmock_description.empty())\
1450 return gmock_description;\
1451 return ::testing::internal::FormatMatcherDescription(\
1452 negation, #name, \
1453 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1454 ::testing::tuple<p0##_type>(p0)));\
1455 }\
1456 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1457 };\
1458 template <typename arg_type>\
1459 operator ::testing::Matcher<arg_type>() const {\
1460 return ::testing::Matcher<arg_type>(\
1461 new gmock_Impl<arg_type>(p0));\
1462 }\
1463 explicit name##MatcherP(p0##_type gmock_p0) : p0(gmock_p0) {\
1464 }\
1465 p0##_type p0;\
1466 private:\
1467 GTEST_DISALLOW_ASSIGN_(name##MatcherP);\
1468 };\
1469 template <typename p0##_type>\
1470 inline name##MatcherP<p0##_type> name(p0##_type p0) {\
1471 return name##MatcherP<p0##_type>(p0);\
1472 }\
1473 template <typename p0##_type>\
1474 template <typename arg_type>\
1475 bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1476 arg_type arg, \
1477 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1478 const

◆ MATCHER_P10

#define MATCHER_P10 ( name,
p0,
p1,
p2,
p3,
p4,
p5,
p6,
p7,
p8,
p9,
description )

Definition at line 2080 of file gmock-generated-matchers.h.

2080#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
2081 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2082 typename p3##_type, typename p4##_type, typename p5##_type, \
2083 typename p6##_type, typename p7##_type, typename p8##_type, \
2084 typename p9##_type>\
2085 class name##MatcherP10 {\
2086 public:\
2087 template <typename arg_type>\
2088 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
2089 public:\
2090 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
2091 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
2092 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
2093 p9##_type gmock_p9)\
2094 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
2095 p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
2096 p8(gmock_p8), p9(gmock_p9) {}\
2097 virtual bool MatchAndExplain(\
2098 arg_type arg, ::testing::MatchResultListener* result_listener) const;\
2099 virtual void DescribeTo(::std::ostream* gmock_os) const {\
2100 *gmock_os << FormatDescription(false);\
2101 }\
2102 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
2103 *gmock_os << FormatDescription(true);\
2104 }\
2105 p0##_type p0;\
2106 p1##_type p1;\
2107 p2##_type p2;\
2108 p3##_type p3;\
2109 p4##_type p4;\
2110 p5##_type p5;\
2111 p6##_type p6;\
2112 p7##_type p7;\
2113 p8##_type p8;\
2114 p9##_type p9;\
2115 private:\
2116 ::testing::internal::string FormatDescription(bool negation) const {\
2117 const ::testing::internal::string gmock_description = (description);\
2118 if (!gmock_description.empty())\
2119 return gmock_description;\
2120 return ::testing::internal::FormatMatcherDescription(\
2121 negation, #name, \
2122 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
2123 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
2124 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2125 p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
2126 }\
2127 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
2128 };\
2129 template <typename arg_type>\
2130 operator ::testing::Matcher<arg_type>() const {\
2131 return ::testing::Matcher<arg_type>(\
2132 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
2133 }\
2134 name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \
2135 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
2136 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
2137 p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \
2138 p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
2139 p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {\
2140 }\
2141 p0##_type p0;\
2142 p1##_type p1;\
2143 p2##_type p2;\
2144 p3##_type p3;\
2145 p4##_type p4;\
2146 p5##_type p5;\
2147 p6##_type p6;\
2148 p7##_type p7;\
2149 p8##_type p8;\
2150 p9##_type p9;\
2151 private:\
2152 GTEST_DISALLOW_ASSIGN_(name##MatcherP10);\
2153 };\
2154 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2155 typename p3##_type, typename p4##_type, typename p5##_type, \
2156 typename p6##_type, typename p7##_type, typename p8##_type, \
2157 typename p9##_type>\
2158 inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2159 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2160 p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
2161 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
2162 p9##_type p9) {\
2163 return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2164 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
2165 p1, p2, p3, p4, p5, p6, p7, p8, p9);\
2166 }\
2167 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2168 typename p3##_type, typename p4##_type, typename p5##_type, \
2169 typename p6##_type, typename p7##_type, typename p8##_type, \
2170 typename p9##_type>\
2171 template <typename arg_type>\
2172 bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2173 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2174 p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
2175 arg_type arg, \
2176 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
2177 const

◆ MATCHER_P2

#define MATCHER_P2 ( name,
p0,
p1,
description )

Definition at line 1480 of file gmock-generated-matchers.h.

1480#define MATCHER_P2(name, p0, p1, description)\
1481 template <typename p0##_type, typename p1##_type>\
1482 class name##MatcherP2 {\
1483 public:\
1484 template <typename arg_type>\
1485 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1486 public:\
1487 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
1488 : p0(gmock_p0), p1(gmock_p1) {}\
1489 virtual bool MatchAndExplain(\
1490 arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1491 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1492 *gmock_os << FormatDescription(false);\
1493 }\
1494 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1495 *gmock_os << FormatDescription(true);\
1496 }\
1497 p0##_type p0;\
1498 p1##_type p1;\
1499 private:\
1500 ::testing::internal::string FormatDescription(bool negation) const {\
1501 const ::testing::internal::string gmock_description = (description);\
1502 if (!gmock_description.empty())\
1503 return gmock_description;\
1504 return ::testing::internal::FormatMatcherDescription(\
1505 negation, #name, \
1506 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1507 ::testing::tuple<p0##_type, p1##_type>(p0, p1)));\
1508 }\
1509 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1510 };\
1511 template <typename arg_type>\
1512 operator ::testing::Matcher<arg_type>() const {\
1513 return ::testing::Matcher<arg_type>(\
1514 new gmock_Impl<arg_type>(p0, p1));\
1515 }\
1516 name##MatcherP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
1517 p1(gmock_p1) {\
1518 }\
1519 p0##_type p0;\
1520 p1##_type p1;\
1521 private:\
1522 GTEST_DISALLOW_ASSIGN_(name##MatcherP2);\
1523 };\
1524 template <typename p0##_type, typename p1##_type>\
1525 inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
1526 p1##_type p1) {\
1527 return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\
1528 }\
1529 template <typename p0##_type, typename p1##_type>\
1530 template <typename arg_type>\
1531 bool name##MatcherP2<p0##_type, \
1532 p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1533 arg_type arg, \
1534 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1535 const

◆ MATCHER_P3

#define MATCHER_P3 ( name,
p0,
p1,
p2,
description )

Definition at line 1537 of file gmock-generated-matchers.h.

1537#define MATCHER_P3(name, p0, p1, p2, description)\
1538 template <typename p0##_type, typename p1##_type, typename p2##_type>\
1539 class name##MatcherP3 {\
1540 public:\
1541 template <typename arg_type>\
1542 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1543 public:\
1544 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
1545 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
1546 virtual bool MatchAndExplain(\
1547 arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1548 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1549 *gmock_os << FormatDescription(false);\
1550 }\
1551 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1552 *gmock_os << FormatDescription(true);\
1553 }\
1554 p0##_type p0;\
1555 p1##_type p1;\
1556 p2##_type p2;\
1557 private:\
1558 ::testing::internal::string FormatDescription(bool negation) const {\
1559 const ::testing::internal::string gmock_description = (description);\
1560 if (!gmock_description.empty())\
1561 return gmock_description;\
1562 return ::testing::internal::FormatMatcherDescription(\
1563 negation, #name, \
1564 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1565 ::testing::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, \
1566 p2)));\
1567 }\
1568 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1569 };\
1570 template <typename arg_type>\
1571 operator ::testing::Matcher<arg_type>() const {\
1572 return ::testing::Matcher<arg_type>(\
1573 new gmock_Impl<arg_type>(p0, p1, p2));\
1574 }\
1575 name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
1576 p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {\
1577 }\
1578 p0##_type p0;\
1579 p1##_type p1;\
1580 p2##_type p2;\
1581 private:\
1582 GTEST_DISALLOW_ASSIGN_(name##MatcherP3);\
1583 };\
1584 template <typename p0##_type, typename p1##_type, typename p2##_type>\
1585 inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
1586 p1##_type p1, p2##_type p2) {\
1587 return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
1588 }\
1589 template <typename p0##_type, typename p1##_type, typename p2##_type>\
1590 template <typename arg_type>\
1591 bool name##MatcherP3<p0##_type, p1##_type, \
1592 p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1593 arg_type arg, \
1594 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1595 const

◆ MATCHER_P4

#define MATCHER_P4 ( name,
p0,
p1,
p2,
p3,
description )

Definition at line 1597 of file gmock-generated-matchers.h.

1597#define MATCHER_P4(name, p0, p1, p2, p3, description)\
1598 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1599 typename p3##_type>\
1600 class name##MatcherP4 {\
1601 public:\
1602 template <typename arg_type>\
1603 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1604 public:\
1605 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1606 p3##_type gmock_p3)\
1607 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3) {}\
1608 virtual bool MatchAndExplain(\
1609 arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1610 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1611 *gmock_os << FormatDescription(false);\
1612 }\
1613 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1614 *gmock_os << FormatDescription(true);\
1615 }\
1616 p0##_type p0;\
1617 p1##_type p1;\
1618 p2##_type p2;\
1619 p3##_type p3;\
1620 private:\
1621 ::testing::internal::string FormatDescription(bool negation) const {\
1622 const ::testing::internal::string gmock_description = (description);\
1623 if (!gmock_description.empty())\
1624 return gmock_description;\
1625 return ::testing::internal::FormatMatcherDescription(\
1626 negation, #name, \
1627 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1628 ::testing::tuple<p0##_type, p1##_type, p2##_type, \
1629 p3##_type>(p0, p1, p2, p3)));\
1630 }\
1631 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1632 };\
1633 template <typename arg_type>\
1634 operator ::testing::Matcher<arg_type>() const {\
1635 return ::testing::Matcher<arg_type>(\
1636 new gmock_Impl<arg_type>(p0, p1, p2, p3));\
1637 }\
1638 name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
1639 p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
1640 p2(gmock_p2), p3(gmock_p3) {\
1641 }\
1642 p0##_type p0;\
1643 p1##_type p1;\
1644 p2##_type p2;\
1645 p3##_type p3;\
1646 private:\
1647 GTEST_DISALLOW_ASSIGN_(name##MatcherP4);\
1648 };\
1649 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1650 typename p3##_type>\
1651 inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \
1652 p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1653 p3##_type p3) {\
1654 return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
1655 p1, p2, p3);\
1656 }\
1657 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1658 typename p3##_type>\
1659 template <typename arg_type>\
1660 bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \
1661 p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1662 arg_type arg, \
1663 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1664 const

◆ MATCHER_P5

#define MATCHER_P5 ( name,
p0,
p1,
p2,
p3,
p4,
description )

Definition at line 1666 of file gmock-generated-matchers.h.

1666#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
1667 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1668 typename p3##_type, typename p4##_type>\
1669 class name##MatcherP5 {\
1670 public:\
1671 template <typename arg_type>\
1672 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1673 public:\
1674 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1675 p3##_type gmock_p3, p4##_type gmock_p4)\
1676 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
1677 p4(gmock_p4) {}\
1678 virtual bool MatchAndExplain(\
1679 arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1680 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1681 *gmock_os << FormatDescription(false);\
1682 }\
1683 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1684 *gmock_os << FormatDescription(true);\
1685 }\
1686 p0##_type p0;\
1687 p1##_type p1;\
1688 p2##_type p2;\
1689 p3##_type p3;\
1690 p4##_type p4;\
1691 private:\
1692 ::testing::internal::string FormatDescription(bool negation) const {\
1693 const ::testing::internal::string gmock_description = (description);\
1694 if (!gmock_description.empty())\
1695 return gmock_description;\
1696 return ::testing::internal::FormatMatcherDescription(\
1697 negation, #name, \
1698 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1699 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1700 p4##_type>(p0, p1, p2, p3, p4)));\
1701 }\
1702 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1703 };\
1704 template <typename arg_type>\
1705 operator ::testing::Matcher<arg_type>() const {\
1706 return ::testing::Matcher<arg_type>(\
1707 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\
1708 }\
1709 name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
1710 p2##_type gmock_p2, p3##_type gmock_p3, \
1711 p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1712 p3(gmock_p3), p4(gmock_p4) {\
1713 }\
1714 p0##_type p0;\
1715 p1##_type p1;\
1716 p2##_type p2;\
1717 p3##_type p3;\
1718 p4##_type p4;\
1719 private:\
1720 GTEST_DISALLOW_ASSIGN_(name##MatcherP5);\
1721 };\
1722 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1723 typename p3##_type, typename p4##_type>\
1724 inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1725 p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1726 p4##_type p4) {\
1727 return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1728 p4##_type>(p0, p1, p2, p3, p4);\
1729 }\
1730 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1731 typename p3##_type, typename p4##_type>\
1732 template <typename arg_type>\
1733 bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1734 p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1735 arg_type arg, \
1736 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1737 const

◆ MATCHER_P6

#define MATCHER_P6 ( name,
p0,
p1,
p2,
p3,
p4,
p5,
description )

Definition at line 1739 of file gmock-generated-matchers.h.

1739#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
1740 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1741 typename p3##_type, typename p4##_type, typename p5##_type>\
1742 class name##MatcherP6 {\
1743 public:\
1744 template <typename arg_type>\
1745 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1746 public:\
1747 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1748 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\
1749 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
1750 p4(gmock_p4), p5(gmock_p5) {}\
1751 virtual bool MatchAndExplain(\
1752 arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1753 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1754 *gmock_os << FormatDescription(false);\
1755 }\
1756 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1757 *gmock_os << FormatDescription(true);\
1758 }\
1759 p0##_type p0;\
1760 p1##_type p1;\
1761 p2##_type p2;\
1762 p3##_type p3;\
1763 p4##_type p4;\
1764 p5##_type p5;\
1765 private:\
1766 ::testing::internal::string FormatDescription(bool negation) const {\
1767 const ::testing::internal::string gmock_description = (description);\
1768 if (!gmock_description.empty())\
1769 return gmock_description;\
1770 return ::testing::internal::FormatMatcherDescription(\
1771 negation, #name, \
1772 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1773 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1774 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
1775 }\
1776 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1777 };\
1778 template <typename arg_type>\
1779 operator ::testing::Matcher<arg_type>() const {\
1780 return ::testing::Matcher<arg_type>(\
1781 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\
1782 }\
1783 name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \
1784 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1785 p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1786 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {\
1787 }\
1788 p0##_type p0;\
1789 p1##_type p1;\
1790 p2##_type p2;\
1791 p3##_type p3;\
1792 p4##_type p4;\
1793 p5##_type p5;\
1794 private:\
1795 GTEST_DISALLOW_ASSIGN_(name##MatcherP6);\
1796 };\
1797 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1798 typename p3##_type, typename p4##_type, typename p5##_type>\
1799 inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1800 p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1801 p3##_type p3, p4##_type p4, p5##_type p5) {\
1802 return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1803 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
1804 }\
1805 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1806 typename p3##_type, typename p4##_type, typename p5##_type>\
1807 template <typename arg_type>\
1808 bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1809 p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1810 arg_type arg, \
1811 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1812 const

◆ MATCHER_P7

#define MATCHER_P7 ( name,
p0,
p1,
p2,
p3,
p4,
p5,
p6,
description )

Definition at line 1814 of file gmock-generated-matchers.h.

1814#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
1815 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1816 typename p3##_type, typename p4##_type, typename p5##_type, \
1817 typename p6##_type>\
1818 class name##MatcherP7 {\
1819 public:\
1820 template <typename arg_type>\
1821 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1822 public:\
1823 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1824 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1825 p6##_type gmock_p6)\
1826 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
1827 p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
1828 virtual bool MatchAndExplain(\
1829 arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1830 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1831 *gmock_os << FormatDescription(false);\
1832 }\
1833 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1834 *gmock_os << FormatDescription(true);\
1835 }\
1836 p0##_type p0;\
1837 p1##_type p1;\
1838 p2##_type p2;\
1839 p3##_type p3;\
1840 p4##_type p4;\
1841 p5##_type p5;\
1842 p6##_type p6;\
1843 private:\
1844 ::testing::internal::string FormatDescription(bool negation) const {\
1845 const ::testing::internal::string gmock_description = (description);\
1846 if (!gmock_description.empty())\
1847 return gmock_description;\
1848 return ::testing::internal::FormatMatcherDescription(\
1849 negation, #name, \
1850 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1851 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1852 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \
1853 p6)));\
1854 }\
1855 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1856 };\
1857 template <typename arg_type>\
1858 operator ::testing::Matcher<arg_type>() const {\
1859 return ::testing::Matcher<arg_type>(\
1860 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\
1861 }\
1862 name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \
1863 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1864 p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \
1865 p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
1866 p6(gmock_p6) {\
1867 }\
1868 p0##_type p0;\
1869 p1##_type p1;\
1870 p2##_type p2;\
1871 p3##_type p3;\
1872 p4##_type p4;\
1873 p5##_type p5;\
1874 p6##_type p6;\
1875 private:\
1876 GTEST_DISALLOW_ASSIGN_(name##MatcherP7);\
1877 };\
1878 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1879 typename p3##_type, typename p4##_type, typename p5##_type, \
1880 typename p6##_type>\
1881 inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1882 p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
1883 p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
1884 p6##_type p6) {\
1885 return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1886 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
1887 }\
1888 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1889 typename p3##_type, typename p4##_type, typename p5##_type, \
1890 typename p6##_type>\
1891 template <typename arg_type>\
1892 bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1893 p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1894 arg_type arg, \
1895 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1896 const

◆ MATCHER_P8

#define MATCHER_P8 ( name,
p0,
p1,
p2,
p3,
p4,
p5,
p6,
p7,
description )

Definition at line 1898 of file gmock-generated-matchers.h.

1898#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
1899 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1900 typename p3##_type, typename p4##_type, typename p5##_type, \
1901 typename p6##_type, typename p7##_type>\
1902 class name##MatcherP8 {\
1903 public:\
1904 template <typename arg_type>\
1905 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1906 public:\
1907 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1908 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1909 p6##_type gmock_p6, p7##_type gmock_p7)\
1910 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
1911 p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
1912 virtual bool MatchAndExplain(\
1913 arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1914 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1915 *gmock_os << FormatDescription(false);\
1916 }\
1917 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1918 *gmock_os << FormatDescription(true);\
1919 }\
1920 p0##_type p0;\
1921 p1##_type p1;\
1922 p2##_type p2;\
1923 p3##_type p3;\
1924 p4##_type p4;\
1925 p5##_type p5;\
1926 p6##_type p6;\
1927 p7##_type p7;\
1928 private:\
1929 ::testing::internal::string FormatDescription(bool negation) const {\
1930 const ::testing::internal::string gmock_description = (description);\
1931 if (!gmock_description.empty())\
1932 return gmock_description;\
1933 return ::testing::internal::FormatMatcherDescription(\
1934 negation, #name, \
1935 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1936 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1937 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \
1938 p3, p4, p5, p6, p7)));\
1939 }\
1940 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1941 };\
1942 template <typename arg_type>\
1943 operator ::testing::Matcher<arg_type>() const {\
1944 return ::testing::Matcher<arg_type>(\
1945 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\
1946 }\
1947 name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \
1948 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1949 p5##_type gmock_p5, p6##_type gmock_p6, \
1950 p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1951 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1952 p7(gmock_p7) {\
1953 }\
1954 p0##_type p0;\
1955 p1##_type p1;\
1956 p2##_type p2;\
1957 p3##_type p3;\
1958 p4##_type p4;\
1959 p5##_type p5;\
1960 p6##_type p6;\
1961 p7##_type p7;\
1962 private:\
1963 GTEST_DISALLOW_ASSIGN_(name##MatcherP8);\
1964 };\
1965 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1966 typename p3##_type, typename p4##_type, typename p5##_type, \
1967 typename p6##_type, typename p7##_type>\
1968 inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
1969 p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
1970 p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
1971 p6##_type p6, p7##_type p7) {\
1972 return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
1973 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
1974 p6, p7);\
1975 }\
1976 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1977 typename p3##_type, typename p4##_type, typename p5##_type, \
1978 typename p6##_type, typename p7##_type>\
1979 template <typename arg_type>\
1980 bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1981 p5##_type, p6##_type, \
1982 p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1983 arg_type arg, \
1984 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1985 const

◆ MATCHER_P9

#define MATCHER_P9 ( name,
p0,
p1,
p2,
p3,
p4,
p5,
p6,
p7,
p8,
description )

Definition at line 1987 of file gmock-generated-matchers.h.

1987#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
1988 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1989 typename p3##_type, typename p4##_type, typename p5##_type, \
1990 typename p6##_type, typename p7##_type, typename p8##_type>\
1991 class name##MatcherP9 {\
1992 public:\
1993 template <typename arg_type>\
1994 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1995 public:\
1996 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1997 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1998 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\
1999 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
2000 p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
2001 p8(gmock_p8) {}\
2002 virtual bool MatchAndExplain(\
2003 arg_type arg, ::testing::MatchResultListener* result_listener) const;\
2004 virtual void DescribeTo(::std::ostream* gmock_os) const {\
2005 *gmock_os << FormatDescription(false);\
2006 }\
2007 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
2008 *gmock_os << FormatDescription(true);\
2009 }\
2010 p0##_type p0;\
2011 p1##_type p1;\
2012 p2##_type p2;\
2013 p3##_type p3;\
2014 p4##_type p4;\
2015 p5##_type p5;\
2016 p6##_type p6;\
2017 p7##_type p7;\
2018 p8##_type p8;\
2019 private:\
2020 ::testing::internal::string FormatDescription(bool negation) const {\
2021 const ::testing::internal::string gmock_description = (description);\
2022 if (!gmock_description.empty())\
2023 return gmock_description;\
2024 return ::testing::internal::FormatMatcherDescription(\
2025 negation, #name, \
2026 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
2027 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
2028 p4##_type, p5##_type, p6##_type, p7##_type, \
2029 p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
2030 }\
2031 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
2032 };\
2033 template <typename arg_type>\
2034 operator ::testing::Matcher<arg_type>() const {\
2035 return ::testing::Matcher<arg_type>(\
2036 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
2037 }\
2038 name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \
2039 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
2040 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
2041 p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
2042 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
2043 p8(gmock_p8) {\
2044 }\
2045 p0##_type p0;\
2046 p1##_type p1;\
2047 p2##_type p2;\
2048 p3##_type p3;\
2049 p4##_type p4;\
2050 p5##_type p5;\
2051 p6##_type p6;\
2052 p7##_type p7;\
2053 p8##_type p8;\
2054 private:\
2055 GTEST_DISALLOW_ASSIGN_(name##MatcherP9);\
2056 };\
2057 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2058 typename p3##_type, typename p4##_type, typename p5##_type, \
2059 typename p6##_type, typename p7##_type, typename p8##_type>\
2060 inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
2061 p4##_type, p5##_type, p6##_type, p7##_type, \
2062 p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
2063 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
2064 p8##_type p8) {\
2065 return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
2066 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
2067 p3, p4, p5, p6, p7, p8);\
2068 }\
2069 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2070 typename p3##_type, typename p4##_type, typename p5##_type, \
2071 typename p6##_type, typename p7##_type, typename p8##_type>\
2072 template <typename arg_type>\
2073 bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
2074 p5##_type, p6##_type, p7##_type, \
2075 p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
2076 arg_type arg, \
2077 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
2078 const