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