gmock-generated-function-mockers.h.pump 9.21 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-function-mockers.h.
4
5
6
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
$$
$var n = 10  $$ The maximum arity we support.
// Copyright 2007, 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.
//
// Author: wan@google.com (Zhanyong Wan)

// Google Mock - a framework for writing C++ mock classes.
//
// This file implements function mockers of various arities.

#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_

44
45
#include "gmock/gmock-spec-builders.h"
#include "gmock/internal/gmock-internal-utils.h"
46

47
48
49
50
#if GTEST_HAS_STD_FUNCTION_
# include <functional>
#endif

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
namespace testing {
namespace internal {

template <typename F>
class FunctionMockerBase;

// Note: class FunctionMocker really belongs to the ::testing
// namespace.  However if we define it in ::testing, MSVC will
// complain when classes in ::testing::internal declare it as a
// friend class template.  To workaround this compiler bug, we define
// FunctionMocker in ::testing::internal and import it into ::testing.
template <typename F>
class FunctionMocker;


$range i 0..n
$for i [[
$range j 1..i
$var typename_As = [[$for j [[, typename A$j]]]]
$var As = [[$for j, [[A$j]]]]
Gennadiy Civil's avatar
 
Gennadiy Civil committed
71
$var as = [[$for j, [[internal::forward<A$j>(a$j)]]]]
72
73
74
75
76
77
78
79
80
81
$var Aas = [[$for j, [[A$j a$j]]]]
$var ms = [[$for j, [[m$j]]]]
$var matchers = [[$for j, [[const Matcher<A$j>& m$j]]]]
template <typename R$typename_As>
class FunctionMocker<R($As)> : public
    internal::FunctionMockerBase<R($As)> {
 public:
  typedef R F($As);
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

Gennadiy Civil's avatar
 
Gennadiy Civil committed
82
83
  MockSpec<F> With($matchers) {
    return MockSpec<F>(this, ::testing::make_tuple($ms));
84
85
86
  }

  R Invoke($Aas) {
87
88
89
90
91
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple($as));
92
93
94
95
96
97
98
99
100
101
102
103
104
105
  }
};


]]
}  // namespace internal

// The style guide prohibits "using" statements in a namespace scope
// inside a header file.  However, the FunctionMocker class template
// is meant to be defined in the ::testing namespace.  The following
// line is just a trick for working around a bug in MSVC 8.0, which
// cannot handle it if we define FunctionMocker in ::testing.
using internal::FunctionMocker;

106
107
108
109
// GMOCK_RESULT_(tn, F) expands to the result type of function type F.
// We define this as a variadic macro in case F contains unprotected
// commas (the same reason that we use variadic macros in other places
// in this file).
110
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
111
112
#define GMOCK_RESULT_(tn, ...) \
    tn ::testing::internal::Function<__VA_ARGS__>::Result
113

114
// The type of argument N of the given function type.
115
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
116
117
#define GMOCK_ARG_(tn, N, ...) \
    tn ::testing::internal::Function<__VA_ARGS__>::Argument##N
118

119
// The matcher type for argument N of the given function type.
120
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
121
122
#define GMOCK_MATCHER_(tn, N, ...) \
    const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>&
123
124
125

// The variable for mocking the given method.
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
126
#define GMOCK_MOCKER_(arity, constness, Method) \
127
    GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
128
129
130
131


$for i [[
$range j 1..i
Gennadiy Civil's avatar
 
Gennadiy Civil committed
132
133
134
135
$var arg_as = [[$for j, [[GMOCK_ARG_(tn, $j, __VA_ARGS__) gmock_a$j]]]]
$var as = [[$for j, \
  [[::testing::internal::forward<GMOCK_ARG_(tn, $j, __VA_ARGS__)>(gmock_a$j)]]]]
$var matcher_arg_as = [[$for j, \
136
                     [[GMOCK_MATCHER_(tn, $j, __VA_ARGS__) gmock_a$j]]]]
Gennadiy Civil's avatar
 
Gennadiy Civil committed
137
$var matcher_as = [[$for j, [[gmock_a$j]]]]
138
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
139
140
141
#define GMOCK_METHOD$i[[]]_(tn, constness, ct, Method, ...) \
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
      $arg_as) constness { \
142
    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
143
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value == $i), \
144
        this_method_does_not_take_$i[[]]_argument[[$if i != 1 [[s]]]]); \
145
146
    GMOCK_MOCKER_($i, constness, Method).SetOwnerAndName(this, #Method); \
    return GMOCK_MOCKER_($i, constness, Method).Invoke($as); \
147
  } \
Gennadiy Civil's avatar
 
