gmock-generated-matchers.h.pump 23.9 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
// 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_

43
#include <iterator>
44
45
46
#include <sstream>
#include <string>
#include <vector>
47
#include "gmock/gmock-matchers.h"
48
49
50
51

namespace testing {
namespace internal {

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
93
$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;
94
  static type GetSelectedFields(const Tuple& $if i==0 [[/* t */]] $else [[t]]) {
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
    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
111
  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
112
113
114
115
116
117
118
  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
119
120
  virtual bool MatchAndExplain(ArgsTuple args,
                               MatchResultListener* listener) const {
121
122
123
124
125
126
127
128
129
130
131
132
    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;
133
134
135
  }

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

  virtual void DescribeNegationTo(::std::ostream* os) const {
142
    *os << "are a tuple ";
143
144
145
146
147
148
149
150
151
152
153
    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) {
154
    *os << "whose fields (";
155
156
157
158
159
160
161
162
163
164
165
166
167
168
    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_;
169
170

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

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_));
  }

184
 private:
185
  const InnerMatcher inner_matcher_;
186
187

  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
188
189
};

190
191
192
// Implements ElementsAre() of 1-$n arguments.  The use of DecayArray in
// the implementation allows ElementsAre() to accept string literals, whose
// inferred type is const char[N] while we want to treat them as const char*.
193
194
195
196
197
198
199
200
201
202
203
204
205


$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
206
    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
207
208
    typedef typename internal::StlContainerView<RawContainer>::type::value_type
        Element;
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_);
220
221
    return MakeMatcher(new ElementsAreMatcherImpl<Container>(&matcher,
                                                             &matcher + 1));
222
223
]] $else [[

224
225
226
227
228
229
230
231
    const Matcher<const Element&> matchers[] = {

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

]]
    };

232
233
    return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers,
                                                             matchers + $i));
234
235
]]

236
237
238
239
240
  }

 private:

$for j [[
241
    const typename DecayArray<T$j>::type e$j[[]]_;
242
243

]]
244
245

  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher$i);
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
305
306
307
308
309
// 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;
};

]]

310
311
}  // namespace internal

312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
// 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);
}


]]
327
328
329
330
331
332
333
334
335
336
337
338
339
340
// 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();
}

341
$range i 1..n
342
343
344
345
346
347
348
349
350
351
$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]]);
}

]]

352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
// ElementsAreArray(array)
// ElementsAreArray(pointer, count)
// ElementsAreArray(vector)
// ElementsAreArray(first, last)
//
// The ElementsAreArray() functions are like ElementsAre(...), except that
// they are given a sequence of matchers or values rather than taking each
// element as a function argument. The sequence can be specified as a
// C-style array, a pointer and count, a vector, or an STL iterator range.
//
// * The array form infers the size of 'array', which must be of a
//   statically-sized C-style array type.
//
// * The (pointer, count) form can take either a statically-sized C-style
//   array or a pointer to a dynamically created array. It does not take
//   ownership of the pointer.
//
// * The vector form can take a std::vector either of values or of matchers.
//
// * The (first, last) form can take any STL iterator range.
//
// All forms of ElementsAreArray() make a copy of the input sequence.
374
375
376
template <typename T>
inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
    const T* first, size_t count) {
377
  return internal::ElementsAreArrayMatcher<T>(first, first + count);
378
379
380
}

template <typename T, size_t N>
381
382
383
384
385
386
387
388
389
inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
    const T (&array)[N]) {
  return internal::ElementsAreArrayMatcher<T>(array, array + N);
}

template <typename T, typename A>
inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
    const std::vector<T, A>& vec) {
  return internal::ElementsAreArrayMatcher<T>(vec.begin(), vec.end());
390
391
}

392
393
394
395
396
397
398
399
400
template <typename Iter>
inline internal::ElementsAreArrayMatcher<
    typename std::iterator_traits<Iter>::value_type>
ElementsAreArray(Iter first, Iter last) {
  typedef typename std::iterator_traits<Iter>::value_type T;
  return internal::ElementsAreArrayMatcher<T>(first, last);
}


401
// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
402
// sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
403
404
405
406

$range i 2..n
$for i [[
$range j 1..i
407
408
409
410
411
412
413
414
415
416
$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]])]]);
417
418
419
420
421
}

]]

// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
422
// sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
423
424
425
426

