Differential D18622 Diff 52199 google/googletest/dist/googlemock/include/gmock/gmock-generated-function-mockers.h.pump
Changeset View
Changeset View
Standalone View
Standalone View
google/googletest/dist/googlemock/include/gmock/gmock-generated-function-mockers.h.pump
- This file was added.
$$ -*- mode: c++; -*- | |||||
$$ This is a Pump source file. Please use Pump to convert | |||||
$$ it to gmock-generated-function-mockers.h. | |||||
$$ | |||||
$var n = 10 $$ The maximum arity we support. | |||||
// Copyright 2007, Google Inc. | |||||
// All rights reserved. | |||||
// | |||||
// Redistribution and use in source and binary forms, with or without | |||||
// modification, are permitted provided that the following conditions are | |||||
// met: | |||||
// | |||||
// * Redistributions of source code must retain the above copyright | |||||
// notice, this list of conditions and the following disclaimer. | |||||
// * Redistributions in binary form must reproduce the above | |||||
// copyright notice, this list of conditions and the following disclaimer | |||||
// in the documentation and/or other materials provided with the | |||||
// distribution. | |||||
// * Neither the name of Google Inc. nor the names of its | |||||
// contributors may be used to endorse or promote products derived from | |||||
// this software without specific prior written permission. | |||||
// | |||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |||||
// Google Mock - a framework for writing C++ mock classes. | |||||
// | |||||
// This file implements function mockers of various arities. | |||||
// GOOGLETEST_CM0002 DO NOT DELETE | |||||
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ | |||||
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ | |||||
#include "gmock/gmock-spec-builders.h" | |||||
#include "gmock/internal/gmock-internal-utils.h" | |||||
#if GTEST_HAS_STD_FUNCTION_ | |||||
# include <functional> | |||||
#endif | |||||
namespace testing { | |||||
namespace internal { | |||||
template <typename F> | |||||
class FunctionMockerBase; | |||||
// Note: class FunctionMocker really belongs to the ::testing | |||||
// namespace. However if we define it in ::testing, MSVC will | |||||
// complain when classes in ::testing::internal declare it as a | |||||
// friend class template. To workaround this compiler bug, we define | |||||
// FunctionMocker in ::testing::internal and import it into ::testing. | |||||
template <typename F> | |||||
class FunctionMocker; | |||||
$range i 0..n | |||||
$for i [[ | |||||
$range j 1..i | |||||
$var typename_As = [[$for j [[, typename A$j]]]] | |||||
$var As = [[$for j, [[A$j]]]] | |||||
$var as = [[$for j, [[internal::forward<A$j>(a$j)]]]] | |||||
$var Aas = [[$for j, [[A$j a$j]]]] | |||||
$var ms = [[$for j, [[m$j]]]] | |||||
$var matchers = [[$for j, [[const Matcher<A$j>& m$j]]]] | |||||
template <typename R$typename_As> | |||||
class FunctionMocker<R($As)> : public | |||||
internal::FunctionMockerBase<R($As)> { | |||||
public: | |||||
typedef R F($As); | |||||
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; | |||||
MockSpec<F> With($matchers) { | |||||
return MockSpec<F>(this, ::testing::make_tuple($ms)); | |||||
} | |||||
R Invoke($Aas) { | |||||
// Even though gcc and MSVC don't enforce it, 'this->' is required | |||||
// by the C++ standard [14.6.4] here, as the base class type is | |||||
// dependent on the template argument (and thus shouldn't be | |||||
// looked into when resolving InvokeWith). | |||||
return this->InvokeWith(ArgumentTuple($as)); | |||||
} | |||||
}; | |||||
]] | |||||
// Removes the given pointer; this is a helper for the expectation setter method | |||||
// for parameterless matchers. | |||||
// | |||||
// We want to make sure that the user cannot set a parameterless expectation on | |||||
// overloaded methods, including methods which are overloaded on const. Example: | |||||
// | |||||
// class MockClass { | |||||
// MOCK_METHOD0(GetName, string&()); | |||||
// MOCK_CONST_METHOD0(GetName, const string&()); | |||||
// }; | |||||
// | |||||
// TEST() { | |||||
// // This should be an error, as it's not clear which overload is expected. | |||||
// EXPECT_CALL(mock, GetName).WillOnce(ReturnRef(value)); | |||||
// } | |||||
// | |||||
// Here are the generated expectation-setter methods: | |||||
// | |||||
// class MockClass { | |||||
// // Overload 1 | |||||
// MockSpec<string&()> gmock_GetName() { ... } | |||||
// // Overload 2. Declared const so that the compiler will generate an | |||||
// // error when trying to resolve between this and overload 4 in | |||||
// // 'gmock_GetName(WithoutMatchers(), nullptr)'. | |||||
// MockSpec<string&()> gmock_GetName( | |||||
// const WithoutMatchers&, const Function<string&()>*) const { | |||||
// // Removes const from this, calls overload 1 | |||||
// return AdjustConstness_(this)->gmock_GetName(); | |||||
// } | |||||
// | |||||
// // Overload 3 | |||||
// const string& gmock_GetName() const { ... } | |||||
// // Overload 4 | |||||
// MockSpec<const string&()> gmock_GetName( | |||||
// const WithoutMatchers&, const Function<const string&()>*) const { | |||||
// // Does not remove const, calls overload 3 | |||||
// return AdjustConstness_const(this)->gmock_GetName(); | |||||
// } | |||||
// } | |||||
// | |||||
template <typename MockType> | |||||
const MockType* AdjustConstness_const(const MockType* mock) { | |||||
return mock; | |||||
} | |||||
// Removes const from and returns the given pointer; this is a helper for the | |||||
// expectation setter method for parameterless matchers. | |||||
template <typename MockType> | |||||
MockType* AdjustConstness_(const MockType* mock) { | |||||
return const_cast<MockType*>(mock); | |||||
} | |||||
} // namespace internal | |||||
// The style guide prohibits "using" statements in a namespace scope | |||||
// inside a header file. However, the FunctionMocker class template | |||||
// is meant to be defined in the ::testing namespace. The following | |||||
// line is just a trick for working around a bug in MSVC 8.0, which | |||||
// cannot handle it if we define FunctionMocker in ::testing. | |||||
using internal::FunctionMocker; | |||||
// GMOCK_RESULT_(tn, F) expands to the result type of function type F. | |||||
// We define this as a variadic macro in case F contains unprotected | |||||
// commas (the same reason that we use variadic macros in other places | |||||
// in this file). | |||||
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! | |||||
#define GMOCK_RESULT_(tn, ...) \ | |||||
tn ::testing::internal::Function<__VA_ARGS__>::Result | |||||
// The type of argument N of the given function type. | |||||
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! | |||||
#define GMOCK_ARG_(tn, N, ...) \ | |||||
tn ::testing::internal::Function<__VA_ARGS__>::Argument##N | |||||
// The matcher type for argument N of the given function type. | |||||
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! | |||||
#define GMOCK_MATCHER_(tn, N, ...) \ | |||||
const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>& | |||||
// The variable for mocking the given method. | |||||
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! | |||||
#define GMOCK_MOCKER_(arity, constness, Method) \ | |||||
GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) | |||||
$for i [[ | |||||
$range j 1..i | |||||
$var arg_as = [[$for j, [[GMOCK_ARG_(tn, $j, __VA_ARGS__) gmock_a$j]]]] | |||||
$var as = [[$for j, \ | |||||
[[::testing::internal::forward<GMOCK_ARG_(tn, $j, __VA_ARGS__)>(gmock_a$j)]]]] | |||||
$var matcher_arg_as = [[$for j, \ | |||||
[[GMOCK_MATCHER_(tn, $j, __VA_ARGS__) gmock_a$j]]]] | |||||
$var matcher_as = [[$for j, [[gmock_a$j]]]] | |||||
$var anything_matchers = [[$for j, \ | |||||
[[::testing::A<GMOCK_ARG_(tn, $j, __VA_ARGS__)>()]]]] | |||||
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! | |||||
#define GMOCK_METHOD$i[[]]_(tn, constness, ct, Method, ...) \ | |||||
GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ | |||||
$arg_as) constness { \ | |||||
GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ | |||||
tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value == $i), \ | |||||
this_method_does_not_take_$i[[]]_argument[[$if i != 1 [[s]]]]); \ | |||||
GMOCK_MOCKER_($i, constness, Method).SetOwnerAndName(this, #Method); \ | |||||
return GMOCK_MOCKER_($i, constness, Method).Invoke($as); \ | |||||
} \ | |||||
::testing::MockSpec<__VA_ARGS__> \ | |||||
gmock_##Method($matcher_arg_as) constness { \ | |||||
GMOCK_MOCKER_($i, constness, Method).RegisterOwner(this); \ | |||||
return GMOCK_MOCKER_($i, constness, Method).With($matcher_as); \ | |||||
} \ | |||||
::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ | |||||
const ::testing::internal::WithoutMatchers&, \ | |||||
constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ | |||||
return ::testing::internal::AdjustConstness_##constness(this)-> \ | |||||
gmock_##Method($anything_matchers); \ | |||||
} \ | |||||
mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_($i, constness, Method) | |||||
]] | |||||
$for i [[ | |||||
#define MOCK_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, , , m, __VA_ARGS__) | |||||
]] | |||||
$for i [[ | |||||
#define MOCK_CONST_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, const, , m, __VA_ARGS__) | |||||
]] | |||||
$for i [[ | |||||
#define MOCK_METHOD$i[[]]_T(m, ...) GMOCK_METHOD$i[[]]_(typename, , , m, __VA_ARGS__) | |||||
]] | |||||
$for i [[ | |||||
#define MOCK_CONST_METHOD$i[[]]_T(m, ...) \ | |||||
GMOCK_METHOD$i[[]]_(typename, const, , m, __VA_ARGS__) | |||||
]] | |||||
$for i [[ | |||||
#define MOCK_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \ | |||||
GMOCK_METHOD$i[[]]_(, , ct, m, __VA_ARGS__) | |||||
]] | |||||
$for i [[ | |||||
#define MOCK_CONST_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \ | |||||
GMOCK_METHOD$i[[]]_(, const, ct, m, __VA_ARGS__) | |||||
]] | |||||
$for i [[ | |||||
#define MOCK_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \ | |||||
GMOCK_METHOD$i[[]]_(typename, , ct, m, __VA_ARGS__) | |||||
]] | |||||
$for i [[ | |||||
#define MOCK_CONST_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \ | |||||
GMOCK_METHOD$i[[]]_(typename, const, ct, m, __VA_ARGS__) | |||||
]] | |||||
// A MockFunction<F> class has one mock method whose type is F. It is | |||||
// useful when you just want your test code to emit some messages and | |||||
// have Google Mock verify the right messages are sent (and perhaps at | |||||
// the right times). For example, if you are exercising code: | |||||
// | |||||
// Foo(1); | |||||
// Foo(2); | |||||
// Foo(3); | |||||
// | |||||
// and want to verify that Foo(1) and Foo(3) both invoke | |||||
// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write: | |||||
// | |||||
// TEST(FooTest, InvokesBarCorrectly) { | |||||
// MyMock mock; | |||||
// MockFunction<void(string check_point_name)> check; | |||||
// { | |||||
// InSequence s; | |||||
// | |||||
// EXPECT_CALL(mock, Bar("a")); | |||||
// EXPECT_CALL(check, Call("1")); | |||||
// EXPECT_CALL(check, Call("2")); | |||||
// EXPECT_CALL(mock, Bar("a")); | |||||
// } | |||||
// Foo(1); | |||||
// check.Call("1"); | |||||
// Foo(2); | |||||
// check.Call("2"); | |||||
// Foo(3); | |||||
// } | |||||
// | |||||
// The expectation spec says that the first Bar("a") must happen | |||||
// before check point "1", the second Bar("a") must happen after check | |||||
// point "2", and nothing should happen between the two check | |||||
// points. The explicit check points make it easy to tell which | |||||
// Bar("a") is called by which call to Foo(). | |||||
// | |||||
// MockFunction<F> can also be used to exercise code that accepts | |||||
// std::function<F> callbacks. To do so, use AsStdFunction() method | |||||
// to create std::function proxy forwarding to original object's Call. | |||||
// Example: | |||||
// | |||||
// TEST(FooTest, RunsCallbackWithBarArgument) { | |||||
// MockFunction<int(string)> callback; | |||||
// EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1)); | |||||
// Foo(callback.AsStdFunction()); | |||||
// } | |||||
template <typename F> | |||||
class MockFunction; | |||||
$for i [[ | |||||
$range j 0..i-1 | |||||
$var ArgTypes = [[$for j, [[A$j]]]] | |||||
$var ArgValues = [[$for j, [[::std::move(a$j)]]]] | |||||
$var ArgDecls = [[$for j, [[A$j a$j]]]] | |||||
template <typename R$for j [[, typename A$j]]> | |||||
class MockFunction<R($ArgTypes)> { | |||||
public: | |||||
MockFunction() {} | |||||
MOCK_METHOD$i[[]]_T(Call, R($ArgTypes)); | |||||
#if GTEST_HAS_STD_FUNCTION_ | |||||
::std::function<R($ArgTypes)> AsStdFunction() { | |||||
return [this]($ArgDecls) -> R { | |||||
return this->Call($ArgValues); | |||||
}; | |||||
} | |||||
#endif // GTEST_HAS_STD_FUNCTION_ | |||||
private: | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); | |||||
}; | |||||
]] | |||||
} // namespace testing | |||||
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ |