Back to home page

sPhenix code displayed by LXR
 
 

    

File indexing completed on 2025-08-07 08:19:52 

0001 // This file was GENERATED by command:
0002 //     pump.py gmock-generated-nice-strict.h.pump
0003 // DO NOT EDIT BY HAND!!!
0004 
0005 // Copyright 2008, Google Inc.
0006 // All rights reserved.
0007 //
0008 // Redistribution and use in source and binary forms, with or without
0009 // modification, are permitted provided that the following conditions are
0010 // met:
0011 //
0012 //     * Redistributions of source code must retain the above copyright
0013 // notice, this list of conditions and the following disclaimer.
0014 //     * Redistributions in binary form must reproduce the above
0015 // copyright notice, this list of conditions and the following disclaimer
0016 // in the documentation and/or other materials provided with the
0017 // distribution.
0018 //     * Neither the name of Google Inc. nor the names of its
0019 // contributors may be used to endorse or promote products derived from
0020 // this software without specific prior written permission.
0021 //
0022 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
0023 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
0024 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
0025 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
0026 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
0027 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
0028 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
0029 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
0030 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
0031 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
0032 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
0033 //
0034 // Author: wan@google.com (Zhanyong Wan)
0035 
0036 // Implements class templates NiceMock, NaggyMock, and StrictMock.
0037 //
0038 // Given a mock class MockFoo that is created using Google Mock,
0039 // NiceMock<MockFoo> is a subclass of MockFoo that allows
0040 // uninteresting calls (i.e. calls to mock methods that have no
0041 // EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
0042 // that prints a warning when an uninteresting call occurs, and
0043 // StrictMock<MockFoo> is a subclass of MockFoo that treats all
0044 // uninteresting calls as errors.
0045 //
0046 // Currently a mock is naggy by default, so MockFoo and
0047 // NaggyMock<MockFoo> behave like the same.  However, we will soon
0048 // switch the default behavior of mocks to be nice, as that in general
0049 // leads to more maintainable tests.  When that happens, MockFoo will
0050 // stop behaving like NaggyMock<MockFoo> and start behaving like
0051 // NiceMock<MockFoo>.
0052 //
0053 // NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
0054 // their respective base class, with up-to 10 arguments.  Therefore
0055 // you can write NiceMock<MockFoo>(5, "a") to construct a nice mock
0056 // where MockFoo has a constructor that accepts (int, const char*),
0057 // for example.
0058 //
0059 // A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
0060 // and StrictMock<MockFoo> only works for mock methods defined using
0061 // the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
0062 // If a mock method is defined in a base class of MockFoo, the "nice"
0063 // or "strict" modifier may not affect it, depending on the compiler.
0064 // In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
0065 // supported.
0066 //
0067 // Another known limitation is that the constructors of the base mock
0068 // cannot have arguments passed by non-const reference, which are
0069 // banned by the Google C++ style guide anyway.
0070 
0071 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
0072 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
0073 
0074 #include "gmock/gmock-spec-builders.h"
0075 #include "gmock/internal/gmock-port.h"
0076 
0077 namespace testing {
0078 
0079 template <class MockClass>
0080 class NiceMock : public MockClass {
0081  public:
0082   // We don't factor out the constructor body to a common method, as
0083   // we have to avoid a possible clash with members of MockClass.
0084   NiceMock() {
0085     ::testing::Mock::AllowUninterestingCalls(
0086         internal::ImplicitCast_<MockClass*>(this));
0087   }
0088 
0089   // C++ doesn't (yet) allow inheritance of constructors, so we have
0090   // to define it for each arity.
0091   template <typename A1>
0092   explicit NiceMock(const A1& a1) : MockClass(a1) {
0093     ::testing::Mock::AllowUninterestingCalls(
0094         internal::ImplicitCast_<MockClass*>(this));
0095   }
0096   template <typename A1, typename A2>
0097   NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
0098     ::testing::Mock::AllowUninterestingCalls(
0099         internal::ImplicitCast_<MockClass*>(this));
0100   }
0101 
0102   template <typename A1, typename A2, typename A3>
0103   NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
0104     ::testing::Mock::AllowUninterestingCalls(
0105         internal::ImplicitCast_<MockClass*>(this));
0106   }
0107 
0108   template <typename A1, typename A2, typename A3, typename A4>
0109   NiceMock(const A1& a1, const A2& a2, const A3& a3,
0110       const A4& a4) : MockClass(a1, a2, a3, a4) {
0111     ::testing::Mock::AllowUninterestingCalls(
0112         internal::ImplicitCast_<MockClass*>(this));
0113   }
0114 
0115   template <typename A1, typename A2, typename A3, typename A4, typename A5>
0116   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0117       const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
0118     ::testing::Mock::AllowUninterestingCalls(
0119         internal::ImplicitCast_<MockClass*>(this));
0120   }
0121 
0122   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0123       typename A6>
0124   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0125       const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
0126     ::testing::Mock::AllowUninterestingCalls(
0127         internal::ImplicitCast_<MockClass*>(this));
0128   }
0129 
0130   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0131       typename A6, typename A7>
0132   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0133       const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
0134       a6, a7) {
0135     ::testing::Mock::AllowUninterestingCalls(
0136         internal::ImplicitCast_<MockClass*>(this));
0137   }
0138 
0139   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0140       typename A6, typename A7, typename A8>
0141   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0142       const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
0143       a2, a3, a4, a5, a6, a7, a8) {
0144     ::testing::Mock::AllowUninterestingCalls(
0145         internal::ImplicitCast_<MockClass*>(this));
0146   }
0147 
0148   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0149       typename A6, typename A7, typename A8, typename A9>
0150   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0151       const A5& a5, const A6& a6, const A7& a7, const A8& a8,
0152       const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
0153     ::testing::Mock::AllowUninterestingCalls(
0154         internal::ImplicitCast_<MockClass*>(this));
0155   }
0156 
0157   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0158       typename A6, typename A7, typename A8, typename A9, typename A10>
0159   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0160       const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
0161       const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
0162     ::testing::Mock::AllowUninterestingCalls(
0163         internal::ImplicitCast_<MockClass*>(this));
0164   }
0165 
0166   virtual ~NiceMock() {
0167     ::testing::Mock::UnregisterCallReaction(
0168         internal::ImplicitCast_<MockClass*>(this));
0169   }
0170 
0171  private:
0172   GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
0173 };
0174 
0175 template <class MockClass>
0176 class NaggyMock : public MockClass {
0177  public:
0178   // We don't factor out the constructor body to a common method, as
0179   // we have to avoid a possible clash with members of MockClass.
0180   NaggyMock() {
0181     ::testing::Mock::WarnUninterestingCalls(
0182         internal::ImplicitCast_<MockClass*>(this));
0183   }
0184 
0185   // C++ doesn't (yet) allow inheritance of constructors, so we have
0186   // to define it for each arity.
0187   template <typename A1>
0188   explicit NaggyMock(const A1& a1) : MockClass(a1) {
0189     ::testing::Mock::WarnUninterestingCalls(
0190         internal::ImplicitCast_<MockClass*>(this));
0191   }
0192   template <typename A1, typename A2>
0193   NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
0194     ::testing::Mock::WarnUninterestingCalls(
0195         internal::ImplicitCast_<MockClass*>(this));
0196   }
0197 
0198   template <typename A1, typename A2, typename A3>
0199   NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
0200     ::testing::Mock::WarnUninterestingCalls(
0201         internal::ImplicitCast_<MockClass*>(this));
0202   }
0203 
0204   template <typename A1, typename A2, typename A3, typename A4>
0205   NaggyMock(const A1& a1, const A2& a2, const A3& a3,
0206       const A4& a4) : MockClass(a1, a2, a3, a4) {
0207     ::testing::Mock::WarnUninterestingCalls(
0208         internal::ImplicitCast_<MockClass*>(this));
0209   }
0210 
0211   template <typename A1, typename A2, typename A3, typename A4, typename A5>
0212   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0213       const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
0214     ::testing::Mock::WarnUninterestingCalls(
0215         internal::ImplicitCast_<MockClass*>(this));
0216   }
0217 
0218   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0219       typename A6>
0220   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0221       const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
0222     ::testing::Mock::WarnUninterestingCalls(
0223         internal::ImplicitCast_<MockClass*>(this));
0224   }
0225 
0226   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0227       typename A6, typename A7>
0228   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0229       const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
0230       a6, a7) {
0231     ::testing::Mock::WarnUninterestingCalls(
0232         internal::ImplicitCast_<MockClass*>(this));
0233   }
0234 
0235   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0236       typename A6, typename A7, typename A8>
0237   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0238       const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
0239       a2, a3, a4, a5, a6, a7, a8) {
0240     ::testing::Mock::WarnUninterestingCalls(
0241         internal::ImplicitCast_<MockClass*>(this));
0242   }
0243 
0244   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0245       typename A6, typename A7, typename A8, typename A9>
0246   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0247       const A5& a5, const A6& a6, const A7& a7, const A8& a8,
0248       const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
0249     ::testing::Mock::WarnUninterestingCalls(
0250         internal::ImplicitCast_<MockClass*>(this));
0251   }
0252 
0253   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0254       typename A6, typename A7, typename A8, typename A9, typename A10>
0255   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0256       const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
0257       const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
0258     ::testing::Mock::WarnUninterestingCalls(
0259         internal::ImplicitCast_<MockClass*>(this));
0260   }
0261 
0262   virtual ~NaggyMock() {
0263     ::testing::Mock::UnregisterCallReaction(
0264         internal::ImplicitCast_<MockClass*>(this));
0265   }
0266 
0267  private:
0268   GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
0269 };
0270 
0271 template <class MockClass>
0272 class StrictMock : public MockClass {
0273  public:
0274   // We don't factor out the constructor body to a common method, as
0275   // we have to avoid a possible clash with members of MockClass.
0276   StrictMock() {
0277     ::testing::Mock::FailUninterestingCalls(
0278         internal::ImplicitCast_<MockClass*>(this));
0279   }
0280 
0281   // C++ doesn't (yet) allow inheritance of constructors, so we have
0282   // to define it for each arity.
0283   template <typename A1>
0284   explicit StrictMock(const A1& a1) : MockClass(a1) {
0285     ::testing::Mock::FailUninterestingCalls(
0286         internal::ImplicitCast_<MockClass*>(this));
0287   }
0288   template <typename A1, typename A2>
0289   StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
0290     ::testing::Mock::FailUninterestingCalls(
0291         internal::ImplicitCast_<MockClass*>(this));
0292   }
0293 
0294   template <typename A1, typename A2, typename A3>
0295   StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
0296     ::testing::Mock::FailUninterestingCalls(
0297         internal::ImplicitCast_<MockClass*>(this));
0298   }
0299 
0300   template <typename A1, typename A2, typename A3, typename A4>
0301   StrictMock(const A1& a1, const A2& a2, const A3& a3,
0302       const A4& a4) : MockClass(a1, a2, a3, a4) {
0303     ::testing::Mock::FailUninterestingCalls(
0304         internal::ImplicitCast_<MockClass*>(this));
0305   }
0306 
0307   template <typename A1, typename A2, typename A3, typename A4, typename A5>
0308   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0309       const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
0310     ::testing::Mock::FailUninterestingCalls(
0311         internal::ImplicitCast_<MockClass*>(this));
0312   }
0313 
0314   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0315       typename A6>
0316   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0317       const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
0318     ::testing::Mock::FailUninterestingCalls(
0319         internal::ImplicitCast_<MockClass*>(this));
0320   }
0321 
0322   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0323       typename A6, typename A7>
0324   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0325       const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
0326       a6, a7) {
0327     ::testing::Mock::FailUninterestingCalls(
0328         internal::ImplicitCast_<MockClass*>(this));
0329   }
0330 
0331   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0332       typename A6, typename A7, typename A8>
0333   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0334       const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
0335       a2, a3, a4, a5, a6, a7, a8) {
0336     ::testing::Mock::FailUninterestingCalls(
0337         internal::ImplicitCast_<MockClass*>(this));
0338   }
0339 
0340   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0341       typename A6, typename A7, typename A8, typename A9>
0342   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0343       const A5& a5, const A6& a6, const A7& a7, const A8& a8,
0344       const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
0345     ::testing::Mock::FailUninterestingCalls(
0346         internal::ImplicitCast_<MockClass*>(this));
0347   }
0348 
0349   template <typename A1, typename A2, typename A3, typename A4, typename A5,
0350       typename A6, typename A7, typename A8, typename A9, typename A10>
0351   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
0352       const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
0353       const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
0354     ::testing::Mock::FailUninterestingCalls(
0355         internal::ImplicitCast_<MockClass*>(this));
0356   }
0357 
0358   virtual ~StrictMock() {
0359     ::testing::Mock::UnregisterCallReaction(
0360         internal::ImplicitCast_<MockClass*>(this));
0361   }
0362 
0363  private:
0364   GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
0365 };
0366 
0367 // The following specializations catch some (relatively more common)
0368 // user errors of nesting nice and strict mocks.  They do NOT catch
0369 // all possible errors.
0370 
0371 // These specializations are declared but not defined, as NiceMock,
0372 // NaggyMock, and StrictMock cannot be nested.
0373 
0374 template <typename MockClass>
0375 class NiceMock<NiceMock<MockClass> >;
0376 template <typename MockClass>
0377 class NiceMock<NaggyMock<MockClass> >;
0378 template <typename MockClass>
0379 class NiceMock<StrictMock<MockClass> >;
0380 
0381 template <typename MockClass>
0382 class NaggyMock<NiceMock<MockClass> >;
0383 template <typename MockClass>
0384 class NaggyMock<NaggyMock<MockClass> >;
0385 template <typename MockClass>
0386 class NaggyMock<StrictMock<MockClass> >;
0387 
0388 template <typename MockClass>
0389 class StrictMock<NiceMock<MockClass> >;
0390 template <typename MockClass>
0391 class StrictMock<NaggyMock<MockClass> >;
0392 template <typename MockClass>
0393 class StrictMock<StrictMock<MockClass> >;
0394 
0395 }  // namespace testing
0396 
0397 #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!