1 | // This file was GENERATED by command: |
2 | // pump.py gmock-generated-nice-strict.h.pump |
3 | // DO NOT EDIT BY HAND!!! |
4 | |
5 | // Copyright 2008, Google Inc. |
6 | // All rights reserved. |
7 | // |
8 | // Redistribution and use in source and binary forms, with or without |
9 | // modification, are permitted provided that the following conditions are |
10 | // met: |
11 | // |
12 | // * Redistributions of source code must retain the above copyright |
13 | // notice, this list of conditions and the following disclaimer. |
14 | // * Redistributions in binary form must reproduce the above |
15 | // copyright notice, this list of conditions and the following disclaimer |
16 | // in the documentation and/or other materials provided with the |
17 | // distribution. |
18 | // * Neither the name of Google Inc. nor the names of its |
19 | // contributors may be used to endorse or promote products derived from |
20 | // this software without specific prior written permission. |
21 | // |
22 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
23 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
24 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
25 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
26 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
27 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
28 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
29 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
30 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
31 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
32 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
33 | |
34 | |
35 | // Implements class templates NiceMock, NaggyMock, and StrictMock. |
36 | // |
37 | // Given a mock class MockFoo that is created using Google Mock, |
38 | // NiceMock<MockFoo> is a subclass of MockFoo that allows |
39 | // uninteresting calls (i.e. calls to mock methods that have no |
40 | // EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo |
41 | // that prints a warning when an uninteresting call occurs, and |
42 | // StrictMock<MockFoo> is a subclass of MockFoo that treats all |
43 | // uninteresting calls as errors. |
44 | // |
45 | // Currently a mock is naggy by default, so MockFoo and |
46 | // NaggyMock<MockFoo> behave like the same. However, we will soon |
47 | // switch the default behavior of mocks to be nice, as that in general |
48 | // leads to more maintainable tests. When that happens, MockFoo will |
49 | // stop behaving like NaggyMock<MockFoo> and start behaving like |
50 | // NiceMock<MockFoo>. |
51 | // |
52 | // NiceMock, NaggyMock, and StrictMock "inherit" the constructors of |
53 | // their respective base class. Therefore you can write |
54 | // NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo |
55 | // has a constructor that accepts (int, const char*), for example. |
56 | // |
57 | // A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>, |
58 | // and StrictMock<MockFoo> only works for mock methods defined using |
59 | // the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class. |
60 | // If a mock method is defined in a base class of MockFoo, the "nice" |
61 | // or "strict" modifier may not affect it, depending on the compiler. |
62 | // In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT |
63 | // supported. |
64 | |
65 | // GOOGLETEST_CM0002 DO NOT DELETE |
66 | |
67 | #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ |
68 | #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ |
69 | |
70 | #include "gmock/gmock-spec-builders.h" |
71 | #include "gmock/internal/gmock-port.h" |
72 | |
73 | namespace testing { |
74 | |
75 | template <class MockClass> |
76 | class NiceMock : public MockClass { |
77 | public: |
78 | NiceMock() : MockClass() { |
79 | ::testing::Mock::AllowUninterestingCalls( |
80 | internal::ImplicitCast_<MockClass*>(this)); |
81 | } |
82 | |
83 | #if GTEST_LANG_CXX11 |
84 | // Ideally, we would inherit base class's constructors through a using |
85 | // declaration, which would preserve their visibility. However, many existing |
86 | // tests rely on the fact that current implementation reexports protected |
87 | // constructors as public. These tests would need to be cleaned up first. |
88 | |
89 | // Single argument constructor is special-cased so that it can be |
90 | // made explicit. |
91 | template <typename A> |
92 | explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) { |
93 | ::testing::Mock::AllowUninterestingCalls( |
94 | internal::ImplicitCast_<MockClass*>(this)); |
95 | } |
96 | |
97 | template <typename A1, typename A2, typename... An> |
98 | NiceMock(A1&& arg1, A2&& arg2, An&&... args) |
99 | : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2), |
100 | std::forward<An>(args)...) { |
101 | ::testing::Mock::AllowUninterestingCalls( |
102 | internal::ImplicitCast_<MockClass*>(this)); |
103 | } |
104 | #else |
105 | // C++98 doesn't have variadic templates, so we have to define one |
106 | // for each arity. |
107 | template <typename A1> |
108 | explicit NiceMock(const A1& a1) : MockClass(a1) { |
109 | ::testing::Mock::AllowUninterestingCalls( |
110 | internal::ImplicitCast_<MockClass*>(this)); |
111 | } |
112 | template <typename A1, typename A2> |
113 | NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { |
114 | ::testing::Mock::AllowUninterestingCalls( |
115 | internal::ImplicitCast_<MockClass*>(this)); |
116 | } |
117 | |
118 | template <typename A1, typename A2, typename A3> |
119 | NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { |
120 | ::testing::Mock::AllowUninterestingCalls( |
121 | internal::ImplicitCast_<MockClass*>(this)); |
122 | } |
123 | |
124 | template <typename A1, typename A2, typename A3, typename A4> |
125 | NiceMock(const A1& a1, const A2& a2, const A3& a3, |
126 | const A4& a4) : MockClass(a1, a2, a3, a4) { |
127 | ::testing::Mock::AllowUninterestingCalls( |
128 | internal::ImplicitCast_<MockClass*>(this)); |
129 | } |
130 | |
131 | template <typename A1, typename A2, typename A3, typename A4, typename A5> |
132 | NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
133 | const A5& a5) : MockClass(a1, a2, a3, a4, a5) { |
134 | ::testing::Mock::AllowUninterestingCalls( |
135 | internal::ImplicitCast_<MockClass*>(this)); |
136 | } |
137 | |
138 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
139 | typename A6> |
140 | NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
141 | const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) { |
142 | ::testing::Mock::AllowUninterestingCalls( |
143 | internal::ImplicitCast_<MockClass*>(this)); |
144 | } |
145 | |
146 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
147 | typename A6, typename A7> |
148 | NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
149 | const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5, |
150 | a6, a7) { |
151 | ::testing::Mock::AllowUninterestingCalls( |
152 | internal::ImplicitCast_<MockClass*>(this)); |
153 | } |
154 | |
155 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
156 | typename A6, typename A7, typename A8> |
157 | NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
158 | const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1, |
159 | a2, a3, a4, a5, a6, a7, a8) { |
160 | ::testing::Mock::AllowUninterestingCalls( |
161 | internal::ImplicitCast_<MockClass*>(this)); |
162 | } |
163 | |
164 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
165 | typename A6, typename A7, typename A8, typename A9> |
166 | NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
167 | const A5& a5, const A6& a6, const A7& a7, const A8& a8, |
168 | const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) { |
169 | ::testing::Mock::AllowUninterestingCalls( |
170 | internal::ImplicitCast_<MockClass*>(this)); |
171 | } |
172 | |
173 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
174 | typename A6, typename A7, typename A8, typename A9, typename A10> |
175 | NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
176 | const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, |
177 | const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { |
178 | ::testing::Mock::AllowUninterestingCalls( |
179 | internal::ImplicitCast_<MockClass*>(this)); |
180 | } |
181 | |
182 | #endif // GTEST_LANG_CXX11 |
183 | |
184 | ~NiceMock() { |
185 | ::testing::Mock::UnregisterCallReaction( |
186 | internal::ImplicitCast_<MockClass*>(this)); |
187 | } |
188 | |
189 | private: |
190 | GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock); |
191 | }; |
192 | |
193 | template <class MockClass> |
194 | class NaggyMock : public MockClass { |
195 | public: |
196 | NaggyMock() : MockClass() { |
197 | ::testing::Mock::WarnUninterestingCalls( |
198 | internal::ImplicitCast_<MockClass*>(this)); |
199 | } |
200 | |
201 | #if GTEST_LANG_CXX11 |
202 | // Ideally, we would inherit base class's constructors through a using |
203 | // declaration, which would preserve their visibility. However, many existing |
204 | // tests rely on the fact that current implementation reexports protected |
205 | // constructors as public. These tests would need to be cleaned up first. |
206 | |
207 | // Single argument constructor is special-cased so that it can be |
208 | // made explicit. |
209 | template <typename A> |
210 | explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) { |
211 | ::testing::Mock::WarnUninterestingCalls( |
212 | internal::ImplicitCast_<MockClass*>(this)); |
213 | } |
214 | |
215 | template <typename A1, typename A2, typename... An> |
216 | NaggyMock(A1&& arg1, A2&& arg2, An&&... args) |
217 | : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2), |
218 | std::forward<An>(args)...) { |
219 | ::testing::Mock::WarnUninterestingCalls( |
220 | internal::ImplicitCast_<MockClass*>(this)); |
221 | } |
222 | #else |
223 | // C++98 doesn't have variadic templates, so we have to define one |
224 | // for each arity. |
225 | template <typename A1> |
226 | explicit NaggyMock(const A1& a1) : MockClass(a1) { |
227 | ::testing::Mock::WarnUninterestingCalls( |
228 | internal::ImplicitCast_<MockClass*>(this)); |
229 | } |
230 | template <typename A1, typename A2> |
231 | NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { |
232 | ::testing::Mock::WarnUninterestingCalls( |
233 | internal::ImplicitCast_<MockClass*>(this)); |
234 | } |
235 | |
236 | template <typename A1, typename A2, typename A3> |
237 | NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { |
238 | ::testing::Mock::WarnUninterestingCalls( |
239 | internal::ImplicitCast_<MockClass*>(this)); |
240 | } |
241 | |
242 | template <typename A1, typename A2, typename A3, typename A4> |
243 | NaggyMock(const A1& a1, const A2& a2, const A3& a3, |
244 | const A4& a4) : MockClass(a1, a2, a3, a4) { |
245 | ::testing::Mock::WarnUninterestingCalls( |
246 | internal::ImplicitCast_<MockClass*>(this)); |
247 | } |
248 | |
249 | template <typename A1, typename A2, typename A3, typename A4, typename A5> |
250 | NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
251 | const A5& a5) : MockClass(a1, a2, a3, a4, a5) { |
252 | ::testing::Mock::WarnUninterestingCalls( |
253 | internal::ImplicitCast_<MockClass*>(this)); |
254 | } |
255 | |
256 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
257 | typename A6> |
258 | NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
259 | const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) { |
260 | ::testing::Mock::WarnUninterestingCalls( |
261 | internal::ImplicitCast_<MockClass*>(this)); |
262 | } |
263 | |
264 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
265 | typename A6, typename A7> |
266 | NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
267 | const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5, |
268 | a6, a7) { |
269 | ::testing::Mock::WarnUninterestingCalls( |
270 | internal::ImplicitCast_<MockClass*>(this)); |
271 | } |
272 | |
273 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
274 | typename A6, typename A7, typename A8> |
275 | NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
276 | const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1, |
277 | a2, a3, a4, a5, a6, a7, a8) { |
278 | ::testing::Mock::WarnUninterestingCalls( |
279 | internal::ImplicitCast_<MockClass*>(this)); |
280 | } |
281 | |
282 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
283 | typename A6, typename A7, typename A8, typename A9> |
284 | NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
285 | const A5& a5, const A6& a6, const A7& a7, const A8& a8, |
286 | const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) { |
287 | ::testing::Mock::WarnUninterestingCalls( |
288 | internal::ImplicitCast_<MockClass*>(this)); |
289 | } |
290 | |
291 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
292 | typename A6, typename A7, typename A8, typename A9, typename A10> |
293 | NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
294 | const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, |
295 | const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { |
296 | ::testing::Mock::WarnUninterestingCalls( |
297 | internal::ImplicitCast_<MockClass*>(this)); |
298 | } |
299 | |
300 | #endif // GTEST_LANG_CXX11 |
301 | |
302 | ~NaggyMock() { |
303 | ::testing::Mock::UnregisterCallReaction( |
304 | internal::ImplicitCast_<MockClass*>(this)); |
305 | } |
306 | |
307 | private: |
308 | GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock); |
309 | }; |
310 | |
311 | template <class MockClass> |
312 | class StrictMock : public MockClass { |
313 | public: |
314 | StrictMock() : MockClass() { |
315 | ::testing::Mock::FailUninterestingCalls( |
316 | internal::ImplicitCast_<MockClass*>(this)); |
317 | } |
318 | |
319 | #if GTEST_LANG_CXX11 |
320 | // Ideally, we would inherit base class's constructors through a using |
321 | // declaration, which would preserve their visibility. However, many existing |
322 | // tests rely on the fact that current implementation reexports protected |
323 | // constructors as public. These tests would need to be cleaned up first. |
324 | |
325 | // Single argument constructor is special-cased so that it can be |
326 | // made explicit. |
327 | template <typename A> |
328 | explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) { |
329 | ::testing::Mock::FailUninterestingCalls( |
330 | internal::ImplicitCast_<MockClass*>(this)); |
331 | } |
332 | |
333 | template <typename A1, typename A2, typename... An> |
334 | StrictMock(A1&& arg1, A2&& arg2, An&&... args) |
335 | : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2), |
336 | std::forward<An>(args)...) { |
337 | ::testing::Mock::FailUninterestingCalls( |
338 | internal::ImplicitCast_<MockClass*>(this)); |
339 | } |
340 | #else |
341 | // C++98 doesn't have variadic templates, so we have to define one |
342 | // for each arity. |
343 | template <typename A1> |
344 | explicit StrictMock(const A1& a1) : MockClass(a1) { |
345 | ::testing::Mock::FailUninterestingCalls( |
346 | internal::ImplicitCast_<MockClass*>(this)); |
347 | } |
348 | template <typename A1, typename A2> |
349 | StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { |
350 | ::testing::Mock::FailUninterestingCalls( |
351 | internal::ImplicitCast_<MockClass*>(this)); |
352 | } |
353 | |
354 | template <typename A1, typename A2, typename A3> |
355 | StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { |
356 | ::testing::Mock::FailUninterestingCalls( |
357 | internal::ImplicitCast_<MockClass*>(this)); |
358 | } |
359 | |
360 | template <typename A1, typename A2, typename A3, typename A4> |
361 | StrictMock(const A1& a1, const A2& a2, const A3& a3, |
362 | const A4& a4) : MockClass(a1, a2, a3, a4) { |
363 | ::testing::Mock::FailUninterestingCalls( |
364 | internal::ImplicitCast_<MockClass*>(this)); |
365 | } |
366 | |
367 | template <typename A1, typename A2, typename A3, typename A4, typename A5> |
368 | StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
369 | const A5& a5) : MockClass(a1, a2, a3, a4, a5) { |
370 | ::testing::Mock::FailUninterestingCalls( |
371 | internal::ImplicitCast_<MockClass*>(this)); |
372 | } |
373 | |
374 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
375 | typename A6> |
376 | StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
377 | const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) { |
378 | ::testing::Mock::FailUninterestingCalls( |
379 | internal::ImplicitCast_<MockClass*>(this)); |
380 | } |
381 | |
382 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
383 | typename A6, typename A7> |
384 | StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
385 | const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5, |
386 | a6, a7) { |
387 | ::testing::Mock::FailUninterestingCalls( |
388 | internal::ImplicitCast_<MockClass*>(this)); |
389 | } |
390 | |
391 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
392 | typename A6, typename A7, typename A8> |
393 | StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
394 | const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1, |
395 | a2, a3, a4, a5, a6, a7, a8) { |
396 | ::testing::Mock::FailUninterestingCalls( |
397 | internal::ImplicitCast_<MockClass*>(this)); |
398 | } |
399 | |
400 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
401 | typename A6, typename A7, typename A8, typename A9> |
402 | StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
403 | const A5& a5, const A6& a6, const A7& a7, const A8& a8, |
404 | const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) { |
405 | ::testing::Mock::FailUninterestingCalls( |
406 | internal::ImplicitCast_<MockClass*>(this)); |
407 | } |
408 | |
409 | template <typename A1, typename A2, typename A3, typename A4, typename A5, |
410 | typename A6, typename A7, typename A8, typename A9, typename A10> |
411 | StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, |
412 | const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, |
413 | const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { |
414 | ::testing::Mock::FailUninterestingCalls( |
415 | internal::ImplicitCast_<MockClass*>(this)); |
416 | } |
417 | |
418 | #endif // GTEST_LANG_CXX11 |
419 | |
420 | ~StrictMock() { |
421 | ::testing::Mock::UnregisterCallReaction( |
422 | internal::ImplicitCast_<MockClass*>(this)); |
423 | } |
424 | |
425 | private: |
426 | GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock); |
427 | }; |
428 | |
429 | // The following specializations catch some (relatively more common) |
430 | // user errors of nesting nice and strict mocks. They do NOT catch |
431 | // all possible errors. |
432 | |
433 | // These specializations are declared but not defined, as NiceMock, |
434 | // NaggyMock, and StrictMock cannot be nested. |
435 | |
436 | template <typename MockClass> |
437 | class NiceMock<NiceMock<MockClass> >; |
438 | template <typename MockClass> |
439 | class NiceMock<NaggyMock<MockClass> >; |
440 | template <typename MockClass> |
441 | class NiceMock<StrictMock<MockClass> >; |
442 | |
443 | template <typename MockClass> |
444 | class NaggyMock<NiceMock<MockClass> >; |
445 | template <typename MockClass> |
446 | class NaggyMock<NaggyMock<MockClass> >; |
447 | template <typename MockClass> |
448 | class NaggyMock<StrictMock<MockClass> >; |
449 | |
450 | template <typename MockClass> |
451 | class StrictMock<NiceMock<MockClass> >; |
452 | template <typename MockClass> |
453 | class StrictMock<NaggyMock<MockClass> >; |
454 | template <typename MockClass> |
455 | class StrictMock<StrictMock<MockClass> >; |
456 | |
457 | } // namespace testing |
458 | |
459 | #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ |
460 | |