C++ Gmock - test function which uses shared_ptr <FactoryClass> - c++

Question

I am new to gtest/gmock and trying to test a simple function in c++ which has a two pointers 'm_propBsh_p' and 'm_eBsh_p'; these pointers becomes valid after some factory-creations, however i do not want to get involve in factory classes complexities and callbacks.
Following is the function definition that i want to write test for:
std::string Foo::toString(const std::string &indent) const
{
....
std::string str =
(m_propBsh_p != nullptr) ? m_propBsh_p -> toString("P-BSH: ") : "-";
str +=
(m_eBsh_p != nullptr) ? m_eBsh_p -> toString("E-BSH: ") : "-";
return str;
}
Since I am just interested in testing this particular toString function therefore I just want to have valid pointers for 'm_propBsh_p' and 'm_eBsh_p'. I am aiming/trying for something like following:
//Assuming to have mocked class for pointers
std::shared_ptr<MockedBshClass> m_mockEBsh_p;
std::shared_ptr<MockedBshClass> m_mockPropBsh_p;
TEST_F(FooTest, toStringBshInfoPass)
{
std::string eBshAndpBshStr = "eBshAndpBshStr";
ON_CALL(*m_mockPropBsh_p, toString(_)).WillByDefault(Return(eBshAndpBshStr));
ON_CALL(*m_mockEBsh_p, toString(_)).WillByDefault(Return(eBshAndpBshStr ));
//EXPECT_CALL((*m_mockPropBsh_p), toString(_)).Times(1);
//EXPECT_CALL((*m_mockEBsh_p), toString(_)).Times(1);
//Call mock or some fake function which makes m_propBsh_p & m_eBsh_p valid.
foo->makePtrValidAgain(); //however this is a complex function which bring more callbacks and complexity and i do not want to call, instead i want to have some fake/mocked function which just gives me valid pointers
EXPECT_THAT(foo->toString(""),HasSubstr(eBshAndpBshStr+eBshAndpBshStr));
}
Following is bit background of the Foo class and pointers:
Class Foo : fooParent..
{
...
void makePtrValidAgain();
std::string toString();
..
typedef std::shared_ptr<BshClass> m_propBsh_p;
typedef std::shared_ptr<BshClass> m_eBsh_p;
...
};
void Foo::makePtrValidAgain()
{
...
auto someFactory = m_dependencyContainer->get<bssh::SomeFactory>();
assert(someFactory);
auto nextTask = [this](std::uint32_t dummy){runAfterFoo();};
m_propBsh_p = someFactory->create(callback, nextTask);
m_propBsh_p->execute();
...
//and same happens with m_eBsh_p
return;
}
I am not sure, what is a best way to avoid complexity for test of such simple function using gmock/gtest, purpose for me is to have valid pointers as mentioned above.

Answer 1

First of all, it seems your ON_CALLs are incorrect. You mock the BshClass, so you want to create expectations on methods of BshClass (and toString() isn't one). You should mock for example
ON_CALL(*m_mockEBsh_p, execute())/*stuff to do*/;
To answer your question:
If the factory is used in Foo constructor already (you passed your mock pointers to m_propBsh_p and m_eBsh_p), then you could just use std::shared_ptr functionality to control if they point to something or not (e.g. via reset()).
Otherwise, it seems a good idea to extract factory method from makePtrValidAgain() - this function already has more than one responsibility, it creates pointers and calls methods on them.
I'd propose something like:
Class Foo : fooParent..
{
...
void makePtrValidAgain();
std::string toString();
..
private:
void resetPointers();
typedef std::shared_ptr<BshClass> m_propBsh_p;
typedef std::shared_ptr<BshClass> m_eBsh_p;
...
};
void Foo::makePtrValidAgain()
{
...
resetPointers(); //if needed
m_propBsh_p->execute();
...
//and same happens with m_eBsh_p
}
void resetPointers()
{
auto someFactory = m_dependencyContainer->get<bssh::SomeFactory>();
assert(someFactory);
auto nextTask = [this](std::uint32_t dummy){runAfterFoo();};
m_propBsh_p = someFactory->create(callback, nextTask);
//also with the other pointer
//or better pass the pointer to reset as argument if possible
}
and call resetPointers() in Foo constructor if possible. Or make it public and call it from UT. This way the problem falls down to first option with m_propBsh_p and m_eBsh_p being set and you have access to them from UT via your mock pointers.