// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Silence C4503 (decorated name length exceeded) for MSVC.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4503)
+#endif
// Google Mock - a framework for writing C++ mock classes.
//
// 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>
using testing::ReturnRef;
using testing::TypedEq;
-template<typename T>
+template <typename T>
class TemplatedCopyable {
public:
TemplatedCopyable() {}
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;
// 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)
+#pragma warning(push)
+#pragma warning(disable : 4373)
#endif
class MockFoo : public FooInterface {
public:
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 {
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)
+#pragma warning(pop)
#endif
template <class T>
MOCK_METHOD(void, DoB, ());
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
+ MockB(const MockB&) = delete;
+ MockB& operator=(const MockB&) = delete;
};
class LegacyMockB {
MOCK_METHOD0(DoB, void());
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockB);
+ LegacyMockB(const LegacyMockB&) = delete;
+ LegacyMockB& operator=(const LegacyMockB&) = delete;
};
template <typename 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>
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>
.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);
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));
(Calltype(STDMETHODCALLTYPE), override, const));
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStackWithCallType);
+ MockStackWithCallType(const MockStackWithCallType&) = delete;
+ MockStackWithCallType& operator=(const MockStackWithCallType&) = delete;
};
template <typename 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>
.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);
MY_MOCK_METHODS1_;
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnArgNumber);
+ MockOverloadedOnArgNumber(const MockOverloadedOnArgNumber&) = delete;
+ MockOverloadedOnArgNumber& operator=(const MockOverloadedOnArgNumber&) =
+ delete;
};
class LegacyMockOverloadedOnArgNumber {
LEGACY_MY_MOCK_METHODS1_;
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockOverloadedOnArgNumber);
+ LegacyMockOverloadedOnArgNumber(const LegacyMockOverloadedOnArgNumber&) =
+ delete;
+ LegacyMockOverloadedOnArgNumber& operator=(
+ const LegacyMockOverloadedOnArgNumber&) = delete;
};
template <typename T>
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:
MY_MOCK_METHODS2_;
private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnConstness);
+ MockOverloadedOnConstness(const MockOverloadedOnConstness&) = delete;
+ MockOverloadedOnConstness& operator=(const MockOverloadedOnConstness&) =
+ delete;
};
TEST(MockMethodOverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) {
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());
}
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));
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));
}
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));
}
template <typename F>
-struct AlternateCallable {
-};
+struct AlternateCallable {};
TYPED_TEST(MockMethodMockFunctionSignatureTest,
IsMockFunctionTemplateArgumentDeducedForAlternateCallable) {
EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
}
-TYPED_TEST(
- MockMethodMockFunctionSignatureTest,
- IsMockFunctionCallMethodSignatureTheSameForAlternateCallable) {
+TYPED_TEST(MockMethodMockFunctionSignatureTest,
+ IsMockFunctionCallMethodSignatureTheSameForAlternateCallable) {
using ForRawSignature = decltype(&MockFunction<TypeParam>::Call);
using ForStdFunction =
decltype(&MockFunction<std::function<TypeParam>>::Call);
EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
}
-
struct MockMethodSizes0 {
MOCK_METHOD(void, func, ());
};
};
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));