1 // This file was GENERATED by command: 2 // pump.py gmock-generated-nice-strict.h.pump 3 // DO NOT EDIT BY HAND!!! 4 5 // Copyright 2008, Google Inc. 6 // All rights reserved. 7 // 8 // Redistribution and use in source and binary forms, with or without 9 // modification, are permitted provided that the following conditions are 10 // met: 11 // 12 // * Redistributions of source code must retain the above copyright 13 // notice, this list of conditions and the following disclaimer. 14 // * Redistributions in binary form must reproduce the above 15 // copyright notice, this list of conditions and the following disclaimer 16 // in the documentation and/or other materials provided with the 17 // distribution. 18 // * Neither the name of Google Inc. nor the names of its 19 // contributors may be used to endorse or promote products derived from 20 // this software without specific prior written permission. 21 // 22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 25 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 28 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 // 34 // Author: wan@google.com (Zhanyong Wan) 35 36 // Implements class templates NiceMock, NaggyMock, and StrictMock. 37 // 38 // Given a mock class MockFoo that is created using Google Mock, 39 // NiceMock<MockFoo> is a subclass of MockFoo that allows 40 // uninteresting calls (i.e. calls to mock methods that have no 41 // EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo 42 // that prints a warning when an uninteresting call occurs, and 43 // StrictMock<MockFoo> is a subclass of MockFoo that treats all 44 // uninteresting calls as errors. 45 // 46 // Currently a mock is naggy by default, so MockFoo and 47 // NaggyMock<MockFoo> behave like the same. However, we will soon 48 // switch the default behavior of mocks to be nice, as that in general 49 // leads to more maintainable tests. When that happens, MockFoo will 50 // stop behaving like NaggyMock<MockFoo> and start behaving like 51 // NiceMock<MockFoo>. 52 // 53 // NiceMock, NaggyMock, and StrictMock "inherit" the constructors of 54 // their respective base class, with up-to 10 arguments. Therefore 55 // you can write NiceMock<MockFoo>(5, "a") to construct a nice mock 56 // where MockFoo has a constructor that accepts (int, const char*), 57 // for example. 58 // 59 // A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>, 60 // and StrictMock<MockFoo> only works for mock methods defined using 61 // the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class. 62 // If a mock method is defined in a base class of MockFoo, the "nice" 63 // or "strict" modifier may not affect it, depending on the compiler. 64 // In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT 65 // supported. 66 // 67 // Another known limitation is that the constructors of the base mock 68 // cannot have arguments passed by non-const reference, which are 69 // banned by the Google C++ style guide anyway. 70 71 // IWYU pragma: private, include "gmock/gmock.h" 72 73 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ 74 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ 75 76 #include "gmock/gmock-spec-builders.h" 77 #include "gmock/internal/gmock-port.h" 78 79 namespace testing { 80 81 template <class MockClass> 82 class NiceMock : public MockClass { 83 public: 84 // We don't factor out the constructor body to a common method, as 85 // we have to avoid a possible clash with members of MockClass. NiceMock()86 NiceMock() { 87 ::testing::Mock::AllowUninterestingCalls( 88 internal::ImplicitCast_<MockClass*>(this)); 89 } 90 91 // C++ doesn't (yet) allow inheritance of constructors, so we have 92 // to define it for each arity. 93 template <typename A1> NiceMock(const A1 & a1)94 explicit NiceMock(const A1& a1) : MockClass(a1) { 95 ::testing::Mock::AllowUninterestingCalls( 96 internal::ImplicitCast_<MockClass*>(this)); 97 } 98 template <typename A1, typename A2> NiceMock(const A1 & a1,const A2 & a2)99 NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { 100 ::testing::Mock::AllowUninterestingCalls( 101 internal::ImplicitCast_<MockClass*>(this)); 102 } 103 104 template <typename A1, typename A2, typename A3> NiceMock(const A1 & a1,const A2 & a2,const A3 & a3)105 NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { 106 ::testing::Mock::AllowUninterestingCalls( 107 internal::ImplicitCast_<MockClass*>(this)); 108 } 109 110 template <typename A1, typename A2, typename A3, typename A4> NiceMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4)111 NiceMock(const A1& a1, const A2& a2, const A3& a3, 112 const A4& a4) : MockClass(a1, a2, a3, a4) { 113 ::testing::Mock::AllowUninterestingCalls( 114 internal::ImplicitCast_<MockClass*>(this)); 115 } 116 117 template <typename A1, typename A2, typename A3, typename A4, typename A5> NiceMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5)118 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 119 const A5& a5) : MockClass(a1, a2, a3, a4, a5) { 120 ::testing::Mock::AllowUninterestingCalls( 121 internal::ImplicitCast_<MockClass*>(this)); 122 } 123 124 template <typename A1, typename A2, typename A3, typename A4, typename A5, 125 typename A6> NiceMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6)126 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 127 const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) { 128 ::testing::Mock::AllowUninterestingCalls( 129 internal::ImplicitCast_<MockClass*>(this)); 130 } 131 132 template <typename A1, typename A2, typename A3, typename A4, typename A5, 133 typename A6, typename A7> NiceMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7)134 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 135 const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5, 136 a6, a7) { 137 ::testing::Mock::AllowUninterestingCalls( 138 internal::ImplicitCast_<MockClass*>(this)); 139 } 140 141 template <typename A1, typename A2, typename A3, typename A4, typename A5, 142 typename A6, typename A7, typename A8> NiceMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7,const A8 & a8)143 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 144 const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1, 145 a2, a3, a4, a5, a6, a7, a8) { 146 ::testing::Mock::AllowUninterestingCalls( 147 internal::ImplicitCast_<MockClass*>(this)); 148 } 149 150 template <typename A1, typename A2, typename A3, typename A4, typename A5, 151 typename A6, typename A7, typename A8, typename A9> NiceMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7,const A8 & a8,const A9 & a9)152 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 153 const A5& a5, const A6& a6, const A7& a7, const A8& a8, 154 const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) { 155 ::testing::Mock::AllowUninterestingCalls( 156 internal::ImplicitCast_<MockClass*>(this)); 157 } 158 159 template <typename A1, typename A2, typename A3, typename A4, typename A5, 160 typename A6, typename A7, typename A8, typename A9, typename A10> NiceMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7,const A8 & a8,const A9 & a9,const A10 & a10)161 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 162 const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, 163 const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { 164 ::testing::Mock::AllowUninterestingCalls( 165 internal::ImplicitCast_<MockClass*>(this)); 166 } 167 ~NiceMock()168 virtual ~NiceMock() { 169 ::testing::Mock::UnregisterCallReaction( 170 internal::ImplicitCast_<MockClass*>(this)); 171 } 172 173 private: 174 GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock); 175 }; 176 177 template <class MockClass> 178 class NaggyMock : public MockClass { 179 public: 180 // We don't factor out the constructor body to a common method, as 181 // we have to avoid a possible clash with members of MockClass. NaggyMock()182 NaggyMock() { 183 ::testing::Mock::WarnUninterestingCalls( 184 internal::ImplicitCast_<MockClass*>(this)); 185 } 186 187 // C++ doesn't (yet) allow inheritance of constructors, so we have 188 // to define it for each arity. 189 template <typename A1> NaggyMock(const A1 & a1)190 explicit NaggyMock(const A1& a1) : MockClass(a1) { 191 ::testing::Mock::WarnUninterestingCalls( 192 internal::ImplicitCast_<MockClass*>(this)); 193 } 194 template <typename A1, typename A2> NaggyMock(const A1 & a1,const A2 & a2)195 NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { 196 ::testing::Mock::WarnUninterestingCalls( 197 internal::ImplicitCast_<MockClass*>(this)); 198 } 199 200 template <typename A1, typename A2, typename A3> NaggyMock(const A1 & a1,const A2 & a2,const A3 & a3)201 NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { 202 ::testing::Mock::WarnUninterestingCalls( 203 internal::ImplicitCast_<MockClass*>(this)); 204 } 205 206 template <typename A1, typename A2, typename A3, typename A4> NaggyMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4)207 NaggyMock(const A1& a1, const A2& a2, const A3& a3, 208 const A4& a4) : MockClass(a1, a2, a3, a4) { 209 ::testing::Mock::WarnUninterestingCalls( 210 internal::ImplicitCast_<MockClass*>(this)); 211 } 212 213 template <typename A1, typename A2, typename A3, typename A4, typename A5> NaggyMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5)214 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 215 const A5& a5) : MockClass(a1, a2, a3, a4, a5) { 216 ::testing::Mock::WarnUninterestingCalls( 217 internal::ImplicitCast_<MockClass*>(this)); 218 } 219 220 template <typename A1, typename A2, typename A3, typename A4, typename A5, 221 typename A6> NaggyMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6)222 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 223 const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) { 224 ::testing::Mock::WarnUninterestingCalls( 225 internal::ImplicitCast_<MockClass*>(this)); 226 } 227 228 template <typename A1, typename A2, typename A3, typename A4, typename A5, 229 typename A6, typename A7> NaggyMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7)230 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 231 const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5, 232 a6, a7) { 233 ::testing::Mock::WarnUninterestingCalls( 234 internal::ImplicitCast_<MockClass*>(this)); 235 } 236 237 template <typename A1, typename A2, typename A3, typename A4, typename A5, 238 typename A6, typename A7, typename A8> NaggyMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7,const A8 & a8)239 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 240 const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1, 241 a2, a3, a4, a5, a6, a7, a8) { 242 ::testing::Mock::WarnUninterestingCalls( 243 internal::ImplicitCast_<MockClass*>(this)); 244 } 245 246 template <typename A1, typename A2, typename A3, typename A4, typename A5, 247 typename A6, typename A7, typename A8, typename A9> NaggyMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7,const A8 & a8,const A9 & a9)248 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 249 const A5& a5, const A6& a6, const A7& a7, const A8& a8, 250 const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) { 251 ::testing::Mock::WarnUninterestingCalls( 252 internal::ImplicitCast_<MockClass*>(this)); 253 } 254 255 template <typename A1, typename A2, typename A3, typename A4, typename A5, 256 typename A6, typename A7, typename A8, typename A9, typename A10> NaggyMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7,const A8 & a8,const A9 & a9,const A10 & a10)257 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 258 const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, 259 const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { 260 ::testing::Mock::WarnUninterestingCalls( 261 internal::ImplicitCast_<MockClass*>(this)); 262 } 263 ~NaggyMock()264 virtual ~NaggyMock() { 265 ::testing::Mock::UnregisterCallReaction( 266 internal::ImplicitCast_<MockClass*>(this)); 267 } 268 269 private: 270 GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock); 271 }; 272 273 template <class MockClass> 274 class StrictMock : public MockClass { 275 public: 276 // We don't factor out the constructor body to a common method, as 277 // we have to avoid a possible clash with members of MockClass. StrictMock()278 StrictMock() { 279 ::testing::Mock::FailUninterestingCalls( 280 internal::ImplicitCast_<MockClass*>(this)); 281 } 282 283 // C++ doesn't (yet) allow inheritance of constructors, so we have 284 // to define it for each arity. 285 template <typename A1> StrictMock(const A1 & a1)286 explicit StrictMock(const A1& a1) : MockClass(a1) { 287 ::testing::Mock::FailUninterestingCalls( 288 internal::ImplicitCast_<MockClass*>(this)); 289 } 290 template <typename A1, typename A2> StrictMock(const A1 & a1,const A2 & a2)291 StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { 292 ::testing::Mock::FailUninterestingCalls( 293 internal::ImplicitCast_<MockClass*>(this)); 294 } 295 296 template <typename A1, typename A2, typename A3> StrictMock(const A1 & a1,const A2 & a2,const A3 & a3)297 StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { 298 ::testing::Mock::FailUninterestingCalls( 299 internal::ImplicitCast_<MockClass*>(this)); 300 } 301 302 template <typename A1, typename A2, typename A3, typename A4> StrictMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4)303 StrictMock(const A1& a1, const A2& a2, const A3& a3, 304 const A4& a4) : MockClass(a1, a2, a3, a4) { 305 ::testing::Mock::FailUninterestingCalls( 306 internal::ImplicitCast_<MockClass*>(this)); 307 } 308 309 template <typename A1, typename A2, typename A3, typename A4, typename A5> StrictMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5)310 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 311 const A5& a5) : MockClass(a1, a2, a3, a4, a5) { 312 ::testing::Mock::FailUninterestingCalls( 313 internal::ImplicitCast_<MockClass*>(this)); 314 } 315 316 template <typename A1, typename A2, typename A3, typename A4, typename A5, 317 typename A6> StrictMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6)318 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 319 const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) { 320 ::testing::Mock::FailUninterestingCalls( 321 internal::ImplicitCast_<MockClass*>(this)); 322 } 323 324 template <typename A1, typename A2, typename A3, typename A4, typename A5, 325 typename A6, typename A7> StrictMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7)326 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 327 const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5, 328 a6, a7) { 329 ::testing::Mock::FailUninterestingCalls( 330 internal::ImplicitCast_<MockClass*>(this)); 331 } 332 333 template <typename A1, typename A2, typename A3, typename A4, typename A5, 334 typename A6, typename A7, typename A8> StrictMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7,const A8 & a8)335 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 336 const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1, 337 a2, a3, a4, a5, a6, a7, a8) { 338 ::testing::Mock::FailUninterestingCalls( 339 internal::ImplicitCast_<MockClass*>(this)); 340 } 341 342 template <typename A1, typename A2, typename A3, typename A4, typename A5, 343 typename A6, typename A7, typename A8, typename A9> StrictMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7,const A8 & a8,const A9 & a9)344 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 345 const A5& a5, const A6& a6, const A7& a7, const A8& a8, 346 const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) { 347 ::testing::Mock::FailUninterestingCalls( 348 internal::ImplicitCast_<MockClass*>(this)); 349 } 350 351 template <typename A1, typename A2, typename A3, typename A4, typename A5, 352 typename A6, typename A7, typename A8, typename A9, typename A10> StrictMock(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7,const A8 & a8,const A9 & a9,const A10 & a10)353 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 354 const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, 355 const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { 356 ::testing::Mock::FailUninterestingCalls( 357 internal::ImplicitCast_<MockClass*>(this)); 358 } 359 ~StrictMock()360 virtual ~StrictMock() { 361 ::testing::Mock::UnregisterCallReaction( 362 internal::ImplicitCast_<MockClass*>(this)); 363 } 364 365 private: 366 GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock); 367 }; 368 369 // The following specializations catch some (relatively more common) 370 // user errors of nesting nice and strict mocks. They do NOT catch 371 // all possible errors. 372 373 // These specializations are declared but not defined, as NiceMock, 374 // NaggyMock, and StrictMock cannot be nested. 375 376 template <typename MockClass> 377 class NiceMock<NiceMock<MockClass> >; 378 template <typename MockClass> 379 class NiceMock<NaggyMock<MockClass> >; 380 template <typename MockClass> 381 class NiceMock<StrictMock<MockClass> >; 382 383 template <typename MockClass> 384 class NaggyMock<NiceMock<MockClass> >; 385 template <typename MockClass> 386 class NaggyMock<NaggyMock<MockClass> >; 387 template <typename MockClass> 388 class NaggyMock<StrictMock<MockClass> >; 389 390 template <typename MockClass> 391 class StrictMock<NiceMock<MockClass> >; 392 template <typename MockClass> 393 class StrictMock<NaggyMock<MockClass> >; 394 template <typename MockClass> 395 class StrictMock<StrictMock<MockClass> >; 396 397 } // namespace testing 398 399 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ 400