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// Author: wan@google.com (Zhanyong Wan)
35
36// Implements class templates NiceMock, NaggyMock, and StrictMock.
37//
38// Given a mock class MockFoo that is created using Google Mock,
39// NiceMock<MockFoo> is a subclass of MockFoo that allows
40// uninteresting calls (i.e. calls to mock methods that have no
41// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
42// that prints a warning when an uninteresting call occurs, and
43// StrictMock<MockFoo> is a subclass of MockFoo that treats all
44// uninteresting calls as errors.
45//
46// Currently a mock is naggy by default, so MockFoo and
47// NaggyMock<MockFoo> behave like the same.  However, we will soon
48// switch the default behavior of mocks to be nice, as that in general
49// leads to more maintainable tests.  When that happens, MockFoo will
50// stop behaving like NaggyMock<MockFoo> and start behaving like
51// NiceMock<MockFoo>.
52//
53// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
54// their respective base class, with up-to 10 arguments.  Therefore
55// you can write NiceMock<MockFoo>(5, "a") to construct a nice mock
56// where MockFoo has a constructor that accepts (int, const char*),
57// for example.
58//
59// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
60// and StrictMock<MockFoo> only works for mock methods defined using
61// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
62// If a mock method is defined in a base class of MockFoo, the "nice"
63// or "strict" modifier may not affect it, depending on the compiler.
64// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
65// supported.
66//
67// Another known limitation is that the constructors of the base mock
68// cannot have arguments passed by non-const reference, which are
69// banned by the Google C++ style guide anyway.
70
71#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
72#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
73
74#include "gmock/gmock-spec-builders.h"
75#include "gmock/internal/gmock-port.h"
76
77namespace testing {
78
79template <class MockClass>
80class NiceMock : public MockClass {
81 public:
82  // We don't factor out the constructor body to a common method, as
83  // we have to avoid a possible clash with members of MockClass.
84  NiceMock() {
85    ::testing::Mock::AllowUninterestingCalls(
86        internal::ImplicitCast_<MockClass*>(this));
87  }
88
89  // C++ doesn't (yet) allow inheritance of constructors, so we have
90  // to define it for each arity.
91  template <typename A1>
92  explicit NiceMock(const A1& a1) : MockClass(a1) {
93    ::testing::Mock::AllowUninterestingCalls(
94        internal::ImplicitCast_<MockClass*>(this));
95  }
96  template <typename A1, typename A2>
97  NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
98    ::testing::Mock::AllowUninterestingCalls(
99        internal::ImplicitCast_<MockClass*>(this));
100  }
101
102  template <typename A1, typename A2, typename A3>
103  NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
104    ::testing::Mock::AllowUninterestingCalls(
105        internal::ImplicitCast_<MockClass*>(this));
106  }
107
108  template <typename A1, typename A2, typename A3, typename A4>
109  NiceMock(const A1& a1, const A2& a2, const A3& a3,
110      const A4& a4) : MockClass(a1, a2, a3, a4) {
111    ::testing::Mock::AllowUninterestingCalls(
112        internal::ImplicitCast_<MockClass*>(this));
113  }
114
115  template <typename A1, typename A2, typename A3, typename A4, typename A5>
116  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
117      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
118    ::testing::Mock::AllowUninterestingCalls(
119        internal::ImplicitCast_<MockClass*>(this));
120  }
121
122  template <typename A1, typename A2, typename A3, typename A4, typename A5,
123      typename A6>
124  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
125      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
126    ::testing::Mock::AllowUninterestingCalls(
127        internal::ImplicitCast_<MockClass*>(this));
128  }
129
130  template <typename A1, typename A2, typename A3, typename A4, typename A5,
131      typename A6, typename A7>
132  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
133      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
134      a6, a7) {
135    ::testing::Mock::AllowUninterestingCalls(
136        internal::ImplicitCast_<MockClass*>(this));
137  }
138
139  template <typename A1, typename A2, typename A3, typename A4, typename A5,
140      typename A6, typename A7, typename A8>
141  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
142      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
143      a2, a3, a4, a5, a6, a7, a8) {
144    ::testing::Mock::AllowUninterestingCalls(
145        internal::ImplicitCast_<MockClass*>(this));
146  }
147
148  template <typename A1, typename A2, typename A3, typename A4, typename A5,
149      typename A6, typename A7, typename A8, typename A9>
150  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
151      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
152      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
153    ::testing::Mock::AllowUninterestingCalls(
154        internal::ImplicitCast_<MockClass*>(this));
155  }
156
157  template <typename A1, typename A2, typename A3, typename A4, typename A5,
158      typename A6, typename A7, typename A8, typename A9, typename A10>
159  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
160      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
161      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
162    ::testing::Mock::AllowUninterestingCalls(
163        internal::ImplicitCast_<MockClass*>(this));
164  }
165
166  virtual ~NiceMock() {
167    ::testing::Mock::UnregisterCallReaction(
168        internal::ImplicitCast_<MockClass*>(this));
169  }
170
171 private:
172  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
173};
174
175template <class MockClass>
176class NaggyMock : public MockClass {
177 public:
178  // We don't factor out the constructor body to a common method, as
179  // we have to avoid a possible clash with members of MockClass.
180  NaggyMock() {
181    ::testing::Mock::WarnUninterestingCalls(
182        internal::ImplicitCast_<MockClass*>(this));
183  }
184
185  // C++ doesn't (yet) allow inheritance of constructors, so we have
186  // to define it for each arity.
187  template <typename A1>
188  explicit NaggyMock(const A1& a1) : MockClass(a1) {
189    ::testing::Mock::WarnUninterestingCalls(
190        internal::ImplicitCast_<MockClass*>(this));
191  }
192  template <typename A1, typename A2>
193  NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
194    ::testing::Mock::WarnUninterestingCalls(
195        internal::ImplicitCast_<MockClass*>(this));
196  }
197
198  template <typename A1, typename A2, typename A3>
199  NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
200    ::testing::Mock::WarnUninterestingCalls(
201        internal::ImplicitCast_<MockClass*>(this));
202  }
203
204  template <typename A1, typename A2, typename A3, typename A4>
205  NaggyMock(const A1& a1, const A2& a2, const A3& a3,
206      const A4& a4) : MockClass(a1, a2, a3, a4) {
207    ::testing::Mock::WarnUninterestingCalls(
208        internal::ImplicitCast_<MockClass*>(this));
209  }
210
211  template <typename A1, typename A2, typename A3, typename A4, typename A5>
212  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
213      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
214    ::testing::Mock::WarnUninterestingCalls(
215        internal::ImplicitCast_<MockClass*>(this));
216  }
217
218  template <typename A1, typename A2, typename A3, typename A4, typename A5,
219      typename A6>
220  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
221      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
222    ::testing::Mock::WarnUninterestingCalls(
223        internal::ImplicitCast_<MockClass*>(this));
224  }
225
226  template <typename A1, typename A2, typename A3, typename A4, typename A5,
227      typename A6, typename A7>
228  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
229      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
230      a6, a7) {
231    ::testing::Mock::WarnUninterestingCalls(
232        internal::ImplicitCast_<MockClass*>(this));
233  }
234
235  template <typename A1, typename A2, typename A3, typename A4, typename A5,
236      typename A6, typename A7, typename A8>
237  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
238      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
239      a2, a3, a4, a5, a6, a7, a8) {
240    ::testing::Mock::WarnUninterestingCalls(
241        internal::ImplicitCast_<MockClass*>(this));
242  }
243
244  template <typename A1, typename A2, typename A3, typename A4, typename A5,
245      typename A6, typename A7, typename A8, typename A9>
246  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
247      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
248      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
249    ::testing::Mock::WarnUninterestingCalls(
250        internal::ImplicitCast_<MockClass*>(this));
251  }
252
253  template <typename A1, typename A2, typename A3, typename A4, typename A5,
254      typename A6, typename A7, typename A8, typename A9, typename A10>
255  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
256      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
257      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
258    ::testing::Mock::WarnUninterestingCalls(
259        internal::ImplicitCast_<MockClass*>(this));
260  }
261
262  virtual ~NaggyMock() {
263    ::testing::Mock::UnregisterCallReaction(
264        internal::ImplicitCast_<MockClass*>(this));
265  }
266
267 private:
268  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
269};
270
271template <class MockClass>
272class StrictMock : public MockClass {
273 public:
274  // We don't factor out the constructor body to a common method, as
275  // we have to avoid a possible clash with members of MockClass.
276  StrictMock() {
277    ::testing::Mock::FailUninterestingCalls(
278        internal::ImplicitCast_<MockClass*>(this));
279  }
280
281  // C++ doesn't (yet) allow inheritance of constructors, so we have
282  // to define it for each arity.
283  template <typename A1>
284  explicit StrictMock(const A1& a1) : MockClass(a1) {
285    ::testing::Mock::FailUninterestingCalls(
286        internal::ImplicitCast_<MockClass*>(this));
287  }
288  template <typename A1, typename A2>
289  StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
290    ::testing::Mock::FailUninterestingCalls(
291        internal::ImplicitCast_<MockClass*>(this));
292  }
293
294  template <typename A1, typename A2, typename A3>
295  StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
296    ::testing::Mock::FailUninterestingCalls(
297        internal::ImplicitCast_<MockClass*>(this));
298  }
299
300  template <typename A1, typename A2, typename A3, typename A4>
301  StrictMock(const A1& a1, const A2& a2, const A3& a3,
302      const A4& a4) : MockClass(a1, a2, a3, a4) {
303    ::testing::Mock::FailUninterestingCalls(
304        internal::ImplicitCast_<MockClass*>(this));
305  }
306
307  template <typename A1, typename A2, typename A3, typename A4, typename A5>
308  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
309      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
310    ::testing::Mock::FailUninterestingCalls(
311        internal::ImplicitCast_<MockClass*>(this));
312  }
313
314  template <typename A1, typename A2, typename A3, typename A4, typename A5,
315      typename A6>
316  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
317      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
318    ::testing::Mock::FailUninterestingCalls(
319        internal::ImplicitCast_<MockClass*>(this));
320  }
321
322  template <typename A1, typename A2, typename A3, typename A4, typename A5,
323      typename A6, typename A7>
324  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
325      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
326      a6, a7) {
327    ::testing::Mock::FailUninterestingCalls(
328        internal::ImplicitCast_<MockClass*>(this));
329  }
330
331  template <typename A1, typename A2, typename A3, typename A4, typename A5,
332      typename A6, typename A7, typename A8>
333  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
334      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
335      a2, a3, a4, a5, a6, a7, a8) {
336    ::testing::Mock::FailUninterestingCalls(
337        internal::ImplicitCast_<MockClass*>(this));
338  }
339
340  template <typename A1, typename A2, typename A3, typename A4, typename A5,
341      typename A6, typename A7, typename A8, typename A9>
342  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
343      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
344      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
345    ::testing::Mock::FailUninterestingCalls(
346        internal::ImplicitCast_<MockClass*>(this));
347  }
348
349  template <typename A1, typename A2, typename A3, typename A4, typename A5,
350      typename A6, typename A7, typename A8, typename A9, typename A10>
351  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
352      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
353      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
354    ::testing::Mock::FailUninterestingCalls(
355        internal::ImplicitCast_<MockClass*>(this));
356  }
357
358  virtual ~StrictMock() {
359    ::testing::Mock::UnregisterCallReaction(
360        internal::ImplicitCast_<MockClass*>(this));
361  }
362
363 private:
364  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
365};
366
367// The following specializations catch some (relatively more common)
368// user errors of nesting nice and strict mocks.  They do NOT catch
369// all possible errors.
370
371// These specializations are declared but not defined, as NiceMock,
372// NaggyMock, and StrictMock cannot be nested.
373
374template <typename MockClass>
375class NiceMock<NiceMock<MockClass> >;
376template <typename MockClass>
377class NiceMock<NaggyMock<MockClass> >;
378template <typename MockClass>
379class NiceMock<StrictMock<MockClass> >;
380
381template <typename MockClass>
382class NaggyMock<NiceMock<MockClass> >;
383template <typename MockClass>
384class NaggyMock<NaggyMock<MockClass> >;
385template <typename MockClass>
386class NaggyMock<StrictMock<MockClass> >;
387
388template <typename MockClass>
389class StrictMock<NiceMock<MockClass> >;
390template <typename MockClass>
391class StrictMock<NaggyMock<MockClass> >;
392template <typename MockClass>
393class StrictMock<StrictMock<MockClass> >;
394
395}  // namespace testing
396
397#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
398