gmock-nice-strict.h 8.76 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 GMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
#define GMOCK_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
93
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;
}

}  // namespace internal
94
95

template <class MockClass>
96
class NiceMock : public MockClass {
97
 public:
Abseil Team's avatar
Abseil Team committed
98
99
100
101
102
103
  static_assert(
      !internal::HasStrictnessModifier<MockClass>(),
      "Can't apply NiceMock to a class hierarchy that already has a "
      "strictness modifier. See "
      "https://github.com/google/googletest/blob/master/googlemock/docs/"
      "cook_book.md#the-nice-the-strict-and-the-naggy-nicestrictnaggy");
104
105
106
107
  NiceMock() : MockClass() {
    ::testing::Mock::AllowUninterestingCalls(
        internal::ImplicitCast_<MockClass*>(this));
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
108

Gennadiy Civil's avatar
 
Gennadiy Civil committed
109
110
111
112
113
  // 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
114
115
116
  // Single argument constructor is special-cased so that it can be
  // made explicit.
  template <typename A>
117
118
119
120
  explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
    ::testing::Mock::AllowUninterestingCalls(
        internal::ImplicitCast_<MockClass*>(this));
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
121

122
123
124
  template <typename TArg1, typename TArg2, typename... An>
  NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
125
126
127
128
                  std::forward<An>(args)...) {
    ::testing::Mock::AllowUninterestingCalls(
        internal::ImplicitCast_<MockClass*>(this));
  }
129

Abseil Team's avatar
Abseil Team committed
130
  ~NiceMock() {  // NOLINT
131
132
133
134
    ::testing::Mock::UnregisterCallReaction(
        internal::ImplicitCast_<MockClass*>(this));
  }

135
136
 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
137
138
};

zhanyong.wan's avatar
zhanyong.wan committed
139
template <class MockClass>
140
class NaggyMock : public MockClass {
Abseil Team's avatar
Abseil Team committed
141
142
143
144
145
146
147
  static_assert(
      !internal::HasStrictnessModifier<MockClass>(),
      "Can't apply NaggyMock to a class hierarchy that already has a "
      "strictness modifier. See "
      "https://github.com/google/googletest/blob/master/googlemock/docs/"
      "cook_book.md#the-nice-the-strict-and-the-naggy-nicestrictnaggy");

zhanyong.wan's avatar
zhanyong.wan committed
148
 public:
149
150
151
152
  NaggyMock() : MockClass() {
    ::testing::Mock::WarnUninterestingCalls(
        internal::ImplicitCast_<MockClass*>(this));
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
153

Gennadiy Civil's avatar
 
Gennadiy Civil committed
154
155
156
157
158
  // 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
159
160
161
  // Single argument constructor is special-cased so that it can be
  // made explicit.
  template <typename A>
162
163
164
165
  explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
    ::testing::Mock::WarnUninterestingCalls(
        internal::ImplicitCast_<MockClass*>(this));
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
166

167
168
169
  template <typename TArg1, typename TArg2, typename... An>
  NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
170
171
172
173
                  std::forward<An>(args)...) {
    ::testing::Mock::WarnUninterestingCalls(
        internal::ImplicitCast_<MockClass*>(this));
  }
zhanyong.wan's avatar
zhanyong.wan committed
174

Abseil Team's avatar
Abseil Team committed
175
  ~NaggyMock() {  // NOLINT
176
177
178
179
    ::testing::Mock::UnregisterCallReaction(
        internal::ImplicitCast_<MockClass*>(this));
  }

zhanyong.wan's avatar
zhanyong.wan committed
180
181
182
183
 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
};

Gennadiy Civil's avatar
Gennadiy Civil committed
184
template <class MockClass>
185
class StrictMock : public MockClass {
186
 public:
Abseil Team's avatar
Abseil Team committed
187
188
189
190
191
192
  static_assert(
      !internal::HasStrictnessModifier<MockClass>(),
      "Can't apply StrictMock to a class hierarchy that already has a "
      "strictness modifier. See "
      "https://github.com/google/googletest/blob/master/googlemock/docs/"
      "cook_book.md#the-nice-the-strict-and-the-naggy-nicestrictnaggy");
193
194
195
196
  StrictMock() : MockClass() {
    ::testing::Mock::FailUninterestingCalls(
        internal::ImplicitCast_<MockClass*>(this));
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
197

Gennadiy Civil's avatar
 
Gennadiy Civil committed
198
199
200
201
202
  // 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
203
204
205
  // Single argument constructor is special-cased so that it can be
  // made explicit.
  template <typename A>
206
207
208
209
  explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
    ::testing::Mock::FailUninterestingCalls(
        internal::ImplicitCast_<MockClass*>(this));
  }
Gennadiy Civil's avatar
Gennadiy Civil committed
210

211
212
213
  template <typename TArg1, typename TArg2, typename... An>
  StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
214
215
216
217
                  std::forward<An>(args)...) {
    ::testing::Mock::FailUninterestingCalls(
        internal::ImplicitCast_<MockClass*>(this));
  }
218

Abseil Team's avatar
Abseil Team committed
219
  ~StrictMock() {  // NOLINT
220
221
222
223
    ::testing::Mock::UnregisterCallReaction(
        internal::ImplicitCast_<MockClass*>(this));
  }

224
225
 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
226
227
228
229
};

}  // namespace testing

Abseil Team's avatar
Abseil Team committed
230
#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_