zhanyong.wan
16 years ago
parent
1afe1c7971
commit
a18423e0ee
9 changed files with 1159 additions and 1049 deletions
@ -0,0 +1,190 @@ |
||||
// 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.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Google Mock - a framework for writing C++ mock classes.
|
||||
//
|
||||
// This file implements some actions that depend on gmock-generated-actions.h.
|
||||
|
||||
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_ |
||||
#define GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_ |
||||
|
||||
#include <gmock/gmock-generated-actions.h> |
||||
|
||||
namespace testing { |
||||
namespace internal { |
||||
|
||||
// Implements the Invoke(f) action. The template argument
|
||||
// FunctionImpl is the implementation type of f, which can be either a
|
||||
// function pointer or a functor. Invoke(f) can be used as an
|
||||
// Action<F> as long as f's type is compatible with F (i.e. f can be
|
||||
// assigned to a tr1::function<F>).
|
||||
template <typename FunctionImpl> |
||||
class InvokeAction { |
||||
public: |
||||
// The c'tor makes a copy of function_impl (either a function
|
||||
// pointer or a functor).
|
||||
explicit InvokeAction(FunctionImpl function_impl) |
||||
: function_impl_(function_impl) {} |
||||
|
||||
template <typename Result, typename ArgumentTuple> |
||||
Result Perform(const ArgumentTuple& args) { |
||||
return InvokeHelper<Result, ArgumentTuple>::Invoke(function_impl_, args); |
||||
} |
||||
private: |
||||
FunctionImpl function_impl_; |
||||
}; |
||||
|
||||
// Implements the Invoke(object_ptr, &Class::Method) action.
|
||||
template <class Class, typename MethodPtr> |
||||
class InvokeMethodAction { |
||||
public: |
||||
InvokeMethodAction(Class* obj_ptr, MethodPtr method_ptr) |
||||
: obj_ptr_(obj_ptr), method_ptr_(method_ptr) {} |
||||
|
||||
template <typename Result, typename ArgumentTuple> |
||||
Result Perform(const ArgumentTuple& args) const { |
||||
return InvokeHelper<Result, ArgumentTuple>::InvokeMethod( |
||||
obj_ptr_, method_ptr_, args); |
||||
} |
||||
private: |
||||
Class* const obj_ptr_; |
||||
const MethodPtr method_ptr_; |
||||
}; |
||||
|
||||
} // namespace internal
|
||||
|
||||
// Various overloads for Invoke().
|
||||
|
||||
// Creates an action that invokes 'function_impl' with the mock
|
||||
// function's arguments.
|
||||
template <typename FunctionImpl> |
||||
PolymorphicAction<internal::InvokeAction<FunctionImpl> > Invoke( |
||||
FunctionImpl function_impl) { |
||||
return MakePolymorphicAction( |
||||
internal::InvokeAction<FunctionImpl>(function_impl)); |
||||
} |
||||
|
||||
// Creates an action that invokes the given method on the given object
|
||||
// with the mock function's arguments.
|
||||
template <class Class, typename MethodPtr> |
||||
PolymorphicAction<internal::InvokeMethodAction<Class, MethodPtr> > Invoke( |
||||
Class* obj_ptr, MethodPtr method_ptr) { |
||||
return MakePolymorphicAction( |
||||
internal::InvokeMethodAction<Class, MethodPtr>(obj_ptr, method_ptr)); |
||||
} |
||||
|
||||
// WithoutArgs(inner_action) can be used in a mock function with a
|
||||
// non-empty argument list to perform inner_action, which takes no
|
||||
// argument. In other words, it adapts an action accepting no
|
||||
// argument to one that accepts (and ignores) arguments.
|
||||
template <typename InnerAction> |
||||
inline internal::WithArgsAction<InnerAction> |
||||
WithoutArgs(const InnerAction& action) { |
||||
return internal::WithArgsAction<InnerAction>(action); |
||||
} |
||||
|
||||
// WithArg<k>(an_action) creates an action that passes the k-th
|
||||
// (0-based) argument of the mock function to an_action and performs
|
||||
// it. It adapts an action accepting one argument to one that accepts
|
||||
// multiple arguments. For convenience, we also provide
|
||||
// WithArgs<k>(an_action) (defined below) as a synonym.
|
||||
template <int k, typename InnerAction> |
||||
inline internal::WithArgsAction<InnerAction, k> |
||||
WithArg(const InnerAction& action) { |
||||
return internal::WithArgsAction<InnerAction, k>(action); |
||||
} |
||||
|
||||
// Action ReturnArg<k>() returns the k-th argument of the mock function.
|
||||
ACTION_TEMPLATE(ReturnArg, |
||||
HAS_1_TEMPLATE_PARAMS(int, k), |
||||
AND_0_VALUE_PARAMS()) { |
||||
return std::tr1::get<k>(args); |
||||
} |
||||
|
||||
// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
|
||||
// mock function to *pointer.
|
||||
ACTION_TEMPLATE(SaveArg, |
||||
HAS_1_TEMPLATE_PARAMS(int, k), |
||||
AND_1_VALUE_PARAMS(pointer)) { |
||||
*pointer = ::std::tr1::get<k>(args); |
||||
} |
||||
|
||||
// Action SetArgReferee<k>(value) assigns 'value' to the variable
|
||||
// referenced by the k-th (0-based) argument of the mock function.
|
||||
ACTION_TEMPLATE(SetArgReferee, |
||||
HAS_1_TEMPLATE_PARAMS(int, k), |
||||
AND_1_VALUE_PARAMS(value)) { |
||||
typedef typename ::std::tr1::tuple_element<k, args_type>::type argk_type; |
||||
// Ensures that argument #k is a reference. If you get a compiler
|
||||
// error on the next line, you are using SetArgReferee<k>(value) in
|
||||
// a mock function whose k-th (0-based) argument is not a reference.
|
||||
GMOCK_COMPILE_ASSERT_(internal::is_reference<argk_type>::value, |
||||
SetArgReferee_must_be_used_with_a_reference_argument); |
||||
::std::tr1::get<k>(args) = value; |
||||
} |
||||
|
||||
// Action SetArrayArgument<k>(first, last) copies the elements in
|
||||
// source range [first, last) to the array pointed to by the k-th
|
||||
// (0-based) argument, which can be either a pointer or an
|
||||
// iterator. The action does not take ownership of the elements in the
|
||||
// source range.
|
||||
ACTION_TEMPLATE(SetArrayArgument, |
||||
HAS_1_TEMPLATE_PARAMS(int, k), |
||||
AND_2_VALUE_PARAMS(first, last)) { |
||||
// Microsoft compiler deprecates ::std::copy, so we want to suppress warning
|
||||
// 4996 (Function call with parameters that may be unsafe) there.
|
||||
#ifdef _MSC_VER |
||||
#pragma warning(push) // Saves the current warning state.
|
||||
#pragma warning(disable:4996) // Temporarily disables warning 4996.
|
||||
#endif |
||||
::std::copy(first, last, ::std::tr1::get<k>(args)); |
||||
#ifdef _MSC_VER |
||||
#pragma warning(pop) // Restores the warning state.
|
||||
#endif |
||||
} |
||||
|
||||
// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
|
||||
// function.
|
||||
ACTION_TEMPLATE(DeleteArg, |
||||
HAS_1_TEMPLATE_PARAMS(int, k), |
||||
AND_0_VALUE_PARAMS()) { |
||||
delete ::std::tr1::get<k>(args); |
||||
} |
||||
|
||||
// Action Throw(exception) can be used in a mock function of any type
|
||||
// to throw the given exception. Any copyable value can be thrown.
|
||||
#if GTEST_HAS_EXCEPTIONS |
||||
ACTION_P(Throw, exception) { throw exception; } |
||||
#endif // GTEST_HAS_EXCEPTIONS
|
||||
|
||||
} // namespace testing
|
||||
|
||||
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
|
||||
@ -0,0 +1,796 @@ |
||||
// 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.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Google Mock - a framework for writing C++ mock classes.
|
||||
//
|
||||
// This file tests the built-in actions in gmock-more-actions.h.
|
||||
|
||||
#include <gmock/gmock-more-actions.h> |
||||
|
||||
#include <functional> |
||||
#include <sstream> |
||||
#include <string> |
||||
#include <gmock/gmock.h> |
||||
#include <gtest/gtest.h> |
||||
|
||||
namespace testing { |
||||
namespace gmock_more_actions_test { |
||||
|
||||
using ::std::plus; |
||||
using ::std::string; |
||||
using ::std::tr1::get; |
||||
using ::std::tr1::make_tuple; |
||||
using ::std::tr1::tuple; |
||||
using ::std::tr1::tuple_element; |
||||
using testing::_; |
||||
using testing::Action; |
||||
using testing::ActionInterface; |
||||
using testing::DeleteArg; |
||||
using testing::Invoke; |
||||
using testing::Return; |
||||
using testing::ReturnArg; |
||||
using testing::SaveArg; |
||||
using testing::SetArgReferee; |
||||
using testing::SetArgumentPointee; |
||||
using testing::StaticAssertTypeEq; |
||||
using testing::Unused; |
||||
using testing::WithArg; |
||||
using testing::WithoutArgs; |
||||
|
||||
// Sample functions and functors for testing Invoke() and etc.
|
||||
int Nullary() { return 1; } |
||||
|
||||
class NullaryFunctor { |
||||
public: |
||||
int operator()() { return 2; } |
||||
}; |
||||
|
||||
bool g_done = false; |
||||
void VoidNullary() { g_done = true; } |
||||
|
||||
class VoidNullaryFunctor { |
||||
public: |
||||
void operator()() { g_done = true; } |
||||
}; |
||||
|
||||
bool Unary(int x) { return x < 0; } |
||||
|
||||
const char* Plus1(const char* s) { return s + 1; } |
||||
|
||||
void VoidUnary(int n) { g_done = true; } |
||||
|
||||
bool ByConstRef(const string& s) { return s == "Hi"; } |
||||
|
||||
const double g_double = 0; |
||||
bool ReferencesGlobalDouble(const double& x) { return &x == &g_double; } |
||||
|
||||
string ByNonConstRef(string& s) { return s += "+"; } // NOLINT
|
||||
|
||||
struct UnaryFunctor { |
||||
int operator()(bool x) { return x ? 1 : -1; } |
||||
}; |
||||
|
||||
const char* Binary(const char* input, short n) { return input + n; } // NOLINT
|
||||
|
||||
void VoidBinary(int, char) { g_done = true; } |
||||
|
||||
int Ternary(int x, char y, short z) { return x + y + z; } // NOLINT
|
||||
|
||||
void VoidTernary(int, char, bool) { g_done = true; } |
||||
|
||||
int SumOf4(int a, int b, int c, int d) { return a + b + c + d; } |
||||
|
||||
int SumOfFirst2(int a, int b, Unused, Unused) { return a + b; } |
||||
|
||||
void VoidFunctionWithFourArguments(char, int, float, double) { g_done = true; } |
||||
|
||||
string Concat4(const char* s1, const char* s2, const char* s3, |
||||
const char* s4) { |
||||
return string(s1) + s2 + s3 + s4; |
||||
} |
||||
|
||||
int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; } |
||||
|
||||
struct SumOf5Functor { |
||||
int operator()(int a, int b, int c, int d, int e) { |
||||
return a + b + c + d + e; |
||||
} |
||||
}; |
||||
|
||||
string Concat5(const char* s1, const char* s2, const char* s3, |
||||
const char* s4, const char* s5) { |
||||
return string(s1) + s2 + s3 + s4 + s5; |
||||
} |
||||
|
||||
int SumOf6(int a, int b, int c, int d, int e, int f) { |
||||
return a + b + c + d + e + f; |
||||
} |
||||
|
||||
struct SumOf6Functor { |
||||
int operator()(int a, int b, int c, int d, int e, int f) { |
||||
return a + b + c + d + e + f; |
||||
} |
||||
}; |
||||
|
||||
string Concat6(const char* s1, const char* s2, const char* s3, |
||||
const char* s4, const char* s5, const char* s6) { |
||||
return string(s1) + s2 + s3 + s4 + s5 + s6; |
||||
} |
||||
|
||||
string Concat7(const char* s1, const char* s2, const char* s3, |
||||
const char* s4, const char* s5, const char* s6, |
||||
const char* s7) { |
||||
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7; |
||||
} |
||||
|
||||
string Concat8(const char* s1, const char* s2, const char* s3, |
||||
const char* s4, const char* s5, const char* s6, |
||||
const char* s7, const char* s8) { |
||||
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8; |
||||
} |
||||
|
||||
string Concat9(const char* s1, const char* s2, const char* s3, |
||||
const char* s4, const char* s5, const char* s6, |
||||
const char* s7, const char* s8, const char* s9) { |
||||
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9; |
||||
} |
||||
|
||||
string Concat10(const char* s1, const char* s2, const char* s3, |
||||
const char* s4, const char* s5, const char* s6, |
||||
const char* s7, const char* s8, const char* s9, |
||||
const char* s10) { |
||||
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10; |
||||
} |
||||
|
||||
class Foo { |
||||
public: |
||||
Foo() : value_(123) {} |
||||
|
||||
int Nullary() const { return value_; } |
||||
|
||||
short Unary(long x) { return static_cast<short>(value_ + x); } // NOLINT
|
||||
|
||||
string Binary(const string& str, char c) const { return str + c; } |
||||
|
||||
int Ternary(int x, bool y, char z) { return value_ + x + y*z; } |
||||
|
||||
int SumOf4(int a, int b, int c, int d) const { |
||||
return a + b + c + d + value_; |
||||
} |
||||
|
||||
int SumOfLast2(Unused, Unused, int a, int b) const { return a + b; } |
||||
|
||||
int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; } |
||||
|
||||
int SumOf6(int a, int b, int c, int d, int e, int f) { |
||||
return a + b + c + d + e + f; |
||||
} |
||||
|
||||
string Concat7(const char* s1, const char* s2, const char* s3, |
||||
const char* s4, const char* s5, const char* s6, |
||||
const char* s7) { |
||||
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7; |
||||
} |
||||
|
||||
string Concat8(const char* s1, const char* s2, const char* s3, |
||||
const char* s4, const char* s5, const char* s6, |
||||
const char* s7, const char* s8) { |
||||
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8; |
||||
} |
||||
|
||||
string Concat9(const char* s1, const char* s2, const char* s3, |
||||
const char* s4, const char* s5, const char* s6, |
||||
const char* s7, const char* s8, const char* s9) { |
||||
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9; |
||||
} |
||||
|
||||
string Concat10(const char* s1, const char* s2, const char* s3, |
||||
const char* s4, const char* s5, const char* s6, |
||||
const char* s7, const char* s8, const char* s9, |
||||
const char* s10) { |
||||
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10; |
||||
} |
||||
private: |
||||
int value_; |
||||
}; |
||||
|
||||
// Tests using Invoke() with a nullary function.
|
||||
TEST(InvokeTest, Nullary) { |
||||
Action<int()> a = Invoke(Nullary); // NOLINT
|
||||
EXPECT_EQ(1, a.Perform(make_tuple())); |
||||
} |
||||
|
||||
// Tests using Invoke() with a unary function.
|
||||
TEST(InvokeTest, Unary) { |
||||
Action<bool(int)> a = Invoke(Unary); // NOLINT
|
||||
EXPECT_FALSE(a.Perform(make_tuple(1))); |
||||
EXPECT_TRUE(a.Perform(make_tuple(-1))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a binary function.
|
||||
TEST(InvokeTest, Binary) { |
||||
Action<const char*(const char*, short)> a = Invoke(Binary); // NOLINT
|
||||
const char* p = "Hello"; |
||||
EXPECT_EQ(p + 2, a.Perform(make_tuple(p, 2))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a ternary function.
|
||||
TEST(InvokeTest, Ternary) { |
||||
Action<int(int, char, short)> a = Invoke(Ternary); // NOLINT
|
||||
EXPECT_EQ(6, a.Perform(make_tuple(1, '\2', 3))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 4-argument function.
|
||||
TEST(InvokeTest, FunctionThatTakes4Arguments) { |
||||
Action<int(int, int, int, int)> a = Invoke(SumOf4); // NOLINT
|
||||
EXPECT_EQ(1234, a.Perform(make_tuple(1000, 200, 30, 4))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 5-argument function.
|
||||
TEST(InvokeTest, FunctionThatTakes5Arguments) { |
||||
Action<int(int, int, int, int, int)> a = Invoke(SumOf5); // NOLINT
|
||||
EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 6-argument function.
|
||||
TEST(InvokeTest, FunctionThatTakes6Arguments) { |
||||
Action<int(int, int, int, int, int, int)> a = Invoke(SumOf6); // NOLINT
|
||||
EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6))); |
||||
} |
||||
|
||||
// A helper that turns the type of a C-string literal from const
|
||||
// char[N] to const char*.
|
||||
inline const char* CharPtr(const char* s) { return s; } |
||||
|
||||
// Tests using Invoke() with a 7-argument function.
|
||||
TEST(InvokeTest, FunctionThatTakes7Arguments) { |
||||
Action<string(const char*, const char*, const char*, const char*, |
||||
const char*, const char*, const char*)> a = |
||||
Invoke(Concat7); |
||||
EXPECT_EQ("1234567", |
||||
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"), |
||||
CharPtr("4"), CharPtr("5"), CharPtr("6"), |
||||
CharPtr("7")))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 8-argument function.
|
||||
TEST(InvokeTest, FunctionThatTakes8Arguments) { |
||||
Action<string(const char*, const char*, const char*, const char*, |
||||
const char*, const char*, const char*, const char*)> a = |
||||
Invoke(Concat8); |
||||
EXPECT_EQ("12345678", |
||||
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"), |
||||
CharPtr("4"), CharPtr("5"), CharPtr("6"), |
||||
CharPtr("7"), CharPtr("8")))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 9-argument function.
|
||||
TEST(InvokeTest, FunctionThatTakes9Arguments) { |
||||
Action<string(const char*, const char*, const char*, const char*, |
||||
const char*, const char*, const char*, const char*, |
||||
const char*)> a = Invoke(Concat9); |
||||
EXPECT_EQ("123456789", |
||||
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"), |
||||
CharPtr("4"), CharPtr("5"), CharPtr("6"), |
||||
CharPtr("7"), CharPtr("8"), CharPtr("9")))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 10-argument function.
|
||||
TEST(InvokeTest, FunctionThatTakes10Arguments) { |
||||
Action<string(const char*, const char*, const char*, const char*, |
||||
const char*, const char*, const char*, const char*, |
||||
const char*, const char*)> a = Invoke(Concat10); |
||||
EXPECT_EQ("1234567890", |
||||
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"), |
||||
CharPtr("4"), CharPtr("5"), CharPtr("6"), |
||||
CharPtr("7"), CharPtr("8"), CharPtr("9"), |
||||
CharPtr("0")))); |
||||
} |
||||
|
||||
// Tests using Invoke() with functions with parameters declared as Unused.
|
||||
TEST(InvokeTest, FunctionWithUnusedParameters) { |
||||
Action<int(int, int, double, const string&)> a1 = |
||||
Invoke(SumOfFirst2); |
||||
EXPECT_EQ(12, a1.Perform(make_tuple(10, 2, 5.6, CharPtr("hi")))); |
||||
|
||||
Action<int(int, int, bool, int*)> a2 = |
||||
Invoke(SumOfFirst2); |
||||
EXPECT_EQ(23, a2.Perform(make_tuple(20, 3, true, static_cast<int*>(NULL)))); |
||||
} |
||||
|
||||
// Tests using Invoke() with methods with parameters declared as Unused.
|
||||
TEST(InvokeTest, MethodWithUnusedParameters) { |
||||
Foo foo; |
||||
Action<int(string, bool, int, int)> a1 = |
||||
Invoke(&foo, &Foo::SumOfLast2); |
||||
EXPECT_EQ(12, a1.Perform(make_tuple(CharPtr("hi"), true, 10, 2))); |
||||
|
||||
Action<int(char, double, int, int)> a2 = |
||||
Invoke(&foo, &Foo::SumOfLast2); |
||||
EXPECT_EQ(23, a2.Perform(make_tuple('a', 2.5, 20, 3))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a functor.
|
||||
TEST(InvokeTest, Functor) { |
||||
Action<int(short, char)> a = Invoke(plus<short>()); // NOLINT
|
||||
EXPECT_EQ(3, a.Perform(make_tuple(1, 2))); |
||||
} |
||||
|
||||
// Tests using Invoke(f) as an action of a compatible type.
|
||||
TEST(InvokeTest, FunctionWithCompatibleType) { |
||||
Action<long(int, short, char, bool)> a = Invoke(SumOf4); // NOLINT
|
||||
EXPECT_EQ(4321, a.Perform(make_tuple(4000, 300, 20, true))); |
||||
} |
||||
|
||||
#if GMOCK_HAS_GOOGLE3_CALLBACK_ |
||||
|
||||
// Tests IgnoreResult(Invoke(result_callback)).
|
||||
TEST(InvokeTest, IgnoreResultOfResultCallback) { |
||||
ResultCallback<int>* c = NewPermanentCallback(Nullary); |
||||
Action<void()> a = IgnoreResult(Invoke(c)); |
||||
a.Perform(make_tuple()); |
||||
} |
||||
|
||||
// Tests IgnoreResult(Invoke(result_callback4)).
|
||||
TEST(InvokeTest, IgnoreResultOfResultCallback4) { |
||||
ResultCallback4<int, int, int, int, int>* c = |
||||
NewPermanentCallback(SumOf4); |
||||
Action<void(int, int, int, int)> a = IgnoreResult(Invoke(c)); |
||||
a.Perform(make_tuple(1, 2, 3, 4)); |
||||
} |
||||
|
||||
#endif // GMOCK_HAS_GOOGLE3_CALLBACK_
|
||||
|
||||
// Tests using Invoke() with an object pointer and a method pointer.
|
||||
|
||||
// Tests using Invoke() with a nullary method.
|
||||
TEST(InvokeMethodTest, Nullary) { |
||||
Foo foo; |
||||
Action<int()> a = Invoke(&foo, &Foo::Nullary); // NOLINT
|
||||
EXPECT_EQ(123, a.Perform(make_tuple())); |
||||
} |
||||
|
||||
// Tests using Invoke() with a unary method.
|
||||
TEST(InvokeMethodTest, Unary) { |
||||
Foo foo; |
||||
Action<short(long)> a = Invoke(&foo, &Foo::Unary); // NOLINT
|
||||
EXPECT_EQ(4123, a.Perform(make_tuple(4000))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a binary method.
|
||||
TEST(InvokeMethodTest, Binary) { |
||||
Foo foo; |
||||
Action<string(const string&, char)> a = Invoke(&foo, &Foo::Binary); |
||||
string s("Hell"); |
||||
EXPECT_EQ("Hello", a.Perform(make_tuple(s, 'o'))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a ternary method.
|
||||
TEST(InvokeMethodTest, Ternary) { |
||||
Foo foo; |
||||
Action<int(int, bool, char)> a = Invoke(&foo, &Foo::Ternary); // NOLINT
|
||||
EXPECT_EQ(1124, a.Perform(make_tuple(1000, true, 1))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 4-argument method.
|
||||
TEST(InvokeMethodTest, MethodThatTakes4Arguments) { |
||||
Foo foo; |
||||
Action<int(int, int, int, int)> a = Invoke(&foo, &Foo::SumOf4); // NOLINT
|
||||
EXPECT_EQ(1357, a.Perform(make_tuple(1000, 200, 30, 4))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 5-argument method.
|
||||
TEST(InvokeMethodTest, MethodThatTakes5Arguments) { |
||||
Foo foo; |
||||
Action<int(int, int, int, int, int)> a = Invoke(&foo, &Foo::SumOf5); // NOLINT
|
||||
EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 6-argument method.
|
||||
TEST(InvokeMethodTest, MethodThatTakes6Arguments) { |
||||
Foo foo; |
||||
Action<int(int, int, int, int, int, int)> a = // NOLINT
|
||||
Invoke(&foo, &Foo::SumOf6); |
||||
EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 7-argument method.
|
||||
TEST(InvokeMethodTest, MethodThatTakes7Arguments) { |
||||
Foo foo; |
||||
Action<string(const char*, const char*, const char*, const char*, |
||||
const char*, const char*, const char*)> a = |
||||
Invoke(&foo, &Foo::Concat7); |
||||
EXPECT_EQ("1234567", |
||||
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"), |
||||
CharPtr("4"), CharPtr("5"), CharPtr("6"), |
||||
CharPtr("7")))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 8-argument method.
|
||||
TEST(InvokeMethodTest, MethodThatTakes8Arguments) { |
||||
Foo foo; |
||||
Action<string(const char*, const char*, const char*, const char*, |
||||
const char*, const char*, const char*, const char*)> a = |
||||
Invoke(&foo, &Foo::Concat8); |
||||
EXPECT_EQ("12345678", |
||||
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"), |
||||
CharPtr("4"), CharPtr("5"), CharPtr("6"), |
||||
CharPtr("7"), CharPtr("8")))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 9-argument method.
|
||||
TEST(InvokeMethodTest, MethodThatTakes9Arguments) { |
||||
Foo foo; |
||||
Action<string(const char*, const char*, const char*, const char*, |
||||
const char*, const char*, const char*, const char*, |
||||
const char*)> a = Invoke(&foo, &Foo::Concat9); |
||||
EXPECT_EQ("123456789", |
||||
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"), |
||||
CharPtr("4"), CharPtr("5"), CharPtr("6"), |
||||
CharPtr("7"), CharPtr("8"), CharPtr("9")))); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 10-argument method.
|
||||
TEST(InvokeMethodTest, MethodThatTakes10Arguments) { |
||||
Foo foo; |
||||
Action<string(const char*, const char*, const char*, const char*, |
||||
const char*, const char*, const char*, const char*, |
||||
const char*, const char*)> a = Invoke(&foo, &Foo::Concat10); |
||||
EXPECT_EQ("1234567890", |
||||
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"), |
||||
CharPtr("4"), CharPtr("5"), CharPtr("6"), |
||||
CharPtr("7"), CharPtr("8"), CharPtr("9"), |
||||
CharPtr("0")))); |
||||
} |
||||
|
||||
// Tests using Invoke(f) as an action of a compatible type.
|
||||
TEST(InvokeMethodTest, MethodWithCompatibleType) { |
||||
Foo foo; |
||||
Action<long(int, short, char, bool)> a = // NOLINT
|
||||
Invoke(&foo, &Foo::SumOf4); |
||||
EXPECT_EQ(4444, a.Perform(make_tuple(4000, 300, 20, true))); |
||||
} |
||||
|
||||
#if GMOCK_HAS_GOOGLE3_CALLBACK_ |
||||
|
||||
// We don't have dedicated tests to verify that Invoke(callback) and
|
||||
// InvokeWithoutArgs(callback) delete the callback argument. Instead,
|
||||
// we rely on the heap checker linked in this test program to do that.
|
||||
|
||||
// Tests that Invoke(non-permanent-callback) kills the process.
|
||||
TEST(InvokeCallbackDeathTest, RejectsNonPermanentCallback) { |
||||
EXPECT_DEATH({ |
||||
Action<int()> a = Invoke(NewCallback(Nullary)); // NOLINT
|
||||
}, ""); |
||||
} |
||||
|
||||
// Tests using Invoke() with a nullary callback.
|
||||
TEST(InvokeCallbackTest, Nullary) { |
||||
// Tests using Invoke(callback) as an action of the exact type.
|
||||
Action<int()> a = Invoke(NewPermanentCallback(Nullary)); // NOLINT
|
||||
EXPECT_EQ(1, a.Perform(make_tuple())); |
||||
|
||||
// Tests using Invoke(callback) as an action of a compatible type.
|
||||
Action<bool()> a2 = Invoke(NewPermanentCallback(Nullary)); // NOLINT
|
||||
EXPECT_TRUE(a2.Perform(make_tuple())); |
||||
|
||||
// Tests using Invoke() on a callback that returns void.
|
||||
Action<void()> a3 = Invoke(NewPermanentCallback(VoidNullary)); // NOLINT
|
||||
g_done = false; |
||||
a3.Perform(make_tuple()); |
||||
EXPECT_TRUE(g_done); |
||||
} |
||||
|
||||
// Tests using Invoke() with a unary callback.
|
||||
TEST(InvokeCallbackTest, Unary) { |
||||
// Tests using Invoke(callback1) as an action of the exact type.
|
||||
Action<bool(int)> a = Invoke(NewPermanentCallback(Unary)); // NOLINT
|
||||
EXPECT_FALSE(a.Perform(make_tuple(1))); |
||||
EXPECT_TRUE(a.Perform(make_tuple(-1))); |
||||
|
||||
// Tests using Invoke(callback1) as an action of a compatible type.
|
||||
Action<int(long)> a2 = Invoke(NewPermanentCallback(Unary)); // NOLINT
|
||||
EXPECT_EQ(0, a2.Perform(make_tuple(1L))); |
||||
EXPECT_EQ(1, a2.Perform(make_tuple(-1L))); |
||||
|
||||
// Tests using Invoke() on a callback that returns void.
|
||||
Action<void(char)> a3 = Invoke(NewPermanentCallback(VoidUnary)); // NOLINT
|
||||
g_done = false; |
||||
a3.Perform(make_tuple('a')); |
||||
EXPECT_TRUE(g_done); |
||||
} |
||||
|
||||
// Tests using Invoke() with a binary callback.
|
||||
TEST(InvokeCallbackTest, Binary) { |
||||
// Tests using Invoke(callback2) as an action of the exact type.
|
||||
Action<const char*(const char*, short)> a = // NOLINT
|
||||
Invoke(NewPermanentCallback(Binary)); |
||||
const char* p = "Hello"; |
||||
EXPECT_EQ(p + 2, a.Perform(make_tuple(p, 2))); |
||||
|
||||
// Tests using Invoke(callback2) as an action of a compatible type.
|
||||
Action<bool(char*, int)> a2 = // NOLINT
|
||||
Invoke(NewPermanentCallback(Binary)); |
||||
char str[] = "Hello"; |
||||
EXPECT_TRUE(a2.Perform(make_tuple(str, 2))); |
||||
|
||||
// Tests using Invoke() on a callback that returns void.
|
||||
Action<void(char, char)> a3 = |
||||
Invoke(NewPermanentCallback(VoidBinary)); // NOLINT
|
||||
g_done = false; |
||||
a3.Perform(make_tuple('a', 'b')); |
||||
EXPECT_TRUE(g_done); |
||||
} |
||||
|
||||
// Tests using Invoke() with a ternary callback.
|
||||
TEST(InvokeCallbackTest, Ternary) { |
||||
// Tests using Invoke(callback3) as an action of the exact type.
|
||||
Action<int(int, char, short)> a = // NOLINT
|
||||
Invoke(NewPermanentCallback(Ternary)); |
||||
EXPECT_EQ(6, a.Perform(make_tuple(1, '\2', 3))); |
||||
|
||||
// Tests using Invoke(callback3) as an action of a compatible type.
|
||||
Action<long(char, int, int)> a2 = // NOLINT
|
||||
Invoke(NewPermanentCallback(Ternary)); |
||||
EXPECT_EQ(6, a2.Perform(make_tuple('\1', 2, 3))); |
||||
|
||||
// Tests using Invoke() on a callback that returns void.
|
||||
Action<void(char, char, bool)> a3 = |
||||
Invoke(NewPermanentCallback(VoidTernary)); // NOLINT
|
||||
g_done = false; |
||||
a3.Perform(make_tuple('a', 'b', true)); |
||||
EXPECT_TRUE(g_done); |
||||
} |
||||
|
||||
// Tests using Invoke() with a 4-argument callback.
|
||||
TEST(InvokeCallbackTest, CallbackThatTakes4Arguments) { |
||||
// Tests using Invoke(callback4) as an action of the exact type.
|
||||
Action<int(int, int, int, int)> a = // NOLINT
|
||||
Invoke(NewPermanentCallback(SumOf4)); |
||||
EXPECT_EQ(1234, a.Perform(make_tuple(1000, 200, 30, 4))); |
||||
|
||||
// Tests using Invoke(callback4) as an action of a compatible type.
|
||||
Action<long(int, short, char, bool)> a2 = // NOLINT
|
||||
Invoke(NewPermanentCallback(SumOf4)); |
||||
EXPECT_EQ(4321, a2.Perform(make_tuple(4000, 300, 20, true))); |
||||
|
||||
// Tests using Invoke() on a callback that returns void.
|
||||
Action<void(char, char, double, double)> a3 = |
||||
Invoke(NewPermanentCallback(VoidFunctionWithFourArguments)); // NOLINT
|
||||
g_done = false; |
||||
a3.Perform(make_tuple('a', 'b', 0, 1)); |
||||
EXPECT_TRUE(g_done); |
||||
} |
||||
|
||||
#endif // GMOCK_HAS_GOOGLE3_CALLBACK_
|
||||
|
||||
// Tests using WithoutArgs with an action that takes no argument.
|
||||
TEST(WithoutArgsTest, NoArg) { |
||||
Action<int(int n)> a = WithoutArgs(Invoke(Nullary)); // NOLINT
|
||||
EXPECT_EQ(1, a.Perform(make_tuple(2))); |
||||
} |
||||
|
||||
// Tests using WithArg with an action that takes 1 argument.
|
||||
TEST(WithArgTest, OneArg) { |
||||
Action<bool(double x, int n)> b = WithArg<1>(Invoke(Unary)); // NOLINT
|
||||
EXPECT_TRUE(b.Perform(make_tuple(1.5, -1))); |
||||
EXPECT_FALSE(b.Perform(make_tuple(1.5, 1))); |
||||
} |
||||
|
||||
TEST(ReturnArgActionTest, WorksForOneArgIntArg0) { |
||||
const Action<int(int)> a = ReturnArg<0>(); |
||||
EXPECT_EQ(5, a.Perform(make_tuple(5))); |
||||
} |
||||
|
||||
TEST(ReturnArgActionTest, WorksForMultiArgBoolArg0) { |
||||
const Action<bool(bool, bool, bool)> a = ReturnArg<0>(); |
||||
EXPECT_TRUE(a.Perform(make_tuple(true, false, false))); |
||||
} |
||||
|
||||
TEST(ReturnArgActionTest, WorksForMultiArgStringArg2) { |
||||
const Action<string(int, int, string, int)> a = ReturnArg<2>(); |
||||
EXPECT_EQ("seven", a.Perform(make_tuple(5, 6, string("seven"), 8))); |
||||
} |
||||
|
||||
TEST(SaveArgActionTest, WorksForSameType) { |
||||
int result = 0; |
||||
const Action<void(int n)> a1 = SaveArg<0>(&result); |
||||
a1.Perform(make_tuple(5)); |
||||
EXPECT_EQ(5, result); |
||||
} |
||||
|
||||
TEST(SaveArgActionTest, WorksForCompatibleType) { |
||||
int result = 0; |
||||
const Action<void(bool, char)> a1 = SaveArg<1>(&result); |
||||
a1.Perform(make_tuple(true, 'a')); |
||||
EXPECT_EQ('a', result); |
||||
} |
||||
|
||||
TEST(SetArgRefereeActionTest, WorksForSameType) { |
||||
int value = 0; |
||||
const Action<void(int&)> a1 = SetArgReferee<0>(1); |
||||
a1.Perform(tuple<int&>(value)); |
||||
EXPECT_EQ(1, value); |
||||
} |
||||
|
||||
TEST(SetArgRefereeActionTest, WorksForCompatibleType) { |
||||
int value = 0; |
||||
const Action<void(int, int&)> a1 = SetArgReferee<1>('a'); |
||||
a1.Perform(tuple<int, int&>(0, value)); |
||||
EXPECT_EQ('a', value); |
||||
} |
||||
|
||||
TEST(SetArgRefereeActionTest, WorksWithExtraArguments) { |
||||
int value = 0; |
||||
const Action<void(bool, int, int&, const char*)> a1 = SetArgReferee<2>('a'); |
||||
a1.Perform(tuple<bool, int, int&, const char*>(true, 0, value, "hi")); |
||||
EXPECT_EQ('a', value); |
||||
} |
||||
|
||||
// A class that can be used to verify that its destructor is called: it will set
|
||||
// the bool provided to the constructor to true when destroyed.
|
||||
class DeletionTester { |
||||
public: |
||||
explicit DeletionTester(bool* is_deleted) |
||||
: is_deleted_(is_deleted) { |
||||
// Make sure the bit is set to false.
|
||||
*is_deleted_ = false; |
||||
} |
||||
|
||||
~DeletionTester() { |
||||
*is_deleted_ = true; |
||||
} |
||||
|
||||
private: |
||||
bool* is_deleted_; |
||||
}; |
||||
|
||||
TEST(DeleteArgActionTest, OneArg) { |
||||
bool is_deleted = false; |
||||
DeletionTester* t = new DeletionTester(&is_deleted); |
||||
const Action<void(DeletionTester*)> a1 = DeleteArg<0>(); // NOLINT
|
||||
EXPECT_FALSE(is_deleted); |
||||
a1.Perform(make_tuple(t)); |
||||
EXPECT_TRUE(is_deleted); |
||||
} |
||||
|
||||
TEST(DeleteArgActionTest, TenArgs) { |
||||
bool is_deleted = false; |
||||
DeletionTester* t = new DeletionTester(&is_deleted); |
||||
const Action<void(bool, int, int, const char*, bool, |
||||
int, int, int, int, DeletionTester*)> a1 = DeleteArg<9>(); |
||||
EXPECT_FALSE(is_deleted); |
||||
a1.Perform(make_tuple(true, 5, 6, CharPtr("hi"), false, 7, 8, 9, 10, t)); |
||||
EXPECT_TRUE(is_deleted); |
||||
} |
||||
|
||||
#if GTEST_HAS_EXCEPTIONS |
||||
|
||||
TEST(ThrowActionTest, ThrowsGivenExceptionInVoidFunction) { |
||||
const Action<void(int n)> a = Throw('a'); |
||||
EXPECT_THROW(a.Perform(make_tuple(0)), char); |
||||
} |
||||
|
||||
class MyException {}; |
||||
|
||||
TEST(ThrowActionTest, ThrowsGivenExceptionInNonVoidFunction) { |
||||
const Action<double(char ch)> a = Throw(MyException()); |
||||
EXPECT_THROW(a.Perform(make_tuple('0')), MyException); |
||||
} |
||||
|
||||
TEST(ThrowActionTest, ThrowsGivenExceptionInNullaryFunction) { |
||||
const Action<double()> a = Throw(MyException()); |
||||
EXPECT_THROW(a.Perform(make_tuple()), MyException); |
||||
} |
||||
|
||||
#endif // GTEST_HAS_EXCEPTIONS
|
||||
|
||||
// Tests that SetArrayArgument<N>(first, last) sets the elements of the array
|
||||
// pointed to by the N-th (0-based) argument to values in range [first, last).
|
||||
TEST(SetArrayArgumentTest, SetsTheNthArray) { |
||||
typedef void MyFunction(bool, int*, char*); |
||||
int numbers[] = { 1, 2, 3 }; |
||||
Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers + 3); |
||||
|
||||
int n[4] = {}; |
||||
int* pn = n; |
||||
char ch[4] = {}; |
||||
char* pch = ch; |
||||
a.Perform(make_tuple(true, pn, pch)); |
||||
EXPECT_EQ(1, n[0]); |
||||
EXPECT_EQ(2, n[1]); |
||||
EXPECT_EQ(3, n[2]); |
||||
EXPECT_EQ(0, n[3]); |
||||
EXPECT_EQ('\0', ch[0]); |
||||
EXPECT_EQ('\0', ch[1]); |
||||
EXPECT_EQ('\0', ch[2]); |
||||
EXPECT_EQ('\0', ch[3]); |
||||
|
||||
// Tests first and last are iterators.
|
||||
std::string letters = "abc"; |
||||
a = SetArrayArgument<2>(letters.begin(), letters.end()); |
||||
std::fill_n(n, 4, 0); |
||||
std::fill_n(ch, 4, '\0'); |
||||
a.Perform(make_tuple(true, pn, pch)); |
||||
EXPECT_EQ(0, n[0]); |
||||
EXPECT_EQ(0, n[1]); |
||||
EXPECT_EQ(0, n[2]); |
||||
EXPECT_EQ(0, n[3]); |
||||
EXPECT_EQ('a', ch[0]); |
||||
EXPECT_EQ('b', ch[1]); |
||||
EXPECT_EQ('c', ch[2]); |
||||
EXPECT_EQ('\0', ch[3]); |
||||
} |
||||
|
||||
// Tests SetArrayArgument<N>(first, last) where first == last.
|
||||
TEST(SetArrayArgumentTest, SetsTheNthArrayWithEmptyRange) { |
||||
typedef void MyFunction(bool, int*); |
||||
int numbers[] = { 1, 2, 3 }; |
||||
Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers); |
||||
|
||||
int n[4] = {}; |
||||
int* pn = n; |
||||
a.Perform(make_tuple(true, pn)); |
||||
EXPECT_EQ(0, n[0]); |
||||
EXPECT_EQ(0, n[1]); |
||||
EXPECT_EQ(0, n[2]); |
||||
EXPECT_EQ(0, n[3]); |
||||
} |
||||
|
||||
// Tests SetArrayArgument<N>(first, last) where *first is convertible
|
||||
// (but not equal) to the argument type.
|
||||
TEST(SetArrayArgumentTest, SetsTheNthArrayWithConvertibleType) { |
||||
typedef void MyFunction(bool, char*); |
||||
int codes[] = { 97, 98, 99 }; |
||||
Action<MyFunction> a = SetArrayArgument<1>(codes, codes + 3); |
||||
|
||||
char ch[4] = {}; |
||||
char* pch = ch; |
||||
a.Perform(make_tuple(true, pch)); |
||||
EXPECT_EQ('a', ch[0]); |
||||
EXPECT_EQ('b', ch[1]); |
||||
EXPECT_EQ('c', ch[2]); |
||||
EXPECT_EQ('\0', ch[3]); |
||||
} |
||||
|
||||
// Test SetArrayArgument<N>(first, last) with iterator as argument.
|
||||
TEST(SetArrayArgumentTest, SetsTheNthArrayWithIteratorArgument) { |
||||
typedef void MyFunction(bool, std::back_insert_iterator<std::string>); |
||||
std::string letters = "abc"; |
||||
Action<MyFunction> a = SetArrayArgument<1>(letters.begin(), letters.end()); |
||||
|
||||
std::string s; |
||||
a.Perform(make_tuple(true, back_inserter(s))); |
||||
EXPECT_EQ(letters, s); |
||||
} |
||||
|
||||
} // namespace gmock_generated_actions_test
|
||||
} // namespace testing
|
||||
Loading…
Reference in new issue