gmock-generated-matchers.h.pump 22.4 KB
Newer Older
1
2
$$ -*- mode: c++; -*-
$$ This is a Pump source file.  Please use Pump to convert it to
3
$$ gmock-generated-actions.h.
4
5
$$
$var n = 10  $$ The maximum arity we support.
6
$$ }} This line fixes auto-indentation of the following code in Emacs.
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Google Mock - a framework for writing C++ mock classes.
//
// This file implements some commonly used variadic matchers.

#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_

#include <sstream>
#include <string>
#include <vector>
46
#include "gmock/gmock-matchers.h"
47
48
49
50

namespace testing {
namespace internal {

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
$range i 0..n-1

// The type of the i-th (0-based) field of Tuple.
#define GMOCK_FIELD_TYPE_(Tuple, i) \
    typename ::std::tr1::tuple_element<i, Tuple>::type

// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
// tuple of type Tuple.  It has two members:
//
//   type: a tuple type whose i-th field is the ki-th field of Tuple.
//   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
//
// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
//
//   type is tuple<int, bool>, and
//   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).

template <class Tuple$for i [[, int k$i = -1]]>
class TupleFields;

// This generic version is used when there are $n selectors.
template <class Tuple$for i [[, int k$i]]>
class TupleFields {
 public:
  typedef ::std::tr1::tuple<$for i, [[GMOCK_FIELD_TYPE_(Tuple, k$i)]]> type;
  static type GetSelectedFields(const Tuple& t) {
    using ::std::tr1::get;
    return type($for i, [[get<k$i>(t)]]);
  }
};

// The following specialization is used for 0 ~ $(n-1) selectors.

$for i [[
$$ }}}
$range j 0..i-1
$range k 0..n-1

template <class Tuple$for j [[, int k$j]]>
class TupleFields<Tuple, $for k, [[$if k < i [[k$k]] $else [[-1]]]]> {
 public:
  typedef ::std::tr1::tuple<$for j, [[GMOCK_FIELD_TYPE_(Tuple, k$j)]]> type;
93
  static type GetSelectedFields(const Tuple& $if i==0 [[/* t */]] $else [[t]]) {
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
    using ::std::tr1::get;
    return type($for j, [[get<k$j>(t)]]);
  }
};

]]

#undef GMOCK_FIELD_TYPE_

// Implements the Args() matcher.

$var ks = [[$for i, [[k$i]]]]
template <class ArgsTuple$for i [[, int k$i = -1]]>
class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
 public:
  // ArgsTuple may have top-level const or reference modifiers.
zhanyong.wan's avatar
zhanyong.wan committed
110
  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
111
112
113
114
115
116
117
  typedef typename internal::TupleFields<RawArgsTuple, $ks>::type SelectedArgs;
  typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;

  template <typename InnerMatcher>
  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}

zhanyong.wan's avatar
zhanyong.wan committed
118
119
  virtual bool MatchAndExplain(ArgsTuple args,
                               MatchResultListener* listener) const {
120
121
122
123
124
125
126
127
128
129
130
131
    const SelectedArgs& selected_args = GetSelectedArgs(args);
    if (!listener->IsInterested())
      return inner_matcher_.Matches(selected_args);

    PrintIndices(listener->stream());
    *listener << "are " << PrintToString(selected_args);

    StringMatchResultListener inner_listener;
    const bool match = inner_matcher_.MatchAndExplain(selected_args,
                                                      &inner_listener);
    PrintIfNotEmpty(inner_listener.str(), listener->stream());
    return match;
132
133
134
  }

  virtual void DescribeTo(::std::ostream* os) const {
135
    *os << "are a tuple ";
136
137
138
139
140
    PrintIndices(os);
    inner_matcher_.DescribeTo(os);
  }

  virtual void DescribeNegationTo(::std::ostream* os) const {
141
    *os << "are a tuple ";
142
143
144
145
146
147
148
149
150
151
152
    PrintIndices(os);
    inner_matcher_.DescribeNegationTo(os);
  }

 private:
  static SelectedArgs GetSelectedArgs(ArgsTuple args) {
    return TupleFields<RawArgsTuple, $ks>::GetSelectedFields(args);
  }

  // Prints the indices of the selected fields.
  static void PrintIndices(::std::ostream* os) {
153
    *os << "whose fields (";
154
155
156
157
158
159
160
161
162
163
164
165
166
167
    const int indices[$n] = { $ks };
    for (int i = 0; i < $n; i++) {
      if (indices[i] < 0)
        break;

      if (i >= 1)
        *os << ", ";

      *os << "#" << indices[i];
    }
    *os << ") ";
  }

  const MonomorphicInnerMatcher inner_matcher_;