$range i 2..n
$for i [[
$range j 1..i
427
428
429
430
431
432
433
434
435
436
$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]])]]);
437
438
439
440
}

]]

441
}  // namespace testing
442
443
444
$$ } // This Pump meta comment fixes auto-indentation in Emacs. It will not
$$   // show up in the generated code.

445

zhanyong.wan's avatar
zhanyong.wan committed
446
// The MATCHER* family of macros can be used in a namespace scope to
zhanyong.wan's avatar
zhanyong.wan committed
447
448
449
450
451
452
// define custom matchers easily.
//
// Basic Usage
// ===========
//
// The syntax
zhanyong.wan's avatar
zhanyong.wan committed
453
454
455
//
//   MATCHER(name, description_string) { statements; }
//
zhanyong.wan's avatar
zhanyong.wan committed
456
457
458
459
// 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'.
460
461
462
463
464
465
466
467
468
469
//
// 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
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
//
//   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
492
493
494
// Argument Type
// =============
//
zhanyong.wan's avatar
zhanyong.wan committed
495
496
497
498
499
500
501
502
503
504
// 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
505
506
507
// Parameterizing Matchers
// =======================
//
zhanyong.wan's avatar
zhanyong.wan committed
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
// 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
538
539
540
// Describing Parameterized Matchers
// =================================
//
541
542
543
544
545
546
547
548
549
550
551
552
// 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) + "]") {
553
554
555
556
//     return low <= arg && arg <= hi;
//   }
//   ...
//   EXPECT_THAT(3, InClosedRange(4, 6));
557
//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
558
//
559
// would generate two failures that contain the text:
560
561
//
//   Expected: is in range [4, 6]
562
563
//   ...
//   Expected: is not in range [2, 4]
564
565
566
567
568
569
570
571
//
// 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));
572
//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
573
//
574
// would generate two failures that contain the text:
575
576
//
//   Expected: in closed range (4, 6)
577
578
//   ...
//   Expected: not (in closed range (2, 4))
579
//
zhanyong.wan's avatar
zhanyong.wan committed
580
581
582
// Types of Matcher Parameters
// ===========================
//
zhanyong.wan's avatar
zhanyong.wan committed
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
// 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
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
// 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
632
633
634
635
636
// 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
637
638
// Caveats
// =======
zhanyong.wan's avatar
zhanyong.wan committed
639
//
zhanyong.wan's avatar
zhanyong.wan committed
640
641
642
643
644
645
646
647
// 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
648
649
650
651
652
653
654
//
// 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
655
656
// More Information
// ================
zhanyong.wan's avatar
zhanyong.wan committed
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
//
// 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]]]]
675
676
$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
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
$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:\
698
699
      [[$if i==1 [[explicit ]]]]gmock_Impl($impl_ctor_param_list)\
          $impl_inits {}\
zhanyong.wan's avatar
zhanyong.wan committed
700
701
      virtual bool MatchAndExplain(\
          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
702
      virtual void DescribeTo(::std::ostream* gmock_os) const {\
703
704
705
706
        *gmock_os << FormatDescription(false);\
      }\
      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
        *gmock_os << FormatDescription(true);\
zhanyong.wan's avatar
zhanyong.wan committed
707
      }\$param_field_decls
708
     private:\
709
710
711
712
713
      ::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(\
714
            negation, #name, \
715
716
717
            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
                ::std::tr1::tuple<$for j, [[p$j##_type]]>($for j, [[p$j]])));\
      }\
718
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
zhanyong.wan's avatar
zhanyong.wan committed
719
720
721
    };\
    template <typename arg_type>\
    operator ::testing::Matcher<arg_type>() const {\
722
      return ::testing::Matcher<arg_type>(\
723
          new gmock_Impl<arg_type>($params));\
zhanyong.wan's avatar
zhanyong.wan committed
724
725
726
    }\
    $class_name($ctor_param_list)$inits {\
    }\$param_field_decls2
727
728
   private:\
    GTEST_DISALLOW_ASSIGN_($class_name);\
zhanyong.wan's avatar
zhanyong.wan committed
729
730
731
732
733
  };\$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
734
  bool $class_name$param_types::gmock_Impl<arg_type>::MatchAndExplain(\
735
      arg_type arg, \
zhanyong.wan's avatar
zhanyong.wan committed
736
737
      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
          const
zhanyong.wan's avatar
zhanyong.wan committed
738
739
740
]]


741
#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_