github.com/jlmucb/cloudproxy@v0.0.0-20170830161738-b5aa0b619bc4/src/third_party/googlemock/include/gmock/gmock-generated-nice-strict.h (about)

     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  
    77  namespace testing {
    78  
    79  template <class MockClass>
    80  class 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  
   175  template <class MockClass>
   176  class 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  
   271  template <class MockClass>
   272  class 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  
   374  template <typename MockClass>
   375  class NiceMock<NiceMock<MockClass> >;
   376  template <typename MockClass>
   377  class NiceMock<NaggyMock<MockClass> >;
   378  template <typename MockClass>
   379  class NiceMock<StrictMock<MockClass> >;
   380  
   381  template <typename MockClass>
   382  class NaggyMock<NiceMock<MockClass> >;
   383  template <typename MockClass>
   384  class NaggyMock<NaggyMock<MockClass> >;
   385  template <typename MockClass>
   386  class NaggyMock<StrictMock<MockClass> >;
   387  
   388  template <typename MockClass>
   389  class StrictMock<NiceMock<MockClass> >;
   390  template <typename MockClass>
   391  class StrictMock<NaggyMock<MockClass> >;
   392  template <typename MockClass>
   393  class StrictMock<StrictMock<MockClass> >;
   394  
   395  }  // namespace testing
   396  
   397  #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_