168
169

  GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
170
171
172
173
174
175
176
177
178
179
180
181
182
};

template <class InnerMatcher$for i [[, int k$i = -1]]>
class ArgsMatcher {
 public:
  explicit ArgsMatcher(const InnerMatcher& inner_matcher)
      : inner_matcher_(inner_matcher) {}

  template <typename ArgsTuple>
  operator Matcher<ArgsTuple>() const {
    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, $ks>(inner_matcher_));
  }

183
 private:
184
  const InnerMatcher inner_matcher_;
185
186

  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
187
188
};

189
// Implements ElementsAre() of 1-$n arguments.
190
191
192
193
194
195
196
197
198
199
200
201
202


$range i 1..n
$for i [[
$range j 1..i
template <$for j, [[typename T$j]]>
class ElementsAreMatcher$i {
 public:
  $if i==1 [[explicit ]]ElementsAreMatcher$i($for j, [[const T$j& e$j]])$if i > 0 [[ : ]]
      $for j, [[e$j[[]]_(e$j)]] {}

  template <typename Container>
  operator Matcher<Container>() const {
zhanyong.wan's avatar
zhanyong.wan committed
203
    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
204
205
    typedef typename internal::StlContainerView<RawContainer>::type::value_type
        Element;
206

207
208
209
210
211
212
213
214
215
216
217
218
219
$if i==1 [[

    // Nokia's Symbian Compiler has a nasty bug where the object put
    // in a one-element local array is not destructed when the array
    // goes out of scope.  This leads to obvious badness as we've
    // added the linked_ptr in it to our other linked_ptrs list.
    // Hence we implement ElementsAreMatcher1 specially to avoid using
    // a local array.
    const Matcher<const Element&> matcher =
        MatcherCast<const Element&>(e1_);
    return MakeMatcher(new ElementsAreMatcherImpl<Container>(&matcher, 1));
]] $else [[

220
221
222
223
224
225
226
227
228
    const Matcher<const Element&> matchers[] = {

$for j [[
      MatcherCast<const Element&>(e$j[[]]_),

]]
    };

    return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers, $i));
229
230
]]

231
232
233
234
235
236
237
238
  }

 private:

$for j [[
  const T$j& e$j[[]]_;

]]
239
240

  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher$i);
241
242
243
244
};


]]
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
// A set of metafunctions for computing the result type of AllOf.
// AllOf(m1, ..., mN) returns
// AllOfResultN<decltype(m1), ..., decltype(mN)>::type.

// Although AllOf isn't defined for one argument, AllOfResult1 is defined
// to simplify the implementation.
template <typename M1>
struct AllOfResult1 {
  typedef M1 type;
};

$range i 1..n

$range i 2..n
$for i [[
$range j 2..i
$var m = i/2
$range k 1..m
$range t m+1..i

template <typename M1$for j [[, typename M$j]]>
struct AllOfResult$i {
  typedef BothOfMatcher<
      typename AllOfResult$m<$for k, [[M$k]]>::type,
      typename AllOfResult$(i-m)<$for t, [[M$t]]>::type
  > type;
};

]]

// A set of metafunctions for computing the result type of AnyOf.
// AnyOf(m1, ..., mN) returns
// AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.

// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
// to simplify the implementation.
template <typename M1>
struct AnyOfResult1 {
  typedef M1 type;
};

$range i 1..n

$range i 2..n
$for i [[
$range j 2..i
$var m = i/2
$range k 1..m
$range t m+1..i

template <typename M1$for j [[, typename M$j]]>
struct AnyOfResult$i {
  typedef EitherOfMatcher<
      typename AnyOfResult$m<$for k, [[M$k]]>::type,
      typename AnyOfResult$(i-m)<$for t, [[M$t]]>::type
  > type;
};

]]

305
306
}  // namespace internal

307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
// fields of it matches a_matcher.  C++ doesn't support default
// arguments for function templates, so we have to overload it.

$range i 0..n
$for i [[
$range j 1..i
template <$for j [[int k$j, ]]typename InnerMatcher>
inline internal::ArgsMatcher<InnerMatcher$for j [[, k$j]]>
Args(const InnerMatcher& matcher) {
  return internal::ArgsMatcher<InnerMatcher$for j [[, k$j]]>(matcher);
}


]]
322
323
324
325
326
327
328
329
330
331
332
333
334
335
// ElementsAre(e0, e1, ..., e_n) matches an STL-style container with
// (n + 1) elements, where the i-th element in the container must
// match the i-th argument in the list.  Each argument of
// ElementsAre() can be either a value or a matcher.  We support up to
// $n arguments.
//
// NOTE: Since ElementsAre() cares about the order of the elements, it
// must not be used with containers whose elements's order is
// undefined (e.g. hash_map).

inline internal::ElementsAreMatcher0 ElementsAre() {
  return internal::ElementsAreMatcher0();
}

336
$range i 1..n
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
$for i [[
$range j 1..i

template <$for j, [[typename T$j]]>
inline internal::ElementsAreMatcher$i<$for j, [[T$j]]> ElementsAre($for j, [[const T$j& e$j]]) {
  return internal::ElementsAreMatcher$i<$for j, [[T$j]]>($for j, [[e$j]]);
}

]]

// ElementsAreArray(array) and ElementAreArray(array, count) are like
// ElementsAre(), except that they take an array of values or
// matchers.  The former form infers the size of 'array', which must
// be a static C-style array.  In the latter form, 'array' can either
// be a static array or a pointer to a dynamically created array.

template <typename T>
inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
    const T* first, size_t count) {
  return internal::ElementsAreArrayMatcher<T>(first, count);
}

template <typename T, size_t N>
inline internal::ElementsAreArrayMatcher<T>
ElementsAreArray(const T (&array)[N]) {
  return internal::ElementsAreArrayMatcher<T>(array, N);
}

365
// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
366
// sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
367
368
369
370

$range i 2..n
$for i [[
$range j 1..i
371
372
373
374
375
376
377
378
379
380
$var m = i/2
$range k 1..m
$range t m+1..i

template <$for j, [[typename M$j]]>
inline typename internal::AllOfResult$i<$for j, [[M$j]]>::type
AllOf($for j, [[M$j m$j]]) {
  return typename internal::AllOfResult$i<$for j, [[M$j]]>::type(
      $if m == 1 [[m1]] $else [[::testing::AllOf($for k, [[m$k]])]],
      $if m+1 == i [[m$i]] $else [[::testing::AllOf($for t, [[m$t]])]]);
381
382
383
384
385
}

]]

// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
386
// sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
387
388
389
390

$range i 2..n
$for i [[
$range j 1..i
391
392
393
394
395
396
397
398
399
400
$var m = i/2
$range k 1..m
$range t m+1..i

template <$for j, [[typename M$j]]>
inline typename internal::AnyOfResult$i<$for j, [[M$j]]>::type
AnyOf($for j, [[M$j m$j]]) {
  return typename internal::AnyOfResult$i<$for j, [[M$j]]>::type(
      $if m == 1 [[m1]] $else [[::testing::AnyOf($for k, [[m$k]])]],
      $if m+1 == i [[m$i]] $else [[::testing::AnyOf($for t, [[m$t]])]]);
401
402
403
404
}

]]

