gmock-generated-matchers.h.pump 17.3 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
#include <sstream>
#include <string>
Abseil Team's avatar
Abseil Team committed
48
#include <utility>
49
#include <vector>
50
#include "gmock/gmock-matchers.h"
51
52
53
54

namespace testing {
namespace internal {

55
56
57
58
$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
59
    typename ::std::tuple_element<i, Tuple>::type
60
61
62
63
64
65
66

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

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

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

]]

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

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

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

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

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

186
 private:
187
  const InnerMatcher inner_matcher_;
188
189

  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
190
191
};

192
193
}  // namespace internal

194
195
196
197
198
199
200
201
202
203
204
205
206
207
// 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);
}


208
209
]]

210
}  // namespace testing
211
212
213
$$ } // This Pump meta comment fixes auto-indentation in Emacs. It will not
$$   // show up in the generated code.

214

zhanyong.wan's avatar
zhanyong.wan committed
215
// The MATCHER* family of macros can be used in a namespace scope to
zhanyong.wan's avatar
zhanyong.wan committed
216
217
218
219
220
221
// define custom matchers easily.
//
// Basic Usage
// ===========
//
// The syntax
zhanyong.wan's avatar
zhanyong.wan committed
222
223
224
//
//   MATCHER(name, description_string) { statements; }
//
zhanyong.wan's avatar
zhanyong.wan committed
225
226
227
228
// 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'.
229
230
231
232
233
234
235
236
237
238
//
// 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
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
//
//   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
261
262
263
// Argument Type
// =============
//
zhanyong.wan's avatar
zhanyong.wan committed
264
265
266
267
268
269
270
271
272
273
// 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
274
275
276
// Parameterizing Matchers
// =======================
//
zhanyong.wan's avatar
zhanyong.wan committed
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
// 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
307
308
309
// Describing Parameterized Matchers
// =================================
//
310
311
312
313
314
315
316
317
318
319
// 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,
320
//       std::string(negation ? "is not" : "is") + " in range [" +
321
//       PrintToString(low) + ", " + PrintToString(hi) + "]") {
322
323
324
325
//     return low <= arg && arg <= hi;
//   }
//   ...
//   EXPECT_THAT(3, InClosedRange(4, 6));
326
//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
327
//
328
// would generate two failures that contain the text:
329
330
//
//   Expected: is in range [4, 6]
331
332
//   ...
//   Expected: is not in range [2, 4]
333
334
335
336
337
338
339
340
//
// 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));
341
//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
342
//
343
// would generate two failures that contain the text:
344
345
//
//   Expected: in closed range (4, 6)
346
347
//   ...
//   Expected: not (in closed range (2, 4))
348
//
zhanyong.wan's avatar
zhanyong.wan committed
349
350
351
// Types of Matcher Parameters
// ===========================
//
zhanyong.wan's avatar
zhanyong.wan committed
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
// 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
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
// 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
401
402
403
404
405
// 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
406
407
// Caveats
// =======
zhanyong.wan's avatar
zhanyong.wan committed
408
//
zhanyong.wan's avatar
zhanyong.wan committed
409
410
411
412
413
414
415
416
// 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
417
418
419
420
421
422
423
//
// 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
424
425
// More Information
// ================
zhanyong.wan's avatar
zhanyong.wan committed
426
427
//
// To learn more about using these macros, please search for 'MATCHER'
Abseil Team's avatar
Abseil Team committed
428
429
// on
// https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md
zhanyong.wan's avatar
zhanyong.wan committed
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444

$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]]]]
445
$var impl_ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
Abseil Team's avatar
Abseil Team committed
446
447
$var impl_inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::std::move(gmock_p$j))]]]]]]
$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::std::move(gmock_p$j))]]]]]]
zhanyong.wan's avatar
zhanyong.wan committed
448
449
450
451
452
453
$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
[[

454
      p$j##_type const p$j;\
zhanyong.wan's avatar
zhanyong.wan committed
455
456
457
458
]]]]
$var param_field_decls2 = [[$for j
[[

459
    p$j##_type const p$j;\
zhanyong.wan's avatar
zhanyong.wan committed
460
461
462
463
464
465
]]]]

#define $macro_name(name$for j [[, p$j]], description)\$template
  class $class_name {\
   public:\
    template <typename arg_type>\
466
467
    class gmock_Impl : public ::testing::MatcherInterface<\
        GTEST_REFERENCE_TO_CONST_(arg_type)> {\
zhanyong.wan's avatar
zhanyong.wan committed
468
     public:\
469
470
      [[$if i==1 [[explicit ]]]]gmock_Impl($impl_ctor_param_list)\
          $impl_inits {}\
zhanyong.wan's avatar
zhanyong.wan committed
471
      virtual bool MatchAndExplain(\
472
473
          GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
          ::testing::MatchResultListener* result_listener) const;\
474
      virtual void DescribeTo(::std::ostream* gmock_os) const {\
475
476
477
478
        *gmock_os << FormatDescription(false);\
      }\
      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
        *gmock_os << FormatDescription(true);\
zhanyong.wan's avatar
zhanyong.wan committed
479
      }\$param_field_decls
480
     private:\
481
482
      ::std::string FormatDescription(bool negation) const {\
        ::std::string gmock_description = (description);\
483
        if (!gmock_description.empty()) {\
484
          return gmock_description;\
485
        }\
486
        return ::testing::internal::FormatMatcherDescription(\
487
            negation, #name, \
488
            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
Abseil Team's avatar
Abseil Team committed
489
                ::std::tuple<$for j, [[p$j##_type]]>($for j, [[p$j]])));\
490
      }\
zhanyong.wan's avatar
zhanyong.wan committed
491
492
493
    };\
    template <typename arg_type>\
    operator ::testing::Matcher<arg_type>() const {\
494
      return ::testing::Matcher<arg_type>(\
495
          new gmock_Impl<arg_type>($params));\
zhanyong.wan's avatar
zhanyong.wan committed
496
    }\
billydonahue's avatar
billydonahue committed
497
    [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {\
zhanyong.wan's avatar
zhanyong.wan committed
498
    }\$param_field_decls2
499
   private:\
zhanyong.wan's avatar
zhanyong.wan committed
500
501
502
503
504
  };\$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
505
  bool $class_name$param_types::gmock_Impl<arg_type>::MatchAndExplain(\
506
      GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
zhanyong.wan's avatar
zhanyong.wan committed
507
508
      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
          const
zhanyong.wan's avatar
zhanyong.wan committed
509
510
511
]]


512
#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_