1 // This file was GENERATED by a script. DO NOT EDIT BY HAND!!! 2 3 // Copyright 2008, Google Inc. 4 // All rights reserved. 5 // 6 // Redistribution and use in source and binary forms, with or without 7 // modification, are permitted provided that the following conditions are 8 // met: 9 // 10 // * Redistributions of source code must retain the above copyright 11 // notice, this list of conditions and the following disclaimer. 12 // * Redistributions in binary form must reproduce the above 13 // copyright notice, this list of conditions and the following disclaimer 14 // in the documentation and/or other materials provided with the 15 // distribution. 16 // * Neither the name of Google Inc. nor the names of its 17 // contributors may be used to endorse or promote products derived from 18 // this software without specific prior written permission. 19 // 20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 // 32 // Author: wan (at) google.com (Zhanyong Wan) 33 34 // Implements class templates NiceMock and StrictMock. 35 // 36 // Given a mock class MockFoo that is created using Google Mock, 37 // NiceMock<MockFoo> is a subclass of MockFoo that allows 38 // uninteresting calls (i.e. calls to mock methods that have no 39 // EXPECT_CALL specs), and StrictMock<MockFoo> is a subclass of 40 // MockFoo that treats all uninteresting calls as errors. 41 // 42 // NiceMock and StrictMock "inherits" the constructors of their 43 // respective base class, with up-to 10 arguments. Therefore you can 44 // write NiceMock<MockFoo>(5, "a") to construct a nice mock where 45 // MockFoo has a constructor that accepts (int, const char*), for 46 // example. 47 // 48 // A known limitation is that NiceMock<MockFoo> and 49 // StrictMock<MockFoo> only works for mock methods defined using the 50 // MOCK_METHOD* family of macros DIRECTLY in the MockFoo class. If a 51 // mock method is defined in a base class of MockFoo, the "nice" or 52 // "strict" modifier may not affect it, depending on the compiler. In 53 // particular, nesting NiceMock and StrictMock is NOT supported. 54 // 55 // Another known limitation is that the constructors of the base mock 56 // cannot have arguments passed by non-const reference, which are 57 // banned by the Google C++ style guide anyway. 58 59 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ 60 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ 61 62 #include "gmock/gmock-spec-builders.h" 63 #include "gmock/internal/gmock-port.h" 64 65 namespace testing { 66 67 template <class MockClass> 68 class NiceMock : public MockClass { 69 public: 70 // We don't factor out the constructor body to a common method, as 71 // we have to avoid a possible clash with members of MockClass. 72 NiceMock() { 73 ::testing::Mock::AllowUninterestingCalls( 74 internal::ImplicitCast_<MockClass*>(this)); 75 } 76 77 // C++ doesn't (yet) allow inheritance of constructors, so we have 78 // to define it for each arity. 79 template <typename A1> 80 explicit NiceMock(const A1& a1) : MockClass(a1) { 81 ::testing::Mock::AllowUninterestingCalls( 82 internal::ImplicitCast_<MockClass*>(this)); 83 } 84 template <typename A1, typename A2> 85 NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { 86 ::testing::Mock::AllowUninterestingCalls( 87 internal::ImplicitCast_<MockClass*>(this)); 88 } 89 90 template <typename A1, typename A2, typename A3> 91 NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { 92 ::testing::Mock::AllowUninterestingCalls( 93 internal::ImplicitCast_<MockClass*>(this)); 94 } 95 96 template <typename A1, typename A2, typename A3, typename A4> 97 NiceMock(const A1& a1, const A2& a2, const A3& a3, 98 const A4& a4) : MockClass(a1, a2, a3, a4) { 99 ::testing::Mock::AllowUninterestingCalls( 100 internal::ImplicitCast_<MockClass*>(this)); 101 } 102 103 template <typename A1, typename A2, typename A3, typename A4, typename A5> 104 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 105 const A5& a5) : MockClass(a1, a2, a3, a4, a5) { 106 ::testing::Mock::AllowUninterestingCalls( 107 internal::ImplicitCast_<MockClass*>(this)); 108 } 109 110 template <typename A1, typename A2, typename A3, typename A4, typename A5, 111 typename A6> 112 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 113 const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) { 114 ::testing::Mock::AllowUninterestingCalls( 115 internal::ImplicitCast_<MockClass*>(this)); 116 } 117 118 template <typename A1, typename A2, typename A3, typename A4, typename A5, 119 typename A6, typename A7> 120 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 121 const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5, 122 a6, a7) { 123 ::testing::Mock::AllowUninterestingCalls( 124 internal::ImplicitCast_<MockClass*>(this)); 125 } 126 127 template <typename A1, typename A2, typename A3, typename A4, typename A5, 128 typename A6, typename A7, typename A8> 129 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 130 const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1, 131 a2, a3, a4, a5, a6, a7, a8) { 132 ::testing::Mock::AllowUninterestingCalls( 133 internal::ImplicitCast_<MockClass*>(this)); 134 } 135 136 template <typename A1, typename A2, typename A3, typename A4, typename A5, 137 typename A6, typename A7, typename A8, typename A9> 138 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 139 const A5& a5, const A6& a6, const A7& a7, const A8& a8, 140 const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) { 141 ::testing::Mock::AllowUninterestingCalls( 142 internal::ImplicitCast_<MockClass*>(this)); 143 } 144 145 template <typename A1, typename A2, typename A3, typename A4, typename A5, 146 typename A6, typename A7, typename A8, typename A9, typename A10> 147 NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 148 const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, 149 const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { 150 ::testing::Mock::AllowUninterestingCalls( 151 internal::ImplicitCast_<MockClass*>(this)); 152 } 153 154 virtual ~NiceMock() { 155 ::testing::Mock::UnregisterCallReaction( 156 internal::ImplicitCast_<MockClass*>(this)); 157 } 158 159 private: 160 GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock); 161 }; 162 163 template <class MockClass> 164 class StrictMock : public MockClass { 165 public: 166 // We don't factor out the constructor body to a common method, as 167 // we have to avoid a possible clash with members of MockClass. 168 StrictMock() { 169 ::testing::Mock::FailUninterestingCalls( 170 internal::ImplicitCast_<MockClass*>(this)); 171 } 172 173 template <typename A1> 174 explicit StrictMock(const A1& a1) : MockClass(a1) { 175 ::testing::Mock::FailUninterestingCalls( 176 internal::ImplicitCast_<MockClass*>(this)); 177 } 178 template <typename A1, typename A2> 179 StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { 180 ::testing::Mock::FailUninterestingCalls( 181 internal::ImplicitCast_<MockClass*>(this)); 182 } 183 184 template <typename A1, typename A2, typename A3> 185 StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { 186 ::testing::Mock::FailUninterestingCalls( 187 internal::ImplicitCast_<MockClass*>(this)); 188 } 189 190 template <typename A1, typename A2, typename A3, typename A4> 191 StrictMock(const A1& a1, const A2& a2, const A3& a3, 192 const A4& a4) : MockClass(a1, a2, a3, a4) { 193 ::testing::Mock::FailUninterestingCalls( 194 internal::ImplicitCast_<MockClass*>(this)); 195 } 196 197 template <typename A1, typename A2, typename A3, typename A4, typename A5> 198 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 199 const A5& a5) : MockClass(a1, a2, a3, a4, a5) { 200 ::testing::Mock::FailUninterestingCalls( 201 internal::ImplicitCast_<MockClass*>(this)); 202 } 203 204 template <typename A1, typename A2, typename A3, typename A4, typename A5, 205 typename A6> 206 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 207 const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) { 208 ::testing::Mock::FailUninterestingCalls( 209 internal::ImplicitCast_<MockClass*>(this)); 210 } 211 212 template <typename A1, typename A2, typename A3, typename A4, typename A5, 213 typename A6, typename A7> 214 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 215 const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5, 216 a6, a7) { 217 ::testing::Mock::FailUninterestingCalls( 218 internal::ImplicitCast_<MockClass*>(this)); 219 } 220 221 template <typename A1, typename A2, typename A3, typename A4, typename A5, 222 typename A6, typename A7, typename A8> 223 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 224 const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1, 225 a2, a3, a4, a5, a6, a7, a8) { 226 ::testing::Mock::FailUninterestingCalls( 227 internal::ImplicitCast_<MockClass*>(this)); 228 } 229 230 template <typename A1, typename A2, typename A3, typename A4, typename A5, 231 typename A6, typename A7, typename A8, typename A9> 232 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 233 const A5& a5, const A6& a6, const A7& a7, const A8& a8, 234 const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) { 235 ::testing::Mock::FailUninterestingCalls( 236 internal::ImplicitCast_<MockClass*>(this)); 237 } 238 239 template <typename A1, typename A2, typename A3, typename A4, typename A5, 240 typename A6, typename A7, typename A8, typename A9, typename A10> 241 StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 242 const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, 243 const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { 244 ::testing::Mock::FailUninterestingCalls( 245 internal::ImplicitCast_<MockClass*>(this)); 246 } 247 248 virtual ~StrictMock() { 249 ::testing::Mock::UnregisterCallReaction( 250 internal::ImplicitCast_<MockClass*>(this)); 251 } 252 253 private: 254 GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock); 255 }; 256 257 // The following specializations catch some (relatively more common) 258 // user errors of nesting nice and strict mocks. They do NOT catch 259 // all possible errors. 260 261 // These specializations are declared but not defined, as NiceMock and 262 // StrictMock cannot be nested. 263 template <typename MockClass> 264 class NiceMock<NiceMock<MockClass> >; 265 template <typename MockClass> 266 class NiceMock<StrictMock<MockClass> >; 267 template <typename MockClass> 268 class StrictMock<NiceMock<MockClass> >; 269 template <typename MockClass> 270 class StrictMock<StrictMock<MockClass> >; 271 272 } // namespace testing 273 274 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ 275
