Gtest and gmock in below code snippet though error

Question

How to achieve gtest or gmock for the private and protected member function. I am new to gtest and gmock. Below is the code for which i need to do gtest or gmock along with my attemp.

constexpr static char _session[]{"S_ID"};

typedef struct {
    int  session;

} Session;

typedef std::function<void(const Session &)> SessionCallback_t;

class Service : public ParentService {
public:
    Service();

    void registerCallback(const SessionCallback_t & callback);

protected:
    virtual void notifyHandler(const Json::Value & data) override;
    virtual void notifyState();
private:
   
    Session mSession;
    SessionCallback_t mCallback;

    void jsonParse(const Json::Value & json_data);
};

My Attemp which doesn't compile

class TestService : public Service {
        public:
        TestService(): Service() {
        }
        bool registerCallback(const SessionCallback_t & cb) {
           // how to achive this?
              
        }


};


class MyTestService : public ::testing::Test {
    
protected:
  virtual void SetUp() {
  }

  virtual void TearDown() {
    
  }
};

 

TEST_F(MyTestService , registerCallbackTest) {
      TestService service;
       EXPECT_TRUE(service.registerCallback(SessionCallback_t));
    
}   

I am stuck with the below interface

1.registerCallback()

2.notifyHandler()

3.notifyState()

4.jsonParse()

Please though some light to proceed further.

Answer 1

Welcome to Stack Overflow!

First, let me recommend this recent episode of CppCast on Designing for Testing. The podcast notes that if you find your code is hard to test, it means it is too tightly coupled and is thus poorly designed.

It also (rightly, IMHO) recommends that you test only public functions. If you find yourself needing to test the private functions, you should probably refactor the code.

One way to do that is to break your code into multiple classes with the public functions you want to test. Then, your composite class can either create and own the class directly (appropriate if it's a basic type with no dependencies or complex resources of its own such as a vector or string class) or can use dependency injection to pass in the dependencies as constructor or method parameters (appropriate for databases, network connections, file systems, etc.).

Then in testing, you pass in a test double, such as a mocked object or a simplified implementation like an in-memory database instead of an out-of-process database connection, that acts like the object but does what you need in the test situation.

That's the basic advice. In your specific case, it looks like you're trying to override a non-virtual function in your TestService. What are you wanting to test exactly?

I wouldn't expect EXPECT_TRUE(service.registerCallback(SessionCallback_t)); to compile because SessionCallback_t names a type, not an instance of a type, so you can't pass it in. Again, what are you trying to accomplish?

---

Update to comment:

Mocking requires virtual functions (or duck typing) and dependency injection.

If you just want to test registerCallback(), I suspect you don't need a mock at all. Rather, you need to look at the function's documentation to see what it says it will do -- sometimes called the contract. For instance, what are the preconditions and postconditions of the function? What are the error cases it might encounter? These are what a unit test should cover.

For instance, does it retain only one callback (hint: as written, yes)? What happens when you call it when there is already a callback registered? Does it tolerate default-initialized std::function objects being passed in?

The bigger question is, how do you validate that your test is correct. If you start triggering notifications on your callback, you're venturing beyond the scope of testing this function in isolation. Instead, you could create an accessor class in your test to publicize what is private so you can validate. Still, you can't compare std::function for equality, so the best you can do is to invoke it and check that an expected side effect happens:

class TestService : public Service {
public:
    const SessionCallback_t& getCallback() const { return mCallback; }
};

struct TestCallback
{
    int mCount = 0;
    void operator()( const Session& ) { ++mCount; }
};

Then in your test, you can write a tests like:

TEST_F(MyTestService , Test_registerCallback_BadCallback) {
    auto service = TestService{};
    EXPECT_THROW( service.registerCallback( SessionCallback_t{} ), std::out_of_range );
}   

// Register and check that it's our callback
TEST_F(MyTestService , Test_registerCallback_CallbackSaved) {
    auto service  = TestService{};
    auto callback = TestCallback{};

    EXPECT_TRUE( service.registerCallback( callback ) );
    EXPECT_EQ( callback.mCount, 0 );

    auto actualCallback = service.getCallback();
    EXPECT_TRUE( actualCallback );

    actualCallback();
    EXPECT_EQ( callback.mCount, 1 );
}   

TEST_F(MyTestService , Test_registerCallback_CallbackOverwrite) {
    auto service   = TestService{};
    auto callback1 = TestCallback{};
    auto callback2 = TestCallback{};

    EXPECT_TRUE( service.registerCallback( callback1 ) );
    EXPECT_TRUE( service.registerCallback( callback2 ) );
    EXPECT_EQ( callback1.mCount, 0 );
    EXPECT_EQ( callback2.mCount, 0 );

    auto actualCallback = service.getCallback();
    EXPECT_TRUE( actualCallback );

    actualCallback();
    EXPECT_EQ( callback1.mCount, 0 );
    EXPECT_EQ( callback2.mCount, 1 );
}