405
}  // namespace testing
406
407
408
$$ } // This Pump meta comment fixes auto-indentation in Emacs. It will not
$$   // show up in the generated code.

409

zhanyong.wan's avatar
zhanyong.wan committed
410
// The MATCHER* family of macros can be used in a namespace scope to
zhanyong.wan's avatar
zhanyong.wan committed
411
412
413
414
415
416
// define custom matchers easily.
//
// Basic Usage
// ===========
//
// The syntax
zhanyong.wan's avatar
zhanyong.wan committed
417
418
419
//
//   MATCHER(name, description_string) { statements; }
//
zhanyong.wan's avatar
zhanyong.wan committed
420
421
422
423
// defines a matcher with the given name that executes the statements,
// which must return a bool to indicate if the match succeeds.  Inside
// the statements, you can refer to the value being matched by 'arg',
// and refer to its type by 'arg_type'.
424
425
426
427
428
429
430
431
432
433
//
// The description string documents what the matcher does, and is used
// to generate the failure message when the match fails.  Since a
// MATCHER() is usually defined in a header file shared by multiple
// C++ source files, we require the description to be a C-string
// literal to avoid possible side effects.  It can be empty, in which
// case we'll use the sequence of words in the matcher name as the
// description.
//
// For example:
zhanyong.wan's avatar
zhanyong.wan committed
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
//
//   MATCHER(IsEven, "") { return (arg % 2) == 0; }
//
// allows you to write
//
//   // Expects mock_foo.Bar(n) to be called where n is even.
//   EXPECT_CALL(mock_foo, Bar(IsEven()));
//
// or,
//
//   // Verifies that the value of some_expression is even.
//   EXPECT_THAT(some_expression, IsEven());
//
// If the above assertion fails, it will print something like:
//
//   Value of: some_expression
//   Expected: is even
//     Actual: 7
//
// where the description "is even" is automatically calculated from the
// matcher name IsEven.
//
zhanyong.wan's avatar
zhanyong.wan committed
456
457
458
// Argument Type
// =============
//
zhanyong.wan's avatar
zhanyong.wan committed
459
460
461
462
463
464
465
466
467
468
// Note that the type of the value being matched (arg_type) is
// determined by the context in which you use the matcher and is
// supplied to you by the compiler, so you don't need to worry about
// declaring it (nor can you).  This allows the matcher to be
// polymorphic.  For example, IsEven() can be used to match any type
// where the value of "(arg % 2) == 0" can be implicitly converted to
// a bool.  In the "Bar(IsEven())" example above, if method Bar()
// takes an int, 'arg_type' will be int; if it takes an unsigned long,
// 'arg_type' will be unsigned long; and so on.
//
zhanyong.wan's avatar
zhanyong.wan committed
469
470
471
// Parameterizing Matchers
// =======================
//
zhanyong.wan's avatar
zhanyong.wan committed
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
// Sometimes you'll want to parameterize the matcher.  For that you
// can use another macro:
//
//   MATCHER_P(name, param_name, description_string) { statements; }
//
// For example:
//
//   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
//
// will allow you to write:
//
//   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
//
// which may lead to this message (assuming n is 10):
//
//   Value of: Blah("a")
//   Expected: has absolute value 10
//     Actual: -9
//
// Note that both the matcher description and its parameter are
// printed, making the message human-friendly.
//
// In the matcher definition body, you can write 'foo_type' to
// reference the type of a parameter named 'foo'.  For example, in the
// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
// 'value_type' to refer to the type of 'value'.
//
// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to
// support multi-parameter matchers.
//
zhanyong.wan's avatar
zhanyong.wan committed
502
503
504
// Describing Parameterized Matchers
// =================================
//
505
506
507
508
509
510
511
512
513
514
515
516
// The last argument to MATCHER*() is a string-typed expression.  The
// expression can reference all of the matcher's parameters and a
// special bool-typed variable named 'negation'.  When 'negation' is
// false, the expression should evaluate to the matcher's description;
// otherwise it should evaluate to the description of the negation of
// the matcher.  For example,
//
//   using testing::PrintToString;
//
//   MATCHER_P2(InClosedRange, low, hi,
//       string(negation ? "is not" : "is") + " in range [" +
//       PrintToString(low) + ", " + PrintToString(hi) + "]") {
517
518
519
520
//     return low <= arg && arg <= hi;
//   }
//   ...
//   EXPECT_THAT(3, InClosedRange(4, 6));
521
//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
522
//
523
// would generate two failures that contain the text:
524
525
//
//   Expected: is in range [4, 6]
526
527
//   ...
//   Expected: is not in range [2, 4]
528
529
530
531
532
533
534
535
//
// If you specify "" as the description, the failure message will
// contain the sequence of words in the matcher name followed by the
// parameter values printed as a tuple.  For example,
//
//   MATCHER_P2(InClosedRange, low, hi, "") { ... }
//   ...
//   EXPECT_THAT(3, InClosedRange(4, 6));
536
//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
537
//
538
// would generate two failures that contain the text:
539
540
//
//   Expected: in closed range (4, 6)
541
542
//   ...
//   Expected: not (in closed range (2, 4))
543
//
zhanyong.wan's avatar
zhanyong.wan committed
544
545
546
// Types of Matcher Parameters
// ===========================
//
zhanyong.wan's avatar
zhanyong.wan committed
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
// For the purpose of typing, you can view
//
//   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
//
// as shorthand for
//
//   template <typename p1_type, ..., typename pk_type>
//   FooMatcherPk<p1_type, ..., pk_type>
//   Foo(p1_type p1, ..., pk_type pk) { ... }
//
// When you write Foo(v1, ..., vk), the compiler infers the types of
// the parameters v1, ..., and vk for you.  If you are not happy with
// the result of the type inference, you can specify the types by
// explicitly instantiating the template, as in Foo<long, bool>(5,
// false).  As said earlier, you don't get to (or need to) specify
// 'arg_type' as that's determined by the context in which the matcher
// is used.  You can assign the result of expression Foo(p1, ..., pk)
// to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This
// can be useful when composing matchers.
//
// While you can instantiate a matcher template with reference types,
// passing the parameters by pointer usually makes your code more
// readable.  If, however, you still want to pass a parameter by
// reference, be aware that in the failure message generated by the
// matcher you will see the value of the referenced object but not its
// address.
//
zhanyong.wan's avatar
zhanyong.wan committed
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
// Explaining Match Results
// ========================
//
// Sometimes the matcher description alone isn't enough to explain why
// the match has failed or succeeded.  For example, when expecting a
// long string, it can be very helpful to also print the diff between
// the expected string and the actual one.  To achieve that, you can
// optionally stream additional information to a special variable
// named result_listener, whose type is a pointer to class
// MatchResultListener:
//
//   MATCHER_P(EqualsLongString, str, "") {
//     if (arg == str) return true;
//
//     *result_listener << "the difference: "
///                     << DiffStrings(str, arg);
//     return false;
//   }
//
// Overloading Matchers
// ====================
//
zhanyong.wan's avatar
zhanyong.wan committed
596
597
598
599
600
// You can overload matchers with different numbers of parameters:
//
//   MATCHER_P(Blah, a, description_string1) { ... }
//   MATCHER_P2(Blah, a, b, description_string2) { ... }
//
zhanyong.wan's avatar
zhanyong.wan committed
601
602
// Caveats
// =======
zhanyong.wan's avatar
zhanyong.wan committed
603
//
zhanyong.wan's avatar
zhanyong.wan committed
604
605
606
607
608
609
610
611
// When defining a new matcher, you should also consider implementing
// MatcherInterface or using MakePolymorphicMatcher().  These
// approaches require more work than the MATCHER* macros, but also
// give you more control on the types of the value being matched and
// the matcher parameters, which may leads to better compiler error
// messages when the matcher is used wrong.  They also allow
// overloading matchers based on parameter types (as opposed to just
// based on the number of parameters).
zhanyong.wan's avatar
zhanyong.wan committed
612
613
614
615
616
617
618
//
// MATCHER*() can only be used in a namespace scope.  The reason is
// that C++ doesn't yet allow function-local types to be used to
// instantiate templates.  The up-coming C++0x standard will fix this.
// Once that's done, we'll consider supporting using MATCHER*() inside
// a function.
//
zhanyong.wan's avatar
zhanyong.wan committed
619
620
// More Information
// ================
zhanyong.wan's avatar
zhanyong.wan committed
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
//
// To learn more about using these macros, please search for 'MATCHER'
// on http://code.google.com/p/googlemock/wiki/CookBook.

