Monero
Loading...
Searching...
No Matches
gmock-generated-matchers.h
Go to the documentation of this file.
1// This file was GENERATED by command:
2// pump.py gmock-generated-matchers.h.pump
3// DO NOT EDIT BY HAND!!!
4
5// Copyright 2008, Google Inc.
6// All rights reserved.
7//
8// Redistribution and use in source and binary forms, with or without
9// modification, are permitted provided that the following conditions are
10// met:
11//
12// * Redistributions of source code must retain the above copyright
13// notice, this list of conditions and the following disclaimer.
14// * Redistributions in binary form must reproduce the above
15// copyright notice, this list of conditions and the following disclaimer
16// in the documentation and/or other materials provided with the
17// distribution.
18// * Neither the name of Google Inc. nor the names of its
19// contributors may be used to endorse or promote products derived from
20// this software without specific prior written permission.
21//
22// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33
34// Google Mock - a framework for writing C++ mock classes.
35//
36// This file implements some commonly used variadic matchers.
37
38#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
39#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
40
41#include <iterator>
42#include <sstream>
43#include <string>
44#include <vector>
45#include "gmock/gmock-matchers.h"
46
47namespace testing {
48namespace internal {
49
50// The type of the i-th (0-based) field of Tuple.
51#define GMOCK_FIELD_TYPE_(Tuple, i) \
52 typename ::testing::tuple_element<i, Tuple>::type
53
54// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
55// tuple of type Tuple. It has two members:
56//
57// type: a tuple type whose i-th field is the ki-th field of Tuple.
58// GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
59//
60// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
61//
62// type is tuple<int, bool>, and
63// GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
64
65template <class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
66 int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
67 int k9 = -1>
68class TupleFields;
69
70// This generic version is used when there are 10 selectors.
71template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
72 int k7, int k8, int k9>
73class TupleFields {
74 public:
75 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
76 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
77 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
78 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
79 GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8),
80 GMOCK_FIELD_TYPE_(Tuple, k9)> type;
81 static type GetSelectedFields(const Tuple& t) {
82 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
83 get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t), get<k9>(t));
84 }
85};
86
87// The following specialization is used for 0 ~ 9 selectors.
88
89template <class Tuple>
90class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
91 public:
92 typedef ::testing::tuple<> type;
93 static type GetSelectedFields(const Tuple& /* t */) {
94 return type();
95 }
96};
97
98template <class Tuple, int k0>
99class TupleFields<Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
100 public:
101 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0)> type;
102 static type GetSelectedFields(const Tuple& t) {
103 return type(get<k0>(t));
104 }
105};
106
107template <class Tuple, int k0, int k1>
108class TupleFields<Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1> {
109 public:
110 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
111 GMOCK_FIELD_TYPE_(Tuple, k1)> type;
112 static type GetSelectedFields(const Tuple& t) {
113 return type(get<k0>(t), get<k1>(t));
114 }
115};
116
117template <class Tuple, int k0, int k1, int k2>
118class TupleFields<Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1> {
119 public:
120 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
121 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type;
122 static type GetSelectedFields(const Tuple& t) {
123 return type(get<k0>(t), get<k1>(t), get<k2>(t));
124 }
125};
126
127template <class Tuple, int k0, int k1, int k2, int k3>
128class TupleFields<Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1> {
129 public:
130 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
131 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
132 GMOCK_FIELD_TYPE_(Tuple, k3)> type;
133 static type GetSelectedFields(const Tuple& t) {
134 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t));
135 }
136};
137
138template <class Tuple, int k0, int k1, int k2, int k3, int k4>
139class TupleFields<Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1> {
140 public:
141 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
142 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
143 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type;
144 static type GetSelectedFields(const Tuple& t) {
145 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t));
146 }
147};
148
149template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5>
150class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1> {
151 public:
152 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
153 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
154 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
155 GMOCK_FIELD_TYPE_(Tuple, k5)> type;
156 static type GetSelectedFields(const Tuple& t) {
157 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
158 get<k5>(t));
159 }
160};
161
162template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6>
163class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1> {
164 public:
165 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
166 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
167 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
168 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type;
169 static type GetSelectedFields(const Tuple& t) {
170 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
171 get<k5>(t), get<k6>(t));
172 }
173};
174
175template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
176 int k7>
177class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1> {
178 public:
179 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
180 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
181 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
182 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
183 GMOCK_FIELD_TYPE_(Tuple, k7)> type;
184 static type GetSelectedFields(const Tuple& t) {
185 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
186 get<k5>(t), get<k6>(t), get<k7>(t));
187 }
188};
189
190template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
191 int k7, int k8>
192class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1> {
193 public:
194 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
195 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
196 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
197 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
198 GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type;
199 static type GetSelectedFields(const Tuple& t) {
200 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
201 get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t));
202 }
203};
204
205#undef GMOCK_FIELD_TYPE_
206
207// Implements the Args() matcher.
208template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
209 int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
210 int k9 = -1>
211class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
212 public:
213 // ArgsTuple may have top-level const or reference modifiers.
214 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
215 typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5,
216 k6, k7, k8, k9>::type SelectedArgs;
217 typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
218
219 template <typename InnerMatcher>
220 explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
221 : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
222
223 virtual bool MatchAndExplain(ArgsTuple args,
224 MatchResultListener* listener) const {
225 const SelectedArgs& selected_args = GetSelectedArgs(args);
226 if (!listener->IsInterested())
227 return inner_matcher_.Matches(selected_args);
228
229 PrintIndices(listener->stream());
230 *listener << "are " << PrintToString(selected_args);
231
232 StringMatchResultListener inner_listener;
233 const bool match = inner_matcher_.MatchAndExplain(selected_args,
234 &inner_listener);
235 PrintIfNotEmpty(inner_listener.str(), listener->stream());
236 return match;
237 }
238
239 virtual void DescribeTo(::std::ostream* os) const {
240 *os << "are a tuple ";
241 PrintIndices(os);
242 inner_matcher_.DescribeTo(os);
243 }
244
245 virtual void DescribeNegationTo(::std::ostream* os) const {
246 *os << "are a tuple ";
247 PrintIndices(os);
248 inner_matcher_.DescribeNegationTo(os);
249 }
250
251 private:
252 static SelectedArgs GetSelectedArgs(ArgsTuple args) {
253 return TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,
254 k9>::GetSelectedFields(args);
255 }
256
257 // Prints the indices of the selected fields.
258 static void PrintIndices(::std::ostream* os) {
259 *os << "whose fields (";
260 const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 };
261 for (int i = 0; i < 10; i++) {
262 if (indices[i] < 0)
263 break;
264
265 if (i >= 1)
266 *os << ", ";
267
268 *os << "#" << indices[i];
269 }
270 *os << ") ";
271 }
272
273 const MonomorphicInnerMatcher inner_matcher_;
274
275 GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
276};
277
278template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
279 int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1,
280 int k8 = -1, int k9 = -1>
281class ArgsMatcher {
282 public:
283 explicit ArgsMatcher(const InnerMatcher& inner_matcher)
284 : inner_matcher_(inner_matcher) {}
285
286 template <typename ArgsTuple>
287 operator Matcher<ArgsTuple>() const {
288 return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k0, k1, k2, k3, k4, k5,
289 k6, k7, k8, k9>(inner_matcher_));
290 }
291
292 private:
293 const InnerMatcher inner_matcher_;
294
295 GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
296};
297
298// A set of metafunctions for computing the result type of AllOf.
299// AllOf(m1, ..., mN) returns
300// AllOfResultN<decltype(m1), ..., decltype(mN)>::type.
301
302// Although AllOf isn't defined for one argument, AllOfResult1 is defined
303// to simplify the implementation.
304template <typename M1>
305struct AllOfResult1 {
306 typedef M1 type;
307};
308
309template <typename M1, typename M2>
310struct AllOfResult2 {
311 typedef BothOfMatcher<
312 typename AllOfResult1<M1>::type,
313 typename AllOfResult1<M2>::type
314 > type;
315};
316
317template <typename M1, typename M2, typename M3>
318struct AllOfResult3 {
319 typedef BothOfMatcher<
320 typename AllOfResult1<M1>::type,
321 typename AllOfResult2<M2, M3>::type
322 > type;
323};
324
325template <typename M1, typename M2, typename M3, typename M4>
326struct AllOfResult4 {
327 typedef BothOfMatcher<
328 typename AllOfResult2<M1, M2>::type,
329 typename AllOfResult2<M3, M4>::type
330 > type;
331};
332
333template <typename M1, typename M2, typename M3, typename M4, typename M5>
334struct AllOfResult5 {
335 typedef BothOfMatcher<
336 typename AllOfResult2<M1, M2>::type,
337 typename AllOfResult3<M3, M4, M5>::type
338 > type;
339};
340
341template <typename M1, typename M2, typename M3, typename M4, typename M5,
342 typename M6>
349
350template <typename M1, typename M2, typename M3, typename M4, typename M5,
351 typename M6, typename M7>
358
359template <typename M1, typename M2, typename M3, typename M4, typename M5,
360 typename M6, typename M7, typename M8>
367
368template <typename M1, typename M2, typename M3, typename M4, typename M5,
369 typename M6, typename M7, typename M8, typename M9>
376
377template <typename M1, typename M2, typename M3, typename M4, typename M5,
378 typename M6, typename M7, typename M8, typename M9, typename M10>
385
386// A set of metafunctions for computing the result type of AnyOf.
387// AnyOf(m1, ..., mN) returns
388// AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.
389
390// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
391// to simplify the implementation.
392template <typename M1>
393struct AnyOfResult1 {
394 typedef M1 type;
395};
396
397template <typename M1, typename M2>
398struct AnyOfResult2 {
399 typedef EitherOfMatcher<
400 typename AnyOfResult1<M1>::type,
401 typename AnyOfResult1<M2>::type
402 > type;
403};
404
405template <typename M1, typename M2, typename M3>
406struct AnyOfResult3 {
407 typedef EitherOfMatcher<
408 typename AnyOfResult1<M1>::type,
409 typename AnyOfResult2<M2, M3>::type
410 > type;
411};
412
413template <typename M1, typename M2, typename M3, typename M4>
414struct AnyOfResult4 {
415 typedef EitherOfMatcher<
416 typename AnyOfResult2<M1, M2>::type,
417 typename AnyOfResult2<M3, M4>::type
418 > type;
419};
420
421template <typename M1, typename M2, typename M3, typename M4, typename M5>
428
429template <typename M1, typename M2, typename M3, typename M4, typename M5,
430 typename M6>
437
438template <typename M1, typename M2, typename M3, typename M4, typename M5,
439 typename M6, typename M7>
446
447template <typename M1, typename M2, typename M3, typename M4, typename M5,
448 typename M6, typename M7, typename M8>
455
456template <typename M1, typename M2, typename M3, typename M4, typename M5,
457 typename M6, typename M7, typename M8, typename M9>
464
465template <typename M1, typename M2, typename M3, typename M4, typename M5,
466 typename M6, typename M7, typename M8, typename M9, typename M10>
473
474} // namespace internal
475
476// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
477// fields of it matches a_matcher. C++ doesn't support default
478// arguments for function templates, so we have to overload it.
479template <typename InnerMatcher>
480inline internal::ArgsMatcher<InnerMatcher>
481Args(const InnerMatcher& matcher) {
482 return internal::ArgsMatcher<InnerMatcher>(matcher);
483}
484
485template <int k1, typename InnerMatcher>
486inline internal::ArgsMatcher<InnerMatcher, k1>
487Args(const InnerMatcher& matcher) {
488 return internal::ArgsMatcher<InnerMatcher, k1>(matcher);
489}
490
491template <int k1, int k2, typename InnerMatcher>
492inline internal::ArgsMatcher<InnerMatcher, k1, k2>
493Args(const InnerMatcher& matcher) {
494 return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher);
495}
496
497template <int k1, int k2, int k3, typename InnerMatcher>
498inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3>
499Args(const InnerMatcher& matcher) {
500 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher);
501}
502
503template <int k1, int k2, int k3, int k4, typename InnerMatcher>
504inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>
505Args(const InnerMatcher& matcher) {
506 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher);
507}
508
509template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher>
510inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>
511Args(const InnerMatcher& matcher) {
512 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher);
513}
514
515template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher>
516inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>
517Args(const InnerMatcher& matcher) {
518 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher);
519}
520
521template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
522 typename InnerMatcher>
523inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7>
524Args(const InnerMatcher& matcher) {
525 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6,
526 k7>(matcher);
527}
528
529template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
530 typename InnerMatcher>
531inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8>
532Args(const InnerMatcher& matcher) {
533 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
534 k8>(matcher);
535}
536
537template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
538 int k9, typename InnerMatcher>
539inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9>
540Args(const InnerMatcher& matcher) {
541 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
542 k9>(matcher);
543}
544
545template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
546 int k9, int k10, typename InnerMatcher>
547inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9,
548 k10>
549Args(const InnerMatcher& matcher) {
550 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
551 k9, k10>(matcher);
552}
553
554// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
555// n elements, where the i-th element in the container must
556// match the i-th argument in the list. Each argument of
557// ElementsAre() can be either a value or a matcher. We support up to
558// 10 arguments.
559//
560// The use of DecayArray in the implementation allows ElementsAre()
561// to accept string literals, whose type is const char[N], but we
562// want to treat them as const char*.
563//
564// NOTE: Since ElementsAre() cares about the order of the elements, it
565// must not be used with containers whose elements's order is
566// undefined (e.g. hash_map).
567
568inline internal::ElementsAreMatcher<
569 ::testing::tuple<> >
570ElementsAre() {
571 typedef ::testing::tuple<> Args;
572 return internal::ElementsAreMatcher<Args>(Args());
573}
574
575template <typename T1>
576inline internal::ElementsAreMatcher<
577 ::testing::tuple<
578 typename internal::DecayArray<T1>::type> >
579ElementsAre(const T1& e1) {
580 typedef ::testing::tuple<
581 typename internal::DecayArray<T1>::type> Args;
582 return internal::ElementsAreMatcher<Args>(Args(e1));
583}
584
585template <typename T1, typename T2>
586inline internal::ElementsAreMatcher<
587 ::testing::tuple<
588 typename internal::DecayArray<T1>::type,
589 typename internal::DecayArray<T2>::type> >
590ElementsAre(const T1& e1, const T2& e2) {
591 typedef ::testing::tuple<
592 typename internal::DecayArray<T1>::type,
593 typename internal::DecayArray<T2>::type> Args;
594 return internal::ElementsAreMatcher<Args>(Args(e1, e2));
595}
596
597template <typename T1, typename T2, typename T3>
598inline internal::ElementsAreMatcher<
599 ::testing::tuple<
600 typename internal::DecayArray<T1>::type,
601 typename internal::DecayArray<T2>::type,
602 typename internal::DecayArray<T3>::type> >
603ElementsAre(const T1& e1, const T2& e2, const T3& e3) {
604 typedef ::testing::tuple<
605 typename internal::DecayArray<T1>::type,
606 typename internal::DecayArray<T2>::type,
607 typename internal::DecayArray<T3>::type> Args;
608 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3));
609}
610
611template <typename T1, typename T2, typename T3, typename T4>
612inline internal::ElementsAreMatcher<
613 ::testing::tuple<
614 typename internal::DecayArray<T1>::type,
615 typename internal::DecayArray<T2>::type,
616 typename internal::DecayArray<T3>::type,
617 typename internal::DecayArray<T4>::type> >
618ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
619 typedef ::testing::tuple<
620 typename internal::DecayArray<T1>::type,
621 typename internal::DecayArray<T2>::type,
622 typename internal::DecayArray<T3>::type,
623 typename internal::DecayArray<T4>::type> Args;
624 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
625}
626
627template <typename T1, typename T2, typename T3, typename T4, typename T5>
628inline internal::ElementsAreMatcher<
629 ::testing::tuple<
630 typename internal::DecayArray<T1>::type,
631 typename internal::DecayArray<T2>::type,
632 typename internal::DecayArray<T3>::type,
633 typename internal::DecayArray<T4>::type,
634 typename internal::DecayArray<T5>::type> >
635ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
636 const T5& e5) {
637 typedef ::testing::tuple<
638 typename internal::DecayArray<T1>::type,
639 typename internal::DecayArray<T2>::type,
640 typename internal::DecayArray<T3>::type,
641 typename internal::DecayArray<T4>::type,
642 typename internal::DecayArray<T5>::type> Args;
643 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
644}
645
646template <typename T1, typename T2, typename T3, typename T4, typename T5,
647 typename T6>
648inline internal::ElementsAreMatcher<
649 ::testing::tuple<
650 typename internal::DecayArray<T1>::type,
651 typename internal::DecayArray<T2>::type,
652 typename internal::DecayArray<T3>::type,
653 typename internal::DecayArray<T4>::type,
654 typename internal::DecayArray<T5>::type,
655 typename internal::DecayArray<T6>::type> >
656ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
657 const T5& e5, const T6& e6) {
658 typedef ::testing::tuple<
659 typename internal::DecayArray<T1>::type,
660 typename internal::DecayArray<T2>::type,
661 typename internal::DecayArray<T3>::type,
662 typename internal::DecayArray<T4>::type,
663 typename internal::DecayArray<T5>::type,
664 typename internal::DecayArray<T6>::type> Args;
665 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6));
666}
667
668template <typename T1, typename T2, typename T3, typename T4, typename T5,
669 typename T6, typename T7>
670inline internal::ElementsAreMatcher<
671 ::testing::tuple<
672 typename internal::DecayArray<T1>::type,
673 typename internal::DecayArray<T2>::type,
674 typename internal::DecayArray<T3>::type,
675 typename internal::DecayArray<T4>::type,
676 typename internal::DecayArray<T5>::type,
677 typename internal::DecayArray<T6>::type,
678 typename internal::DecayArray<T7>::type> >
679ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
680 const T5& e5, const T6& e6, const T7& e7) {
681 typedef ::testing::tuple<
682 typename internal::DecayArray<T1>::type,
683 typename internal::DecayArray<T2>::type,
684 typename internal::DecayArray<T3>::type,
685 typename internal::DecayArray<T4>::type,
686 typename internal::DecayArray<T5>::type,
687 typename internal::DecayArray<T6>::type,
688 typename internal::DecayArray<T7>::type> Args;
689 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7));
690}
691
692template <typename T1, typename T2, typename T3, typename T4, typename T5,
693 typename T6, typename T7, typename T8>
694inline internal::ElementsAreMatcher<
695 ::testing::tuple<
696 typename internal::DecayArray<T1>::type,
697 typename internal::DecayArray<T2>::type,
698 typename internal::DecayArray<T3>::type,
699 typename internal::DecayArray<T4>::type,
700 typename internal::DecayArray<T5>::type,
701 typename internal::DecayArray<T6>::type,
702 typename internal::DecayArray<T7>::type,
703 typename internal::DecayArray<T8>::type> >
704ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
705 const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
706 typedef ::testing::tuple<
707 typename internal::DecayArray<T1>::type,
708 typename internal::DecayArray<T2>::type,
709 typename internal::DecayArray<T3>::type,
710 typename internal::DecayArray<T4>::type,
711 typename internal::DecayArray<T5>::type,
712 typename internal::DecayArray<T6>::type,
713 typename internal::DecayArray<T7>::type,
714 typename internal::DecayArray<T8>::type> Args;
715 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
716 e8));
717}
718
719template <typename T1, typename T2, typename T3, typename T4, typename T5,
720 typename T6, typename T7, typename T8, typename T9>
721inline internal::ElementsAreMatcher<
722 ::testing::tuple<
723 typename internal::DecayArray<T1>::type,
724 typename internal::DecayArray<T2>::type,
725 typename internal::DecayArray<T3>::type,
726 typename internal::DecayArray<T4>::type,
727 typename internal::DecayArray<T5>::type,
728 typename internal::DecayArray<T6>::type,
729 typename internal::DecayArray<T7>::type,
730 typename internal::DecayArray<T8>::type,
731 typename internal::DecayArray<T9>::type> >
732ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
733 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
734 typedef ::testing::tuple<
735 typename internal::DecayArray<T1>::type,
736 typename internal::DecayArray<T2>::type,
737 typename internal::DecayArray<T3>::type,
738 typename internal::DecayArray<T4>::type,
739 typename internal::DecayArray<T5>::type,
740 typename internal::DecayArray<T6>::type,
741 typename internal::DecayArray<T7>::type,
742 typename internal::DecayArray<T8>::type,
743 typename internal::DecayArray<T9>::type> Args;
744 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
745 e8, e9));
746}
747
748template <typename T1, typename T2, typename T3, typename T4, typename T5,
749 typename T6, typename T7, typename T8, typename T9, typename T10>
750inline internal::ElementsAreMatcher<
751 ::testing::tuple<
752 typename internal::DecayArray<T1>::type,
753 typename internal::DecayArray<T2>::type,
754 typename internal::DecayArray<T3>::type,
755 typename internal::DecayArray<T4>::type,
756 typename internal::DecayArray<T5>::type,
757 typename internal::DecayArray<T6>::type,
758 typename internal::DecayArray<T7>::type,
759 typename internal::DecayArray<T8>::type,
760 typename internal::DecayArray<T9>::type,
761 typename internal::DecayArray<T10>::type> >
762ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
763 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
764 const T10& e10) {
765 typedef ::testing::tuple<
766 typename internal::DecayArray<T1>::type,
767 typename internal::DecayArray<T2>::type,
768 typename internal::DecayArray<T3>::type,
769 typename internal::DecayArray<T4>::type,
770 typename internal::DecayArray<T5>::type,
771 typename internal::DecayArray<T6>::type,
772 typename internal::DecayArray<T7>::type,
773 typename internal::DecayArray<T8>::type,
774 typename internal::DecayArray<T9>::type,
775 typename internal::DecayArray<T10>::type> Args;
776 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
777 e8, e9, e10));
778}
779
780// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
781// that matches n elements in any order. We support up to n=10 arguments.
782
783inline internal::UnorderedElementsAreMatcher<
784 ::testing::tuple<> >
785UnorderedElementsAre() {
786 typedef ::testing::tuple<> Args;
787 return internal::UnorderedElementsAreMatcher<Args>(Args());
788}
789
790template <typename T1>
791inline internal::UnorderedElementsAreMatcher<
792 ::testing::tuple<
793 typename internal::DecayArray<T1>::type> >
794UnorderedElementsAre(const T1& e1) {
795 typedef ::testing::tuple<
796 typename internal::DecayArray<T1>::type> Args;
797 return internal::UnorderedElementsAreMatcher<Args>(Args(e1));
798}
799
800template <typename T1, typename T2>
801inline internal::UnorderedElementsAreMatcher<
802 ::testing::tuple<
803 typename internal::DecayArray<T1>::type,
804 typename internal::DecayArray<T2>::type> >
805UnorderedElementsAre(const T1& e1, const T2& e2) {
806 typedef ::testing::tuple<
807 typename internal::DecayArray<T1>::type,
808 typename internal::DecayArray<T2>::type> Args;
809 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2));
810}
811
812template <typename T1, typename T2, typename T3>
813inline internal::UnorderedElementsAreMatcher<
814 ::testing::tuple<
815 typename internal::DecayArray<T1>::type,
816 typename internal::DecayArray<T2>::type,
817 typename internal::DecayArray<T3>::type> >
818UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3) {
819 typedef ::testing::tuple<
820 typename internal::DecayArray<T1>::type,
821 typename internal::DecayArray<T2>::type,
822 typename internal::DecayArray<T3>::type> Args;
823 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3));
824}
825
826template <typename T1, typename T2, typename T3, typename T4>
827inline internal::UnorderedElementsAreMatcher<
828 ::testing::tuple<
829 typename internal::DecayArray<T1>::type,
830 typename internal::DecayArray<T2>::type,
831 typename internal::DecayArray<T3>::type,
832 typename internal::DecayArray<T4>::type> >
833UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
834 typedef ::testing::tuple<
835 typename internal::DecayArray<T1>::type,
836 typename internal::DecayArray<T2>::type,
837 typename internal::DecayArray<T3>::type,
838 typename internal::DecayArray<T4>::type> Args;
839 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
840}
841
842template <typename T1, typename T2, typename T3, typename T4, typename T5>
843inline internal::UnorderedElementsAreMatcher<
844 ::testing::tuple<
845 typename internal::DecayArray<T1>::type,
846 typename internal::DecayArray<T2>::type,
847 typename internal::DecayArray<T3>::type,
848 typename internal::DecayArray<T4>::type,
849 typename internal::DecayArray<T5>::type> >
850UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
851 const T5& e5) {
852 typedef ::testing::tuple<
853 typename internal::DecayArray<T1>::type,
854 typename internal::DecayArray<T2>::type,
855 typename internal::DecayArray<T3>::type,
856 typename internal::DecayArray<T4>::type,
857 typename internal::DecayArray<T5>::type> Args;
858 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
859}
860
861template <typename T1, typename T2, typename T3, typename T4, typename T5,
862 typename T6>
863inline internal::UnorderedElementsAreMatcher<
864 ::testing::tuple<
865 typename internal::DecayArray<T1>::type,
866 typename internal::DecayArray<T2>::type,
867 typename internal::DecayArray<T3>::type,
868 typename internal::DecayArray<T4>::type,
869 typename internal::DecayArray<T5>::type,
870 typename internal::DecayArray<T6>::type> >
871UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
872 const T5& e5, const T6& e6) {
873 typedef ::testing::tuple<
874 typename internal::DecayArray<T1>::type,
875 typename internal::DecayArray<T2>::type,
876 typename internal::DecayArray<T3>::type,
877 typename internal::DecayArray<T4>::type,
878 typename internal::DecayArray<T5>::type,
879 typename internal::DecayArray<T6>::type> Args;
880 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
881 e6));
882}
883
884template <typename T1, typename T2, typename T3, typename T4, typename T5,
885 typename T6, typename T7>
886inline internal::UnorderedElementsAreMatcher<
887 ::testing::tuple<
888 typename internal::DecayArray<T1>::type,
889 typename internal::DecayArray<T2>::type,
890 typename internal::DecayArray<T3>::type,
891 typename internal::DecayArray<T4>::type,
892 typename internal::DecayArray<T5>::type,
893 typename internal::DecayArray<T6>::type,
894 typename internal::DecayArray<T7>::type> >
895UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
896 const T5& e5, const T6& e6, const T7& e7) {
897 typedef ::testing::tuple<
898 typename internal::DecayArray<T1>::type,
899 typename internal::DecayArray<T2>::type,
900 typename internal::DecayArray<T3>::type,
901 typename internal::DecayArray<T4>::type,
902 typename internal::DecayArray<T5>::type,
903 typename internal::DecayArray<T6>::type,
904 typename internal::DecayArray<T7>::type> Args;
905 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
906 e6, e7));
907}
908
909template <typename T1, typename T2, typename T3, typename T4, typename T5,
910 typename T6, typename T7, typename T8>
911inline internal::UnorderedElementsAreMatcher<
912 ::testing::tuple<
913 typename internal::DecayArray<T1>::type,
914 typename internal::DecayArray<T2>::type,
915 typename internal::DecayArray<T3>::type,
916 typename internal::DecayArray<T4>::type,
917 typename internal::DecayArray<T5>::type,
918 typename internal::DecayArray<T6>::type,
919 typename internal::DecayArray<T7>::type,
920 typename internal::DecayArray<T8>::type> >
921UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
922 const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
923 typedef ::testing::tuple<
924 typename internal::DecayArray<T1>::type,
925 typename internal::DecayArray<T2>::type,
926 typename internal::DecayArray<T3>::type,
927 typename internal::DecayArray<T4>::type,
928 typename internal::DecayArray<T5>::type,
929 typename internal::DecayArray<T6>::type,
930 typename internal::DecayArray<T7>::type,
931 typename internal::DecayArray<T8>::type> Args;
932 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
933 e6, e7, e8));
934}
935
936template <typename T1, typename T2, typename T3, typename T4, typename T5,
937 typename T6, typename T7, typename T8, typename T9>
938inline internal::UnorderedElementsAreMatcher<
939 ::testing::tuple<
940 typename internal::DecayArray<T1>::type,
941 typename internal::DecayArray<T2>::type,
942 typename internal::DecayArray<T3>::type,
943 typename internal::DecayArray<T4>::type,
944 typename internal::DecayArray<T5>::type,
945 typename internal::DecayArray<T6>::type,
946 typename internal::DecayArray<T7>::type,
947 typename internal::DecayArray<T8>::type,
948 typename internal::DecayArray<T9>::type> >
949UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
950 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
951 typedef ::testing::tuple<
952 typename internal::DecayArray<T1>::type,
953 typename internal::DecayArray<T2>::type,
954 typename internal::DecayArray<T3>::type,
955 typename internal::DecayArray<T4>::type,
956 typename internal::DecayArray<T5>::type,
957 typename internal::DecayArray<T6>::type,
958 typename internal::DecayArray<T7>::type,
959 typename internal::DecayArray<T8>::type,
960 typename internal::DecayArray<T9>::type> Args;
961 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
962 e6, e7, e8, e9));
963}
964
965template <typename T1, typename T2, typename T3, typename T4, typename T5,
966 typename T6, typename T7, typename T8, typename T9, typename T10>
967inline internal::UnorderedElementsAreMatcher<
968 ::testing::tuple<
969 typename internal::DecayArray<T1>::type,
970 typename internal::DecayArray<T2>::type,
971 typename internal::DecayArray<T3>::type,
972 typename internal::DecayArray<T4>::type,
973 typename internal::DecayArray<T5>::type,
974 typename internal::DecayArray<T6>::type,
975 typename internal::DecayArray<T7>::type,
976 typename internal::DecayArray<T8>::type,
977 typename internal::DecayArray<T9>::type,
978 typename internal::DecayArray<T10>::type> >
979UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
980 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
981 const T10& e10) {
982 typedef ::testing::tuple<
983 typename internal::DecayArray<T1>::type,
984 typename internal::DecayArray<T2>::type,
985 typename internal::DecayArray<T3>::type,
986 typename internal::DecayArray<T4>::type,
987 typename internal::DecayArray<T5>::type,
988 typename internal::DecayArray<T6>::type,
989 typename internal::DecayArray<T7>::type,
990 typename internal::DecayArray<T8>::type,
991 typename internal::DecayArray<T9>::type,
992 typename internal::DecayArray<T10>::type> Args;
993 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
994 e6, e7, e8, e9, e10));
995}
996
997// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
998// sub-matchers. AllOf is called fully qualified to prevent ADL from firing.
999
1000template <typename M1, typename M2>
1001inline typename internal::AllOfResult2<M1, M2>::type
1002AllOf(M1 m1, M2 m2) {
1003 return typename internal::AllOfResult2<M1, M2>::type(
1004 m1,
1005 m2);
1006}
1007
1008template <typename M1, typename M2, typename M3>
1009inline typename internal::AllOfResult3<M1, M2, M3>::type
1010AllOf(M1 m1, M2 m2, M3 m3) {
1011 return typename internal::AllOfResult3<M1, M2, M3>::type(
1012 m1,
1013 ::testing::AllOf(m2, m3));
1014}
1015
1016template <typename M1, typename M2, typename M3, typename M4>
1017inline typename internal::AllOfResult4<M1, M2, M3, M4>::type
1018AllOf(M1 m1, M2 m2, M3 m3, M4 m4) {
1019 return typename internal::AllOfResult4<M1, M2, M3, M4>::type(
1020 ::testing::AllOf(m1, m2),
1021 ::testing::AllOf(m3, m4));
1022}
1023
1024template <typename M1, typename M2, typename M3, typename M4, typename M5>
1025inline typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type
1026AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
1027 return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type(
1028 ::testing::AllOf(m1, m2),
1029 ::testing::AllOf(m3, m4, m5));
1030}
1031
1032template <typename M1, typename M2, typename M3, typename M4, typename M5,
1033 typename M6>
1034inline typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type
1035AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
1036 return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type(
1037 ::testing::AllOf(m1, m2, m3),
1038 ::testing::AllOf(m4, m5, m6));
1039}
1040
1041template <typename M1, typename M2, typename M3, typename M4, typename M5,
1042 typename M6, typename M7>
1043inline typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
1044AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
1045 return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
1046 ::testing::AllOf(m1, m2, m3),
1047 ::testing::AllOf(m4, m5, m6, m7));
1048}
1049
1050template <typename M1, typename M2, typename M3, typename M4, typename M5,
1051 typename M6, typename M7, typename M8>
1052inline typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
1053AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
1054 return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
1055 ::testing::AllOf(m1, m2, m3, m4),
1056 ::testing::AllOf(m5, m6, m7, m8));
1057}
1058
1059template <typename M1, typename M2, typename M3, typename M4, typename M5,
1060 typename M6, typename M7, typename M8, typename M9>
1061inline typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
1062AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
1063 return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
1064 M9>::type(
1065 ::testing::AllOf(m1, m2, m3, m4),
1066 ::testing::AllOf(m5, m6, m7, m8, m9));
1067}
1068
1069template <typename M1, typename M2, typename M3, typename M4, typename M5,
1070 typename M6, typename M7, typename M8, typename M9, typename M10>
1071inline typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1072 M10>::type
1073AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
1074 return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1075 M10>::type(
1076 ::testing::AllOf(m1, m2, m3, m4, m5),
1077 ::testing::AllOf(m6, m7, m8, m9, m10));
1078}
1079
1080// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
1081// sub-matchers. AnyOf is called fully qualified to prevent ADL from firing.
1082
1083template <typename M1, typename M2>
1084inline typename internal::AnyOfResult2<M1, M2>::type
1085AnyOf(M1 m1, M2 m2) {
1086 return typename internal::AnyOfResult2<M1, M2>::type(
1087 m1,
1088 m2);
1089}
1090
1091template <typename M1, typename M2, typename M3>
1092inline typename internal::AnyOfResult3<M1, M2, M3>::type
1093AnyOf(M1 m1, M2 m2, M3 m3) {
1094 return typename internal::AnyOfResult3<M1, M2, M3>::type(
1095 m1,
1096 ::testing::AnyOf(m2, m3));
1097}
1098
1099template <typename M1, typename M2, typename M3, typename M4>
1100inline typename internal::AnyOfResult4<M1, M2, M3, M4>::type
1101AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) {
1102 return typename internal::AnyOfResult4<M1, M2, M3, M4>::type(
1103 ::testing::AnyOf(m1, m2),
1104 ::testing::AnyOf(m3, m4));
1105}
1106
1107template <typename M1, typename M2, typename M3, typename M4, typename M5>
1108inline typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type
1109AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
1110 return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type(
1111 ::testing::AnyOf(m1, m2),
1112 ::testing::AnyOf(m3, m4, m5));
1113}
1114
1115template <typename M1, typename M2, typename M3, typename M4, typename M5,
1116 typename M6>
1117inline typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type
1118AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
1119 return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type(
1120 ::testing::AnyOf(m1, m2, m3),
1121 ::testing::AnyOf(m4, m5, m6));
1122}
1123
1124template <typename M1, typename M2, typename M3, typename M4, typename M5,
1125 typename M6, typename M7>
1126inline typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
1127AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
1128 return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
1129 ::testing::AnyOf(m1, m2, m3),
1130 ::testing::AnyOf(m4, m5, m6, m7));
1131}
1132
1133template <typename M1, typename M2, typename M3, typename M4, typename M5,
1134 typename M6, typename M7, typename M8>
1135inline typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
1136AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
1137 return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
1138 ::testing::AnyOf(m1, m2, m3, m4),
1139 ::testing::AnyOf(m5, m6, m7, m8));
1140}
1141
1142template <typename M1, typename M2, typename M3, typename M4, typename M5,
1143 typename M6, typename M7, typename M8, typename M9>
1144inline typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
1145AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
1146 return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
1147 M9>::type(
1148 ::testing::AnyOf(m1, m2, m3, m4),
1149 ::testing::AnyOf(m5, m6, m7, m8, m9));
1150}
1151
1152template <typename M1, typename M2, typename M3, typename M4, typename M5,
1153 typename M6, typename M7, typename M8, typename M9, typename M10>
1154inline typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1155 M10>::type
1156AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
1157 return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1158 M10>::type(
1159 ::testing::AnyOf(m1, m2, m3, m4, m5),
1160 ::testing::AnyOf(m6, m7, m8, m9, m10));
1161}
1162
1163} // namespace testing
1164
1165
1166// The MATCHER* family of macros can be used in a namespace scope to
1167// define custom matchers easily.
1168//
1169// Basic Usage
1170// ===========
1171//
1172// The syntax
1173//
1174// MATCHER(name, description_string) { statements; }
1175//
1176// defines a matcher with the given name that executes the statements,
1177// which must return a bool to indicate if the match succeeds. Inside
1178// the statements, you can refer to the value being matched by 'arg',
1179// and refer to its type by 'arg_type'.
1180//
1181// The description string documents what the matcher does, and is used
1182// to generate the failure message when the match fails. Since a
1183// MATCHER() is usually defined in a header file shared by multiple
1184// C++ source files, we require the description to be a C-string
1185// literal to avoid possible side effects. It can be empty, in which
1186// case we'll use the sequence of words in the matcher name as the
1187// description.
1188//
1189// For example:
1190//
1191// MATCHER(IsEven, "") { return (arg % 2) == 0; }
1192//
1193// allows you to write
1194//
1195// // Expects mock_foo.Bar(n) to be called where n is even.
1196// EXPECT_CALL(mock_foo, Bar(IsEven()));
1197//
1198// or,
1199//
1200// // Verifies that the value of some_expression is even.
1201// EXPECT_THAT(some_expression, IsEven());
1202//
1203// If the above assertion fails, it will print something like:
1204//
1205// Value of: some_expression
1206// Expected: is even
1207// Actual: 7
1208//
1209// where the description "is even" is automatically calculated from the
1210// matcher name IsEven.
1211//
1212// Argument Type
1213// =============
1214//
1215// Note that the type of the value being matched (arg_type) is
1216// determined by the context in which you use the matcher and is
1217// supplied to you by the compiler, so you don't need to worry about
1218// declaring it (nor can you). This allows the matcher to be
1219// polymorphic. For example, IsEven() can be used to match any type
1220// where the value of "(arg % 2) == 0" can be implicitly converted to
1221// a bool. In the "Bar(IsEven())" example above, if method Bar()
1222// takes an int, 'arg_type' will be int; if it takes an unsigned long,
1223// 'arg_type' will be unsigned long; and so on.
1224//
1225// Parameterizing Matchers
1226// =======================
1227//
1228// Sometimes you'll want to parameterize the matcher. For that you
1229// can use another macro:
1230//
1231// MATCHER_P(name, param_name, description_string) { statements; }
1232//
1233// For example:
1234//
1235// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
1236//
1237// will allow you to write:
1238//
1239// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
1240//
1241// which may lead to this message (assuming n is 10):
1242//
1243// Value of: Blah("a")
1244// Expected: has absolute value 10
1245// Actual: -9
1246//
1247// Note that both the matcher description and its parameter are
1248// printed, making the message human-friendly.
1249//
1250// In the matcher definition body, you can write 'foo_type' to
1251// reference the type of a parameter named 'foo'. For example, in the
1252// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
1253// 'value_type' to refer to the type of 'value'.
1254//
1255// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to
1256// support multi-parameter matchers.
1257//
1258// Describing Parameterized Matchers
1259// =================================
1260//
1261// The last argument to MATCHER*() is a string-typed expression. The
1262// expression can reference all of the matcher's parameters and a
1263// special bool-typed variable named 'negation'. When 'negation' is
1264// false, the expression should evaluate to the matcher's description;
1265// otherwise it should evaluate to the description of the negation of
1266// the matcher. For example,
1267//
1268// using testing::PrintToString;
1269//
1270// MATCHER_P2(InClosedRange, low, hi,
1271// string(negation ? "is not" : "is") + " in range [" +
1272// PrintToString(low) + ", " + PrintToString(hi) + "]") {
1273// return low <= arg && arg <= hi;
1274// }
1275// ...
1276// EXPECT_THAT(3, InClosedRange(4, 6));
1277// EXPECT_THAT(3, Not(InClosedRange(2, 4)));
1278//
1279// would generate two failures that contain the text:
1280//
1281// Expected: is in range [4, 6]
1282// ...
1283// Expected: is not in range [2, 4]
1284//
1285// If you specify "" as the description, the failure message will
1286// contain the sequence of words in the matcher name followed by the
1287// parameter values printed as a tuple. For example,
1288//
1289// MATCHER_P2(InClosedRange, low, hi, "") { ... }
1290// ...
1291// EXPECT_THAT(3, InClosedRange(4, 6));
1292// EXPECT_THAT(3, Not(InClosedRange(2, 4)));
1293//
1294// would generate two failures that contain the text:
1295//
1296// Expected: in closed range (4, 6)
1297// ...
1298// Expected: not (in closed range (2, 4))
1299//
1300// Types of Matcher Parameters
1301// ===========================
1302//
1303// For the purpose of typing, you can view
1304//
1305// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
1306//
1307// as shorthand for
1308//
1309// template <typename p1_type, ..., typename pk_type>
1310// FooMatcherPk<p1_type, ..., pk_type>
1311// Foo(p1_type p1, ..., pk_type pk) { ... }
1312//
1313// When you write Foo(v1, ..., vk), the compiler infers the types of
1314// the parameters v1, ..., and vk for you. If you are not happy with
1315// the result of the type inference, you can specify the types by
1316// explicitly instantiating the template, as in Foo<long, bool>(5,
1317// false). As said earlier, you don't get to (or need to) specify
1318// 'arg_type' as that's determined by the context in which the matcher
1319// is used. You can assign the result of expression Foo(p1, ..., pk)
1320// to a variable of type FooMatcherPk<p1_type, ..., pk_type>. This
1321// can be useful when composing matchers.
1322//
1323// While you can instantiate a matcher template with reference types,
1324// passing the parameters by pointer usually makes your code more
1325// readable. If, however, you still want to pass a parameter by
1326// reference, be aware that in the failure message generated by the
1327// matcher you will see the value of the referenced object but not its
1328// address.
1329//
1330// Explaining Match Results
1331// ========================
1332//
1333// Sometimes the matcher description alone isn't enough to explain why
1334// the match has failed or succeeded. For example, when expecting a
1335// long string, it can be very helpful to also print the diff between
1336// the expected string and the actual one. To achieve that, you can
1337// optionally stream additional information to a special variable
1338// named result_listener, whose type is a pointer to class
1339// MatchResultListener:
1340//
1341// MATCHER_P(EqualsLongString, str, "") {
1342// if (arg == str) return true;
1343//
1344// *result_listener << "the difference: "
1346// return false;
1347// }
1348//
1349// Overloading Matchers
1350// ====================
1351//
1352// You can overload matchers with different numbers of parameters:
1353//
1354// MATCHER_P(Blah, a, description_string1) { ... }
1355// MATCHER_P2(Blah, a, b, description_string2) { ... }
1356//
1357// Caveats
1358// =======
1359//
1360// When defining a new matcher, you should also consider implementing
1361// MatcherInterface or using MakePolymorphicMatcher(). These
1362// approaches require more work than the MATCHER* macros, but also
1363// give you more control on the types of the value being matched and
1364// the matcher parameters, which may leads to better compiler error
1365// messages when the matcher is used wrong. They also allow
1366// overloading matchers based on parameter types (as opposed to just
1367// based on the number of parameters).
1368//
1369// MATCHER*() can only be used in a namespace scope. The reason is
1370// that C++ doesn't yet allow function-local types to be used to
1371// instantiate templates. The up-coming C++0x standard will fix this.
1372// Once that's done, we'll consider supporting using MATCHER*() inside
1373// a function.
1374//
1375// More Information
1376// ================
1377//
1378// To learn more about using these macros, please search for 'MATCHER'
1379// on http://code.google.com/p/googlemock/wiki/CookBook.
1380
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
1427
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
1479
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
1536
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
1596
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
1665
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
1738
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
1813
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
1897
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
1986
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
2079
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
2178
2179#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
testing::MatchResultListener
Definition gmock-matchers.h:80
testing::MatchResultListener::stream
::std::ostream * stream()
Definition gmock-matchers.h:98
testing::MatchResultListener::IsInterested
bool IsInterested() const
Definition gmock-matchers.h:104
testing::MatcherInterface
Definition gmock-matchers.h:143
testing::Matcher
Definition gmock-matchers.h:319
testing::StringMatchResultListener
Definition gmock-matchers.h:184
testing::StringMatchResultListener::str
internal::string str() const
Definition gmock-matchers.h:189
testing::internal::ArgsMatcherImpl
Definition gmock-generated-matchers.h:211
testing::internal::ArgsMatcherImpl::SelectedArgs
internal::TupleFields< RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 >::type SelectedArgs
Definition gmock-generated-matchers.h:216
testing::internal::ArgsMatcherImpl::GetSelectedArgs
static SelectedArgs GetSelectedArgs(ArgsTuple args)
Definition gmock-generated-matchers.h:252
testing::internal::ArgsMatcherImpl::PrintIndices
static void PrintIndices(::std::ostream *os)
Definition gmock-generated-matchers.h:258
testing::internal::ArgsMatcherImpl::MatchAndExplain
virtual bool MatchAndExplain(ArgsTuple args, MatchResultListener *listener) const
Definition gmock-generated-matchers.h:223
testing::internal::ArgsMatcherImpl::GTEST_DISALLOW_ASSIGN_
GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl)
testing::internal::ArgsMatcherImpl::inner_matcher_
const MonomorphicInnerMatcher inner_matcher_
Definition gmock-generated-matchers.h:273
testing::internal::ArgsMatcherImpl::GTEST_REMOVE_REFERENCE_AND_CONST_
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple
testing::internal::ArgsMatcherImpl::ArgsMatcherImpl
ArgsMatcherImpl(const InnerMatcher &inner_matcher)
Definition gmock-generated-matchers.h:220
testing::internal::ArgsMatcherImpl::DescribeTo
virtual void DescribeTo(::std::ostream *os) const
Definition gmock-generated-matchers.h:239
testing::internal::ArgsMatcherImpl::MonomorphicInnerMatcher
Matcher< const SelectedArgs & > MonomorphicInnerMatcher
Definition gmock-generated-matchers.h:217
testing::internal::ArgsMatcherImpl::DescribeNegationTo
virtual void DescribeNegationTo(::std::ostream *os) const
Definition gmock-generated-matchers.h:245
testing::internal::ArgsMatcher
Definition gmock-generated-matchers.h:281
testing::internal::ArgsMatcher::ArgsMatcher
ArgsMatcher(const InnerMatcher &inner_matcher)
Definition gmock-generated-matchers.h:283
testing::internal::ArgsMatcher::inner_matcher_
const InnerMatcher inner_matcher_
Definition gmock-generated-matchers.h:293
testing::internal::BothOfMatcher
Definition gmock-matchers.h:1638
testing::internal::EitherOfMatcher
Definition gmock-matchers.h:1733
testing::internal::ElementsAreMatcher
Definition gmock-matchers.h:3477
testing::internal::TupleFields< Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >::GetSelectedFields
static type GetSelectedFields(const Tuple &)
Definition gmock-generated-matchers.h:93
testing::internal::TupleFields< Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >::type
::testing::tuple type
Definition gmock-generated-matchers.h:92
testing::internal::TupleFields< Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1 >::GetSelectedFields
static type GetSelectedFields(const Tuple &t)
Definition gmock-generated-matchers.h:102
testing::internal::TupleFields< Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1 >::type
::testing::tuple< GMOCK_FIELD_TYPE_(Tuple, k0)> type
Definition gmock-generated-matchers.h:101
testing::internal::TupleFields< Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1 >::type
::testing::tuple< GMOCK_FIELD_TYPE_(Tuple, k0), GMOCK_FIELD_TYPE_(Tuple, k1)> type
Definition gmock-generated-matchers.h:111
testing::internal::TupleFields< Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1 >::GetSelectedFields
static type GetSelectedFields(const Tuple &t)
Definition gmock-generated-matchers.h:112
testing::internal::TupleFields< Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1 >::type
::testing::tuple< GMOCK_FIELD_TYPE_(Tuple, k0), GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type
Definition gmock-generated-matchers.h:121
testing::internal::TupleFields< Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1 >::GetSelectedFields
static type GetSelectedFields(const Tuple &t)
Definition gmock-generated-matchers.h:122
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1 >::type
::testing::tuple< GMOCK_FIELD_TYPE_(Tuple, k0), GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), GMOCK_FIELD_TYPE_(Tuple, k3)> type
Definition gmock-generated-matchers.h:132
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1 >::GetSelectedFields
static type GetSelectedFields(const Tuple &t)
Definition gmock-generated-matchers.h:133
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1 >::GetSelectedFields
static type GetSelectedFields(const Tuple &t)
Definition gmock-generated-matchers.h:144
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1 >::type
::testing::tuple< GMOCK_FIELD_TYPE_(Tuple, k0), GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type
Definition gmock-generated-matchers.h:143
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1 >::GetSelectedFields
static type GetSelectedFields(const Tuple &t)
Definition gmock-generated-matchers.h:156
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1 >::type
::testing::tuple< GMOCK_FIELD_TYPE_(Tuple, k0), GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4), GMOCK_FIELD_TYPE_(Tuple, k5)> type
Definition gmock-generated-matchers.h:155
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1 >::type
::testing::tuple< GMOCK_FIELD_TYPE_(Tuple, k0), GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4), GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6), GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type
Definition gmock-generated-matchers.h:198
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1 >::GetSelectedFields
static type GetSelectedFields(const Tuple &t)
Definition gmock-generated-matchers.h:199
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1 >::type
::testing::tuple< GMOCK_FIELD_TYPE_(Tuple, k0), GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4), GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6), GMOCK_FIELD_TYPE_(Tuple, k7)> type
Definition gmock-generated-matchers.h:183
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1 >::GetSelectedFields
static type GetSelectedFields(const Tuple &t)
Definition gmock-generated-matchers.h:184
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1 >::type
::testing::tuple< GMOCK_FIELD_TYPE_(Tuple, k0), GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4), GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type
Definition gmock-generated-matchers.h:168
testing::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1 >::GetSelectedFields
static type GetSelectedFields(const Tuple &t)
Definition gmock-generated-matchers.h:169
testing::internal::TupleFields
Definition gmock-generated-matchers.h:73
testing::internal::TupleFields::GetSelectedFields
static type GetSelectedFields(const Tuple &t)
Definition gmock-generated-matchers.h:81
testing::internal::TupleFields::type
::testing::tuple< GMOCK_FIELD_TYPE_(Tuple, k0), GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4), GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6), GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8), GMOCK_FIELD_TYPE_(Tuple, k9)> type
Definition gmock-generated-matchers.h:80
testing::internal::UnorderedElementsAreMatcher
Definition gmock-matchers.h:3451
GMOCK_FIELD_TYPE_
#define GMOCK_FIELD_TYPE_(Tuple, i)
Definition gmock-generated-matchers.h:51
get
void get(std::istream &input, bool &res)
Definition io.h:61
const
#define const
Definition ipfrdr.c:80
testing::internal
Definition gmock-actions.h:64
testing::internal::PrintIfNotEmpty
void PrintIfNotEmpty(const internal::string &explanation, ::std::ostream *os)
Definition gmock-matchers.h:678
testing
Definition gmock-actions.h:53
testing::AllOf
internal::AllOfResult2< M1, M2 >::type AllOf(M1 m1, M2 m2)
Definition gmock-generated-matchers.h:1002
testing::Args
internal::ArgsMatcher< InnerMatcher > Args(const InnerMatcher &matcher)
Definition gmock-generated-matchers.h:481
testing::ElementsAre
internal::ElementsAreMatcher< ::testing::tuple<> > ElementsAre()
Definition gmock-generated-matchers.h:570
testing::UnorderedElementsAre
internal::UnorderedElementsAreMatcher< ::testing::tuple<> > UnorderedElementsAre()
Definition gmock-generated-matchers.h:785
testing::PrintToString
::std::string PrintToString(const T &value)
Definition gtest-printers.h:980
testing::MakeMatcher
Matcher< T > MakeMatcher(const MatcherInterface< T > *impl)
Definition gmock-matchers.h:484
testing::AnyOf
internal::AnyOfResult2< M1, M2 >::type AnyOf(M1 m1, M2 m2)
Definition gmock-generated-matchers.h:1085
testing::SafeMatcherCast
Matcher< T > SafeMatcherCast(const M &polymorphic_matcher)
Definition gmock-matchers.h:665
testing::internal::AllOfResult10
Definition gmock-generated-matchers.h:379
testing::internal::AllOfResult10::type
BothOfMatcher< typename AllOfResult5< M1, M2, M3, M4, M5 >::type, typename AllOfResult5< M6, M7, M8, M9, M10 >::type > type
Definition gmock-generated-matchers.h:383
testing::internal::AllOfResult1
Definition gmock-generated-matchers.h:305
testing::internal::AllOfResult1::type
M1 type
Definition gmock-generated-matchers.h:306
testing::internal::AllOfResult2
Definition gmock-generated-matchers.h:310
testing::internal::AllOfResult2::type
BothOfMatcher< typename AllOfResult1< M1 >::type, typename AllOfResult1< M2 >::type > type
Definition gmock-generated-matchers.h:314
testing::internal::AllOfResult3
Definition gmock-generated-matchers.h:318
testing::internal::AllOfResult3::type
BothOfMatcher< typename AllOfResult1< M1 >::type, typename AllOfResult2< M2, M3 >::type > type
Definition gmock-generated-matchers.h:322
testing::internal::AllOfResult4
Definition gmock-generated-matchers.h:326
testing::internal::AllOfResult4::type
BothOfMatcher< typename AllOfResult2< M1, M2 >::type, typename AllOfResult2< M3, M4 >::type > type
Definition gmock-generated-matchers.h:330
testing::internal::AllOfResult5
Definition gmock-generated-matchers.h:334
testing::internal::AllOfResult5::type
BothOfMatcher< typename AllOfResult2< M1, M2 >::type, typename AllOfResult3< M3, M4, M5 >::type > type
Definition gmock-generated-matchers.h:338
testing::internal::AllOfResult6
Definition gmock-generated-matchers.h:343
testing::internal::AllOfResult6::type
BothOfMatcher< typename AllOfResult3< M1, M2, M3 >::type, typename AllOfResult3< M4, M5, M6 >::type > type
Definition gmock-generated-matchers.h:347
testing::internal::AllOfResult7
Definition gmock-generated-matchers.h:352
testing::internal::AllOfResult7::type
BothOfMatcher< typename AllOfResult3< M1, M2, M3 >::type, typename AllOfResult4< M4, M5, M6, M7 >::type > type
Definition gmock-generated-matchers.h:356
testing::internal::AllOfResult8
Definition gmock-generated-matchers.h:361
testing::internal::AllOfResult8::type
BothOfMatcher< typename AllOfResult4< M1, M2, M3, M4 >::type, typename AllOfResult4< M5, M6, M7, M8 >::type > type
Definition gmock-generated-matchers.h:365
testing::internal::AllOfResult9
Definition gmock-generated-matchers.h:370
testing::internal::AllOfResult9::type
BothOfMatcher< typename AllOfResult4< M1, M2, M3, M4 >::type, typename AllOfResult5< M5, M6, M7, M8, M9 >::type > type
Definition gmock-generated-matchers.h:374
testing::internal::AnyOfResult10
Definition gmock-generated-matchers.h:467
testing::internal::AnyOfResult10::type
EitherOfMatcher< typename AnyOfResult5< M1, M2, M3, M4, M5 >::type, typename AnyOfResult5< M6, M7, M8, M9, M10 >::type > type
Definition gmock-generated-matchers.h:471
testing::internal::AnyOfResult1
Definition gmock-generated-matchers.h:393
testing::internal::AnyOfResult1::type
M1 type
Definition gmock-generated-matchers.h:394
testing::internal::AnyOfResult2
Definition gmock-generated-matchers.h:398
testing::internal::AnyOfResult2::type
EitherOfMatcher< typename AnyOfResult1< M1 >::type, typename AnyOfResult1< M2 >::type > type
Definition gmock-generated-matchers.h:402
testing::internal::AnyOfResult3
Definition gmock-generated-matchers.h:406
testing::internal::AnyOfResult3::type
EitherOfMatcher< typename AnyOfResult1< M1 >::type, typename AnyOfResult2< M2, M3 >::type > type
Definition gmock-generated-matchers.h:410
testing::internal::AnyOfResult4
Definition gmock-generated-matchers.h:414
testing::internal::AnyOfResult4::type
EitherOfMatcher< typename AnyOfResult2< M1, M2 >::type, typename AnyOfResult2< M3, M4 >::type > type
Definition gmock-generated-matchers.h:418
testing::internal::AnyOfResult5
Definition gmock-generated-matchers.h:422
testing::internal::AnyOfResult5::type
EitherOfMatcher< typename AnyOfResult2< M1, M2 >::type, typename AnyOfResult3< M3, M4, M5 >::type > type
Definition gmock-generated-matchers.h:426
testing::internal::AnyOfResult6
Definition gmock-generated-matchers.h:431
testing::internal::AnyOfResult6::type
EitherOfMatcher< typename AnyOfResult3< M1, M2, M3 >::type, typename AnyOfResult3< M4, M5, M6 >::type > type
Definition gmock-generated-matchers.h:435
testing::internal::AnyOfResult7
Definition gmock-generated-matchers.h:440
testing::internal::AnyOfResult7::type
EitherOfMatcher< typename AnyOfResult3< M1, M2, M3 >::type, typename AnyOfResult4< M4, M5, M6, M7 >::type > type
Definition gmock-generated-matchers.h:444
testing::internal::AnyOfResult8
Definition gmock-generated-matchers.h:449
testing::internal::AnyOfResult8::type
EitherOfMatcher< typename AnyOfResult4< M1, M2, M3, M4 >::type, typename AnyOfResult4< M5, M6, M7, M8 >::type > type
Definition gmock-generated-matchers.h:453
testing::internal::AnyOfResult9
Definition gmock-generated-matchers.h:458
testing::internal::AnyOfResult9::type
EitherOfMatcher< typename AnyOfResult4< M1, M2, M3, M4 >::type, typename AnyOfResult5< M5, M6, M7, M8, M9 >::type > type
Definition gmock-generated-matchers.h:462
testing::internal::DecayArray::type
T type
Definition gmock-internal-utils.h:353
Generated on for Monero by doxygen 1.16.1