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