$range i 0..n
$for i

[[
$var macro_name = [[$if i==0 [[MATCHER]] $elif i==1 [[MATCHER_P]]
                                         $else [[MATCHER_P$i]]]]
$var class_name = [[name##Matcher[[$if i==0 [[]] $elif i==1 [[P]]
                                                 $else [[P$i]]]]]]
$range j 0..i-1
$var template = [[$if i==0 [[]] $else [[

  template <$for j, [[typename p$j##_type]]>\
]]]]
$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
639
640
$var impl_ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
$var impl_inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]
zhanyong.wan's avatar
zhanyong.wan committed
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]
$var params = [[$for j, [[p$j]]]]
$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]]
$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]]
$var param_field_decls = [[$for j
[[

      p$j##_type p$j;\
]]]]
$var param_field_decls2 = [[$for j
[[

    p$j##_type p$j;\
]]]]

#define $macro_name(name$for j [[, p$j]], description)\$template
  class $class_name {\
   public:\
    template <typename arg_type>\
    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
     public:\
662
663
      [[$if i==1 [[explicit ]]]]gmock_Impl($impl_ctor_param_list)\
          $impl_inits {}\
zhanyong.wan's avatar
zhanyong.wan committed
664
665
      virtual bool MatchAndExplain(\
          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
666
      virtual void DescribeTo(::std::ostream* gmock_os) const {\
667
668
669
670
        *gmock_os << FormatDescription(false);\
      }\
      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
        *gmock_os << FormatDescription(true);\
zhanyong.wan's avatar
zhanyong.wan committed
671
      }\$param_field_decls
672
     private:\
673
674
675
676
677
      ::testing::internal::string FormatDescription(bool negation) const {\
        const ::testing::internal::string gmock_description = (description);\
        if (!gmock_description.empty())\
          return gmock_description;\
        return ::testing::internal::FormatMatcherDescription(\
678
            negation, #name, \
679
680
681
            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
                ::std::tr1::tuple<$for j, [[p$j##_type]]>($for j, [[p$j]])));\
      }\
682
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
zhanyong.wan's avatar
zhanyong.wan committed
683
684
685
    };\
    template <typename arg_type>\
    operator ::testing::Matcher<arg_type>() const {\
686
      return ::testing::Matcher<arg_type>(\
687
          new gmock_Impl<arg_type>($params));\
zhanyong.wan's avatar
zhanyong.wan committed
688
689
690
    }\
    $class_name($ctor_param_list)$inits {\
    }\$param_field_decls2
691
692
   private:\
    GTEST_DISALLOW_ASSIGN_($class_name);\
zhanyong.wan's avatar
zhanyong.wan committed
693
694
695
696
697
  };\$template
  inline $class_name$param_types name($param_types_and_names) {\
    return $class_name$param_types($params);\
  }\$template
  template <typename arg_type>\
zhanyong.wan's avatar
zhanyong.wan committed
698
  bool $class_name$param_types::gmock_Impl<arg_type>::MatchAndExplain(\
699
      arg_type arg, \
zhanyong.wan's avatar
zhanyong.wan committed
700
701
      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
          const
zhanyong.wan's avatar
zhanyong.wan committed
702
703
704
]]


705
#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_