GoogleMock初探(0)

在进行测试过程中，待测的类或者方法经常会依赖其他类或方法的实现。如果此时这些依赖还没有实现，则需要打桩。另外测试讲求独立，测试之间的互相依赖会导致测试最终混乱不堪。

GoogleMock提供一套方法来快速的实现打桩，并让打桩的类或者方法轻松的按照你的要求来进行一系列动作。

现在有一个还没实现具体方法的的抽象基类

//MyClass.hpp
#pragma once

class MyClass
{
public:virtual int add(int a, int b) = 0;

    virtual int plus(int a, int b) = 0;
};

一个要使用其方法的类

//UseMyClass.hpp
#pragma once

#include "MyClass.hpp"

class UseMyClass
{
public:
    int useAddAndPlus(int a, int b)
    {
        return myclass->add(a, b) + myclass->plus(a, b);
    }

    void set(MyClass* m)
    {
        myclass = m;
    }
private:
    MyClass* myclass;
};

现在要对UseMyClass进行单元测试，但它的方法又依赖于MyClass中方法的实现，这种情况下就要对MyClass进行mock

//MockMyClass.hpp
#pragma once

#include <gmock/gmock.h>
#include "MyClass.hpp"

class MockMyClass : public MyClass
{
public:
    MOCK_METHOD2(add, int(int a, int b));
    MOCK_METHOD2(plus, int(int a, int b));
};

最后在测试的时候调用mock的方法，并设置其预期的动作

//MockTest.cpp
#include <gtest/gtest.h>
#include "UseMyClass.hpp"
#include "MockMyClass.hpp"

TEST(TestUseMyClass, useAddAndPlus)
{
    UseMyClass useMyClass;
    MockMyClass mockMyClass;
    EXPECT_CALL(mockMyClass, add(1,1)).WillOnce(testing::Return(2));
    EXPECT_CALL(mockMyClass, plus(1,1)).WillOnce(testing::Return(1));
    useMyClass.set(&mockMyClass);
    EXPECT_EQ(3, useMyClass.useAddAndPlus(1, 1));
}

编译

g++ mockTest.cpp -lgtest -lgtest_main -lgmock  -lpthread -o myMock

运行结果

以上就是一个简单的使用GoogleMock的例子。下面介绍一下如何写mock的代码：

1. 必须包含头文件<gmock/hmock.h>

2. 对于一个待mock的方法

ReturnType func(arg0, arg1,....)

其mock方法的书写方式为:

MOCK_METHODn(func, ReturnType(arg0, arg1, ...))

其中n为参数个数

3. 对于在测试中mock方法的期待动作的基础写法：

EXPECT_CALL(mock_object, method(matchers))
    .Times(cardinality)
    .WillOnce(action)
    .WillRepeatedly(action);

EXPECT_CALL声明一个调用期待，就是我们期待这个对象的这个方法按什么样的逻辑去执行。

mock_object是mock的对象，例如上例中的mockMyClass

method是mock的方法，例如上例中的add, plus

Times表示这个方法期望被执行多少次

WillOnce表示执行一次方法时，将执行其参数action的方法。一般我们使用Return方法，用于指定一次调用的输出

WillRepeatedly表示一直调用方法时，将执行其参数action的方法。需要注意下它和WillOnce的区别，WillOnce是一次，WillRepeatedly是一直

举个例子：

EXPECT_CALL(mockMyClass, add(_,_))
    .Times(6)
    .WillOnce(Return(2))
    .WillRepeatedly(Return(3))

这个例子表示，我们期望MyClass类的一个实例的方法add被调用6次，被调用是传入的参数不指定，但第一次被调用返回6，后面每次被调用返回3

例外注意，Times(cardinality) WillOnce(action) WillRepeatedly(action) 都不是必须要写的，按你自己的需要去选择要写哪个或者哪些

在公司的测试代码中像上例这种情况很少见，公司代码中mock不是为了为那些没有实现的方法打桩，而是为了减少UT之间的相互依赖。

试想如果class A 依赖于class B的实现，如果不给B打桩的话，A的UT肯定会依赖于B的实现，而有了mock则可以直接对依赖B的方法直接打桩而不去管B的真正实现，减少了测试的耦合性，使得测试间互相独立，容易调试。

下面对这种减少依赖而使用mock的情况举个例子：

一个实现其自己的方法的MyClass

//MyClass.hpp
#pragma once

#ifdef UT
#include "MockMyClass.hpp"
class MyClass_orig
#else
class MyClass
#endif
{
public:
    int add(int a, int b)
    {
        return a + b;
    }

    int plus(int a, int b)
    {
        return a * b;
    }
};

一个类的方法依赖于其他类（MyClass）方法的类UseMyClass

//UseMyClass.hpp
#pragma once

#include "MyClass.hpp"

class UseMyClass
{
public:
    int useAddAndPlus(int a, int b)
    {
        return myclass->add(a, b) + myclass->plus(a, b);
    }

    void set(MyClass* m)
    {
        myclass = m;
    }
private:
    MyClass* myclass;
};

对MyClass进行mock

//MockMyClass.hpp
#pragma once

#include <gmock/gmock.h>
 
class MyClass
{
public:
    MOCK_METHOD2(add, int(int a, int b));
    MOCK_METHOD2(plus, int(int a, int b));
};

最后对UseMyClass 进行测试

#define UT

#include <gtest/gtest.h>
#include "UseMyClass.hpp"


TEST(TestUseMyClass, useAddAndPlus)
{
    UseMyClass useMyClass;
    MyClass mockMyClass;
    EXPECT_CALL(mockMyClass, add(1,1)).WillOnce(testing::Return(2));
    EXPECT_CALL(mockMyClass, plus(1,1)).WillOnce(testing::Return(2));
    useMyClass.set(&mockMyClass);
    EXPECT_EQ(3, useMyClass.useAddAndPlus(1, 1));
}

编译

g++ mockTest.cpp -lgtest -lgtest_main -lgmock  -lpthread -o myMock

运行结果

注意，我故意让plus返回2，这样可以看出最后测试的时候用的是mock的类方法而非真正的类方法。

参考文章：

https://github.com/google/googletest/blob/master/googlemock/docs/ForDummies.md