gmock-nice-strict.h 10.2 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
// Copyright 2008, 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.
Gennadiy Civil's avatar
 
Gennadiy Civil committed
29

zhanyong.wan's avatar
zhanyong.wan committed
30
// Implements class templates NiceMock, NaggyMock, and StrictMock.
31
32
33
34
//
// Given a mock class MockFoo that is created using Google Mock,
// NiceMock<MockFoo> is a subclass of MockFoo that allows
// uninteresting calls (i.e. calls to mock methods that have no
zhanyong.wan's avatar
zhanyong.wan committed
35
36
37
38
// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
// that prints a warning when an uninteresting call occurs, and
// StrictMock<MockFoo> is a subclass of MockFoo that treats all
// uninteresting calls as errors.
39
//
zhanyong.wan's avatar
zhanyong.wan committed
40
41
42
43
44
45
// Currently a mock is naggy by default, so MockFoo and
// NaggyMock<MockFoo> behave like the same.  However, we will soon
// switch the default behavior of mocks to be nice, as that in general
// leads to more maintainable tests.  When that happens, MockFoo will
// stop behaving like NaggyMock<MockFoo> and start behaving like
// NiceMock<MockFoo>.
46
//
zhanyong.wan's avatar
zhanyong.wan committed
47
// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
Gennadiy Civil's avatar
Gennadiy Civil committed
48
49
50
// their respective base class.  Therefore you can write
// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
// has a constructor that accepts (int, const char*), for example.
zhanyong.wan's avatar
zhanyong.wan committed
51
52
53
54
55
56
57
58
//
// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
// and StrictMock<MockFoo> only works for mock methods defined using
// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
// If a mock method is defined in a base class of MockFoo, the "nice"
// or "strict" modifier may not affect it, depending on the compiler.
// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
// supported.
59

60
61
62
// IWYU pragma: private, include "gmock/gmock.h"
// IWYU pragma: friend gmock/.*

Abseil Team's avatar
Abseil Team committed
63
64
#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
65

Abseil Team's avatar
Abseil Team committed
66
67
#include <type_traits>

68
69
#include "gmock/gmock-spec-builders.h"
#include "gmock/internal/gmock-port.h"
70
71

namespace testing {
Abseil Team's avatar
Abseil Team committed
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
template <class MockClass>
class NiceMock;
template <class MockClass>
class NaggyMock;
template <class MockClass>
class StrictMock;

namespace internal {
template <typename T>
std::true_type StrictnessModifierProbe(const NiceMock<T>&);
template <typename T>
std::true_type StrictnessModifierProbe(const NaggyMock<T>&);
template <typename T>
std::true_type StrictnessModifierProbe(const StrictMock<T>&);
std::false_type StrictnessModifierProbe(...);

template <typename T>
constexpr bool HasStrictnessModifier() {
  return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value;
}

Abseil Team's avatar
Abseil Team committed
93
94
95
96
97
98
99
// Base classes that register and deregister with testing::Mock to alter the
// default behavior around uninteresting calls. Inheriting from one of these
// classes first and then MockClass ensures the MockClass constructor is run
// after registration, and that the MockClass destructor runs before
// deregistration. This guarantees that MockClass's constructor and destructor
// run with the same level of strictness as its instance methods.

Abseil Team's avatar
Abseil Team committed
100
101
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW && \
    (defined(_MSC_VER) || defined(__clang__))
Abseil Team's avatar
Abseil Team committed
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
// We need to mark these classes with this declspec to ensure that
// the empty base class optimization is performed.
#define GTEST_INTERNAL_EMPTY_BASE_CLASS __declspec(empty_bases)
#else
#define GTEST_INTERNAL_EMPTY_BASE_CLASS
#endif

template <typename Base>
class NiceMockImpl {
 public:
  NiceMockImpl() { ::testing::Mock::AllowUninterestingCalls(this); }

  ~NiceMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
};

template <typename Base>
class NaggyMockImpl {
 public:
  NaggyMockImpl() { ::testing::Mock::WarnUninterestingCalls(this); }

  ~NaggyMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
};

template <typename Base>
class StrictMockImpl {
 public:
  StrictMockImpl() { ::testing::Mock::FailUninterestingCalls(this); }

