gmock-nice-strict.h 10.3 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

30

zhanyong.wan's avatar
zhanyong.wan committed
31
// Implements class templates NiceMock, NaggyMock, and StrictMock.
32
33
34
35
//
// 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
36
37
38
39
// 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.
40
//
zhanyong.wan's avatar
zhanyong.wan committed
41
42
43
44
45
46
// 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>.
47
//
zhanyong.wan's avatar
zhanyong.wan committed
48
// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
Gennadiy Civil's avatar
Gennadiy Civil committed
49
50
51
// 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
52
53
54
55
56
57
58
59
//
// 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.
60

Gennadiy Civil's avatar
 
Gennadiy Civil committed
61
62
// GOOGLETEST_CM0002 DO NOT DELETE

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
  static_assert(
      !internal::HasStrictnessModifier<MockClass>(),
      "Can't apply NiceMock to a class hierarchy that already has a "
      "strictness modifier. See "
144
145
      "https://github.com/google/googletest/blob/master/docs/"
      "gmock_cook_book.md#the-nice-the-strict-and-the-naggy-nicestrictnaggy");
146
  NiceMock() : MockClass() {
Abseil Team's avatar
Abseil Team committed
147
148
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
149
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
150

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

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

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

zhanyong.wan's avatar
zhanyong.wan committed
176
template <class MockClass>
Abseil Team's avatar
Abseil Team committed
177
178
179
class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
    : private internal::NaggyMockImpl<MockClass>,
      public MockClass {
Abseil Team's avatar
Abseil Team committed
180
181
182
183
  static_assert(
      !internal::HasStrictnessModifier<MockClass>(),
      "Can't apply NaggyMock to a class hierarchy that already has a "
      "strictness modifier. See "
184
185
      "https://github.com/google/googletest/blob/master/docs/"
      "gmock_cook_book.md#the-nice-the-strict-and-the-naggy-nicestrictnaggy");
Abseil Team's avatar
Abseil Team committed
186

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

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

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

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

Gennadiy Civil's avatar
Gennadiy Civil committed
218
template <class MockClass>
Abseil Team's avatar
Abseil Team committed
219
220
221
class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
    : private internal::StrictMockImpl<MockClass>,
      public MockClass {
222
 public:
Abseil Team's avatar
Abseil Team committed
223
224
225
226
  static_assert(
      !internal::HasStrictnessModifier<MockClass>(),
      "Can't apply StrictMock to a class hierarchy that already has a "
      "strictness modifier. See "
227
228
      "https://github.com/google/googletest/blob/master/docs/"
      "gmock_cook_book.md#the-nice-the-strict-and-the-naggy-nicestrictnaggy");
229
  StrictMock() : MockClass() {
Abseil Team's avatar
Abseil Team committed
230
231
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
232
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
233

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

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

255
256
 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
257
258
};

Abseil Team's avatar
Abseil Team committed
259
260
#undef GTEST_INTERNAL_EMPTY_BASE_CLASS

261
262
}  // namespace testing

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