gmock-generated-matchers.h.pump 18.5 KB
Newer Older
1
$$ -*- mode: c++; -*-
Gennadiy Civil's avatar
 
Gennadiy Civil committed
2
3
$$ This is a Pump source file. Please use Pump to convert
$$ it to gmock-generated-matchers.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
// 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.

Gennadiy Civil's avatar
 
Gennadiy Civil committed
40
41
// GOOGLETEST_CM0002 DO NOT DELETE

42
43
44
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_

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

namespace testing {
namespace internal {

54
55
56
57
$range i 0..n-1

// The type of the i-th (0-based) field of Tuple.
#define GMOCK_FIELD_TYPE_(Tuple, i) \
Abseil Team's avatar
Abseil Team committed
58
    typename ::std::tuple_element<i, Tuple>::type
59
60
61
62
63
64
65

// 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.
//
Abseil Team's avatar
Abseil Team committed
66
67
// For example, in class TupleFields<std::tuple<bool, char, int>, 2, 0>,
// we have:
68
//
Abseil Team's avatar
Abseil Team committed
69
70
//   type is std::tuple<int, bool>, and
//   GetSelectedFields(std::make_tuple(true, 'a', 42)) is (42, true).
71
72
73
74
75
76
77
78

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:
Abseil Team's avatar
Abseil Team committed
79
  typedef ::std::tuple<$for i, [[GMOCK_FIELD_TYPE_(Tuple, k$i)]]> type;
80
  static type GetSelectedFields(const Tuple& t) {
Abseil Team's avatar
Abseil Team committed
81
    return type($for i, [[std::get<k$i>(t)]]);
82
83
84
85
86
87
88
89
90
91
92
93
94
  }
};

// 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:
Abseil Team's avatar
Abseil Team committed
95
  typedef ::std::tuple<$for j, [[GMOCK_FIELD_TYPE_(Tuple, k$j)]]> type;
96
  static type GetSelectedFields(const Tuple& $if i==0 [[/* t */]] $else [[t]]) {
Abseil Team's avatar
Abseil Team committed
97
    return type($for j, [[std::get<k$j>(t)]]);
98
99
100
101
102
103
104
105
106
107
108
109
110
111
  }
};

]]

#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
112
  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
113
114
115
116
117
118
119
  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
120
121
  virtual bool MatchAndExplain(ArgsTuple args,
                               MatchResultListener* listener) const {
122
123
124
125
126
127
128
129
130
131
132
133
    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;
134
135
136
  }

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

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

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

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

185
 private:
186
  const InnerMatcher inner_matcher_;
187
188

  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
189
190
};

191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
// 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;
};

]]

221
222
}  // namespace internal

223
224
225
226
227
228
229
230
231
232
233
234
235
236
// 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);
}


237
238
239
]]

// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
240
// sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
241
242
243
244

$range i 2..n
$for i [[
$range j 1..i
245
246
247
248
249
250
251
252
253
254
$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]])]]);
255
256
257
258
}

]]

259
}  // namespace testing
260
261
262
$$ } // This Pump meta comment fixes auto-indentation in Emacs. It will not
$$   // show up in the generated code.

263

