2

I need to write the gtest to test some existing code that has a non-virtual method, hence I am testing using the below source, but I am getting the compilation error

package/web/webscr/sample_template_class3.cpp: In function âint main()â: package/web/webscr/sample_template_class3.cpp:64: error: âclass Templatemyclassâ has no member named âgmock_displayâ

sample_template_class3.cpp

#include <iostream> #include <gtest/gtest.h> #include <gmock/gmock.h> using namespace std; template < class myclass> class Templatemyclass { private: myclass T; public : void display() { T.display(); } }; class Test { public: void display() { cout<<"Inside the display Test:" <<endl; } }; class MockTest { public: MOCK_METHOD0(display,void()); }; class FinalTest { public: void show( Templatemyclass<Test> t) { t.display(); cout<<"Inside the display FinalTest:" <<endl; } }; int main() { FinalTest test1; Templatemyclass<Test> obj1; Templatemyclass<MockTest> obj2; EXPECT_CALL(obj2,display()).Times(1); test1.show(obj1); return 1; }
Improve this question

2 Answers 2

Reset to default
3

There are a couple of issues in your code. I have changed it below and commented the code by way of explanation. If this is not clear enough, add a comment and I'll try and explain further.

#include <iostream> #include <gtest/gtest.h> #include <gmock/gmock.h> using namespace std; template <class myclass> class Templatemyclass { private: // Hold a non-const ref or pointer to 'myclass' so that the actual // object passed in the c'tor is used in 'display()'. If a copy is // used instead, the mock expectations will not be met. myclass* T; public : // Pass 'myclass' in the c'tor by non-const ref or pointer. explicit Templatemyclass(myclass* t) : T(t) {} void display() { T->display(); } }; class Test { public: void display() { cout << "Inside the display Test:" << endl; } }; class MockTest { public: MOCK_METHOD0(display, void()); }; class FinalTest { public: // Templatise this function so we can pass either a Templatemyclass<Test> // or a Templatemyclass<MockTest>. Pass using non-const ref or pointer // again so that the actual instance with the mock expectations set on it // will be used, and not a copy of that object. template<class T> void show(T& t) { t.display(); cout<<"Inside the display FinalTest:" <<endl; } }; int main() { Test test; Templatemyclass<Test> obj1(&test); MockTest mock_test; Templatemyclass<MockTest> obj2(&mock_test); EXPECT_CALL(mock_test,display()).Times(1); FinalTest test1; test1.show(obj1); test1.show(obj2); return 0; }

The following could possibly simplify the case:

#include <iostream> #include <gtest/gtest.h> #include <gmock/gmock.h> template <class myclass> class Templatemyclass { public: myclass T; void show() const { T.display(); } }; struct Test { void display() const { std::cout << "Inside the display Test:\n"; } }; struct MockTest { MOCK_CONST_METHOD0(display, void()); }; int main() { Templatemyclass<Test> obj1; obj1.show(); Templatemyclass<MockTest> obj2; EXPECT_CALL(obj2.T, display()).Times(1); obj2.show(); return 0; }
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Another awesome answer by Fraser!!! Hey, Fraser, I'm looking around for information on how to mock non-virtual methods WITHOUT using templates. I've found some pretty interesting answers out there, including these two: stackoverflow.com/a/2857770/1735836 and stackoverflow.com/q/1127918/1735836. Would love to hear your thoughts!!!
I think I'd be inclined to try HippoMocks, but I've got no personal experience here. We used GoogleMock for a while in our codebase and it was pretty painful to set up and maintain the tests. For example, it really doesn't play nice with C++11 smart pointers. Another possibility I've heard good things about is typemock.com/isolatorpp-product-page. This should avoid you having to change your production code just for tests too, but I don't think it's free and again I have no personal experience. Other than those, I'd choose one of the two options...
... mentioned in stackoverflow.com/a/2857770. I hate modifying the source code just to accommodate tests, so I'd avoid the options in the question of stackoverflow.com/q/1127918. So that leaves 1. redeclare functions to be tested or 2. inject "virtual" if a given PP flag is set. For me, the decision comes down to the actual code to be tested. I'd favour 1 since it's non-intrusive, but it's maybe not a possibility if there are lots of functions to be tested. For 2, I'd ensure the PP flag is only set for those tests which really need it - normal tests use the real functions.
0

If you don't want to change your source code, you can leverage injector++. Currently it only supports x86 Windows. But Linux and x64 Windows support will come soon. Below examples will give you a brief idea:

Mock non-virtual methods

Below example fakes BaseClassTest::getAnInteger() by using fakeFunc():

class FakeClassNonVirtualMethodTestFixture : public ::testing::Test { public: int fakeFunc() { return 6; } }; TEST_F(FakeClassNonVirtualMethodTestFixture, FakeIntFunctionWhenCalled) { // Prepare int expected = 6; InjectorPP::Injector injector; injector.whenCalled(INJECTORPP_MEMBER_FUNCTION(BaseClassTest::getAnInteger)) .willExecute(INJECTORPP_MEMBER_FUNCTION(FakeClassNonVirtualMethodTestFixture::fakeFunc)); BaseClassTest b = BaseClassTest(); // Act // FakeFunc will be executed! int actual = b.getAnInteger(); // Assert EXPECT_EQ(expected, actual); }

Mock virtual methods

Injector++ supports virtual method mocking (Amazing, huh?). Below is a simple example:

int FakeIntFuncForDerived() { return 2; } TEST_F(FakeClassVirtualMethodTestFixture, MockDerivedClassVirtualMemberFunctionWhenCalled) { // Prepare int expected = 2; BaseClassTest* derived = new SubClassTest(); InjectorPP::Injector injector; injector.whenCalledVirtualMethod(derived, "getAnIntegerVirtual") .willExecute(fakeIntFuncForDerived); // Act // FakeIntFuncForDerived() will be exectued! int actual = derived->getAnIntegerVirtual(); // Assert EXPECT_EQ(expected, actual); delete derived; derived = NULL; }

Mock static methods

Injector++ supports static method mocking. Below is a simple example:

Address FakeGetAnAddress() { Address addr; addr.setAddressLine("fakeAddressLine"); addr.setZipCode("fakeZipCode"); return addr; } TEST_F(FakeClassNonVirtualMethodTestFixture, FakeStaticFunctionReturnUserDefinedClassWhenCalled) { // Prepare Address expected; expected.setAddressLine("fakeAddressLine"); expected.setZipCode("fakeZipCode"); InjectorPP::Injector injector; injector.whenCalled(INJECTORPP_STATIC_MEMBER_FUNCTION(BaseClassTest::getAnAddressStatic)) .willExecute(INJECTORPP_MEMBER_FUNCTION(FakeClassNonVirtualMethodTestFixture::fakeGetAnAddress)); // Act // FakeGetAnAddress will be executed! Address actual = BaseClassTest::getAnAddressStatic(); // Assert EXPECT_EQ(expected, actual); }
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.