Gennadiy Civil committed
148
149
  ::testing::MockSpec<__VA_ARGS__> \
      gmock_##Method($matcher_arg_as) constness { \
150
    GMOCK_MOCKER_($i, constness, Method).RegisterOwner(this); \
Gennadiy Civil's avatar
 
Gennadiy Civil committed
151
    return GMOCK_MOCKER_($i, constness, Method).With($matcher_as); \
152
  } \
153
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_($i, constness, Method)
154
155
156
157


]]
$for i [[
158
#define MOCK_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, , , m, __VA_ARGS__)
159
160
161
162
163

]]


$for i [[
164
#define MOCK_CONST_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, const, , m, __VA_ARGS__)
165
166
167
168
169

]]


$for i [[
170
#define MOCK_METHOD$i[[]]_T(m, ...) GMOCK_METHOD$i[[]]_(typename, , , m, __VA_ARGS__)
171
172
173
174
175

]]


$for i [[
176
177
#define MOCK_CONST_METHOD$i[[]]_T(m, ...) \
    GMOCK_METHOD$i[[]]_(typename, const, , m, __VA_ARGS__)
178
179
180
181
182

]]


$for i [[
183
184
#define MOCK_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \
    GMOCK_METHOD$i[[]]_(, , ct, m, __VA_ARGS__)
185
186
187
188
189

]]


$for i [[
190
191
#define MOCK_CONST_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \
    GMOCK_METHOD$i[[]]_(, const, ct, m, __VA_ARGS__)
192
193
194
195
196

]]


$for i [[
197
198
#define MOCK_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \
    GMOCK_METHOD$i[[]]_(typename, , ct, m, __VA_ARGS__)
199
200
201
202
203

]]


$for i [[
204
205
#define MOCK_CONST_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \
    GMOCK_METHOD$i[[]]_(typename, const, ct, m, __VA_ARGS__)
206
207
208

]]

209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
// A MockFunction<F> class has one mock method whose type is F.  It is
// useful when you just want your test code to emit some messages and
// have Google Mock verify the right messages are sent (and perhaps at
// the right times).  For example, if you are exercising code:
//
//   Foo(1);
//   Foo(2);
//   Foo(3);
//
// and want to verify that Foo(1) and Foo(3) both invoke
// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
//
// TEST(FooTest, InvokesBarCorrectly) {
//   MyMock mock;
//   MockFunction<void(string check_point_name)> check;
//   {
//     InSequence s;
//
//     EXPECT_CALL(mock, Bar("a"));
//     EXPECT_CALL(check, Call("1"));
//     EXPECT_CALL(check, Call("2"));
//     EXPECT_CALL(mock, Bar("a"));
//   }
//   Foo(1);
//   check.Call("1");
//   Foo(2);
//   check.Call("2");
//   Foo(3);
// }
//
// The expectation spec says that the first Bar("a") must happen
// before check point "1", the second Bar("a") must happen after check
// point "2", and nothing should happen between the two check
// points. The explicit check points make it easy to tell which
// Bar("a") is called by which call to Foo().
244
245
246
247
248
249
250
251
252
253
254
//
// MockFunction<F> can also be used to exercise code that accepts
// std::function<F> callbacks. To do so, use AsStdFunction() method
// to create std::function proxy forwarding to original object's Call.
// Example:
//
// TEST(FooTest, RunsCallbackWithBarArgument) {
//   MockFunction<int(string)> callback;
//   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
//   Foo(callback.AsStdFunction());
// }
255
256
257
258
259
260
template <typename F>
class MockFunction;


$for i [[
$range j 0..i-1
261
$var ArgTypes = [[$for j, [[A$j]]]]
Gennadiy Civil's avatar
 
Gennadiy Civil committed
262
$var ArgValues = [[$for j, [[::std::move(a$j)]]]]
263
$var ArgDecls = [[$for j, [[A$j a$j]]]]
264
template <typename R$for j [[, typename A$j]]>
265
class MockFunction<R($ArgTypes)> {
266
 public:
267
268
  MockFunction() {}

269
270
  MOCK_METHOD$i[[]]_T(Call, R($ArgTypes));

271
#if GTEST_HAS_STD_FUNCTION_
Gennadiy Civil's avatar
 
Gennadiy Civil committed
272
  ::std::function<R($ArgTypes)> AsStdFunction() {
273
    return [this]($ArgDecls) -> R {
Gennadiy Civil's avatar
 
Gennadiy Civil committed
274
      return this->Call($ArgValues);
275
276
    };
  }
277
#endif  // GTEST_HAS_STD_FUNCTION_
278
279
280

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
281
282
283
284
};


]]
285
286
287
}  // namespace testing

#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_