diff options
| -rw-r--r-- | googlemock/include/gmock/gmock-generated-nice-strict.h.pump | 90 |
1 files changed, 60 insertions, 30 deletions
diff --git a/googlemock/include/gmock/gmock-generated-nice-strict.h.pump b/googlemock/include/gmock/gmock-generated-nice-strict.h.pump index 3ee1ce7f..4973c356 100644 --- a/googlemock/include/gmock/gmock-generated-nice-strict.h.pump +++ b/googlemock/include/gmock/gmock-generated-nice-strict.h.pump @@ -52,10 +52,9 @@ $var n = 10 $$ The maximum arity we support. // NiceMock<MockFoo>. // // NiceMock, NaggyMock, and StrictMock "inherit" the constructors of -// their respective base class, with up-to $n arguments. Therefore -// you can write NiceMock<MockFoo>(5, "a") to construct a nice mock -// where MockFoo has a constructor that accepts (int, const char*), -// for example. +// their respective base class. Therefore you can write +// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo +// has a constructor that accepts (int, const char*), for example. // // A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>, // and StrictMock<MockFoo> only works for mock methods defined using @@ -64,10 +63,6 @@ $var n = 10 $$ The maximum arity we support. // or "strict" modifier may not affect it, depending on the compiler. // In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT // supported. -// -// Another known limitation is that the constructors of the base mock -// cannot have arguments passed by non-const reference, which are -// banned by the Google C++ style guide anyway. #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ @@ -88,44 +83,79 @@ $var method=[[$if kind==0 [[AllowUninterestingCalls]] $elif kind==1 [[WarnUninterestingCalls]] $else [[FailUninterestingCalls]]]] +namespace internal { + +// $clazz[[]]Base serves as a mix-in to establish the "uninteresting call" +// behavior for $clazz on construction. It accomplishes this via CRTP to get +// access to the derived MockClass. +template <class MockClass> +class $clazz[[]]Base { + protected: + $clazz[[]]Base(); + + ~$clazz[[]]Base(); +}; + +} // namespace internal + template <class MockClass> -class $clazz : public MockClass { +class $clazz : public MockClass, public internal::$clazz[[]]Base<MockClass> { public: - // We don't factor out the constructor body to a common method, as - // we have to avoid a possible clash with members of MockClass. - $clazz() { - ::testing::Mock::$method( - internal::ImplicitCast_<MockClass*>(this)); - } - - // C++ doesn't (yet) allow inheritance of constructors, so we have - // to define it for each arity. + $clazz() : MockClass() {} + +#if GTEST_LANG_CXX11 + // Ideally, we would inherit base class's constructors through a using + // declaration, which would preserve their visibility. However, many existing + // tests rely on the fact that current implementation reexports protected + // constructors as public. These tests would need to be cleaned up first. + + // Single argument constructor is special-cased so that it can be + // made explicit. + template <typename A> + explicit $clazz(A&& arg) : MockClass(std::forward<A>(arg)) {} + + template <typename A1, typename A2, typename... An> + $clazz(A1&& arg1, A2&& arg2, An&&... args) + : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2), + std::forward<An>(args)...) {} +#else + // C++98 doesn't have variadic templates, so we have to define one + // for each arity. template <typename A1> - explicit $clazz(const A1& a1) : MockClass(a1) { - ::testing::Mock::$method( - internal::ImplicitCast_<MockClass*>(this)); - } + explicit $clazz(const A1& a1) : MockClass(a1) {} $range i 2..n $for i [[ $range j 1..i template <$for j, [[typename A$j]]> - $clazz($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) { - ::testing::Mock::$method( - internal::ImplicitCast_<MockClass*>(this)); - } + $clazz($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) {} ]] - virtual ~$clazz() { - ::testing::Mock::UnregisterCallReaction( - internal::ImplicitCast_<MockClass*>(this)); - } +#endif // GTEST_LANG_CXX11 private: GTEST_DISALLOW_COPY_AND_ASSIGN_($clazz); }; +namespace internal { + +template <typename MockClass> +$clazz[[]]Base<MockClass>::$clazz[[]]Base() { + ::testing::Mock::$method( + internal::ImplicitCast_<MockClass*>( + static_cast<$clazz<MockClass> *>(this))); +} + +template <typename MockClass> +$clazz[[]]Base<MockClass>::~$clazz[[]]Base() { + ::testing::Mock::UnregisterCallReaction( + internal::ImplicitCast_<MockClass*>( + static_cast<$clazz<MockClass>*>(this))); +} + +} // namespace internal + ]] // The following specializations catch some (relatively more common) |