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 // GOOGLETEST_CM0002 DO NOT DELETE
39
40 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
41 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
42
43 #include <iterator>
44 #include <sstream>
45 #include <string>
46 #include <vector>
47 #include "gmock/gmock-matchers.h"
48
49 namespace testing {
50 namespace internal {
51
52 // The type of the i-th (0-based) field of Tuple.
53 #define GMOCK_FIELD_TYPE_(Tuple, i) \
54 typename ::testing::tuple_element<i, Tuple>::type
55
56 // TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
57 // tuple of type Tuple. It has two members:
58 //
59 // type: a tuple type whose i-th field is the ki-th field of Tuple.
60 // GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
61 //
62 // For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
63 //
64 // type is tuple<int, bool>, and
65 // GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
66
67 template <class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
68 int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
69 int k9 = -1>
70 class TupleFields;
71
72 // This generic version is used when there are 10 selectors.
73 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
74 int k7, int k8, int k9>
75 class TupleFields {
76 public:
77 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
78 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
79 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
80 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
81 GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8),
82 GMOCK_FIELD_TYPE_(Tuple, k9)> type;
GetSelectedFields(const Tuple & t)83 static type GetSelectedFields(const Tuple& t) {
84 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
85 get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t), get<k9>(t));
86 }
87 };
88
89 // The following specialization is used for 0 ~ 9 selectors.
90
91 template <class Tuple>
92 class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
93 public:
94 typedef ::testing::tuple<> type;
GetSelectedFields(const Tuple &)95 static type GetSelectedFields(const Tuple& /* t */) {
96 return type();
97 }
98 };
99
100 template <class Tuple, int k0>
101 class TupleFields<Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
102 public:
103 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0)> type;
GetSelectedFields(const Tuple & t)104 static type GetSelectedFields(const Tuple& t) {
105 return type(get<k0>(t));
106 }
107 };
108
109 template <class Tuple, int k0, int k1>
110 class TupleFields<Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1> {
111 public:
112 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
113 GMOCK_FIELD_TYPE_(Tuple, k1)> type;
GetSelectedFields(const Tuple & t)114 static type GetSelectedFields(const Tuple& t) {
115 return type(get<k0>(t), get<k1>(t));
116 }
117 };
118
119 template <class Tuple, int k0, int k1, int k2>
120 class TupleFields<Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1> {
121 public:
122 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
123 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type;
GetSelectedFields(const Tuple & t)124 static type GetSelectedFields(const Tuple& t) {
125 return type(get<k0>(t), get<k1>(t), get<k2>(t));
126 }
127 };
128
129 template <class Tuple, int k0, int k1, int k2, int k3>
130 class TupleFields<Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1> {
131 public:
132 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
133 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
134 GMOCK_FIELD_TYPE_(Tuple, k3)> type;
GetSelectedFields(const Tuple & t)135 static type GetSelectedFields(const Tuple& t) {
136 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t));
137 }
138 };
139
140 template <class Tuple, int k0, int k1, int k2, int k3, int k4>
141 class TupleFields<Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1> {
142 public:
143 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
144 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
145 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type;
GetSelectedFields(const Tuple & t)146 static type GetSelectedFields(const Tuple& t) {
147 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t));
148 }
149 };
150
151 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5>
152 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1> {
153 public:
154 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
155 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
156 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
157 GMOCK_FIELD_TYPE_(Tuple, k5)> type;
GetSelectedFields(const Tuple & t)158 static type GetSelectedFields(const Tuple& t) {
159 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
160 get<k5>(t));
161 }
162 };
163
164 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6>
165 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1> {
166 public:
167 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
168 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
169 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
170 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type;
GetSelectedFields(const Tuple & t)171 static type GetSelectedFields(const Tuple& t) {
172 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
173 get<k5>(t), get<k6>(t));
174 }
175 };
176
177 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
178 int k7>
179 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1> {
180 public:
181 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
182 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
183 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
184 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
185 GMOCK_FIELD_TYPE_(Tuple, k7)> type;
GetSelectedFields(const Tuple & t)186 static type GetSelectedFields(const Tuple& t) {
187 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
188 get<k5>(t), get<k6>(t), get<k7>(t));
189 }
190 };
191
192 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
193 int k7, int k8>
194 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1> {
195 public:
196 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
197 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
198 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
199 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
200 GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type;
GetSelectedFields(const Tuple & t)201 static type GetSelectedFields(const Tuple& t) {
202 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
203 get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t));
204 }
205 };
206
207 #undef GMOCK_FIELD_TYPE_
208
209 // Implements the Args() matcher.
210 template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
211 int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
212 int k9 = -1>
213 class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
214 public:
215 // ArgsTuple may have top-level const or reference modifiers.
216 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
217 typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5,
218 k6, k7, k8, k9>::type SelectedArgs;
219 typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
220
221 template <typename InnerMatcher>
ArgsMatcherImpl(const InnerMatcher & inner_matcher)222 explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
223 : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
224
MatchAndExplain(ArgsTuple args,MatchResultListener * listener)225 virtual bool MatchAndExplain(ArgsTuple args,
226 MatchResultListener* listener) const {
227 const SelectedArgs& selected_args = GetSelectedArgs(args);
228 if (!listener->IsInterested())
229 return inner_matcher_.Matches(selected_args);
230
231 PrintIndices(listener->stream());
232 *listener << "are " << PrintToString(selected_args);
233
234 StringMatchResultListener inner_listener;
235 const bool match = inner_matcher_.MatchAndExplain(selected_args,
236 &inner_listener);
237 PrintIfNotEmpty(inner_listener.str(), listener->stream());
238 return match;
239 }
240
DescribeTo(::std::ostream * os)241 virtual void DescribeTo(::std::ostream* os) const {
242 *os << "are a tuple ";
243 PrintIndices(os);
244 inner_matcher_.DescribeTo(os);
245 }
246
DescribeNegationTo(::std::ostream * os)247 virtual void DescribeNegationTo(::std::ostream* os) const {
248 *os << "are a tuple ";
249 PrintIndices(os);
250 inner_matcher_.DescribeNegationTo(os);
251 }
252
253 private:
GetSelectedArgs(ArgsTuple args)254 static SelectedArgs GetSelectedArgs(ArgsTuple args) {
255 return TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,
256 k9>::GetSelectedFields(args);
257 }
258
259 // Prints the indices of the selected fields.
PrintIndices(::std::ostream * os)260 static void PrintIndices(::std::ostream* os) {
261 *os << "whose fields (";
262 const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 };
263 for (int i = 0; i < 10; i++) {
264 if (indices[i] < 0)
265 break;
266
267 if (i >= 1)
268 *os << ", ";
269
270 *os << "#" << indices[i];
271 }
272 *os << ") ";
273 }
274
275 const MonomorphicInnerMatcher inner_matcher_;
276
277 GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
278 };
279
280 template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
281 int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1,
282 int k8 = -1, int k9 = -1>
283 class ArgsMatcher {
284 public:
ArgsMatcher(const InnerMatcher & inner_matcher)285 explicit ArgsMatcher(const InnerMatcher& inner_matcher)
286 : inner_matcher_(inner_matcher) {}
287
288 template <typename ArgsTuple>
289 operator Matcher<ArgsTuple>() const {
290 return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k0, k1, k2, k3, k4, k5,
291 k6, k7, k8, k9>(inner_matcher_));
292 }
293
294 private:
295 const InnerMatcher inner_matcher_;
296
297 GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
298 };
299
300 // A set of metafunctions for computing the result type of AllOf.
301 // AllOf(m1, ..., mN) returns
302 // AllOfResultN<decltype(m1), ..., decltype(mN)>::type.
303
304 // Although AllOf isn't defined for one argument, AllOfResult1 is defined
305 // to simplify the implementation.
306 template <typename M1>
307 struct AllOfResult1 {
308 typedef M1 type;
309 };
310
311 template <typename M1, typename M2>
312 struct AllOfResult2 {
313 typedef BothOfMatcher<
314 typename AllOfResult1<M1>::type,
315 typename AllOfResult1<M2>::type
316 > type;
317 };
318
319 template <typename M1, typename M2, typename M3>
320 struct AllOfResult3 {
321 typedef BothOfMatcher<
322 typename AllOfResult1<M1>::type,
323 typename AllOfResult2<M2, M3>::type
324 > type;
325 };
326
327 template <typename M1, typename M2, typename M3, typename M4>
328 struct AllOfResult4 {
329 typedef BothOfMatcher<
330 typename AllOfResult2<M1, M2>::type,
331 typename AllOfResult2<M3, M4>::type
332 > type;
333 };
334
335 template <typename M1, typename M2, typename M3, typename M4, typename M5>
336 struct AllOfResult5 {
337 typedef BothOfMatcher<
338 typename AllOfResult2<M1, M2>::type,
339 typename AllOfResult3<M3, M4, M5>::type
340 > type;
341 };
342
343 template <typename M1, typename M2, typename M3, typename M4, typename M5,
344 typename M6>
345 struct AllOfResult6 {
346 typedef BothOfMatcher<
347 typename AllOfResult3<M1, M2, M3>::type,
348 typename AllOfResult3<M4, M5, M6>::type
349 > type;
350 };
351
352 template <typename M1, typename M2, typename M3, typename M4, typename M5,
353 typename M6, typename M7>
354 struct AllOfResult7 {
355 typedef BothOfMatcher<
356 typename AllOfResult3<M1, M2, M3>::type,
357 typename AllOfResult4<M4, M5, M6, M7>::type
358 > type;
359 };
360
361 template <typename M1, typename M2, typename M3, typename M4, typename M5,
362 typename M6, typename M7, typename M8>
363 struct AllOfResult8 {
364 typedef BothOfMatcher<
365 typename AllOfResult4<M1, M2, M3, M4>::type,
366 typename AllOfResult4<M5, M6, M7, M8>::type
367 > type;
368 };
369
370 template <typename M1, typename M2, typename M3, typename M4, typename M5,
371 typename M6, typename M7, typename M8, typename M9>
372 struct AllOfResult9 {
373 typedef BothOfMatcher<
374 typename AllOfResult4<M1, M2, M3, M4>::type,
375 typename AllOfResult5<M5, M6, M7, M8, M9>::type
376 > type;
377 };
378
379 template <typename M1, typename M2, typename M3, typename M4, typename M5,
380 typename M6, typename M7, typename M8, typename M9, typename M10>
381 struct AllOfResult10 {
382 typedef BothOfMatcher<
383 typename AllOfResult5<M1, M2, M3, M4, M5>::type,
384 typename AllOfResult5<M6, M7, M8, M9, M10>::type
385 > type;
386 };
387
388 // A set of metafunctions for computing the result type of AnyOf.
389 // AnyOf(m1, ..., mN) returns
390 // AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.
391
392 // Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
393 // to simplify the implementation.
394 template <typename M1>
395 struct AnyOfResult1 {
396 typedef M1 type;
397 };
398
399 template <typename M1, typename M2>
400 struct AnyOfResult2 {
401 typedef EitherOfMatcher<
402 typename AnyOfResult1<M1>::type,
403 typename AnyOfResult1<M2>::type
404 > type;
405 };
406
407 template <typename M1, typename M2, typename M3>
408 struct AnyOfResult3 {
409 typedef EitherOfMatcher<
410 typename AnyOfResult1<M1>::type,
411 typename AnyOfResult2<M2, M3>::type
412 > type;
413 };
414
415 template <typename M1, typename M2, typename M3, typename M4>
416 struct AnyOfResult4 {
417 typedef EitherOfMatcher<
418 typename AnyOfResult2<M1, M2>::type,
419 typename AnyOfResult2<M3, M4>::type
420 > type;
421 };
422
423 template <typename M1, typename M2, typename M3, typename M4, typename M5>
424 struct AnyOfResult5 {
425 typedef EitherOfMatcher<
426 typename AnyOfResult2<M1, M2>::type,
427 typename AnyOfResult3<M3, M4, M5>::type
428 > type;
429 };
430
431 template <typename M1, typename M2, typename M3, typename M4, typename M5,
432 typename M6>
433 struct AnyOfResult6 {
434 typedef EitherOfMatcher<
435 typename AnyOfResult3<M1, M2, M3>::type,
436 typename AnyOfResult3<M4, M5, M6>::type
437 > type;
438 };
439
440 template <typename M1, typename M2, typename M3, typename M4, typename M5,
441 typename M6, typename M7>
442 struct AnyOfResult7 {
443 typedef EitherOfMatcher<
444 typename AnyOfResult3<M1, M2, M3>::type,
445 typename AnyOfResult4<M4, M5, M6, M7>::type
446 > type;
447 };
448
449 template <typename M1, typename M2, typename M3, typename M4, typename M5,
450 typename M6, typename M7, typename M8>
451 struct AnyOfResult8 {
452 typedef EitherOfMatcher<
453 typename AnyOfResult4<M1, M2, M3, M4>::type,
454 typename AnyOfResult4<M5, M6, M7, M8>::type
455 > type;
456 };
457
458 template <typename M1, typename M2, typename M3, typename M4, typename M5,
459 typename M6, typename M7, typename M8, typename M9>
460 struct AnyOfResult9 {
461 typedef EitherOfMatcher<
462 typename AnyOfResult4<M1, M2, M3, M4>::type,
463 typename AnyOfResult5<M5, M6, M7, M8, M9>::type
464 > type;
465 };
466
467 template <typename M1, typename M2, typename M3, typename M4, typename M5,
468 typename M6, typename M7, typename M8, typename M9, typename M10>
469 struct AnyOfResult10 {
470 typedef EitherOfMatcher<
471 typename AnyOfResult5<M1, M2, M3, M4, M5>::type,
472 typename AnyOfResult5<M6, M7, M8, M9, M10>::type
473 > type;
474 };
475
476 } // namespace internal
477
478 // Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
479 // fields of it matches a_matcher. C++ doesn't support default
480 // arguments for function templates, so we have to overload it.
481 template <typename InnerMatcher>
482 inline internal::ArgsMatcher<InnerMatcher>
Args(const InnerMatcher & matcher)483 Args(const InnerMatcher& matcher) {
484 return internal::ArgsMatcher<InnerMatcher>(matcher);
485 }
486
487 template <int k1, typename InnerMatcher>
488 inline internal::ArgsMatcher<InnerMatcher, k1>
Args(const InnerMatcher & matcher)489 Args(const InnerMatcher& matcher) {
490 return internal::ArgsMatcher<InnerMatcher, k1>(matcher);
491 }
492
493 template <int k1, int k2, typename InnerMatcher>
494 inline internal::ArgsMatcher<InnerMatcher, k1, k2>
Args(const InnerMatcher & matcher)495 Args(const InnerMatcher& matcher) {
496 return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher);
497 }
498
499 template <int k1, int k2, int k3, typename InnerMatcher>
500 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3>
Args(const InnerMatcher & matcher)501 Args(const InnerMatcher& matcher) {
502 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher);
503 }
504
505 template <int k1, int k2, int k3, int k4, typename InnerMatcher>
506 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>
Args(const InnerMatcher & matcher)507 Args(const InnerMatcher& matcher) {
508 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher);
509 }
510
511 template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher>
512 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>
Args(const InnerMatcher & matcher)513 Args(const InnerMatcher& matcher) {
514 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher);
515 }
516
517 template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher>
518 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>
Args(const InnerMatcher & matcher)519 Args(const InnerMatcher& matcher) {
520 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher);
521 }
522
523 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
524 typename InnerMatcher>
525 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7>
Args(const InnerMatcher & matcher)526 Args(const InnerMatcher& matcher) {
527 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6,
528 k7>(matcher);
529 }
530
531 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
532 typename InnerMatcher>
533 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8>
Args(const InnerMatcher & matcher)534 Args(const InnerMatcher& matcher) {
535 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
536 k8>(matcher);
537 }
538
539 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
540 int k9, typename InnerMatcher>
541 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9>
Args(const InnerMatcher & matcher)542 Args(const InnerMatcher& matcher) {
543 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
544 k9>(matcher);
545 }
546
547 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
548 int k9, int k10, typename InnerMatcher>
549 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9,
550 k10>
Args(const InnerMatcher & matcher)551 Args(const InnerMatcher& matcher) {
552 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
553 k9, k10>(matcher);
554 }
555
556 // ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
557 // n elements, where the i-th element in the container must
558 // match the i-th argument in the list. Each argument of
559 // ElementsAre() can be either a value or a matcher. We support up to
560 // 10 arguments.
561 //
562 // The use of DecayArray in the implementation allows ElementsAre()
563 // to accept string literals, whose type is const char[N], but we
564 // want to treat them as const char*.
565 //
566 // NOTE: Since ElementsAre() cares about the order of the elements, it
567 // must not be used with containers whose elements's order is
568 // undefined (e.g. hash_map).
569
570 inline internal::ElementsAreMatcher<
571 ::testing::tuple<> >
ElementsAre()572 ElementsAre() {
573 typedef ::testing::tuple<> Args;
574 return internal::ElementsAreMatcher<Args>(Args());
575 }
576
577 template <typename T1>
578 inline internal::ElementsAreMatcher<
579 ::testing::tuple<
580 typename internal::DecayArray<T1>::type> >
ElementsAre(const T1 & e1)581 ElementsAre(const T1& e1) {
582 typedef ::testing::tuple<
583 typename internal::DecayArray<T1>::type> Args;
584 return internal::ElementsAreMatcher<Args>(Args(e1));
585 }
586
587 template <typename T1, typename T2>
588 inline internal::ElementsAreMatcher<
589 ::testing::tuple<
590 typename internal::DecayArray<T1>::type,
591 typename internal::DecayArray<T2>::type> >
ElementsAre(const T1 & e1,const T2 & e2)592 ElementsAre(const T1& e1, const T2& e2) {
593 typedef ::testing::tuple<
594 typename internal::DecayArray<T1>::type,
595 typename internal::DecayArray<T2>::type> Args;
596 return internal::ElementsAreMatcher<Args>(Args(e1, e2));
597 }
598
599 template <typename T1, typename T2, typename T3>
600 inline internal::ElementsAreMatcher<
601 ::testing::tuple<
602 typename internal::DecayArray<T1>::type,
603 typename internal::DecayArray<T2>::type,
604 typename internal::DecayArray<T3>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3)605 ElementsAre(const T1& e1, const T2& e2, const T3& e3) {
606 typedef ::testing::tuple<
607 typename internal::DecayArray<T1>::type,
608 typename internal::DecayArray<T2>::type,
609 typename internal::DecayArray<T3>::type> Args;
610 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3));
611 }
612
613 template <typename T1, typename T2, typename T3, typename T4>
614 inline internal::ElementsAreMatcher<
615 ::testing::tuple<
616 typename internal::DecayArray<T1>::type,
617 typename internal::DecayArray<T2>::type,
618 typename internal::DecayArray<T3>::type,
619 typename internal::DecayArray<T4>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4)620 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
621 typedef ::testing::tuple<
622 typename internal::DecayArray<T1>::type,
623 typename internal::DecayArray<T2>::type,
624 typename internal::DecayArray<T3>::type,
625 typename internal::DecayArray<T4>::type> Args;
626 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
627 }
628
629 template <typename T1, typename T2, typename T3, typename T4, typename T5>
630 inline internal::ElementsAreMatcher<
631 ::testing::tuple<
632 typename internal::DecayArray<T1>::type,
633 typename internal::DecayArray<T2>::type,
634 typename internal::DecayArray<T3>::type,
635 typename internal::DecayArray<T4>::type,
636 typename internal::DecayArray<T5>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5)637 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
638 const T5& e5) {
639 typedef ::testing::tuple<
640 typename internal::DecayArray<T1>::type,
641 typename internal::DecayArray<T2>::type,
642 typename internal::DecayArray<T3>::type,
643 typename internal::DecayArray<T4>::type,
644 typename internal::DecayArray<T5>::type> Args;
645 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
646 }
647
648 template <typename T1, typename T2, typename T3, typename T4, typename T5,
649 typename T6>
650 inline internal::ElementsAreMatcher<
651 ::testing::tuple<
652 typename internal::DecayArray<T1>::type,
653 typename internal::DecayArray<T2>::type,
654 typename internal::DecayArray<T3>::type,
655 typename internal::DecayArray<T4>::type,
656 typename internal::DecayArray<T5>::type,
657 typename internal::DecayArray<T6>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6)658 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
659 const T5& e5, const T6& e6) {
660 typedef ::testing::tuple<
661 typename internal::DecayArray<T1>::type,
662 typename internal::DecayArray<T2>::type,
663 typename internal::DecayArray<T3>::type,
664 typename internal::DecayArray<T4>::type,
665 typename internal::DecayArray<T5>::type,
666 typename internal::DecayArray<T6>::type> Args;
667 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6));
668 }
669
670 template <typename T1, typename T2, typename T3, typename T4, typename T5,
671 typename T6, typename T7>
672 inline internal::ElementsAreMatcher<
673 ::testing::tuple<
674 typename internal::DecayArray<T1>::type,
675 typename internal::DecayArray<T2>::type,
676 typename internal::DecayArray<T3>::type,
677 typename internal::DecayArray<T4>::type,
678 typename internal::DecayArray<T5>::type,
679 typename internal::DecayArray<T6>::type,
680 typename internal::DecayArray<T7>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7)681 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
682 const T5& e5, const T6& e6, const T7& e7) {
683 typedef ::testing::tuple<
684 typename internal::DecayArray<T1>::type,
685 typename internal::DecayArray<T2>::type,
686 typename internal::DecayArray<T3>::type,
687 typename internal::DecayArray<T4>::type,
688 typename internal::DecayArray<T5>::type,
689 typename internal::DecayArray<T6>::type,
690 typename internal::DecayArray<T7>::type> Args;
691 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7));
692 }
693
694 template <typename T1, typename T2, typename T3, typename T4, typename T5,
695 typename T6, typename T7, typename T8>
696 inline internal::ElementsAreMatcher<
697 ::testing::tuple<
698 typename internal::DecayArray<T1>::type,
699 typename internal::DecayArray<T2>::type,
700 typename internal::DecayArray<T3>::type,
701 typename internal::DecayArray<T4>::type,
702 typename internal::DecayArray<T5>::type,
703 typename internal::DecayArray<T6>::type,
704 typename internal::DecayArray<T7>::type,
705 typename internal::DecayArray<T8>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8)706 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
707 const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
708 typedef ::testing::tuple<
709 typename internal::DecayArray<T1>::type,
710 typename internal::DecayArray<T2>::type,
711 typename internal::DecayArray<T3>::type,
712 typename internal::DecayArray<T4>::type,
713 typename internal::DecayArray<T5>::type,
714 typename internal::DecayArray<T6>::type,
715 typename internal::DecayArray<T7>::type,
716 typename internal::DecayArray<T8>::type> Args;
717 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
718 e8));
719 }
720
721 template <typename T1, typename T2, typename T3, typename T4, typename T5,
722 typename T6, typename T7, typename T8, typename T9>
723 inline internal::ElementsAreMatcher<
724 ::testing::tuple<
725 typename internal::DecayArray<T1>::type,
726 typename internal::DecayArray<T2>::type,
727 typename internal::DecayArray<T3>::type,
728 typename internal::DecayArray<T4>::type,
729 typename internal::DecayArray<T5>::type,
730 typename internal::DecayArray<T6>::type,
731 typename internal::DecayArray<T7>::type,
732 typename internal::DecayArray<T8>::type,
733 typename internal::DecayArray<T9>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8,const T9 & e9)734 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
735 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
736 typedef ::testing::tuple<
737 typename internal::DecayArray<T1>::type,
738 typename internal::DecayArray<T2>::type,
739 typename internal::DecayArray<T3>::type,
740 typename internal::DecayArray<T4>::type,
741 typename internal::DecayArray<T5>::type,
742 typename internal::DecayArray<T6>::type,
743 typename internal::DecayArray<T7>::type,
744 typename internal::DecayArray<T8>::type,
745 typename internal::DecayArray<T9>::type> Args;
746 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
747 e8, e9));
748 }
749
750 template <typename T1, typename T2, typename T3, typename T4, typename T5,
751 typename T6, typename T7, typename T8, typename T9, typename T10>
752 inline internal::ElementsAreMatcher<
753 ::testing::tuple<
754 typename internal::DecayArray<T1>::type,
755 typename internal::DecayArray<T2>::type,
756 typename internal::DecayArray<T3>::type,
757 typename internal::DecayArray<T4>::type,
758 typename internal::DecayArray<T5>::type,
759 typename internal::DecayArray<T6>::type,
760 typename internal::DecayArray<T7>::type,
761 typename internal::DecayArray<T8>::type,
762 typename internal::DecayArray<T9>::type,
763 typename internal::DecayArray<T10>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8,const T9 & e9,const T10 & e10)764 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
765 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
766 const T10& e10) {
767 typedef ::testing::tuple<
768 typename internal::DecayArray<T1>::type,
769 typename internal::DecayArray<T2>::type,
770 typename internal::DecayArray<T3>::type,
771 typename internal::DecayArray<T4>::type,
772 typename internal::DecayArray<T5>::type,
773 typename internal::DecayArray<T6>::type,
774 typename internal::DecayArray<T7>::type,
775 typename internal::DecayArray<T8>::type,
776 typename internal::DecayArray<T9>::type,
777 typename internal::DecayArray<T10>::type> Args;
778 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
779 e8, e9, e10));
780 }
781
782 // UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
783 // that matches n elements in any order. We support up to n=10 arguments.
784 //
785 // If you have >10 elements, consider UnorderedElementsAreArray() or
786 // UnorderedPointwise() instead.
787
788 inline internal::UnorderedElementsAreMatcher<
789 ::testing::tuple<> >
UnorderedElementsAre()790 UnorderedElementsAre() {
791 typedef ::testing::tuple<> Args;
792 return internal::UnorderedElementsAreMatcher<Args>(Args());
793 }
794
795 template <typename T1>
796 inline internal::UnorderedElementsAreMatcher<
797 ::testing::tuple<
798 typename internal::DecayArray<T1>::type> >
UnorderedElementsAre(const T1 & e1)799 UnorderedElementsAre(const T1& e1) {
800 typedef ::testing::tuple<
801 typename internal::DecayArray<T1>::type> Args;
802 return internal::UnorderedElementsAreMatcher<Args>(Args(e1));
803 }
804
805 template <typename T1, typename T2>
806 inline internal::UnorderedElementsAreMatcher<
807 ::testing::tuple<
808 typename internal::DecayArray<T1>::type,
809 typename internal::DecayArray<T2>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2)810 UnorderedElementsAre(const T1& e1, const T2& e2) {
811 typedef ::testing::tuple<
812 typename internal::DecayArray<T1>::type,
813 typename internal::DecayArray<T2>::type> Args;
814 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2));
815 }
816
817 template <typename T1, typename T2, typename T3>
818 inline internal::UnorderedElementsAreMatcher<
819 ::testing::tuple<
820 typename internal::DecayArray<T1>::type,
821 typename internal::DecayArray<T2>::type,
822 typename internal::DecayArray<T3>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3)823 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3) {
824 typedef ::testing::tuple<
825 typename internal::DecayArray<T1>::type,
826 typename internal::DecayArray<T2>::type,
827 typename internal::DecayArray<T3>::type> Args;
828 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3));
829 }
830
831 template <typename T1, typename T2, typename T3, typename T4>
832 inline internal::UnorderedElementsAreMatcher<
833 ::testing::tuple<
834 typename internal::DecayArray<T1>::type,
835 typename internal::DecayArray<T2>::type,
836 typename internal::DecayArray<T3>::type,
837 typename internal::DecayArray<T4>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4)838 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
839 typedef ::testing::tuple<
840 typename internal::DecayArray<T1>::type,
841 typename internal::DecayArray<T2>::type,
842 typename internal::DecayArray<T3>::type,
843 typename internal::DecayArray<T4>::type> Args;
844 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
845 }
846
847 template <typename T1, typename T2, typename T3, typename T4, typename T5>
848 inline internal::UnorderedElementsAreMatcher<
849 ::testing::tuple<
850 typename internal::DecayArray<T1>::type,
851 typename internal::DecayArray<T2>::type,
852 typename internal::DecayArray<T3>::type,
853 typename internal::DecayArray<T4>::type,
854 typename internal::DecayArray<T5>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5)855 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
856 const T5& e5) {
857 typedef ::testing::tuple<
858 typename internal::DecayArray<T1>::type,
859 typename internal::DecayArray<T2>::type,
860 typename internal::DecayArray<T3>::type,
861 typename internal::DecayArray<T4>::type,
862 typename internal::DecayArray<T5>::type> Args;
863 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
864 }
865
866 template <typename T1, typename T2, typename T3, typename T4, typename T5,
867 typename T6>
868 inline internal::UnorderedElementsAreMatcher<
869 ::testing::tuple<
870 typename internal::DecayArray<T1>::type,
871 typename internal::DecayArray<T2>::type,
872 typename internal::DecayArray<T3>::type,
873 typename internal::DecayArray<T4>::type,
874 typename internal::DecayArray<T5>::type,
875 typename internal::DecayArray<T6>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6)876 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
877 const T5& e5, const T6& e6) {
878 typedef ::testing::tuple<
879 typename internal::DecayArray<T1>::type,
880 typename internal::DecayArray<T2>::type,
881 typename internal::DecayArray<T3>::type,
882 typename internal::DecayArray<T4>::type,
883 typename internal::DecayArray<T5>::type,
884 typename internal::DecayArray<T6>::type> Args;
885 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
886 e6));
887 }
888
889 template <typename T1, typename T2, typename T3, typename T4, typename T5,
890 typename T6, typename T7>
891 inline internal::UnorderedElementsAreMatcher<
892 ::testing::tuple<
893 typename internal::DecayArray<T1>::type,
894 typename internal::DecayArray<T2>::type,
895 typename internal::DecayArray<T3>::type,
896 typename internal::DecayArray<T4>::type,
897 typename internal::DecayArray<T5>::type,
898 typename internal::DecayArray<T6>::type,
899 typename internal::DecayArray<T7>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7)900 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
901 const T5& e5, const T6& e6, const T7& e7) {
902 typedef ::testing::tuple<
903 typename internal::DecayArray<T1>::type,
904 typename internal::DecayArray<T2>::type,
905 typename internal::DecayArray<T3>::type,
906 typename internal::DecayArray<T4>::type,
907 typename internal::DecayArray<T5>::type,
908 typename internal::DecayArray<T6>::type,
909 typename internal::DecayArray<T7>::type> Args;
910 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
911 e6, e7));
912 }
913
914 template <typename T1, typename T2, typename T3, typename T4, typename T5,
915 typename T6, typename T7, typename T8>
916 inline internal::UnorderedElementsAreMatcher<
917 ::testing::tuple<
918 typename internal::DecayArray<T1>::type,
919 typename internal::DecayArray<T2>::type,
920 typename internal::DecayArray<T3>::type,
921 typename internal::DecayArray<T4>::type,
922 typename internal::DecayArray<T5>::type,
923 typename internal::DecayArray<T6>::type,
924 typename internal::DecayArray<T7>::type,
925 typename internal::DecayArray<T8>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8)926 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
927 const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
928 typedef ::testing::tuple<
929 typename internal::DecayArray<T1>::type,
930 typename internal::DecayArray<T2>::type,
931 typename internal::DecayArray<T3>::type,
932 typename internal::DecayArray<T4>::type,
933 typename internal::DecayArray<T5>::type,
934 typename internal::DecayArray<T6>::type,
935 typename internal::DecayArray<T7>::type,
936 typename internal::DecayArray<T8>::type> Args;
937 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
938 e6, e7, e8));
939 }
940
941 template <typename T1, typename T2, typename T3, typename T4, typename T5,
942 typename T6, typename T7, typename T8, typename T9>
943 inline internal::UnorderedElementsAreMatcher<
944 ::testing::tuple<
945 typename internal::DecayArray<T1>::type,
946 typename internal::DecayArray<T2>::type,
947 typename internal::DecayArray<T3>::type,
948 typename internal::DecayArray<T4>::type,
949 typename internal::DecayArray<T5>::type,
950 typename internal::DecayArray<T6>::type,
951 typename internal::DecayArray<T7>::type,
952 typename internal::DecayArray<T8>::type,
953 typename internal::DecayArray<T9>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8,const T9 & e9)954 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
955 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
956 typedef ::testing::tuple<
957 typename internal::DecayArray<T1>::type,
958 typename internal::DecayArray<T2>::type,
959 typename internal::DecayArray<T3>::type,
960 typename internal::DecayArray<T4>::type,
961 typename internal::DecayArray<T5>::type,
962 typename internal::DecayArray<T6>::type,
963 typename internal::DecayArray<T7>::type,
964 typename internal::DecayArray<T8>::type,
965 typename internal::DecayArray<T9>::type> Args;
966 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
967 e6, e7, e8, e9));
968 }
969
970 template <typename T1, typename T2, typename T3, typename T4, typename T5,
971 typename T6, typename T7, typename T8, typename T9, typename T10>
972 inline internal::UnorderedElementsAreMatcher<
973 ::testing::tuple<
974 typename internal::DecayArray<T1>::type,
975 typename internal::DecayArray<T2>::type,
976 typename internal::DecayArray<T3>::type,
977 typename internal::DecayArray<T4>::type,
978 typename internal::DecayArray<T5>::type,
979 typename internal::DecayArray<T6>::type,
980 typename internal::DecayArray<T7>::type,
981 typename internal::DecayArray<T8>::type,
982 typename internal::DecayArray<T9>::type,
983 typename internal::DecayArray<T10>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8,const T9 & e9,const T10 & e10)984 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
985 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
986 const T10& e10) {
987 typedef ::testing::tuple<
988 typename internal::DecayArray<T1>::type,
989 typename internal::DecayArray<T2>::type,
990 typename internal::DecayArray<T3>::type,
991 typename internal::DecayArray<T4>::type,
992 typename internal::DecayArray<T5>::type,
993 typename internal::DecayArray<T6>::type,
994 typename internal::DecayArray<T7>::type,
995 typename internal::DecayArray<T8>::type,
996 typename internal::DecayArray<T9>::type,
997 typename internal::DecayArray<T10>::type> Args;
998 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
999 e6, e7, e8, e9, e10));
1000 }
1001
1002 // AllOf(m1, m2, ..., mk) matches any value that matches all of the given
1003 // sub-matchers. AllOf is called fully qualified to prevent ADL from firing.
1004
1005 template <typename M1, typename M2>
1006 inline typename internal::AllOfResult2<M1, M2>::type
AllOf(M1 m1,M2 m2)1007 AllOf(M1 m1, M2 m2) {
1008 return typename internal::AllOfResult2<M1, M2>::type(
1009 m1,
1010 m2);
1011 }
1012
1013 template <typename M1, typename M2, typename M3>
1014 inline typename internal::AllOfResult3<M1, M2, M3>::type
AllOf(M1 m1,M2 m2,M3 m3)1015 AllOf(M1 m1, M2 m2, M3 m3) {
1016 return typename internal::AllOfResult3<M1, M2, M3>::type(
1017 m1,
1018 ::testing::AllOf(m2, m3));
1019 }
1020
1021 template <typename M1, typename M2, typename M3, typename M4>
1022 inline typename internal::AllOfResult4<M1, M2, M3, M4>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4)1023 AllOf(M1 m1, M2 m2, M3 m3, M4 m4) {
1024 return typename internal::AllOfResult4<M1, M2, M3, M4>::type(
1025 ::testing::AllOf(m1, m2),
1026 ::testing::AllOf(m3, m4));
1027 }
1028
1029 template <typename M1, typename M2, typename M3, typename M4, typename M5>
1030 inline typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5)1031 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
1032 return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type(
1033 ::testing::AllOf(m1, m2),
1034 ::testing::AllOf(m3, m4, m5));
1035 }
1036
1037 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1038 typename M6>
1039 inline typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6)1040 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
1041 return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type(
1042 ::testing::AllOf(m1, m2, m3),
1043 ::testing::AllOf(m4, m5, m6));
1044 }
1045
1046 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1047 typename M6, typename M7>
1048 inline typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7)1049 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
1050 return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
1051 ::testing::AllOf(m1, m2, m3),
1052 ::testing::AllOf(m4, m5, m6, m7));
1053 }
1054
1055 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1056 typename M6, typename M7, typename M8>
1057 inline typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8)1058 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
1059 return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
1060 ::testing::AllOf(m1, m2, m3, m4),
1061 ::testing::AllOf(m5, m6, m7, m8));
1062 }
1063
1064 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1065 typename M6, typename M7, typename M8, typename M9>
1066 inline typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8,M9 m9)1067 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
1068 return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
1069 M9>::type(
1070 ::testing::AllOf(m1, m2, m3, m4),
1071 ::testing::AllOf(m5, m6, m7, m8, m9));
1072 }
1073
1074 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1075 typename M6, typename M7, typename M8, typename M9, typename M10>
1076 inline typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1077 M10>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8,M9 m9,M10 m10)1078 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
1079 return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1080 M10>::type(
1081 ::testing::AllOf(m1, m2, m3, m4, m5),
1082 ::testing::AllOf(m6, m7, m8, m9, m10));
1083 }
1084
1085 // AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
1086 // sub-matchers. AnyOf is called fully qualified to prevent ADL from firing.
1087
1088 template <typename M1, typename M2>
1089 inline typename internal::AnyOfResult2<M1, M2>::type
AnyOf(M1 m1,M2 m2)1090 AnyOf(M1 m1, M2 m2) {
1091 return typename internal::AnyOfResult2<M1, M2>::type(
1092 m1,
1093 m2);
1094 }
1095
1096 template <typename M1, typename M2, typename M3>
1097 inline typename internal::AnyOfResult3<M1, M2, M3>::type
AnyOf(M1 m1,M2 m2,M3 m3)1098 AnyOf(M1 m1, M2 m2, M3 m3) {
1099 return typename internal::AnyOfResult3<M1, M2, M3>::type(
1100 m1,
1101 ::testing::AnyOf(m2, m3));
1102 }
1103
1104 template <typename M1, typename M2, typename M3, typename M4>
1105 inline typename internal::AnyOfResult4<M1, M2, M3, M4>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4)1106 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) {
1107 return typename internal::AnyOfResult4<M1, M2, M3, M4>::type(
1108 ::testing::AnyOf(m1, m2),
1109 ::testing::AnyOf(m3, m4));
1110 }
1111
1112 template <typename M1, typename M2, typename M3, typename M4, typename M5>
1113 inline typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5)1114 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
1115 return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type(
1116 ::testing::AnyOf(m1, m2),
1117 ::testing::AnyOf(m3, m4, m5));
1118 }
1119
1120 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1121 typename M6>
1122 inline typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6)1123 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
1124 return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type(
1125 ::testing::AnyOf(m1, m2, m3),
1126 ::testing::AnyOf(m4, m5, m6));
1127 }
1128
1129 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1130 typename M6, typename M7>
1131 inline typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7)1132 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
1133 return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
1134 ::testing::AnyOf(m1, m2, m3),
1135 ::testing::AnyOf(m4, m5, m6, m7));
1136 }
1137
1138 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1139 typename M6, typename M7, typename M8>
1140 inline typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8)1141 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
1142 return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
1143 ::testing::AnyOf(m1, m2, m3, m4),
1144 ::testing::AnyOf(m5, m6, m7, m8));
1145 }
1146
1147 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1148 typename M6, typename M7, typename M8, typename M9>
1149 inline typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8,M9 m9)1150 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
1151 return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
1152 M9>::type(
1153 ::testing::AnyOf(m1, m2, m3, m4),
1154 ::testing::AnyOf(m5, m6, m7, m8, m9));
1155 }
1156
1157 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1158 typename M6, typename M7, typename M8, typename M9, typename M10>
1159 inline typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1160 M10>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8,M9 m9,M10 m10)1161 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
1162 return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1163 M10>::type(
1164 ::testing::AnyOf(m1, m2, m3, m4, m5),
1165 ::testing::AnyOf(m6, m7, m8, m9, m10));
1166 }
1167
1168 } // namespace testing
1169
1170
1171 // The MATCHER* family of macros can be used in a namespace scope to
1172 // define custom matchers easily.
1173 //
1174 // Basic Usage
1175 // ===========
1176 //
1177 // The syntax
1178 //
1179 // MATCHER(name, description_string) { statements; }
1180 //
1181 // defines a matcher with the given name that executes the statements,
1182 // which must return a bool to indicate if the match succeeds. Inside
1183 // the statements, you can refer to the value being matched by 'arg',
1184 // and refer to its type by 'arg_type'.
1185 //
1186 // The description string documents what the matcher does, and is used
1187 // to generate the failure message when the match fails. Since a
1188 // MATCHER() is usually defined in a header file shared by multiple
1189 // C++ source files, we require the description to be a C-string
1190 // literal to avoid possible side effects. It can be empty, in which
1191 // case we'll use the sequence of words in the matcher name as the
1192 // description.
1193 //
1194 // For example:
1195 //
1196 // MATCHER(IsEven, "") { return (arg % 2) == 0; }
1197 //
1198 // allows you to write
1199 //
1200 // // Expects mock_foo.Bar(n) to be called where n is even.
1201 // EXPECT_CALL(mock_foo, Bar(IsEven()));
1202 //
1203 // or,
1204 //
1205 // // Verifies that the value of some_expression is even.
1206 // EXPECT_THAT(some_expression, IsEven());
1207 //
1208 // If the above assertion fails, it will print something like:
1209 //
1210 // Value of: some_expression
1211 // Expected: is even
1212 // Actual: 7
1213 //
1214 // where the description "is even" is automatically calculated from the
1215 // matcher name IsEven.
1216 //
1217 // Argument Type
1218 // =============
1219 //
1220 // Note that the type of the value being matched (arg_type) is
1221 // determined by the context in which you use the matcher and is
1222 // supplied to you by the compiler, so you don't need to worry about
1223 // declaring it (nor can you). This allows the matcher to be
1224 // polymorphic. For example, IsEven() can be used to match any type
1225 // where the value of "(arg % 2) == 0" can be implicitly converted to
1226 // a bool. In the "Bar(IsEven())" example above, if method Bar()
1227 // takes an int, 'arg_type' will be int; if it takes an unsigned long,
1228 // 'arg_type' will be unsigned long; and so on.
1229 //
1230 // Parameterizing Matchers
1231 // =======================
1232 //
1233 // Sometimes you'll want to parameterize the matcher. For that you
1234 // can use another macro:
1235 //
1236 // MATCHER_P(name, param_name, description_string) { statements; }
1237 //
1238 // For example:
1239 //
1240 // MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
1241 //
1242 // will allow you to write:
1243 //
1244 // EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
1245 //
1246 // which may lead to this message (assuming n is 10):
1247 //
1248 // Value of: Blah("a")
1249 // Expected: has absolute value 10
1250 // Actual: -9
1251 //
1252 // Note that both the matcher description and its parameter are
1253 // printed, making the message human-friendly.
1254 //
1255 // In the matcher definition body, you can write 'foo_type' to
1256 // reference the type of a parameter named 'foo'. For example, in the
1257 // body of MATCHER_P(HasAbsoluteValue, value) above, you can write
1258 // 'value_type' to refer to the type of 'value'.
1259 //
1260 // We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to
1261 // support multi-parameter matchers.
1262 //
1263 // Describing Parameterized Matchers
1264 // =================================
1265 //
1266 // The last argument to MATCHER*() is a string-typed expression. The
1267 // expression can reference all of the matcher's parameters and a
1268 // special bool-typed variable named 'negation'. When 'negation' is
1269 // false, the expression should evaluate to the matcher's description;
1270 // otherwise it should evaluate to the description of the negation of
1271 // the matcher. For example,
1272 //
1273 // using testing::PrintToString;
1274 //
1275 // MATCHER_P2(InClosedRange, low, hi,
1276 // std::string(negation ? "is not" : "is") + " in range [" +
1277 // PrintToString(low) + ", " + PrintToString(hi) + "]") {
1278 // return low <= arg && arg <= hi;
1279 // }
1280 // ...
1281 // EXPECT_THAT(3, InClosedRange(4, 6));
1282 // EXPECT_THAT(3, Not(InClosedRange(2, 4)));
1283 //
1284 // would generate two failures that contain the text:
1285 //
1286 // Expected: is in range [4, 6]
1287 // ...
1288 // Expected: is not in range [2, 4]
1289 //
1290 // If you specify "" as the description, the failure message will
1291 // contain the sequence of words in the matcher name followed by the
1292 // parameter values printed as a tuple. For example,
1293 //
1294 // MATCHER_P2(InClosedRange, low, hi, "") { ... }
1295 // ...
1296 // EXPECT_THAT(3, InClosedRange(4, 6));
1297 // EXPECT_THAT(3, Not(InClosedRange(2, 4)));
1298 //
1299 // would generate two failures that contain the text:
1300 //
1301 // Expected: in closed range (4, 6)
1302 // ...
1303 // Expected: not (in closed range (2, 4))
1304 //
1305 // Types of Matcher Parameters
1306 // ===========================
1307 //
1308 // For the purpose of typing, you can view
1309 //
1310 // MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
1311 //
1312 // as shorthand for
1313 //
1314 // template <typename p1_type, ..., typename pk_type>
1315 // FooMatcherPk<p1_type, ..., pk_type>
1316 // Foo(p1_type p1, ..., pk_type pk) { ... }
1317 //
1318 // When you write Foo(v1, ..., vk), the compiler infers the types of
1319 // the parameters v1, ..., and vk for you. If you are not happy with
1320 // the result of the type inference, you can specify the types by
1321 // explicitly instantiating the template, as in Foo<long, bool>(5,
1322 // false). As said earlier, you don't get to (or need to) specify
1323 // 'arg_type' as that's determined by the context in which the matcher
1324 // is used. You can assign the result of expression Foo(p1, ..., pk)
1325 // to a variable of type FooMatcherPk<p1_type, ..., pk_type>. This
1326 // can be useful when composing matchers.
1327 //
1328 // While you can instantiate a matcher template with reference types,
1329 // passing the parameters by pointer usually makes your code more
1330 // readable. If, however, you still want to pass a parameter by
1331 // reference, be aware that in the failure message generated by the
1332 // matcher you will see the value of the referenced object but not its
1333 // address.
1334 //
1335 // Explaining Match Results
1336 // ========================
1337 //
1338 // Sometimes the matcher description alone isn't enough to explain why
1339 // the match has failed or succeeded. For example, when expecting a
1340 // long string, it can be very helpful to also print the diff between
1341 // the expected string and the actual one. To achieve that, you can
1342 // optionally stream additional information to a special variable
1343 // named result_listener, whose type is a pointer to class
1344 // MatchResultListener:
1345 //
1346 // MATCHER_P(EqualsLongString, str, "") {
1347 // if (arg == str) return true;
1348 //
1349 // *result_listener << "the difference: "
1350 /// << DiffStrings(str, arg);
1351 // return false;
1352 // }
1353 //
1354 // Overloading Matchers
1355 // ====================
1356 //
1357 // You can overload matchers with different numbers of parameters:
1358 //
1359 // MATCHER_P(Blah, a, description_string1) { ... }
1360 // MATCHER_P2(Blah, a, b, description_string2) { ... }
1361 //
1362 // Caveats
1363 // =======
1364 //
1365 // When defining a new matcher, you should also consider implementing
1366 // MatcherInterface or using MakePolymorphicMatcher(). These
1367 // approaches require more work than the MATCHER* macros, but also
1368 // give you more control on the types of the value being matched and
1369 // the matcher parameters, which may leads to better compiler error
1370 // messages when the matcher is used wrong. They also allow
1371 // overloading matchers based on parameter types (as opposed to just
1372 // based on the number of parameters).
1373 //
1374 // MATCHER*() can only be used in a namespace scope. The reason is
1375 // that C++ doesn't yet allow function-local types to be used to
1376 // instantiate templates. The up-coming C++0x standard will fix this.
1377 // Once that's done, we'll consider supporting using MATCHER*() inside
1378 // a function.
1379 //
1380 // More Information
1381 // ================
1382 //
1383 // To learn more about using these macros, please search for 'MATCHER'
1384 // on
1385 // https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md
1386
1387 #define MATCHER(name, description)\
1388 class name##Matcher {\
1389 public:\
1390 template <typename arg_type>\
1391 class gmock_Impl : public ::testing::MatcherInterface<\
1392 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
1393 public:\
1394 gmock_Impl()\
1395 {}\
1396 virtual bool MatchAndExplain(\
1397 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1398 ::testing::MatchResultListener* result_listener) const;\
1399 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1400 *gmock_os << FormatDescription(false);\
1401 }\
1402 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1403 *gmock_os << FormatDescription(true);\
1404 }\
1405 private:\
1406 ::std::string FormatDescription(bool negation) const {\
1407 ::std::string gmock_description = (description);\
1408 if (!gmock_description.empty())\
1409 return gmock_description;\
1410 return ::testing::internal::FormatMatcherDescription(\
1411 negation, #name, \
1412 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1413 ::testing::tuple<>()));\
1414 }\
1415 };\
1416 template <typename arg_type>\
1417 operator ::testing::Matcher<arg_type>() const {\
1418 return ::testing::Matcher<arg_type>(\
1419 new gmock_Impl<arg_type>());\
1420 }\
1421 name##Matcher() {\
1422 }\
1423 private:\
1424 };\
1425 inline name##Matcher name() {\
1426 return name##Matcher();\
1427 }\
1428 template <typename arg_type>\
1429 bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
1430 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1431 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1432 const
1433
1434 #define MATCHER_P(name, p0, description)\
1435 template <typename p0##_type>\
1436 class name##MatcherP {\
1437 public:\
1438 template <typename arg_type>\
1439 class gmock_Impl : public ::testing::MatcherInterface<\
1440 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
1441 public:\
1442 explicit gmock_Impl(p0##_type gmock_p0)\
1443 : p0(::testing::internal::move(gmock_p0)) {}\
1444 virtual bool MatchAndExplain(\
1445 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1446 ::testing::MatchResultListener* result_listener) const;\
1447 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1448 *gmock_os << FormatDescription(false);\
1449 }\
1450 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1451 *gmock_os << FormatDescription(true);\
1452 }\
1453 p0##_type const p0;\
1454 private:\
1455 ::std::string FormatDescription(bool negation) const {\
1456 ::std::string gmock_description = (description);\
1457 if (!gmock_description.empty())\
1458 return gmock_description;\
1459 return ::testing::internal::FormatMatcherDescription(\
1460 negation, #name, \
1461 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1462 ::testing::tuple<p0##_type>(p0)));\
1463 }\
1464 };\
1465 template <typename arg_type>\
1466 operator ::testing::Matcher<arg_type>() const {\
1467 return ::testing::Matcher<arg_type>(\
1468 new gmock_Impl<arg_type>(p0));\
1469 }\
1470 explicit name##MatcherP(p0##_type gmock_p0) : \
1471 p0(::testing::internal::move(gmock_p0)) {\
1472 }\
1473 p0##_type const p0;\
1474 private:\
1475 };\
1476 template <typename p0##_type>\
1477 inline name##MatcherP<p0##_type> name(p0##_type p0) {\
1478 return name##MatcherP<p0##_type>(p0);\
1479 }\
1480 template <typename p0##_type>\
1481 template <typename arg_type>\
1482 bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1483 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1484 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1485 const
1486
1487 #define MATCHER_P2(name, p0, p1, description)\
1488 template <typename p0##_type, typename p1##_type>\
1489 class name##MatcherP2 {\
1490 public:\
1491 template <typename arg_type>\
1492 class gmock_Impl : public ::testing::MatcherInterface<\
1493 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
1494 public:\
1495 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
1496 : p0(::testing::internal::move(gmock_p0)), \
1497 p1(::testing::internal::move(gmock_p1)) {}\
1498 virtual bool MatchAndExplain(\
1499 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1500 ::testing::MatchResultListener* result_listener) const;\
1501 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1502 *gmock_os << FormatDescription(false);\
1503 }\
1504 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1505 *gmock_os << FormatDescription(true);\
1506 }\
1507 p0##_type const p0;\
1508 p1##_type const p1;\
1509 private:\
1510 ::std::string FormatDescription(bool negation) const {\
1511 ::std::string gmock_description = (description);\
1512 if (!gmock_description.empty())\
1513 return gmock_description;\
1514 return ::testing::internal::FormatMatcherDescription(\
1515 negation, #name, \
1516 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1517 ::testing::tuple<p0##_type, p1##_type>(p0, p1)));\
1518 }\
1519 };\
1520 template <typename arg_type>\
1521 operator ::testing::Matcher<arg_type>() const {\
1522 return ::testing::Matcher<arg_type>(\
1523 new gmock_Impl<arg_type>(p0, p1));\
1524 }\
1525 name##MatcherP2(p0##_type gmock_p0, \
1526 p1##_type gmock_p1) : p0(::testing::internal::move(gmock_p0)), \
1527 p1(::testing::internal::move(gmock_p1)) {\
1528 }\
1529 p0##_type const p0;\
1530 p1##_type const p1;\
1531 private:\
1532 };\
1533 template <typename p0##_type, typename p1##_type>\
1534 inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
1535 p1##_type p1) {\
1536 return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\
1537 }\
1538 template <typename p0##_type, typename p1##_type>\
1539 template <typename arg_type>\
1540 bool name##MatcherP2<p0##_type, \
1541 p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1542 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1543 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1544 const
1545
1546 #define MATCHER_P3(name, p0, p1, p2, description)\
1547 template <typename p0##_type, typename p1##_type, typename p2##_type>\
1548 class name##MatcherP3 {\
1549 public:\
1550 template <typename arg_type>\
1551 class gmock_Impl : public ::testing::MatcherInterface<\
1552 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
1553 public:\
1554 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
1555 : p0(::testing::internal::move(gmock_p0)), \
1556 p1(::testing::internal::move(gmock_p1)), \
1557 p2(::testing::internal::move(gmock_p2)) {}\
1558 virtual bool MatchAndExplain(\
1559 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1560 ::testing::MatchResultListener* result_listener) const;\
1561 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1562 *gmock_os << FormatDescription(false);\
1563 }\
1564 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1565 *gmock_os << FormatDescription(true);\
1566 }\
1567 p0##_type const p0;\
1568 p1##_type const p1;\
1569 p2##_type const p2;\
1570 private:\
1571 ::std::string FormatDescription(bool negation) const {\
1572 ::std::string gmock_description = (description);\
1573 if (!gmock_description.empty())\
1574 return gmock_description;\
1575 return ::testing::internal::FormatMatcherDescription(\
1576 negation, #name, \
1577 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1578 ::testing::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, \
1579 p2)));\
1580 }\
1581 };\
1582 template <typename arg_type>\
1583 operator ::testing::Matcher<arg_type>() const {\
1584 return ::testing::Matcher<arg_type>(\
1585 new gmock_Impl<arg_type>(p0, p1, p2));\
1586 }\
1587 name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
1588 p2##_type gmock_p2) : p0(::testing::internal::move(gmock_p0)), \
1589 p1(::testing::internal::move(gmock_p1)), \
1590 p2(::testing::internal::move(gmock_p2)) {\
1591 }\
1592 p0##_type const p0;\
1593 p1##_type const p1;\
1594 p2##_type const p2;\
1595 private:\
1596 };\
1597 template <typename p0##_type, typename p1##_type, typename p2##_type>\
1598 inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
1599 p1##_type p1, p2##_type p2) {\
1600 return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
1601 }\
1602 template <typename p0##_type, typename p1##_type, typename p2##_type>\
1603 template <typename arg_type>\
1604 bool name##MatcherP3<p0##_type, p1##_type, \
1605 p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1606 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1607 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1608 const
1609
1610 #define MATCHER_P4(name, p0, p1, p2, p3, description)\
1611 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1612 typename p3##_type>\
1613 class name##MatcherP4 {\
1614 public:\
1615 template <typename arg_type>\
1616 class gmock_Impl : public ::testing::MatcherInterface<\
1617 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
1618 public:\
1619 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1620 p3##_type gmock_p3)\
1621 : p0(::testing::internal::move(gmock_p0)), \
1622 p1(::testing::internal::move(gmock_p1)), \
1623 p2(::testing::internal::move(gmock_p2)), \
1624 p3(::testing::internal::move(gmock_p3)) {}\
1625 virtual bool MatchAndExplain(\
1626 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1627 ::testing::MatchResultListener* result_listener) const;\
1628 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1629 *gmock_os << FormatDescription(false);\
1630 }\
1631 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1632 *gmock_os << FormatDescription(true);\
1633 }\
1634 p0##_type const p0;\
1635 p1##_type const p1;\
1636 p2##_type const p2;\
1637 p3##_type const p3;\
1638 private:\
1639 ::std::string FormatDescription(bool negation) const {\
1640 ::std::string gmock_description = (description);\
1641 if (!gmock_description.empty())\
1642 return gmock_description;\
1643 return ::testing::internal::FormatMatcherDescription(\
1644 negation, #name, \
1645 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1646 ::testing::tuple<p0##_type, p1##_type, p2##_type, \
1647 p3##_type>(p0, p1, p2, p3)));\
1648 }\
1649 };\
1650 template <typename arg_type>\
1651 operator ::testing::Matcher<arg_type>() const {\
1652 return ::testing::Matcher<arg_type>(\
1653 new gmock_Impl<arg_type>(p0, p1, p2, p3));\
1654 }\
1655 name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
1656 p2##_type gmock_p2, \
1657 p3##_type gmock_p3) : p0(::testing::internal::move(gmock_p0)), \
1658 p1(::testing::internal::move(gmock_p1)), \
1659 p2(::testing::internal::move(gmock_p2)), \
1660 p3(::testing::internal::move(gmock_p3)) {\
1661 }\
1662 p0##_type const p0;\
1663 p1##_type const p1;\
1664 p2##_type const p2;\
1665 p3##_type const p3;\
1666 private:\
1667 };\
1668 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1669 typename p3##_type>\
1670 inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \
1671 p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1672 p3##_type p3) {\
1673 return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
1674 p1, p2, p3);\
1675 }\
1676 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1677 typename p3##_type>\
1678 template <typename arg_type>\
1679 bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \
1680 p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1681 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1682 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1683 const
1684
1685 #define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
1686 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1687 typename p3##_type, typename p4##_type>\
1688 class name##MatcherP5 {\
1689 public:\
1690 template <typename arg_type>\
1691 class gmock_Impl : public ::testing::MatcherInterface<\
1692 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
1693 public:\
1694 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1695 p3##_type gmock_p3, p4##_type gmock_p4)\
1696 : p0(::testing::internal::move(gmock_p0)), \
1697 p1(::testing::internal::move(gmock_p1)), \
1698 p2(::testing::internal::move(gmock_p2)), \
1699 p3(::testing::internal::move(gmock_p3)), \
1700 p4(::testing::internal::move(gmock_p4)) {}\
1701 virtual bool MatchAndExplain(\
1702 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1703 ::testing::MatchResultListener* result_listener) const;\
1704 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1705 *gmock_os << FormatDescription(false);\
1706 }\
1707 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1708 *gmock_os << FormatDescription(true);\
1709 }\
1710 p0##_type const p0;\
1711 p1##_type const p1;\
1712 p2##_type const p2;\
1713 p3##_type const p3;\
1714 p4##_type const p4;\
1715 private:\
1716 ::std::string FormatDescription(bool negation) const {\
1717 ::std::string gmock_description = (description);\
1718 if (!gmock_description.empty())\
1719 return gmock_description;\
1720 return ::testing::internal::FormatMatcherDescription(\
1721 negation, #name, \
1722 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1723 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1724 p4##_type>(p0, p1, p2, p3, p4)));\
1725 }\
1726 };\
1727 template <typename arg_type>\
1728 operator ::testing::Matcher<arg_type>() const {\
1729 return ::testing::Matcher<arg_type>(\
1730 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\
1731 }\
1732 name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
1733 p2##_type gmock_p2, p3##_type gmock_p3, \
1734 p4##_type gmock_p4) : p0(::testing::internal::move(gmock_p0)), \
1735 p1(::testing::internal::move(gmock_p1)), \
1736 p2(::testing::internal::move(gmock_p2)), \
1737 p3(::testing::internal::move(gmock_p3)), \
1738 p4(::testing::internal::move(gmock_p4)) {\
1739 }\
1740 p0##_type const p0;\
1741 p1##_type const p1;\
1742 p2##_type const p2;\
1743 p3##_type const p3;\
1744 p4##_type const p4;\
1745 private:\
1746 };\
1747 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1748 typename p3##_type, typename p4##_type>\
1749 inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1750 p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1751 p4##_type p4) {\
1752 return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1753 p4##_type>(p0, p1, p2, p3, p4);\
1754 }\
1755 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1756 typename p3##_type, typename p4##_type>\
1757 template <typename arg_type>\
1758 bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1759 p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1760 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1761 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1762 const
1763
1764 #define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
1765 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1766 typename p3##_type, typename p4##_type, typename p5##_type>\
1767 class name##MatcherP6 {\
1768 public:\
1769 template <typename arg_type>\
1770 class gmock_Impl : public ::testing::MatcherInterface<\
1771 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
1772 public:\
1773 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1774 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\
1775 : p0(::testing::internal::move(gmock_p0)), \
1776 p1(::testing::internal::move(gmock_p1)), \
1777 p2(::testing::internal::move(gmock_p2)), \
1778 p3(::testing::internal::move(gmock_p3)), \
1779 p4(::testing::internal::move(gmock_p4)), \
1780 p5(::testing::internal::move(gmock_p5)) {}\
1781 virtual bool MatchAndExplain(\
1782 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1783 ::testing::MatchResultListener* result_listener) const;\
1784 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1785 *gmock_os << FormatDescription(false);\
1786 }\
1787 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1788 *gmock_os << FormatDescription(true);\
1789 }\
1790 p0##_type const p0;\
1791 p1##_type const p1;\
1792 p2##_type const p2;\
1793 p3##_type const p3;\
1794 p4##_type const p4;\
1795 p5##_type const p5;\
1796 private:\
1797 ::std::string FormatDescription(bool negation) const {\
1798 ::std::string gmock_description = (description);\
1799 if (!gmock_description.empty())\
1800 return gmock_description;\
1801 return ::testing::internal::FormatMatcherDescription(\
1802 negation, #name, \
1803 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1804 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1805 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
1806 }\
1807 };\
1808 template <typename arg_type>\
1809 operator ::testing::Matcher<arg_type>() const {\
1810 return ::testing::Matcher<arg_type>(\
1811 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\
1812 }\
1813 name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \
1814 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1815 p5##_type gmock_p5) : p0(::testing::internal::move(gmock_p0)), \
1816 p1(::testing::internal::move(gmock_p1)), \
1817 p2(::testing::internal::move(gmock_p2)), \
1818 p3(::testing::internal::move(gmock_p3)), \
1819 p4(::testing::internal::move(gmock_p4)), \
1820 p5(::testing::internal::move(gmock_p5)) {\
1821 }\
1822 p0##_type const p0;\
1823 p1##_type const p1;\
1824 p2##_type const p2;\
1825 p3##_type const p3;\
1826 p4##_type const p4;\
1827 p5##_type const p5;\
1828 private:\
1829 };\
1830 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1831 typename p3##_type, typename p4##_type, typename p5##_type>\
1832 inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1833 p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1834 p3##_type p3, p4##_type p4, p5##_type p5) {\
1835 return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1836 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
1837 }\
1838 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1839 typename p3##_type, typename p4##_type, typename p5##_type>\
1840 template <typename arg_type>\
1841 bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1842 p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1843 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1844 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1845 const
1846
1847 #define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
1848 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1849 typename p3##_type, typename p4##_type, typename p5##_type, \
1850 typename p6##_type>\
1851 class name##MatcherP7 {\
1852 public:\
1853 template <typename arg_type>\
1854 class gmock_Impl : public ::testing::MatcherInterface<\
1855 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
1856 public:\
1857 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1858 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1859 p6##_type gmock_p6)\
1860 : p0(::testing::internal::move(gmock_p0)), \
1861 p1(::testing::internal::move(gmock_p1)), \
1862 p2(::testing::internal::move(gmock_p2)), \
1863 p3(::testing::internal::move(gmock_p3)), \
1864 p4(::testing::internal::move(gmock_p4)), \
1865 p5(::testing::internal::move(gmock_p5)), \
1866 p6(::testing::internal::move(gmock_p6)) {}\
1867 virtual bool MatchAndExplain(\
1868 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1869 ::testing::MatchResultListener* result_listener) const;\
1870 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1871 *gmock_os << FormatDescription(false);\
1872 }\
1873 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1874 *gmock_os << FormatDescription(true);\
1875 }\
1876 p0##_type const p0;\
1877 p1##_type const p1;\
1878 p2##_type const p2;\
1879 p3##_type const p3;\
1880 p4##_type const p4;\
1881 p5##_type const p5;\
1882 p6##_type const p6;\
1883 private:\
1884 ::std::string FormatDescription(bool negation) const {\
1885 ::std::string gmock_description = (description);\
1886 if (!gmock_description.empty())\
1887 return gmock_description;\
1888 return ::testing::internal::FormatMatcherDescription(\
1889 negation, #name, \
1890 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1891 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1892 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \
1893 p6)));\
1894 }\
1895 };\
1896 template <typename arg_type>\
1897 operator ::testing::Matcher<arg_type>() const {\
1898 return ::testing::Matcher<arg_type>(\
1899 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\
1900 }\
1901 name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \
1902 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1903 p5##_type gmock_p5, \
1904 p6##_type gmock_p6) : p0(::testing::internal::move(gmock_p0)), \
1905 p1(::testing::internal::move(gmock_p1)), \
1906 p2(::testing::internal::move(gmock_p2)), \
1907 p3(::testing::internal::move(gmock_p3)), \
1908 p4(::testing::internal::move(gmock_p4)), \
1909 p5(::testing::internal::move(gmock_p5)), \
1910 p6(::testing::internal::move(gmock_p6)) {\
1911 }\
1912 p0##_type const p0;\
1913 p1##_type const p1;\
1914 p2##_type const p2;\
1915 p3##_type const p3;\
1916 p4##_type const p4;\
1917 p5##_type const p5;\
1918 p6##_type const p6;\
1919 private:\
1920 };\
1921 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1922 typename p3##_type, typename p4##_type, typename p5##_type, \
1923 typename p6##_type>\
1924 inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1925 p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
1926 p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
1927 p6##_type p6) {\
1928 return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1929 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
1930 }\
1931 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1932 typename p3##_type, typename p4##_type, typename p5##_type, \
1933 typename p6##_type>\
1934 template <typename arg_type>\
1935 bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1936 p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1937 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1938 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1939 const
1940
1941 #define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
1942 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1943 typename p3##_type, typename p4##_type, typename p5##_type, \
1944 typename p6##_type, typename p7##_type>\
1945 class name##MatcherP8 {\
1946 public:\
1947 template <typename arg_type>\
1948 class gmock_Impl : public ::testing::MatcherInterface<\
1949 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
1950 public:\
1951 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1952 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1953 p6##_type gmock_p6, p7##_type gmock_p7)\
1954 : p0(::testing::internal::move(gmock_p0)), \
1955 p1(::testing::internal::move(gmock_p1)), \
1956 p2(::testing::internal::move(gmock_p2)), \
1957 p3(::testing::internal::move(gmock_p3)), \
1958 p4(::testing::internal::move(gmock_p4)), \
1959 p5(::testing::internal::move(gmock_p5)), \
1960 p6(::testing::internal::move(gmock_p6)), \
1961 p7(::testing::internal::move(gmock_p7)) {}\
1962 virtual bool MatchAndExplain(\
1963 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1964 ::testing::MatchResultListener* result_listener) const;\
1965 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1966 *gmock_os << FormatDescription(false);\
1967 }\
1968 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1969 *gmock_os << FormatDescription(true);\
1970 }\
1971 p0##_type const p0;\
1972 p1##_type const p1;\
1973 p2##_type const p2;\
1974 p3##_type const p3;\
1975 p4##_type const p4;\
1976 p5##_type const p5;\
1977 p6##_type const p6;\
1978 p7##_type const p7;\
1979 private:\
1980 ::std::string FormatDescription(bool negation) const {\
1981 ::std::string gmock_description = (description);\
1982 if (!gmock_description.empty())\
1983 return gmock_description;\
1984 return ::testing::internal::FormatMatcherDescription(\
1985 negation, #name, \
1986 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1987 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1988 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \
1989 p3, p4, p5, p6, p7)));\
1990 }\
1991 };\
1992 template <typename arg_type>\
1993 operator ::testing::Matcher<arg_type>() const {\
1994 return ::testing::Matcher<arg_type>(\
1995 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\
1996 }\
1997 name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \
1998 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1999 p5##_type gmock_p5, p6##_type gmock_p6, \
2000 p7##_type gmock_p7) : p0(::testing::internal::move(gmock_p0)), \
2001 p1(::testing::internal::move(gmock_p1)), \
2002 p2(::testing::internal::move(gmock_p2)), \
2003 p3(::testing::internal::move(gmock_p3)), \
2004 p4(::testing::internal::move(gmock_p4)), \
2005 p5(::testing::internal::move(gmock_p5)), \
2006 p6(::testing::internal::move(gmock_p6)), \
2007 p7(::testing::internal::move(gmock_p7)) {\
2008 }\
2009 p0##_type const p0;\
2010 p1##_type const p1;\
2011 p2##_type const p2;\
2012 p3##_type const p3;\
2013 p4##_type const p4;\
2014 p5##_type const p5;\
2015 p6##_type const p6;\
2016 p7##_type const p7;\
2017 private:\
2018 };\
2019 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2020 typename p3##_type, typename p4##_type, typename p5##_type, \
2021 typename p6##_type, typename p7##_type>\
2022 inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
2023 p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
2024 p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
2025 p6##_type p6, p7##_type p7) {\
2026 return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
2027 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
2028 p6, p7);\
2029 }\
2030 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2031 typename p3##_type, typename p4##_type, typename p5##_type, \
2032 typename p6##_type, typename p7##_type>\
2033 template <typename arg_type>\
2034 bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
2035 p5##_type, p6##_type, \
2036 p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
2037 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
2038 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
2039 const
2040
2041 #define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
2042 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2043 typename p3##_type, typename p4##_type, typename p5##_type, \
2044 typename p6##_type, typename p7##_type, typename p8##_type>\
2045 class name##MatcherP9 {\
2046 public:\
2047 template <typename arg_type>\
2048 class gmock_Impl : public ::testing::MatcherInterface<\
2049 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
2050 public:\
2051 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
2052 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
2053 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\
2054 : p0(::testing::internal::move(gmock_p0)), \
2055 p1(::testing::internal::move(gmock_p1)), \
2056 p2(::testing::internal::move(gmock_p2)), \
2057 p3(::testing::internal::move(gmock_p3)), \
2058 p4(::testing::internal::move(gmock_p4)), \
2059 p5(::testing::internal::move(gmock_p5)), \
2060 p6(::testing::internal::move(gmock_p6)), \
2061 p7(::testing::internal::move(gmock_p7)), \
2062 p8(::testing::internal::move(gmock_p8)) {}\
2063 virtual bool MatchAndExplain(\
2064 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
2065 ::testing::MatchResultListener* result_listener) const;\
2066 virtual void DescribeTo(::std::ostream* gmock_os) const {\
2067 *gmock_os << FormatDescription(false);\
2068 }\
2069 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
2070 *gmock_os << FormatDescription(true);\
2071 }\
2072 p0##_type const p0;\
2073 p1##_type const p1;\
2074 p2##_type const p2;\
2075 p3##_type const p3;\
2076 p4##_type const p4;\
2077 p5##_type const p5;\
2078 p6##_type const p6;\
2079 p7##_type const p7;\
2080 p8##_type const p8;\
2081 private:\
2082 ::std::string FormatDescription(bool negation) const {\
2083 ::std::string gmock_description = (description);\
2084 if (!gmock_description.empty())\
2085 return gmock_description;\
2086 return ::testing::internal::FormatMatcherDescription(\
2087 negation, #name, \
2088 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
2089 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
2090 p4##_type, p5##_type, p6##_type, p7##_type, \
2091 p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
2092 }\
2093 };\
2094 template <typename arg_type>\
2095 operator ::testing::Matcher<arg_type>() const {\
2096 return ::testing::Matcher<arg_type>(\
2097 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
2098 }\
2099 name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \
2100 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
2101 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
2102 p8##_type gmock_p8) : p0(::testing::internal::move(gmock_p0)), \
2103 p1(::testing::internal::move(gmock_p1)), \
2104 p2(::testing::internal::move(gmock_p2)), \
2105 p3(::testing::internal::move(gmock_p3)), \
2106 p4(::testing::internal::move(gmock_p4)), \
2107 p5(::testing::internal::move(gmock_p5)), \
2108 p6(::testing::internal::move(gmock_p6)), \
2109 p7(::testing::internal::move(gmock_p7)), \
2110 p8(::testing::internal::move(gmock_p8)) {\
2111 }\
2112 p0##_type const p0;\
2113 p1##_type const p1;\
2114 p2##_type const p2;\
2115 p3##_type const p3;\
2116 p4##_type const p4;\
2117 p5##_type const p5;\
2118 p6##_type const p6;\
2119 p7##_type const p7;\
2120 p8##_type const p8;\
2121 private:\
2122 };\
2123 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2124 typename p3##_type, typename p4##_type, typename p5##_type, \
2125 typename p6##_type, typename p7##_type, typename p8##_type>\
2126 inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
2127 p4##_type, p5##_type, p6##_type, p7##_type, \
2128 p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
2129 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
2130 p8##_type p8) {\
2131 return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
2132 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
2133 p3, p4, p5, p6, p7, p8);\
2134 }\
2135 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2136 typename p3##_type, typename p4##_type, typename p5##_type, \
2137 typename p6##_type, typename p7##_type, typename p8##_type>\
2138 template <typename arg_type>\
2139 bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
2140 p5##_type, p6##_type, p7##_type, \
2141 p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
2142 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
2143 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
2144 const
2145
2146 #define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
2147 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2148 typename p3##_type, typename p4##_type, typename p5##_type, \
2149 typename p6##_type, typename p7##_type, typename p8##_type, \
2150 typename p9##_type>\
2151 class name##MatcherP10 {\
2152 public:\
2153 template <typename arg_type>\
2154 class gmock_Impl : public ::testing::MatcherInterface<\
2155 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
2156 public:\
2157 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
2158 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
2159 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
2160 p9##_type gmock_p9)\
2161 : p0(::testing::internal::move(gmock_p0)), \
2162 p1(::testing::internal::move(gmock_p1)), \
2163 p2(::testing::internal::move(gmock_p2)), \
2164 p3(::testing::internal::move(gmock_p3)), \
2165 p4(::testing::internal::move(gmock_p4)), \
2166 p5(::testing::internal::move(gmock_p5)), \
2167 p6(::testing::internal::move(gmock_p6)), \
2168 p7(::testing::internal::move(gmock_p7)), \
2169 p8(::testing::internal::move(gmock_p8)), \
2170 p9(::testing::internal::move(gmock_p9)) {}\
2171 virtual bool MatchAndExplain(\
2172 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
2173 ::testing::MatchResultListener* result_listener) const;\
2174 virtual void DescribeTo(::std::ostream* gmock_os) const {\
2175 *gmock_os << FormatDescription(false);\
2176 }\
2177 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
2178 *gmock_os << FormatDescription(true);\
2179 }\
2180 p0##_type const p0;\
2181 p1##_type const p1;\
2182 p2##_type const p2;\
2183 p3##_type const p3;\
2184 p4##_type const p4;\
2185 p5##_type const p5;\
2186 p6##_type const p6;\
2187 p7##_type const p7;\
2188 p8##_type const p8;\
2189 p9##_type const p9;\
2190 private:\
2191 ::std::string FormatDescription(bool negation) const {\
2192 ::std::string gmock_description = (description);\
2193 if (!gmock_description.empty())\
2194 return gmock_description;\
2195 return ::testing::internal::FormatMatcherDescription(\
2196 negation, #name, \
2197 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
2198 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
2199 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2200 p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
2201 }\
2202 };\
2203 template <typename arg_type>\
2204 operator ::testing::Matcher<arg_type>() const {\
2205 return ::testing::Matcher<arg_type>(\
2206 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
2207 }\
2208 name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \
2209 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
2210 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
2211 p8##_type gmock_p8, \
2212 p9##_type gmock_p9) : p0(::testing::internal::move(gmock_p0)), \
2213 p1(::testing::internal::move(gmock_p1)), \
2214 p2(::testing::internal::move(gmock_p2)), \
2215 p3(::testing::internal::move(gmock_p3)), \
2216 p4(::testing::internal::move(gmock_p4)), \
2217 p5(::testing::internal::move(gmock_p5)), \
2218 p6(::testing::internal::move(gmock_p6)), \
2219 p7(::testing::internal::move(gmock_p7)), \
2220 p8(::testing::internal::move(gmock_p8)), \
2221 p9(::testing::internal::move(gmock_p9)) {\
2222 }\
2223 p0##_type const p0;\
2224 p1##_type const p1;\
2225 p2##_type const p2;\
2226 p3##_type const p3;\
2227 p4##_type const p4;\
2228 p5##_type const p5;\
2229 p6##_type const p6;\
2230 p7##_type const p7;\
2231 p8##_type const p8;\
2232 p9##_type const p9;\
2233 private:\
2234 };\
2235 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2236 typename p3##_type, typename p4##_type, typename p5##_type, \
2237 typename p6##_type, typename p7##_type, typename p8##_type, \
2238 typename p9##_type>\
2239 inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2240 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2241 p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
2242 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
2243 p9##_type p9) {\
2244 return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2245 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
2246 p1, p2, p3, p4, p5, p6, p7, p8, p9);\
2247 }\
2248 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2249 typename p3##_type, typename p4##_type, typename p5##_type, \
2250 typename p6##_type, typename p7##_type, typename p8##_type, \
2251 typename p9##_type>\
2252 template <typename arg_type>\
2253 bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2254 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2255 p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
2256 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
2257 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
2258 const
2259
2260 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
2261