1$$ -*- mode: c++; -*-
2$$ This is a Pump source file. Please use Pump to convert
3$$ it to gmock-generated-nice-strict.h.
4$$
5$var n = 10  $$ The maximum arity we support.
6// Copyright 2008, Google Inc.
7// All rights reserved.
8//
9// Redistribution and use in source and binary forms, with or without
10// modification, are permitted provided that the following conditions are
11// met:
12//
13//     * Redistributions of source code must retain the above copyright
14// notice, this list of conditions and the following disclaimer.
15//     * Redistributions in binary form must reproduce the above
16// copyright notice, this list of conditions and the following disclaimer
17// in the documentation and/or other materials provided with the
18// distribution.
19//     * Neither the name of Google Inc. nor the names of its
20// contributors may be used to endorse or promote products derived from
21// this software without specific prior written permission.
22//
23// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34
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.  Therefore you can write
55// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
56// has a constructor that accepts (int, const char*), for example.
57//
58// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
59// and StrictMock<MockFoo> only works for mock methods defined using
60// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
61// If a mock method is defined in a base class of MockFoo, the "nice"
62// or "strict" modifier may not affect it, depending on the compiler.
63// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
64// supported.
65
66// GOOGLETEST_CM0002 DO NOT DELETE
67
68#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
69#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
70
71#include "gmock/gmock-spec-builders.h"
72#include "gmock/internal/gmock-port.h"
73
74namespace testing {
75
76$range kind 0..2
77$for kind [[
78
79$var clazz=[[$if kind==0 [[NiceMock]]
80             $elif kind==1 [[NaggyMock]]
81             $else [[StrictMock]]]]
82
83$var method=[[$if kind==0 [[AllowUninterestingCalls]]
84             $elif kind==1 [[WarnUninterestingCalls]]
85             $else [[FailUninterestingCalls]]]]
86
87template <class MockClass>
88class $clazz : public MockClass {
89 public:
90  $clazz() : MockClass() {
91    ::testing::Mock::$method(
92        internal::ImplicitCast_<MockClass*>(this));
93  }
94
95#if GTEST_LANG_CXX11
96  // Ideally, we would inherit base class's constructors through a using
97  // declaration, which would preserve their visibility. However, many existing
98  // tests rely on the fact that current implementation reexports protected
99  // constructors as public. These tests would need to be cleaned up first.
100
101  // Single argument constructor is special-cased so that it can be
102  // made explicit.
103  template <typename A>
104  explicit $clazz(A&& arg) : MockClass(std::forward<A>(arg)) {
105    ::testing::Mock::$method(
106        internal::ImplicitCast_<MockClass*>(this));
107  }
108
109  template <typename A1, typename A2, typename... An>
110  $clazz(A1&& arg1, A2&& arg2, An&&... args)
111      : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2),
112                  std::forward<An>(args)...) {
113    ::testing::Mock::$method(
114        internal::ImplicitCast_<MockClass*>(this));
115  }
116#else
117  // C++98 doesn't have variadic templates, so we have to define one
118  // for each arity.
119  template <typename A1>
120  explicit $clazz(const A1& a1) : MockClass(a1) {
121    ::testing::Mock::$method(
122        internal::ImplicitCast_<MockClass*>(this));
123  }
124
125$range i 2..n
126$for i [[
127$range j 1..i
128  template <$for j, [[typename A$j]]>
129  $clazz($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) {
130    ::testing::Mock::$method(
131        internal::ImplicitCast_<MockClass*>(this));
132  }
133
134
135]]
136#endif  // GTEST_LANG_CXX11
137
138  ~$clazz() {
139    ::testing::Mock::UnregisterCallReaction(
140        internal::ImplicitCast_<MockClass*>(this));
141  }
142
143 private:
144  GTEST_DISALLOW_COPY_AND_ASSIGN_($clazz);
145};
146
147]]
148
149// The following specializations catch some (relatively more common)
150// user errors of nesting nice and strict mocks.  They do NOT catch
151// all possible errors.
152
153// These specializations are declared but not defined, as NiceMock,
154// NaggyMock, and StrictMock cannot be nested.
155
156template <typename MockClass>
157class NiceMock<NiceMock<MockClass> >;
158template <typename MockClass>
159class NiceMock<NaggyMock<MockClass> >;
160template <typename MockClass>
161class NiceMock<StrictMock<MockClass> >;
162
163template <typename MockClass>
164class NaggyMock<NiceMock<MockClass> >;
165template <typename MockClass>
166class NaggyMock<NaggyMock<MockClass> >;
167template <typename MockClass>
168class NaggyMock<StrictMock<MockClass> >;
169
170template <typename MockClass>
171class StrictMock<NiceMock<MockClass> >;
172template <typename MockClass>
173class StrictMock<NaggyMock<MockClass> >;
174template <typename MockClass>
175class StrictMock<StrictMock<MockClass> >;
176
177}  // namespace testing
178
179#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
180