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