Accessing protected variable in googletest - c++

Question

I have this class testC that is meant for google testing
class testC : public A { };
and then bunch of TEST's that are in the same file.
TEST(test_case_name, test_name) {
... test body ...
}
A is structured like this
class A{
protected:
B b;
public:
//constructors
//destructor
//member functions
Q: How can I access b in all the TEST(){} functions through testC?
I tried to do a getter in testC
public:
testC getTest(){
testC test;
return test;
}
and i also tried with returning a reference, but no luck...

Answer 1

Try the FRIEND_TEST macro provided by googletest. Have a look in the advanced guide under Private class members.
You have to declare the test as a friend of the code under test. If I'm not mistaken you have to declare the friendship for all tests that want to access protected members.
class MySystemUnderTest
{
#ifdef _MY_UNIT_TEST
FRIEND_TEST(MySystemUnderTest_test, functionA_prereq_expected);
FRIEND_TEST(MySystemUnderTest_test, functionB_prereq_expected);
#endif
...
};
In the example above I use the preprocessor symbol _MY_UNIT_TEST to remove the declaration from productive code. The methods functionA_prereq_expected and functionB_prereq_expected would be defined in the test fixture MySystemUnderTest_test.
You have to add the FRIEND_TEST declaration in the code under test. That's the price you have to pay if you want to test against protected / private members.

Answer 2

Instead of adding the FRIEND_TEST directly into the class to be tested ClassToTest surrounded by an #ifdef statement (as suggested by the post by anhoppe) for protected members and methods I would create another class test::ClassToTest which inherits from the class to be tested and registers the test suite and the tests as friends as follows:
Inside file implementation.hpp:
namespace some {
namespace complicated {
namespace ns {
// Class that we want to test
class ClassToTest {
public:
constexpr ClassToTest() noexcept
: member_to_be_accessed{7} {
return;
}
protected:
// The protected member (or method) to be accessed
int member_to_be_accessed;
};
}
}
}
Inside the file test.hpp:
#include <gtest/gtest.h>
#include "implementation.hpp"
namespace test {
// The derived class that registers the test fixture and tests as friends
class ClassToTest : public some::complicated::ns::ClassToTest {
using some::complicated::ns::ClassToTest::ClassToTest;
friend class SomeTestFixture;
FRIEND_TEST(SomeTestFixture, someTest);
};
// The test fixture
class SomeTestFixture : public testing::Test {
protected:
SomeTestFixture() noexcept
: class_to_test{} {
return;
}
ClassToTest class_to_test;
};
// A test
TEST_F(SomeTestFixture, someTest) {
EXPECT_EQ(class_to_test.member_to_be_accessed, 7);
}
}
The advantage of this is that you clearly separate the test from the implementation and that you can get around the restriction regarding namespaces:
If the class is defined in a namespace, then in order to be friends of
the class, test fixtures and tests must be defined in the exact same
namespace, without inline or anonymous namespaces.
Furthermore, as pointed out in "Testing Private Code" section of the "Advanced GoogleTest Guide" generally the black-box approach should be used: Code should be tested through its public interface only. If you can, re-structure your code separating the interface from the implementation using the Pointer to Implementation (PImpl) design strategy and test the internals independently.