zhanyong.wan's avatar
zhanyong.wan committed
264
// The MATCHER* family of macros can be used in a namespace scope to
zhanyong.wan's avatar
zhanyong.wan committed
265
266
267
268
269
270
// define custom matchers easily.
//
// Basic Usage
// ===========
//
// The syntax
zhanyong.wan's avatar
zhanyong.wan committed
271
272
273
//
//   MATCHER(name, description_string) { statements; }
//
zhanyong.wan's avatar
zhanyong.wan committed
274
275
276
277
// 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'.
278
279
280
281
282
283
284
285
286
287
//
// 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
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
//
//   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
310
311
312
// Argument Type
// =============
//
zhanyong.wan's avatar
zhanyong.wan committed
313
314
315
316
317
318
319
320
321
322
// 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
323
324
325
// Parameterizing Matchers
// =======================
//
zhanyong.wan's avatar
zhanyong.wan committed
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
// 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
356
357
358
// Describing Parameterized Matchers
// =================================
//
359
360
361
362
363
364
365
366
367
368
// 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,
369
//       std::string(negation ? "is not" : "is") + " in range [" +
370
//       PrintToString(low) + ", " + PrintToString(hi) + "]") {
371
372
373
374
//     return low <= arg && arg <= hi;
//   }
//   ...
//   EXPECT_THAT(3, InClosedRange(4, 6));
375
//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
376
//
377
// would generate two failures that contain the text:
378
379
//
//   Expected: is in range [4, 6]
380
381
//   ...
//   Expected: is not in range [2, 4]
382
383
384
385
386
387
388
389
//
// 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));
390
//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
391
//
392
// would generate two failures that contain the text:
393
394
//
//   Expected: in closed range (4, 6)
395
396
//   ...
//   Expected: not (in closed range (2, 4))
397
//
zhanyong.wan's avatar
zhanyong.wan committed
398
399
400
// Types of Matcher Parameters
// ===========================
//
zhanyong.wan's avatar
zhanyong.wan committed
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
// 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
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
// 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
450
451
452
453
454
// 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
455
456
// Caveats
// =======
zhanyong.wan's avatar
zhanyong.wan committed
457
//
zhanyong.wan's avatar
zhanyong.wan committed
458
459
460
461
462
463
464
465
// 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
466
467
468
469
470
471
472
//
// 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
473
474
// More Information
// ================
zhanyong.wan's avatar
zhanyong.wan committed
475
476
//
// To learn more about using these macros, please search for 'MATCHER'
Abseil Team's avatar
Abseil Team committed
477
478
// on
// https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md
zhanyong.wan's avatar
zhanyong.wan committed
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493

$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]]]]
494
$var impl_ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
495
496
$var impl_inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::testing::internal::move(gmock_p$j))]]]]]]
$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::testing::internal::move(gmock_p$j))]]]]]]
zhanyong.wan's avatar
zhanyong.wan committed
497
498
499
500
501
502
$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
[[

503
      p$j##_type const p$j;\
zhanyong.wan's avatar
zhanyong.wan committed
504
505
506
507
]]]]
$var param_field_decls2 = [[$for j
[[

508
    p$j##_type const p$j;\
zhanyong.wan's avatar
zhanyong.wan committed
509
510
511
512
513
514
]]]]

#define $macro_name(name$for j [[, p$j]], description)\$template
  class $class_name {\
   public:\
    template <typename arg_type>\
515
516
    class gmock_Impl : public ::testing::MatcherInterface<\
        GTEST_REFERENCE_TO_CONST_(arg_type)> {\
zhanyong.wan's avatar
zhanyong.wan committed
517
     public:\
518
519
      [[$if i==1 [[explicit ]]]]gmock_Impl($impl_ctor_param_list)\
          $impl_inits {}\
zhanyong.wan's avatar
zhanyong.wan committed
520
      virtual bool MatchAndExplain(\
521
522
          GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
          ::testing::MatchResultListener* result_listener) const;\
523
      virtual void DescribeTo(::std::ostream* gmock_os) const {\
524
525
526
527
        *gmock_os << FormatDescription(false);\
      }\
      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
        *gmock_os << FormatDescription(true);\
zhanyong.wan's avatar
zhanyong.wan committed
528
      }\$param_field_decls
529
     private:\
530
531
      ::std::string FormatDescription(bool negation) const {\
        ::std::string gmock_description = (description);\
532
        if (!gmock_description.empty()) {\
533
          return gmock_description;\
534
        }\
535
        return ::testing::internal::FormatMatcherDescription(\
536
            negation, #name, \
537
            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
Abseil Team's avatar
Abseil Team committed
538
                ::std::tuple<$for j, [[p$j##_type]]>($for j, [[p$j]])));\
539
      }\
zhanyong.wan's avatar
zhanyong.wan committed
540
541
542
    };\
    template <typename arg_type>\
    operator ::testing::Matcher<arg_type>() const {\
543
      return ::testing::Matcher<arg_type>(\
544
          new gmock_Impl<arg_type>($params));\
zhanyong.wan's avatar
zhanyong.wan committed
545
    }\
billydonahue's avatar
billydonahue committed
546
    [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {\
zhanyong.wan's avatar
zhanyong.wan committed
547
    }\$param_field_decls2
548
   private:\
zhanyong.wan's avatar
zhanyong.wan committed
549
550
551
552
553
  };\$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
554
  bool $class_name$param_types::gmock_Impl<arg_type>::MatchAndExplain(\
555
      GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
zhanyong.wan's avatar
zhanyong.wan committed
556
557
      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
          const
zhanyong.wan's avatar
zhanyong.wan committed
558
559
560
]]


561
#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_