通过 setargreferee 传递向量时，gtest 中未实现 EXPECT_CALL

Question

#include <gtest/gtest.h>
#include <gmock/gmock.h>

enum class InfoState : uint8_t
{
    OFF     = 0,
    ON      = 1,

};

class MyInfo
{
public:
    MyInfo(){};
    MyInfo(const MyInfo&){};
    MyInfo& operator=(const MyInfo&){}
    MOCK_METHOD0(getState, InfoState(void));
};

class ServiceClient
{
public:
    MOCK_METHOD1(getInfo, bool(std::vector<MyInfo> &myInfoList));
};

class MyClassA
{
public:
    ServiceClient m_serviceClient;

    void updateStatus()
    {
        std::vector<MyInfo> myInfoList;
        if (m_serviceClient.getInfo(myInfoList))
        {
            for (auto& info: myInfoList)
            {
                if (InfoState::ON == info.getState())
                {
                    //notifyObservers(true);
                    break;
                }
            }
        }
    }
};

TEST(infoTest, test1)
{
    MyClassA testObj;

    std::vector<MyInfo> myTestInfoList(1);

    EXPECT_CALL(myTestInfoList[0], getState()).WillOnce(::testing::Return(InfoState::ON));

    EXPECT_CALL(testObj.m_serviceClient, getInfo(::testing::_))
         .WillOnce(::testing::DoAll(::testing::SetArgReferee<0(myTestInfoList),::testing::Return(true)));

    testObj.updateStatus();
}

I want to test MyClassA::updateStatus method. In this case I want to set on MyInfo object inside myTestInfoList EXPECT_CALL with return value InfoState::ON. Then I put my list to tested method by SetArgReferee. When it comes to execution of info.getState() it returns InfoState::OFF and gtest says "Uninteresting mock function call - returning default value.". Why this problem occurs and how I can test it ?

Answer 1

As Quarra comment, the main problem is a copy constructor. I am not a Google Test specialist, yet I found a solution to your problem.

As per GMock , I found out that mocked objects cannot be copied - this is the design principle and the decision of Google Test implementers. Here this decision has been justified back in 2009.

Therefore by not defining the copy constructor inside of mocked objects, it will be deleted ( live code ). Here is the error code

/opt/compiler-explorer/libs/googletest/release-1.10.0/googlemock/include/gmock/gmock-spec-builders.h:1483:3: note: 'FunctionMocker' has been explicitly marked deleted here

  FunctionMocker(const FunctionMocker&) = delete;

Yet the main problem here is in fact the actual need of a copy constructor, and this is caused by two factors:

1. As I stated before GMock by design deletes copy construction, and even if you will create your own implementation - all EXPECT_CALL and other GMock essential functionalities would not be copied! This is exactly the issue you are having. So you've created a custom copy constructor, and all GMock functionality is gone. Despite the fact that this constructor is empty - it will not work out of the box anyway.

MyInfo(const MyInfo&){};

2. Second problem is the std::vector which you are using demands from you (in this use-case) that the type meets the CopyConstructible concept. Therefore this will not work.

What concerns me is the fact that EXPECT_CALL is using copy instead of move semantics or passing a reference. This is done despite the fact that you explicitly set that argument shall be a reference (not a copy!) SetArgReferee<0>(myTestInfoList) . Moreover by design GMock objects are not copyable. This looks like a design flaw or bug to me, yet I am not a Google Test expert. I will do more research on that and maybe raise a bug report/question to GTest implementors.

Ok but to find the solution we need to first find a method in GMock API which do not use a copy, and afterward use std::vector functionality which is not calling a copy constructor.

The first problem will be solved by changing EXPECT_CALL to ON_CALL and to open the possibility for calling std::vector functionality we will also use Invoke from GMock API. ( Live code )

TEST(infoTest, test1)
{
    MyClassA testObj;

    std::vector<MyInfo> myTestInfoList(1);

    ON_CALL(myTestInfoList[0], getState()).WillByDefault(::testing::Invoke(
            []()
            {
                return InfoState::ON;
            }));

    ON_CALL(testObj.m_serviceClient, getInfo(::testing::_))
         .WillByDefault(::testing::Invoke(
            [](std::vector<MyInfo> &myInfoList)
            {
                return true;
            }));

    testObj.updateStatus();
}

This works with explicitly deleted copy constructor -> MyInfo(const MyInfo&) = delete; yet logic is also deleted right now.

To overcome the second problem, which is STL copy, we can simply use std::swap and fill passed std::vector& . Swapping values doesn't copy the data - hence we are good to go.

    ON_CALL(testObj.m_serviceClient, getInfo(::testing::_))
         .WillByDefault(::testing::Invoke(
            [&myTestInfoList](std::vector<MyInfo> &myInfoList)
            {
                std::swap(myInfoList, myTestInfoList);
                return true;
            }));

here is the working solution .

As said before I will try to investigate why GMock EXPECT_CALL forces a copy.