aboutsummaryrefslogtreecommitdiff
path: root/googlemock/test/gmock-function-mocker_test.cc
diff options
context:
space:
mode:
Diffstat (limited to 'googlemock/test/gmock-function-mocker_test.cc')
-rw-r--r--googlemock/test/gmock-function-mocker_test.cc196
1 files changed, 110 insertions, 86 deletions
diff --git a/googlemock/test/gmock-function-mocker_test.cc b/googlemock/test/gmock-function-mocker_test.cc
index 45a524e2..f7b31ae3 100644
--- a/googlemock/test/gmock-function-mocker_test.cc
+++ b/googlemock/test/gmock-function-mocker_test.cc
@@ -27,17 +27,19 @@
// (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 tests the function mocker classes.
#include "gmock/gmock-function-mocker.h"
-#if GTEST_OS_WINDOWS
+// Silence C4503 (decorated name length exceeded) for MSVC.
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4503)
+
+#ifdef GTEST_OS_WINDOWS
// MSDN says the header file to be included for STDMETHOD is BaseTyps.h but
// we are getting compiler errors if we use basetyps.h, hence including
// objbase.h for definition of STDMETHOD.
-# include <objbase.h>
+#include <objbase.h>
#endif // GTEST_OS_WINDOWS
#include <functional>
@@ -65,10 +67,10 @@ using testing::Return;
using testing::ReturnRef;
using testing::TypedEq;
-template<typename T>
+template <typename T>
class TemplatedCopyable {
public:
- TemplatedCopyable() {}
+ TemplatedCopyable() = default;
template <typename U>
TemplatedCopyable(const U& other) {} // NOLINT
@@ -76,13 +78,13 @@ class TemplatedCopyable {
class FooInterface {
public:
- virtual ~FooInterface() {}
+ virtual ~FooInterface() = default;
virtual void VoidReturning(int x) = 0;
virtual int Nullary() = 0;
virtual bool Unary(int x) = 0;
- virtual long Binary(short x, int y) = 0; // NOLINT
+ virtual long Binary(short x, int y) = 0; // NOLINT
virtual int Decimal(bool b, char c, short d, int e, long f, // NOLINT
float g, double h, unsigned i, char* j,
const std::string& k) = 0;
@@ -118,7 +120,7 @@ class FooInterface {
virtual int RefQualifiedOverloaded() & = 0;
virtual int RefQualifiedOverloaded() && = 0;
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
STDMETHOD_(int, CTNullary)() = 0;
STDMETHOD_(bool, CTUnary)(int x) = 0;
STDMETHOD_(int, CTDecimal)
@@ -132,13 +134,10 @@ class FooInterface {
// significant in determining whether two virtual functions had the same
// signature. This was fixed in Visual Studio 2008. However, the compiler
// still emits a warning that alerts about this change in behavior.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable : 4373)
-#endif
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4373)
class MockFoo : public FooInterface {
public:
- MockFoo() {}
+ MockFoo() = default;
// Makes sure that a mock function parameter can be named.
MOCK_METHOD(void, VoidReturning, (int n)); // NOLINT
@@ -179,7 +178,7 @@ class MockFoo : public FooInterface {
MOCK_METHOD(int (*)(bool), ReturnsFunctionPointer1, (int), ());
MOCK_METHOD(fn_ptr, ReturnsFunctionPointer2, (int), ());
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
MOCK_METHOD(int, CTNullary, (), (Calltype(STDMETHODCALLTYPE)));
MOCK_METHOD(bool, CTUnary, (int), (Calltype(STDMETHODCALLTYPE)));
MOCK_METHOD(int, CTDecimal,
@@ -203,12 +202,13 @@ class MockFoo : public FooInterface {
MOCK_METHOD(int, RefQualifiedOverloaded, (), (ref(&&), override));
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
+ MockFoo(const MockFoo&) = delete;
+ MockFoo& operator=(const MockFoo&) = delete;
};
class LegacyMockFoo : public FooInterface {
public:
- LegacyMockFoo() {}
+ LegacyMockFoo() = default;
// Makes sure that a mock function parameter can be named.
MOCK_METHOD1(VoidReturning, void(int n)); // NOLINT
@@ -248,7 +248,7 @@ class LegacyMockFoo : public FooInterface {
MOCK_METHOD1(ReturnsFunctionPointer1, int (*(int))(bool));
MOCK_METHOD1(ReturnsFunctionPointer2, fn_ptr(int));
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTNullary, int());
MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTUnary, bool(int)); // NOLINT
MOCK_METHOD10_WITH_CALLTYPE(STDMETHODCALLTYPE, CTDecimal,
@@ -275,12 +275,11 @@ class LegacyMockFoo : public FooInterface {
int RefQualifiedOverloaded() && override { return 0; }
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockFoo);
+ LegacyMockFoo(const LegacyMockFoo&) = delete;
+ LegacyMockFoo& operator=(const LegacyMockFoo&) = delete;
};
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4373
template <class T>
class FunctionMockerTest : public testing::Test {
@@ -405,7 +404,7 @@ TYPED_TEST(FunctionMockerTest, MocksTypeWithTemplatedCopyCtor) {
EXPECT_TRUE(this->foo_->TypeWithTemplatedCopyCtor(TemplatedCopyable<int>()));
}
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
// Tests mocking a nullary function with calltype.
TYPED_TEST(FunctionMockerTest, MocksNullaryFunctionWithCallType) {
EXPECT_CALL(this->mock_foo_, CTNullary())
@@ -488,22 +487,24 @@ TEST(FunctionMockerTest, RefQualified) {
class MockB {
public:
- MockB() {}
+ MockB() = default;
MOCK_METHOD(void, DoB, ());
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
+ MockB(const MockB&) = delete;
+ MockB& operator=(const MockB&) = delete;
};
class LegacyMockB {
public:
- LegacyMockB() {}
+ LegacyMockB() = default;
MOCK_METHOD0(DoB, void());
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockB);
+ LegacyMockB(const LegacyMockB&) = delete;
+ LegacyMockB& operator=(const LegacyMockB&) = delete;
};
template <typename T>
@@ -533,7 +534,7 @@ TYPED_TEST(ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOfTimes) {
template <typename T>
class StackInterface {
public:
- virtual ~StackInterface() {}
+ virtual ~StackInterface() = default;
// Template parameter appears in function parameter.
virtual void Push(const T& value) = 0;
@@ -546,7 +547,7 @@ class StackInterface {
template <typename T>
class MockStack : public StackInterface<T> {
public:
- MockStack() {}
+ MockStack() = default;
MOCK_METHOD(void, Push, (const T& elem), ());
MOCK_METHOD(void, Pop, (), (final));
@@ -558,13 +559,14 @@ class MockStack : public StackInterface<T> {
MOCK_METHOD((std::map<int, int>), ReturnTypeWithComma, (int), (const));
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStack);
+ MockStack(const MockStack&) = delete;
+ MockStack& operator=(const MockStack&) = delete;
};
template <typename T>
class LegacyMockStack : public StackInterface<T> {
public:
- LegacyMockStack() {}
+ LegacyMockStack() = default;
MOCK_METHOD1_T(Push, void(const T& elem));
MOCK_METHOD0_T(Pop, void());
@@ -576,7 +578,8 @@ class LegacyMockStack : public StackInterface<T> {
MOCK_CONST_METHOD1_T(ReturnTypeWithComma, std::map<int, int>(int)); // NOLINT
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockStack);
+ LegacyMockStack(const LegacyMockStack&) = delete;
+ LegacyMockStack& operator=(const LegacyMockStack&) = delete;
};
template <typename T>
@@ -595,10 +598,8 @@ TYPED_TEST(TemplateMockTest, Works) {
.WillOnce(Return(0));
EXPECT_CALL(mock, Push(_));
int n = 5;
- EXPECT_CALL(mock, GetTop())
- .WillOnce(ReturnRef(n));
- EXPECT_CALL(mock, Pop())
- .Times(AnyNumber());
+ EXPECT_CALL(mock, GetTop()).WillOnce(ReturnRef(n));
+ EXPECT_CALL(mock, Pop()).Times(AnyNumber());
EXPECT_EQ(0, mock.GetSize());
mock.Push(5);
@@ -612,16 +613,14 @@ TYPED_TEST(TemplateMockTest, MethodWithCommaInReturnTypeWorks) {
TypeParam mock;
const std::map<int, int> a_map;
- EXPECT_CALL(mock, ReturnTypeWithComma())
- .WillOnce(Return(a_map));
- EXPECT_CALL(mock, ReturnTypeWithComma(1))
- .WillOnce(Return(a_map));
+ EXPECT_CALL(mock, ReturnTypeWithComma()).WillOnce(Return(a_map));
+ EXPECT_CALL(mock, ReturnTypeWithComma(1)).WillOnce(Return(a_map));
EXPECT_EQ(a_map, mock.ReturnTypeWithComma());
EXPECT_EQ(a_map, mock.ReturnTypeWithComma(1));
}
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
// Tests mocking template interfaces with calltype.
template <typename T>
@@ -650,7 +649,8 @@ class MockStackWithCallType : public StackInterfaceWithCallType<T> {
(Calltype(STDMETHODCALLTYPE), override, const));
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStackWithCallType);
+ MockStackWithCallType(const MockStackWithCallType&) = delete;
+ MockStackWithCallType& operator=(const MockStackWithCallType&) = delete;
};
template <typename T>
@@ -664,7 +664,9 @@ class LegacyMockStackWithCallType : public StackInterfaceWithCallType<T> {
MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetTop, const T&());
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockStackWithCallType);
+ LegacyMockStackWithCallType(const LegacyMockStackWithCallType&) = delete;
+ LegacyMockStackWithCallType& operator=(const LegacyMockStackWithCallType&) =
+ delete;
};
template <typename T>
@@ -685,10 +687,8 @@ TYPED_TEST(TemplateMockTestWithCallType, Works) {
.WillOnce(Return(0));
EXPECT_CALL(mock, Push(_));
int n = 5;
- EXPECT_CALL(mock, GetTop())
- .WillOnce(ReturnRef(n));
- EXPECT_CALL(mock, Pop())
- .Times(AnyNumber());
+ EXPECT_CALL(mock, GetTop()).WillOnce(ReturnRef(n));
+ EXPECT_CALL(mock, Pop()).Times(AnyNumber());
EXPECT_EQ(0, mock.GetSize());
mock.Push(5);
@@ -711,22 +711,27 @@ TYPED_TEST(TemplateMockTestWithCallType, Works) {
class MockOverloadedOnArgNumber {
public:
- MockOverloadedOnArgNumber() {}
+ MockOverloadedOnArgNumber() = default;
MY_MOCK_METHODS1_;
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnArgNumber);
+ MockOverloadedOnArgNumber(const MockOverloadedOnArgNumber&) = delete;
+ MockOverloadedOnArgNumber& operator=(const MockOverloadedOnArgNumber&) =
+ delete;
};
class LegacyMockOverloadedOnArgNumber {
public:
- LegacyMockOverloadedOnArgNumber() {}
+ LegacyMockOverloadedOnArgNumber() = default;
LEGACY_MY_MOCK_METHODS1_;
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockOverloadedOnArgNumber);
+ LegacyMockOverloadedOnArgNumber(const LegacyMockOverloadedOnArgNumber&) =
+ delete;
+ LegacyMockOverloadedOnArgNumber& operator=(
+ const LegacyMockOverloadedOnArgNumber&) = delete;
};
template <typename T>
@@ -747,18 +752,20 @@ TYPED_TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) {
EXPECT_TRUE(mock.Overloaded(true, 1));
}
-#define MY_MOCK_METHODS2_ \
- MOCK_CONST_METHOD1(Overloaded, int(int n)); \
- MOCK_METHOD1(Overloaded, int(int n))
+#define MY_MOCK_METHODS2_ \
+ MOCK_CONST_METHOD1(Overloaded, int(int n)); \
+ MOCK_METHOD1(Overloaded, int(int n))
class MockOverloadedOnConstness {
public:
- MockOverloadedOnConstness() {}
+ MockOverloadedOnConstness() = default;
MY_MOCK_METHODS2_;
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnConstness);
+ MockOverloadedOnConstness(const MockOverloadedOnConstness&) = delete;
+ MockOverloadedOnConstness& operator=(const MockOverloadedOnConstness&) =
+ delete;
};
TEST(MockMethodOverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) {
@@ -779,9 +786,7 @@ TEST(MockMethodMockFunctionTest, WorksForVoidNullary) {
TEST(MockMethodMockFunctionTest, WorksForNonVoidNullary) {
MockFunction<int()> foo;
- EXPECT_CALL(foo, Call())
- .WillOnce(Return(1))
- .WillOnce(Return(2));
+ EXPECT_CALL(foo, Call()).WillOnce(Return(1)).WillOnce(Return(2));
EXPECT_EQ(1, foo.Call());
EXPECT_EQ(2, foo.Call());
}
@@ -794,19 +799,17 @@ TEST(MockMethodMockFunctionTest, WorksForVoidUnary) {
TEST(MockMethodMockFunctionTest, WorksForNonVoidBinary) {
MockFunction<int(bool, int)> foo;
- EXPECT_CALL(foo, Call(false, 42))
- .WillOnce(Return(1))
- .WillOnce(Return(2));
- EXPECT_CALL(foo, Call(true, Ge(100)))
- .WillOnce(Return(3));
+ EXPECT_CALL(foo, Call(false, 42)).WillOnce(Return(1)).WillOnce(Return(2));
+ EXPECT_CALL(foo, Call(true, Ge(100))).WillOnce(Return(3));
EXPECT_EQ(1, foo.Call(false, 42));
EXPECT_EQ(2, foo.Call(false, 42));
EXPECT_EQ(3, foo.Call(true, 120));
}
TEST(MockMethodMockFunctionTest, WorksFor10Arguments) {
- MockFunction<int(bool a0, char a1, int a2, int a3, int a4,
- int a5, int a6, char a7, int a8, bool a9)> foo;
+ MockFunction<int(bool a0, char a1, int a2, int a3, int a4, int a5, int a6,
+ char a7, int a8, bool a9)>
+ foo;
EXPECT_CALL(foo, Call(_, 'a', _, _, _, _, _, _, _, _))
.WillOnce(Return(1))
.WillOnce(Return(2));
@@ -816,9 +819,7 @@ TEST(MockMethodMockFunctionTest, WorksFor10Arguments) {
TEST(MockMethodMockFunctionTest, AsStdFunction) {
MockFunction<int(int)> foo;
- auto call = [](const std::function<int(int)> &f, int i) {
- return f(i);
- };
+ auto call = [](const std::function<int(int)>& f, int i) { return f(i); };
EXPECT_CALL(foo, Call(1)).WillOnce(Return(-1));
EXPECT_CALL(foo, Call(2)).WillOnce(Return(-2));
EXPECT_EQ(-1, call(foo.AsStdFunction(), 1));
@@ -836,10 +837,8 @@ TEST(MockMethodMockFunctionTest, AsStdFunctionReturnsReference) {
}
TEST(MockMethodMockFunctionTest, AsStdFunctionWithReferenceParameter) {
- MockFunction<int(int &)> foo;
- auto call = [](const std::function<int(int& )> &f, int &i) {
- return f(i);
- };
+ MockFunction<int(int&)> foo;
+ auto call = [](const std::function<int(int&)>& f, int& i) { return f(i); };
int i = 42;
EXPECT_CALL(foo, Call(i)).WillOnce(Return(-1));
EXPECT_EQ(-1, call(foo.AsStdFunction(), i));
@@ -849,7 +848,7 @@ namespace {
template <typename Expected, typename F>
static constexpr bool IsMockFunctionTemplateArgumentDeducedTo(
- const MockFunction<F>&) {
+ const internal::MockFunction<F>&) {
return std::is_same<F, Expected>::value;
}
@@ -868,14 +867,14 @@ TYPED_TEST(MockMethodMockFunctionSignatureTest,
IsMockFunctionTemplateArgumentDeducedForRawSignature) {
using Argument = TypeParam;
MockFunction<Argument> foo;
- EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<Argument>(foo));
+ EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
}
TYPED_TEST(MockMethodMockFunctionSignatureTest,
IsMockFunctionTemplateArgumentDeducedForStdFunction) {
using Argument = std::function<TypeParam>;
MockFunction<Argument> foo;
- EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<Argument>(foo));
+ EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
}
TYPED_TEST(
@@ -887,12 +886,21 @@ TYPED_TEST(
EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
}
-TYPED_TEST(
- MockMethodMockFunctionSignatureTest,
- IsMockFunctionAsStdFunctionMethodSignatureTheSameForRawSignatureAndStdFunction) {
- using ForRawSignature = decltype(&MockFunction<TypeParam>::AsStdFunction);
+template <typename F>
+struct AlternateCallable {};
+
+TYPED_TEST(MockMethodMockFunctionSignatureTest,
+ IsMockFunctionTemplateArgumentDeducedForAlternateCallable) {
+ using Argument = AlternateCallable<TypeParam>;
+ MockFunction<Argument> foo;
+ EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
+}
+
+TYPED_TEST(MockMethodMockFunctionSignatureTest,
+ IsMockFunctionCallMethodSignatureTheSameForAlternateCallable) {
+ using ForRawSignature = decltype(&MockFunction<TypeParam>::Call);
using ForStdFunction =
- decltype(&MockFunction<std::function<TypeParam>>::AsStdFunction);
+ decltype(&MockFunction<std::function<TypeParam>>::Call);
EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
}
@@ -913,22 +921,21 @@ struct MockMethodSizes4 {
};
struct LegacyMockMethodSizes0 {
- MOCK_METHOD0(func, void());
+ MOCK_METHOD0(func, void());
};
struct LegacyMockMethodSizes1 {
- MOCK_METHOD1(func, void(int));
+ MOCK_METHOD1(func, void(int));
};
struct LegacyMockMethodSizes2 {
- MOCK_METHOD2(func, void(int, int));
+ MOCK_METHOD2(func, void(int, int));
};
struct LegacyMockMethodSizes3 {
- MOCK_METHOD3(func, void(int, int, int));
+ MOCK_METHOD3(func, void(int, int, int));
};
struct LegacyMockMethodSizes4 {
- MOCK_METHOD4(func, void(int, int, int, int));
+ MOCK_METHOD4(func, void(int, int, int, int));
};
-
TEST(MockMethodMockFunctionTest, MockMethodSizeOverhead) {
EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes1));
EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes2));
@@ -943,6 +950,21 @@ TEST(MockMethodMockFunctionTest, MockMethodSizeOverhead) {
EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(MockMethodSizes0));
}
+TEST(MockMethodMockFunctionTest, EnsureNoUnusedMemberFunction) {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic error "-Wunused-member-function"
+#endif
+ // https://github.com/google/googletest/issues/4052
+ struct Foo {
+ MOCK_METHOD(void, foo, ());
+ };
+ EXPECT_CALL(Foo(), foo()).Times(0);
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+}
+
void hasTwoParams(int, int);
void MaybeThrows();
void DoesntThrow() noexcept;
@@ -972,3 +994,5 @@ TEST(MockMethodMockFunctionTest, NoexceptSpecifierPreserved) {
} // namespace gmock_function_mocker_test
} // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4503
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-22 12:36:56 +0000