1// Copyright 2008, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8// * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10// * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14// * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30
31// Implements class templates NiceMock, NaggyMock, and StrictMock.
32//
33// Given a mock class MockFoo that is created using Google Mock,
34// NiceMock<MockFoo> is a subclass of MockFoo that allows
35// uninteresting calls (i.e. calls to mock methods that have no
36// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
37// that prints a warning when an uninteresting call occurs, and
38// StrictMock<MockFoo> is a subclass of MockFoo that treats all
39// uninteresting calls as errors.
40//
41// Currently a mock is naggy by default, so MockFoo and
42// NaggyMock<MockFoo> behave like the same. However, we will soon
43// switch the default behavior of mocks to be nice, as that in general
44// leads to more maintainable tests. When that happens, MockFoo will
45// stop behaving like NaggyMock<MockFoo> and start behaving like
46// NiceMock<MockFoo>.
47//
48// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
49// their respective base class. Therefore you can write
50// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
51// has a constructor that accepts (int, const char*), for example.
52//
53// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
54// and StrictMock<MockFoo> only works for mock methods defined using
55// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
56// If a mock method is defined in a base class of MockFoo, the "nice"
57// or "strict" modifier may not affect it, depending on the compiler.
58// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
59// supported.
60
61// GOOGLETEST_CM0002 DO NOT DELETE
62
63#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
64#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
65
66#include <type_traits>
67
68#include "gmock/gmock-spec-builders.h"
69#include "gmock/internal/gmock-port.h"
70
71namespace testing {
72template <class MockClass>
73class NiceMock;
74template <class MockClass>
75class NaggyMock;
76template <class MockClass>
77class StrictMock;
78
79namespace internal {
80template <typename T>
81std::true_type StrictnessModifierProbe(const NiceMock<T>&);
82template <typename T>
83std::true_type StrictnessModifierProbe(const NaggyMock<T>&);
84template <typename T>
85std::true_type StrictnessModifierProbe(const StrictMock<T>&);
86std::false_type StrictnessModifierProbe(...);
87
88template <typename T>
89constexpr bool HasStrictnessModifier() {
90 return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value;
91}
92
93// Base classes that register and deregister with testing::Mock to alter the
94// default behavior around uninteresting calls. Inheriting from one of these
95// classes first and then MockClass ensures the MockClass constructor is run
96// after registration, and that the MockClass destructor runs before
97// deregistration. This guarantees that MockClass's constructor and destructor
98// run with the same level of strictness as its instance methods.
99
100#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW && \
101 (defined(_MSC_VER) || defined(__clang__))
102// We need to mark these classes with this declspec to ensure that
103// the empty base class optimization is performed.
104#define GTEST_INTERNAL_EMPTY_BASE_CLASS __declspec(empty_bases)
105#else
106#define GTEST_INTERNAL_EMPTY_BASE_CLASS
107#endif
108
109template <typename Base>
110class NiceMockImpl {
111 public:
112 NiceMockImpl() { ::testing::Mock::AllowUninterestingCalls(this); }
113
114 ~NiceMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
115};
116
117template <typename Base>
118class NaggyMockImpl {
119 public:
120 NaggyMockImpl() { ::testing::Mock::WarnUninterestingCalls(this); }
121
122 ~NaggyMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
123};
124
125template <typename Base>
126class StrictMockImpl {
127 public:
128 StrictMockImpl() { ::testing::Mock::FailUninterestingCalls(this); }
129
130 ~StrictMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
131};
132
133} // namespace internal
134
135template <class MockClass>
136class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
137 : private internal::NiceMockImpl<MockClass>,
138 public MockClass {
139 public:
140 static_assert(!internal::HasStrictnessModifier<MockClass>(),
141 "Can't apply NiceMock to a class hierarchy that already has a "
142 "strictness modifier. See "
143 "https://google.github.io/googletest/"
144 "gmock_cook_book.html#NiceStrictNaggy");
145 NiceMock() : MockClass() {
146 static_assert(sizeof(*this) == sizeof(MockClass),
147 "The impl subclass shouldn't introduce any padding");
148 }
149
150 // Ideally, we would inherit base class's constructors through a using
151 // declaration, which would preserve their visibility. However, many existing
152 // tests rely on the fact that current implementation reexports protected
153 // constructors as public. These tests would need to be cleaned up first.
154
155 // Single argument constructor is special-cased so that it can be
156 // made explicit.
157 template <typename A>
158 explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
159 static_assert(sizeof(*this) == sizeof(MockClass),
160 "The impl subclass shouldn't introduce any padding");
161 }
162
163 template <typename TArg1, typename TArg2, typename... An>
164 NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
165 : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
166 std::forward<An>(args)...) {
167 static_assert(sizeof(*this) == sizeof(MockClass),
168 "The impl subclass shouldn't introduce any padding");
169 }
170
171 private:
172 GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
173};
174
175template <class MockClass>
176class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
177 : private internal::NaggyMockImpl<MockClass>,
178 public MockClass {
179 static_assert(!internal::HasStrictnessModifier<MockClass>(),
180 "Can't apply NaggyMock to a class hierarchy that already has a "
181 "strictness modifier. See "
182 "https://google.github.io/googletest/"
183 "gmock_cook_book.html#NiceStrictNaggy");
184
185 public:
186 NaggyMock() : MockClass() {
187 static_assert(sizeof(*this) == sizeof(MockClass),
188 "The impl subclass shouldn't introduce any padding");
189 }
190
191 // Ideally, we would inherit base class's constructors through a using
192 // declaration, which would preserve their visibility. However, many existing
193 // tests rely on the fact that current implementation reexports protected
194 // constructors as public. These tests would need to be cleaned up first.
195
196 // Single argument constructor is special-cased so that it can be
197 // made explicit.
198 template <typename A>
199 explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
200 static_assert(sizeof(*this) == sizeof(MockClass),
201 "The impl subclass shouldn't introduce any padding");
202 }
203
204 template <typename TArg1, typename TArg2, typename... An>
205 NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
206 : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
207 std::forward<An>(args)...) {
208 static_assert(sizeof(*this) == sizeof(MockClass),
209 "The impl subclass shouldn't introduce any padding");
210 }
211
212 private:
213 GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
214};
215
216template <class MockClass>
217class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
218 : private internal::StrictMockImpl<MockClass>,
219 public MockClass {
220 public:
221 static_assert(
222 !internal::HasStrictnessModifier<MockClass>(),
223 "Can't apply StrictMock to a class hierarchy that already has a "
224 "strictness modifier. See "
225 "https://google.github.io/googletest/"
226 "gmock_cook_book.html#NiceStrictNaggy");
227 StrictMock() : MockClass() {
228 static_assert(sizeof(*this) == sizeof(MockClass),
229 "The impl subclass shouldn't introduce any padding");
230 }
231
232 // Ideally, we would inherit base class's constructors through a using
233 // declaration, which would preserve their visibility. However, many existing
234 // tests rely on the fact that current implementation reexports protected
235 // constructors as public. These tests would need to be cleaned up first.
236
237 // Single argument constructor is special-cased so that it can be
238 // made explicit.
239 template <typename A>
240 explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
241 static_assert(sizeof(*this) == sizeof(MockClass),
242 "The impl subclass shouldn't introduce any padding");
243 }
244
245 template <typename TArg1, typename TArg2, typename... An>
246 StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
247 : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
248 std::forward<An>(args)...) {
249 static_assert(sizeof(*this) == sizeof(MockClass),
250 "The impl subclass shouldn't introduce any padding");
251 }
252
253 private:
254 GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
255};
256
257#undef GTEST_INTERNAL_EMPTY_BASE_CLASS
258
259} // namespace testing
260
261#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
262