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#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ 72#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ 73 74#include "gmock/gmock-spec-builders.h" 75#include "gmock/internal/gmock-port.h" 76 77namespace testing { 78 79template <class MockClass> 80class NiceMock : public MockClass { 81 public: 82 // We don't factor out the constructor body to a common method, as 83 // we have to avoid a possible clash with members of MockClass. 84 NiceMock() { 85 ::testing::Mock::AllowUninterestingCalls( 86 internal::ImplicitCast_<MockClass*>(this)); 87 } 88 89 // C++ doesn't (yet) allow inheritance of constructors, so we have 90 // to define it for each arity. 91 template <typename A1> 92 explicit NiceMock(const A1& a1) : MockClass(a1) { 93 ::testing::Mock::AllowUninterestingCalls( 94 internal::ImplicitCast_<MockClass*>(this)); 95 } 96 template <typename A1, typename A2> 97 NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { 98 ::testing::Mock::AllowUninterestingCalls( 99 internal::ImplicitCast_<MockClass*>(this)); 100 } 101 102 template <typename A1, typename A2, typename A3> 103 NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { 104 ::testing::Mock::AllowUninterestingCalls( 105 internal::ImplicitCast_<MockClass*>(this)); 106 } 107 108 template <typename A1, typename A2, typename A3, typename A4> 109 NiceMock(const A1& a1, const A2& a2, const A3& a3, 110 const A4& a4) : MockClass(a1, a2, a3, a4) { 111 ::testing::Mock::AllowUninterestingCalls( 112 internal::ImplicitCast_<MockClass*>(this)); 113 } 114 115 template <typename A1, typename A2, typename A3, typename A4, typename A5> 116 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 117 const A5& a5) : MockClass(a1, a2, a3, a4, a5) { 118 ::testing::Mock::AllowUninterestingCalls( 119 internal::ImplicitCast_<MockClass*>(this)); 120 } 121 122 template <typename A1, typename A2, typename A3, typename A4, typename A5, 123 typename A6> 124 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 125 const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) { 126 ::testing::Mock::AllowUninterestingCalls( 127 internal::ImplicitCast_<MockClass*>(this)); 128 } 129 130 template <typename A1, typename A2, typename A3, typename A4, typename A5, 131 typename A6, typename A7> 132 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 133 const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5, 134 a6, a7) { 135 ::testing::Mock::AllowUninterestingCalls( 136 internal::ImplicitCast_<MockClass*>(this)); 137 } 138 139 template <typename A1, typename A2, typename A3, typename A4, typename A5, 140 typename A6, typename A7, typename A8> 141 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 142 const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1, 143 a2, a3, a4, a5, a6, a7, a8) { 144 ::testing::Mock::AllowUninterestingCalls( 145 internal::ImplicitCast_<MockClass*>(this)); 146 } 147 148 template <typename A1, typename A2, typename A3, typename A4, typename A5, 149 typename A6, typename A7, typename A8, typename A9> 150 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 151 const A5& a5, const A6& a6, const A7& a7, const A8& a8, 152 const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) { 153 ::testing::Mock::AllowUninterestingCalls( 154 internal::ImplicitCast_<MockClass*>(this)); 155 } 156 157 template <typename A1, typename A2, typename A3, typename A4, typename A5, 158 typename A6, typename A7, typename A8, typename A9, typename A10> 159 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 160 const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, 161 const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { 162 ::testing::Mock::AllowUninterestingCalls( 163 internal::ImplicitCast_<MockClass*>(this)); 164 } 165 166 virtual ~NiceMock() { 167 ::testing::Mock::UnregisterCallReaction( 168 internal::ImplicitCast_<MockClass*>(this)); 169 } 170 171 private: 172 GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock); 173}; 174 175template <class MockClass> 176class NaggyMock : public MockClass { 177 public: 178 // We don't factor out the constructor body to a common method, as 179 // we have to avoid a possible clash with members of MockClass. 180 NaggyMock() { 181 ::testing::Mock::WarnUninterestingCalls( 182 internal::ImplicitCast_<MockClass*>(this)); 183 } 184 185 // C++ doesn't (yet) allow inheritance of constructors, so we have 186 // to define it for each arity. 187 template <typename A1> 188 explicit NaggyMock(const A1& a1) : MockClass(a1) { 189 ::testing::Mock::WarnUninterestingCalls( 190 internal::ImplicitCast_<MockClass*>(this)); 191 } 192 template <typename A1, typename A2> 193 NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { 194 ::testing::Mock::WarnUninterestingCalls( 195 internal::ImplicitCast_<MockClass*>(this)); 196 } 197 198 template <typename A1, typename A2, typename A3> 199 NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { 200 ::testing::Mock::WarnUninterestingCalls( 201 internal::ImplicitCast_<MockClass*>(this)); 202 } 203 204 template <typename A1, typename A2, typename A3, typename A4> 205 NaggyMock(const A1& a1, const A2& a2, const A3& a3, 206 const A4& a4) : MockClass(a1, a2, a3, a4) { 207 ::testing::Mock::WarnUninterestingCalls( 208 internal::ImplicitCast_<MockClass*>(this)); 209 } 210 211 template <typename A1, typename A2, typename A3, typename A4, typename A5> 212 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 213 const A5& a5) : MockClass(a1, a2, a3, a4, a5) { 214 ::testing::Mock::WarnUninterestingCalls( 215 internal::ImplicitCast_<MockClass*>(this)); 216 } 217 218 template <typename A1, typename A2, typename A3, typename A4, typename A5, 219 typename A6> 220 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 221 const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) { 222 ::testing::Mock::WarnUninterestingCalls( 223 internal::ImplicitCast_<MockClass*>(this)); 224 } 225 226 template <typename A1, typename A2, typename A3, typename A4, typename A5, 227 typename A6, typename A7> 228 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 229 const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5, 230 a6, a7) { 231 ::testing::Mock::WarnUninterestingCalls( 232 internal::ImplicitCast_<MockClass*>(this)); 233 } 234 235 template <typename A1, typename A2, typename A3, typename A4, typename A5, 236 typename A6, typename A7, typename A8> 237 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 238 const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1, 239 a2, a3, a4, a5, a6, a7, a8) { 240 ::testing::Mock::WarnUninterestingCalls( 241 internal::ImplicitCast_<MockClass*>(this)); 242 } 243 244 template <typename A1, typename A2, typename A3, typename A4, typename A5, 245 typename A6, typename A7, typename A8, typename A9> 246 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 247 const A5& a5, const A6& a6, const A7& a7, const A8& a8, 248 const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) { 249 ::testing::Mock::WarnUninterestingCalls( 250 internal::ImplicitCast_<MockClass*>(this)); 251 } 252 253 template <typename A1, typename A2, typename A3, typename A4, typename A5, 254 typename A6, typename A7, typename A8, typename A9, typename A10> 255 NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 256 const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, 257 const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { 258 ::testing::Mock::WarnUninterestingCalls( 259 internal::ImplicitCast_<MockClass*>(this)); 260 } 261 262 virtual ~NaggyMock() { 263 ::testing::Mock::UnregisterCallReaction( 264 internal::ImplicitCast_<MockClass*>(this)); 265 } 266 267 private: 268 GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock); 269}; 270 271template <class MockClass> 272class StrictMock : public MockClass { 273 public: 274 // We don't factor out the constructor body to a common method, as 275 // we have to avoid a possible clash with members of MockClass. 276 StrictMock() { 277 ::testing::Mock::FailUninterestingCalls( 278 internal::ImplicitCast_<MockClass*>(this)); 279 } 280 281 // C++ doesn't (yet) allow inheritance of constructors, so we have 282 // to define it for each arity. 283 template <typename A1> 284 explicit StrictMock(const A1& a1) : MockClass(a1) { 285 ::testing::Mock::FailUninterestingCalls( 286 internal::ImplicitCast_<MockClass*>(this)); 287 } 288 template <typename A1, typename A2> 289 StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { 290 ::testing::Mock::FailUninterestingCalls( 291 internal::ImplicitCast_<MockClass*>(this)); 292 } 293 294 template <typename A1, typename A2, typename A3> 295 StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { 296 ::testing::Mock::FailUninterestingCalls( 297 internal::ImplicitCast_<MockClass*>(this)); 298 } 299 300 template <typename A1, typename A2, typename A3, typename A4> 301 StrictMock(const A1& a1, const A2& a2, const A3& a3, 302 const A4& a4) : MockClass(a1, a2, a3, a4) { 303 ::testing::Mock::FailUninterestingCalls( 304 internal::ImplicitCast_<MockClass*>(this)); 305 } 306 307 template <typename A1, typename A2, typename A3, typename A4, typename A5> 308 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 309 const A5& a5) : MockClass(a1, a2, a3, a4, a5) { 310 ::testing::Mock::FailUninterestingCalls( 311 internal::ImplicitCast_<MockClass*>(this)); 312 } 313 314 template <typename A1, typename A2, typename A3, typename A4, typename A5, 315 typename A6> 316 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 317 const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) { 318 ::testing::Mock::FailUninterestingCalls( 319 internal::ImplicitCast_<MockClass*>(this)); 320 } 321 322 template <typename A1, typename A2, typename A3, typename A4, typename A5, 323 typename A6, typename A7> 324 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 325 const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5, 326 a6, a7) { 327 ::testing::Mock::FailUninterestingCalls( 328 internal::ImplicitCast_<MockClass*>(this)); 329 } 330 331 template <typename A1, typename A2, typename A3, typename A4, typename A5, 332 typename A6, typename A7, typename A8> 333 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 334 const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1, 335 a2, a3, a4, a5, a6, a7, a8) { 336 ::testing::Mock::FailUninterestingCalls( 337 internal::ImplicitCast_<MockClass*>(this)); 338 } 339 340 template <typename A1, typename A2, typename A3, typename A4, typename A5, 341 typename A6, typename A7, typename A8, typename A9> 342 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 343 const A5& a5, const A6& a6, const A7& a7, const A8& a8, 344 const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) { 345 ::testing::Mock::FailUninterestingCalls( 346 internal::ImplicitCast_<MockClass*>(this)); 347 } 348 349 template <typename A1, typename A2, typename A3, typename A4, typename A5, 350 typename A6, typename A7, typename A8, typename A9, typename A10> 351 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 352 const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, 353 const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { 354 ::testing::Mock::FailUninterestingCalls( 355 internal::ImplicitCast_<MockClass*>(this)); 356 } 357 358 virtual ~StrictMock() { 359 ::testing::Mock::UnregisterCallReaction( 360 internal::ImplicitCast_<MockClass*>(this)); 361 } 362 363 private: 364 GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock); 365}; 366 367// The following specializations catch some (relatively more common) 368// user errors of nesting nice and strict mocks. They do NOT catch 369// all possible errors. 370 371// These specializations are declared but not defined, as NiceMock, 372// NaggyMock, and StrictMock cannot be nested. 373 374template <typename MockClass> 375class NiceMock<NiceMock<MockClass> >; 376template <typename MockClass> 377class NiceMock<NaggyMock<MockClass> >; 378template <typename MockClass> 379class NiceMock<StrictMock<MockClass> >; 380 381template <typename MockClass> 382class NaggyMock<NiceMock<MockClass> >; 383template <typename MockClass> 384class NaggyMock<NaggyMock<MockClass> >; 385template <typename MockClass> 386class NaggyMock<StrictMock<MockClass> >; 387 388template <typename MockClass> 389class StrictMock<NiceMock<MockClass> >; 390template <typename MockClass> 391class StrictMock<NaggyMock<MockClass> >; 392template <typename MockClass> 393class StrictMock<StrictMock<MockClass> >; 394 395} // namespace testing 396 397#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ 398