  ~StrictMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
};

Abseil Team's avatar
Abseil Team committed
133
}  // namespace internal
134
135

template <class MockClass>
Abseil Team's avatar
Abseil Team committed
136
137
138
class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
    : private internal::NiceMockImpl<MockClass>,
      public MockClass {
139
 public:
Abseil Team's avatar
Abseil Team committed
140
141
142
143
144
  static_assert(!internal::HasStrictnessModifier<MockClass>(),
                "Can't apply NiceMock to a class hierarchy that already has a "
                "strictness modifier. See "
                "https://google.github.io/googletest/"
                "gmock_cook_book.html#NiceStrictNaggy");
145
  NiceMock() : MockClass() {
Abseil Team's avatar
Abseil Team committed
146
147
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
148
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
149

Gennadiy Civil's avatar
 
Gennadiy Civil committed
150
151
152
153
154
  // Ideally, we would inherit base class's constructors through a using
  // declaration, which would preserve their visibility. However, many existing
  // tests rely on the fact that current implementation reexports protected
  // constructors as public. These tests would need to be cleaned up first.

Gennadiy Civil's avatar
Gennadiy Civil committed
155
156
157
  // Single argument constructor is special-cased so that it can be
  // made explicit.
  template <typename A>
158
  explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
Abseil Team's avatar
Abseil Team committed
159
160
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
161
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
162

163
164
165
  template <typename TArg1, typename TArg2, typename... An>
  NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
166
                  std::forward<An>(args)...) {
Abseil Team's avatar
Abseil Team committed
167
168
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
169
170
  }

171
172
 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
173
174
};

zhanyong.wan's avatar
zhanyong.wan committed
175
template <class MockClass>
Abseil Team's avatar
Abseil Team committed
176
177
178
class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
    : private internal::NaggyMockImpl<MockClass>,
      public MockClass {
Abseil Team's avatar
Abseil Team committed
179
180
181
182
183
  static_assert(!internal::HasStrictnessModifier<MockClass>(),
                "Can't apply NaggyMock to a class hierarchy that already has a "
                "strictness modifier. See "
                "https://google.github.io/googletest/"
                "gmock_cook_book.html#NiceStrictNaggy");
Abseil Team's avatar
Abseil Team committed
184

zhanyong.wan's avatar
zhanyong.wan committed
185
 public:
186
  NaggyMock() : MockClass() {
Abseil Team's avatar
Abseil Team committed
187
188
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
189
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
190

Gennadiy Civil's avatar
 
Gennadiy Civil committed
191
192
193
194
195
  // Ideally, we would inherit base class's constructors through a using
  // declaration, which would preserve their visibility. However, many existing
  // tests rely on the fact that current implementation reexports protected
  // constructors as public. These tests would need to be cleaned up first.

Gennadiy Civil's avatar
Gennadiy Civil committed
196
197
198
  // Single argument constructor is special-cased so that it can be
  // made explicit.
  template <typename A>
199
  explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
Abseil Team's avatar
Abseil Team committed
200
201
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
202
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
203

204
205
206
  template <typename TArg1, typename TArg2, typename... An>
  NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
207
                  std::forward<An>(args)...) {
Abseil Team's avatar
Abseil Team committed
208
209
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
210
211
  }

zhanyong.wan's avatar
zhanyong.wan committed
212
213
214
215
 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
};

Gennadiy Civil's avatar
Gennadiy Civil committed
216
template <class MockClass>
Abseil Team's avatar
Abseil Team committed
217
218
219
class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
    : private internal::StrictMockImpl<MockClass>,
      public MockClass {
220
 public:
Abseil Team's avatar
Abseil Team committed
221
222
223
224
  static_assert(
      !internal::HasStrictnessModifier<MockClass>(),
      "Can't apply StrictMock to a class hierarchy that already has a "
      "strictness modifier. See "
Abseil Team's avatar
Abseil Team committed
225
226
      "https://google.github.io/googletest/"
      "gmock_cook_book.html#NiceStrictNaggy");
227
  StrictMock() : MockClass() {
Abseil Team's avatar
Abseil Team committed
228
229
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
230
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
231

Gennadiy Civil's avatar
 
Gennadiy Civil committed
232
233
234
235
236
  // Ideally, we would inherit base class's constructors through a using
  // declaration, which would preserve their visibility. However, many existing
  // tests rely on the fact that current implementation reexports protected
  // constructors as public. These tests would need to be cleaned up first.

Gennadiy Civil's avatar
Gennadiy Civil committed
237
238
239
  // Single argument constructor is special-cased so that it can be
  // made explicit.
  template <typename A>
240
  explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
Abseil Team's avatar
Abseil Team committed
241
242
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
243
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
244

245
246
247
  template <typename TArg1, typename TArg2, typename... An>
  StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
248
                  std::forward<An>(args)...) {
Abseil Team's avatar
Abseil Team committed
249
250
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
251
252
  }

253
254
 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
255
256
};

Abseil Team's avatar
Abseil Team committed
257
258
#undef GTEST_INTERNAL_EMPTY_BASE_CLASS

259
260
}  // namespace testing

Abseil Team's avatar
Abseil Team committed
261
#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_