googlemock/include/gmock/gmock-nice-strict.h

   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 // Implements class templates NiceMock, NaggyMock, and StrictMock.
  31 //
  32 // Given a mock class MockFoo that is created using Google Mock,
  33 // NiceMock<MockFoo> is a subclass of MockFoo that allows
  34 // uninteresting calls (i.e. calls to mock methods that have no
  35 // EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
  36 // that prints a warning when an uninteresting call occurs, and
  37 // StrictMock<MockFoo> is a subclass of MockFoo that treats all
  38 // uninteresting calls as errors.
  39 //
  40 // Currently a mock is naggy by default, so MockFoo and
  41 // NaggyMock<MockFoo> behave like the same.  However, we will soon
  42 // switch the default behavior of mocks to be nice, as that in general
  43 // leads to more maintainable tests.  When that happens, MockFoo will
  44 // stop behaving like NaggyMock<MockFoo> and start behaving like
  45 // NiceMock<MockFoo>.
  46 //
  47 // NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
  48 // their respective base class.  Therefore you can write
  49 // NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
  50 // has a constructor that accepts (int, const char*), for example.
  51 //
  52 // A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
  53 // and StrictMock<MockFoo> only works for mock methods defined using
  54 // the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
  55 // If a mock method is defined in a base class of MockFoo, the "nice"
  56 // or "strict" modifier may not affect it, depending on the compiler.
  57 // In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
  58 // supported.
  59
  60 // IWYU pragma: private, include "gmock/gmock.h"
  61 // IWYU pragma: friend gmock/.*
  62
  63 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
  64 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
  65
  66 #include <cstdint>
  67 #include <type_traits>
  68
  69 #include "gmock/gmock-spec-builders.h"
  70 #include "gmock/internal/gmock-port.h"
  71
  72 namespace testing {
  73 template <class MockClass>
  74 class NiceMock;
  75 template <class MockClass>
  76 class NaggyMock;
  77 template <class MockClass>
  78 class StrictMock;
  79
  80 namespace internal {
  81 template <typename T>
  82 std::true_type StrictnessModifierProbe(const NiceMock<T>&);
  83 template <typename T>
  84 std::true_type StrictnessModifierProbe(const NaggyMock<T>&);
  85 template <typename T>
  86 std::true_type StrictnessModifierProbe(const StrictMock<T>&);
  87 std::false_type StrictnessModifierProbe(...);
  88
  89 template <typename T>
  90 constexpr bool HasStrictnessModifier() {
  91   return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value;
  92 }
  93
  94 // Base classes that register and deregister with testing::Mock to alter the
  95 // default behavior around uninteresting calls. Inheriting from one of these
  96 // classes first and then MockClass ensures the MockClass constructor is run
  97 // after registration, and that the MockClass destructor runs before
  98 // deregistration. This guarantees that MockClass's constructor and destructor
  99 // run with the same level of strictness as its instance methods.
 100
 101 #if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW) && \
 102     (defined(_MSC_VER) || defined(__clang__))
 103 // We need to mark these classes with this declspec to ensure that
 104 // the empty base class optimization is performed.
 105 #define GTEST_INTERNAL_EMPTY_BASE_CLASS __declspec(empty_bases)
 106 #else
 107 #define GTEST_INTERNAL_EMPTY_BASE_CLASS
 108 #endif
 109
 110 template <typename Base>
 111 class NiceMockImpl {
 112  public:
 113   NiceMockImpl() {
 114     ::testing::Mock::AllowUninterestingCalls(reinterpret_cast<uintptr_t>(this));
 115   }
 116
 117   ~NiceMockImpl() {
 118     ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this));
 119   }
 120 };
 121
 122 template <typename Base>
 123 class NaggyMockImpl {
 124  public:
 125   NaggyMockImpl() {
 126     ::testing::Mock::WarnUninterestingCalls(reinterpret_cast<uintptr_t>(this));
 127   }
 128
 129   ~NaggyMockImpl() {
 130     ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this));
 131   }
 132 };
 133
 134 template <typename Base>
 135 class StrictMockImpl {
 136  public:
 137   StrictMockImpl() {
 138     ::testing::Mock::FailUninterestingCalls(reinterpret_cast<uintptr_t>(this));
 139   }
 140
 141   ~StrictMockImpl() {
 142     ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this));
 143   }
 144 };
 145
 146 }  // namespace internal
 147
 148 template <class MockClass>
 149 class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
 150     : private internal::NiceMockImpl<MockClass>,
 151       public MockClass {
 152  public:
 153   static_assert(!internal::HasStrictnessModifier<MockClass>(),
 154                 "Can't apply NiceMock to a class hierarchy that already has a "
 155                 "strictness modifier. See "
 156                 "https://google.github.io/googletest/"
 157                 "gmock_cook_book.html#NiceStrictNaggy");
 158   NiceMock() : MockClass() {
 159     static_assert(sizeof(*this) == sizeof(MockClass),
 160                   "The impl subclass shouldn't introduce any padding");
 161   }
 162
 163   // Ideally, we would inherit base class's constructors through a using
 164   // declaration, which would preserve their visibility. However, many existing
 165   // tests rely on the fact that current implementation reexports protected
 166   // constructors as public. These tests would need to be cleaned up first.
 167
 168   // Single argument constructor is special-cased so that it can be
 169   // made explicit.
 170   template <typename A>
 171   explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
 172     static_assert(sizeof(*this) == sizeof(MockClass),
 173                   "The impl subclass shouldn't introduce any padding");
 174   }
 175
 176   template <typename TArg1, typename TArg2, typename... An>
 177   NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
 178       : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
 179                   std::forward<An>(args)...) {
 180     static_assert(sizeof(*this) == sizeof(MockClass),
 181                   "The impl subclass shouldn't introduce any padding");
 182   }
 183
 184  private:
 185   NiceMock(const NiceMock&) = delete;
 186   NiceMock& operator=(const NiceMock&) = delete;
 187 };
 188
 189 template <class MockClass>
 190 class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
 191     : private internal::NaggyMockImpl<MockClass>,
 192       public MockClass {
 193   static_assert(!internal::HasStrictnessModifier<MockClass>(),
 194                 "Can't apply NaggyMock to a class hierarchy that already has a "
 195                 "strictness modifier. See "
 196                 "https://google.github.io/googletest/"
 197                 "gmock_cook_book.html#NiceStrictNaggy");
 198
 199  public:
 200   NaggyMock() : MockClass() {
 201     static_assert(sizeof(*this) == sizeof(MockClass),
 202                   "The impl subclass shouldn't introduce any padding");
 203   }
 204
 205   // Ideally, we would inherit base class's constructors through a using
 206   // declaration, which would preserve their visibility. However, many existing
 207   // tests rely on the fact that current implementation reexports protected
 208   // constructors as public. These tests would need to be cleaned up first.
 209
 210   // Single argument constructor is special-cased so that it can be
 211   // made explicit.
 212   template <typename A>
 213   explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
 214     static_assert(sizeof(*this) == sizeof(MockClass),
 215                   "The impl subclass shouldn't introduce any padding");
 216   }
 217
 218   template <typename TArg1, typename TArg2, typename... An>
 219   NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
 220       : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
 221                   std::forward<An>(args)...) {
 222     static_assert(sizeof(*this) == sizeof(MockClass),
 223                   "The impl subclass shouldn't introduce any padding");
 224   }
 225
 226  private:
 227   NaggyMock(const NaggyMock&) = delete;
 228   NaggyMock& operator=(const NaggyMock&) = delete;
 229 };
 230
 231 template <class MockClass>
 232 class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
 233     : private internal::StrictMockImpl<MockClass>,
 234       public MockClass {
 235  public:
 236   static_assert(
 237       !internal::HasStrictnessModifier<MockClass>(),
 238       "Can't apply StrictMock to a class hierarchy that already has a "
 239       "strictness modifier. See "
 240       "https://google.github.io/googletest/"
 241       "gmock_cook_book.html#NiceStrictNaggy");
 242   StrictMock() : MockClass() {
 243     static_assert(sizeof(*this) == sizeof(MockClass),
 244                   "The impl subclass shouldn't introduce any padding");
 245   }
 246
 247   // Ideally, we would inherit base class's constructors through a using
 248   // declaration, which would preserve their visibility. However, many existing
 249   // tests rely on the fact that current implementation reexports protected
 250   // constructors as public. These tests would need to be cleaned up first.
 251
 252   // Single argument constructor is special-cased so that it can be
 253   // made explicit.
 254   template <typename A>
 255   explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
 256     static_assert(sizeof(*this) == sizeof(MockClass),
 257                   "The impl subclass shouldn't introduce any padding");
 258   }
 259
 260   template <typename TArg1, typename TArg2, typename... An>
 261   StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
 262       : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
 263                   std::forward<An>(args)...) {
 264     static_assert(sizeof(*this) == sizeof(MockClass),
 265                   "The impl subclass shouldn't introduce any padding");
 266   }
 267
 268  private:
 269   StrictMock(const StrictMock&) = delete;
 270   StrictMock& operator=(const StrictMock&) = delete;
 271 };
 272
 273 #undef GTEST_INTERNAL_EMPTY_BASE_CLASS
 274
 275 }  // namespace testing
 276
 277 #endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_