gmock-generated-function-mockers.h.pump 8.37 KB
Newer Older
1
2
3
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
$$ -*- mode: c++; -*-
$$ This is a Pump source file.  Please use Pump to convert it to
$$ gmock-generated-function-mockers.h.
$$
$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
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

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]]]]
$var as = [[$for j, [[a$j]]]]
$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;

  MockSpec<F>& With($matchers) {

$if i >= 1 [[
81
    this->current_spec().SetMatchers(::testing::make_tuple($ms));
82
83
84
85
86
87

]]
    return this->current_spec();
  }

  R Invoke($Aas) {
88
89
90
91
92
    // 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));
93
94
95
96
97
98
99
100
101
102
103
104
105
106
  }
};


]]
}  // 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;

107
108
109
110
// 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).
111
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
112
113
#define GMOCK_RESULT_(tn, ...) \
    tn ::testing::internal::Function<__VA_ARGS__>::Result
114

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

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

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


$for i [[
$range j 1..i
$var arg_as = [[$for j, \
134
      [[GMOCK_ARG_(tn, $j, __VA_ARGS__) gmock_a$j]]]]
135
136
$var as = [[$for j, [[gmock_a$j]]]]
$var matcher_as = [[$for j, \
137
                     [[GMOCK_MATCHER_(tn, $j, __VA_ARGS__) 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
  } \
148
  ::testing::MockSpec<__VA_ARGS__>& \
149
      gmock_##Method($matcher_as) constness { \
150
151
    GMOCK_MOCKER_($i, constness, Method).RegisterOwner(this); \
    return GMOCK_MOCKER_($i, constness, Method).With($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
244
245
246
247
248
249
250
251
252
// 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().
template <typename F>
class MockFunction;


$for i [[
$range j 0..i-1
template <typename R$for j [[, typename A$j]]>
class MockFunction<R($for j, [[A$j]])> {
 public:
253
254
  MockFunction() {}

255
  MOCK_METHOD$i[[]]_T(Call, R($for j, [[A$j]]));
256
257
258

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
259
260
261
262
};


]]
263
264
265
}  // namespace testing

#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_