?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download | RSS feed

  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.  
  35. // Implements class templates NiceMock, NaggyMock, and StrictMock.
  36. //
  37. // Given a mock class MockFoo that is created using Google Mock,
  38. // NiceMock<MockFoo> is a subclass of MockFoo that allows
  39. // uninteresting calls (i.e. calls to mock methods that have no
  40. // EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
  41. // that prints a warning when an uninteresting call occurs, and
  42. // StrictMock<MockFoo> is a subclass of MockFoo that treats all
  43. // uninteresting calls as errors.
  44. //
  45. // Currently a mock is naggy by default, so MockFoo and
  46. // NaggyMock<MockFoo> behave like the same.  However, we will soon
  47. // switch the default behavior of mocks to be nice, as that in general
  48. // leads to more maintainable tests.  When that happens, MockFoo will
  49. // stop behaving like NaggyMock<MockFoo> and start behaving like
  50. // NiceMock<MockFoo>.
  51. //
  52. // NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
  53. // their respective base class.  Therefore you can write
  54. // NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
  55. // has a constructor that accepts (int, const char*), for example.
  56. //
  57. // A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
  58. // and StrictMock<MockFoo> only works for mock methods defined using
  59. // the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
  60. // If a mock method is defined in a base class of MockFoo, the "nice"
  61. // or "strict" modifier may not affect it, depending on the compiler.
  62. // In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
  63. // supported.
  64.  
  65. // GOOGLETEST_CM0002 DO NOT DELETE
  66.  
  67. #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
  68. #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
  69.  
  70. #include "gmock/gmock-spec-builders.h"
  71. #include "gmock/internal/gmock-port.h"
  72.  
  73. namespace testing {
  74.  
  75. template <class MockClass>
  76. class NiceMock : public MockClass {
  77.  public:
  78.   NiceMock() : MockClass() {
  79.     ::testing::Mock::AllowUninterestingCalls(
  80.         internal::ImplicitCast_<MockClass*>(this));
  81.   }
  82.  
  83. #if GTEST_LANG_CXX11
  84.   // Ideally, we would inherit base class's constructors through a using
  85.   // declaration, which would preserve their visibility. However, many existing
  86.   // tests rely on the fact that current implementation reexports protected
  87.   // constructors as public. These tests would need to be cleaned up first.
  88.  
  89.   // Single argument constructor is special-cased so that it can be
  90.   // made explicit.
  91.   template <typename A>
  92.   explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
  93.     ::testing::Mock::AllowUninterestingCalls(
  94.         internal::ImplicitCast_<MockClass*>(this));
  95.   }
  96.  
  97.   template <typename A1, typename A2, typename... An>
  98.   NiceMock(A1&& arg1, A2&& arg2, An&&... args)
  99.       : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2),
  100.                   std::forward<An>(args)...) {
  101.     ::testing::Mock::AllowUninterestingCalls(
  102.         internal::ImplicitCast_<MockClass*>(this));
  103.   }
  104. #else
  105.   // C++98 doesn't have variadic templates, so we have to define one
  106.   // for each arity.
  107.   template <typename A1>
  108.   explicit NiceMock(const A1& a1) : MockClass(a1) {
  109.     ::testing::Mock::AllowUninterestingCalls(
  110.         internal::ImplicitCast_<MockClass*>(this));
  111.   }
  112.   template <typename A1, typename A2>
  113.   NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
  114.     ::testing::Mock::AllowUninterestingCalls(
  115.         internal::ImplicitCast_<MockClass*>(this));
  116.   }
  117.  
  118.   template <typename A1, typename A2, typename A3>
  119.   NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
  120.     ::testing::Mock::AllowUninterestingCalls(
  121.         internal::ImplicitCast_<MockClass*>(this));
  122.   }
  123.  
  124.   template <typename A1, typename A2, typename A3, typename A4>
  125.   NiceMock(const A1& a1, const A2& a2, const A3& a3,
  126.       const A4& a4) : MockClass(a1, a2, a3, a4) {
  127.     ::testing::Mock::AllowUninterestingCalls(
  128.         internal::ImplicitCast_<MockClass*>(this));
  129.   }
  130.  
  131.   template <typename A1, typename A2, typename A3, typename A4, typename A5>
  132.   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  133.       const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
  134.     ::testing::Mock::AllowUninterestingCalls(
  135.         internal::ImplicitCast_<MockClass*>(this));
  136.   }
  137.  
  138.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  139.       typename A6>
  140.   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  141.       const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
  142.     ::testing::Mock::AllowUninterestingCalls(
  143.         internal::ImplicitCast_<MockClass*>(this));
  144.   }
  145.  
  146.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  147.       typename A6, typename A7>
  148.   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  149.       const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
  150.       a6, a7) {
  151.     ::testing::Mock::AllowUninterestingCalls(
  152.         internal::ImplicitCast_<MockClass*>(this));
  153.   }
  154.  
  155.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  156.       typename A6, typename A7, typename A8>
  157.   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  158.       const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
  159.       a2, a3, a4, a5, a6, a7, a8) {
  160.     ::testing::Mock::AllowUninterestingCalls(
  161.         internal::ImplicitCast_<MockClass*>(this));
  162.   }
  163.  
  164.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  165.       typename A6, typename A7, typename A8, typename A9>
  166.   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  167.       const A5& a5, const A6& a6, const A7& a7, const A8& a8,
  168.       const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
  169.     ::testing::Mock::AllowUninterestingCalls(
  170.         internal::ImplicitCast_<MockClass*>(this));
  171.   }
  172.  
  173.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  174.       typename A6, typename A7, typename A8, typename A9, typename A10>
  175.   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  176.       const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
  177.       const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
  178.     ::testing::Mock::AllowUninterestingCalls(
  179.         internal::ImplicitCast_<MockClass*>(this));
  180.   }
  181.  
  182. #endif  // GTEST_LANG_CXX11
  183.  
  184.   ~NiceMock() {
  185.     ::testing::Mock::UnregisterCallReaction(
  186.         internal::ImplicitCast_<MockClass*>(this));
  187.   }
  188.  
  189.  private:
  190.   GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
  191. };
  192.  
  193. template <class MockClass>
  194. class NaggyMock : public MockClass {
  195.  public:
  196.   NaggyMock() : MockClass() {
  197.     ::testing::Mock::WarnUninterestingCalls(
  198.         internal::ImplicitCast_<MockClass*>(this));
  199.   }
  200.  
  201. #if GTEST_LANG_CXX11
  202.   // Ideally, we would inherit base class's constructors through a using
  203.   // declaration, which would preserve their visibility. However, many existing
  204.   // tests rely on the fact that current implementation reexports protected
  205.   // constructors as public. These tests would need to be cleaned up first.
  206.  
  207.   // Single argument constructor is special-cased so that it can be
  208.   // made explicit.
  209.   template <typename A>
  210.   explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
  211.     ::testing::Mock::WarnUninterestingCalls(
  212.         internal::ImplicitCast_<MockClass*>(this));
  213.   }
  214.  
  215.   template <typename A1, typename A2, typename... An>
  216.   NaggyMock(A1&& arg1, A2&& arg2, An&&... args)
  217.       : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2),
  218.                   std::forward<An>(args)...) {
  219.     ::testing::Mock::WarnUninterestingCalls(
  220.         internal::ImplicitCast_<MockClass*>(this));
  221.   }
  222. #else
  223.   // C++98 doesn't have variadic templates, so we have to define one
  224.   // for each arity.
  225.   template <typename A1>
  226.   explicit NaggyMock(const A1& a1) : MockClass(a1) {
  227.     ::testing::Mock::WarnUninterestingCalls(
  228.         internal::ImplicitCast_<MockClass*>(this));
  229.   }
  230.   template <typename A1, typename A2>
  231.   NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
  232.     ::testing::Mock::WarnUninterestingCalls(
  233.         internal::ImplicitCast_<MockClass*>(this));
  234.   }
  235.  
  236.   template <typename A1, typename A2, typename A3>
  237.   NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
  238.     ::testing::Mock::WarnUninterestingCalls(
  239.         internal::ImplicitCast_<MockClass*>(this));
  240.   }
  241.  
  242.   template <typename A1, typename A2, typename A3, typename A4>
  243.   NaggyMock(const A1& a1, const A2& a2, const A3& a3,
  244.       const A4& a4) : MockClass(a1, a2, a3, a4) {
  245.     ::testing::Mock::WarnUninterestingCalls(
  246.         internal::ImplicitCast_<MockClass*>(this));
  247.   }
  248.  
  249.   template <typename A1, typename A2, typename A3, typename A4, typename A5>
  250.   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  251.       const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
  252.     ::testing::Mock::WarnUninterestingCalls(
  253.         internal::ImplicitCast_<MockClass*>(this));
  254.   }
  255.  
  256.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  257.       typename A6>
  258.   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  259.       const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
  260.     ::testing::Mock::WarnUninterestingCalls(
  261.         internal::ImplicitCast_<MockClass*>(this));
  262.   }
  263.  
  264.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  265.       typename A6, typename A7>
  266.   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  267.       const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
  268.       a6, a7) {
  269.     ::testing::Mock::WarnUninterestingCalls(
  270.         internal::ImplicitCast_<MockClass*>(this));
  271.   }
  272.  
  273.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  274.       typename A6, typename A7, typename A8>
  275.   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  276.       const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
  277.       a2, a3, a4, a5, a6, a7, a8) {
  278.     ::testing::Mock::WarnUninterestingCalls(
  279.         internal::ImplicitCast_<MockClass*>(this));
  280.   }
  281.  
  282.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  283.       typename A6, typename A7, typename A8, typename A9>
  284.   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  285.       const A5& a5, const A6& a6, const A7& a7, const A8& a8,
  286.       const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
  287.     ::testing::Mock::WarnUninterestingCalls(
  288.         internal::ImplicitCast_<MockClass*>(this));
  289.   }
  290.  
  291.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  292.       typename A6, typename A7, typename A8, typename A9, typename A10>
  293.   NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  294.       const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
  295.       const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
  296.     ::testing::Mock::WarnUninterestingCalls(
  297.         internal::ImplicitCast_<MockClass*>(this));
  298.   }
  299.  
  300. #endif  // GTEST_LANG_CXX11
  301.  
  302.   ~NaggyMock() {
  303.     ::testing::Mock::UnregisterCallReaction(
  304.         internal::ImplicitCast_<MockClass*>(this));
  305.   }
  306.  
  307.  private:
  308.   GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
  309. };
  310.  
  311. template <class MockClass>
  312. class StrictMock : public MockClass {
  313.  public:
  314.   StrictMock() : MockClass() {
  315.     ::testing::Mock::FailUninterestingCalls(
  316.         internal::ImplicitCast_<MockClass*>(this));
  317.   }
  318.  
  319. #if GTEST_LANG_CXX11
  320.   // Ideally, we would inherit base class's constructors through a using
  321.   // declaration, which would preserve their visibility. However, many existing
  322.   // tests rely on the fact that current implementation reexports protected
  323.   // constructors as public. These tests would need to be cleaned up first.
  324.  
  325.   // Single argument constructor is special-cased so that it can be
  326.   // made explicit.
  327.   template <typename A>
  328.   explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
  329.     ::testing::Mock::FailUninterestingCalls(
  330.         internal::ImplicitCast_<MockClass*>(this));
  331.   }
  332.  
  333.   template <typename A1, typename A2, typename... An>
  334.   StrictMock(A1&& arg1, A2&& arg2, An&&... args)
  335.       : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2),
  336.                   std::forward<An>(args)...) {
  337.     ::testing::Mock::FailUninterestingCalls(
  338.         internal::ImplicitCast_<MockClass*>(this));
  339.   }
  340. #else
  341.   // C++98 doesn't have variadic templates, so we have to define one
  342.   // for each arity.
  343.   template <typename A1>
  344.   explicit StrictMock(const A1& a1) : MockClass(a1) {
  345.     ::testing::Mock::FailUninterestingCalls(
  346.         internal::ImplicitCast_<MockClass*>(this));
  347.   }
  348.   template <typename A1, typename A2>
  349.   StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
  350.     ::testing::Mock::FailUninterestingCalls(
  351.         internal::ImplicitCast_<MockClass*>(this));
  352.   }
  353.  
  354.   template <typename A1, typename A2, typename A3>
  355.   StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
  356.     ::testing::Mock::FailUninterestingCalls(
  357.         internal::ImplicitCast_<MockClass*>(this));
  358.   }
  359.  
  360.   template <typename A1, typename A2, typename A3, typename A4>
  361.   StrictMock(const A1& a1, const A2& a2, const A3& a3,
  362.       const A4& a4) : MockClass(a1, a2, a3, a4) {
  363.     ::testing::Mock::FailUninterestingCalls(
  364.         internal::ImplicitCast_<MockClass*>(this));
  365.   }
  366.  
  367.   template <typename A1, typename A2, typename A3, typename A4, typename A5>
  368.   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  369.       const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
  370.     ::testing::Mock::FailUninterestingCalls(
  371.         internal::ImplicitCast_<MockClass*>(this));
  372.   }
  373.  
  374.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  375.       typename A6>
  376.   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  377.       const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
  378.     ::testing::Mock::FailUninterestingCalls(
  379.         internal::ImplicitCast_<MockClass*>(this));
  380.   }
  381.  
  382.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  383.       typename A6, typename A7>
  384.   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  385.       const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
  386.       a6, a7) {
  387.     ::testing::Mock::FailUninterestingCalls(
  388.         internal::ImplicitCast_<MockClass*>(this));
  389.   }
  390.  
  391.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  392.       typename A6, typename A7, typename A8>
  393.   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  394.       const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
  395.       a2, a3, a4, a5, a6, a7, a8) {
  396.     ::testing::Mock::FailUninterestingCalls(
  397.         internal::ImplicitCast_<MockClass*>(this));
  398.   }
  399.  
  400.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  401.       typename A6, typename A7, typename A8, typename A9>
  402.   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  403.       const A5& a5, const A6& a6, const A7& a7, const A8& a8,
  404.       const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
  405.     ::testing::Mock::FailUninterestingCalls(
  406.         internal::ImplicitCast_<MockClass*>(this));
  407.   }
  408.  
  409.   template <typename A1, typename A2, typename A3, typename A4, typename A5,
  410.       typename A6, typename A7, typename A8, typename A9, typename A10>
  411.   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
  412.       const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
  413.       const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
  414.     ::testing::Mock::FailUninterestingCalls(
  415.         internal::ImplicitCast_<MockClass*>(this));
  416.   }
  417.  
  418. #endif  // GTEST_LANG_CXX11
  419.  
  420.   ~StrictMock() {
  421.     ::testing::Mock::UnregisterCallReaction(
  422.         internal::ImplicitCast_<MockClass*>(this));
  423.   }
  424.  
  425.  private:
  426.   GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
  427. };
  428.  
  429. // The following specializations catch some (relatively more common)
  430. // user errors of nesting nice and strict mocks.  They do NOT catch
  431. // all possible errors.
  432.  
  433. // These specializations are declared but not defined, as NiceMock,
  434. // NaggyMock, and StrictMock cannot be nested.
  435.  
  436. template <typename MockClass>
  437. class NiceMock<NiceMock<MockClass> >;
  438. template <typename MockClass>
  439. class NiceMock<NaggyMock<MockClass> >;
  440. template <typename MockClass>
  441. class NiceMock<StrictMock<MockClass> >;
  442.  
  443. template <typename MockClass>
  444. class NaggyMock<NiceMock<MockClass> >;
  445. template <typename MockClass>
  446. class NaggyMock<NaggyMock<MockClass> >;
  447. template <typename MockClass>
  448. class NaggyMock<StrictMock<MockClass> >;
  449.  
  450. template <typename MockClass>
  451. class StrictMock<NiceMock<MockClass> >;
  452. template <typename MockClass>
  453. class StrictMock<NaggyMock<MockClass> >;
  454. template <typename MockClass>
  455. class StrictMock<StrictMock<MockClass> >;
  456.  
  457. }  // namespace testing
  458.  
  459. #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
  460.