Mock dependencies of class under tests - c++

Question

I want to test some code that is written to run on an embedded processor in a Visual Studio Native Unit Test project.
The TestMe class has several methods that are good candidates for testing, but the Foo and Bar classes directly access memory mapped registers that are only available on the embedded processor.
#pragma once
#include "Foo.h"
#include "Bar.h"
class TestMe
{
public:
TestMe(Foo& aFoo, Bar& aBar);
~TestMe();
float FooBar();
};
What is the best way to mock away these objects so that I can test the TestMe class?
Edit: For me the best way would be the one that interferes as little as possible with the software that is being tested.

Answer 1

"Best" is always subjective, but I like using templates for this kind of mocking:
template <typename TFoo, typename TBar>
class TestMeImpl
{
public:
TestMeImpl(TFoo& aFoo, TBar& aBar);
~TestMeImpl();
float FooBar();
};
using TestMe = TestMeImpl<Foo, Bar>;
You would write unit tests against TestMeImpl, but expose TestMe to your users.

Answer 2

Your Foo and Bar are passed to constructor by reference.
There are two approaches to this.
My personal favor is to use interface and leverage polymorphic objects.
So it looks like this:
class IFoo {
public:
virtual void someFunction() = 0;
};
class IBar {
public:
virtual void otherFunction() = 0;
};
class Foo : public IFoo {
....
void someFunction() {
}
};
class Bar : public IBar {
.....
void otherFunction() {
}
};
class TestMe {
public:
TestMe(IFoo& aFoo, IBar& aBar);
~TestMe();
float FooBar();
};
// test code (GMock example):
class MockFoo : public IFoo {
MOCK_METHOD(someFunction(), void());
};
class MockBar : public IBar {
MOCK_METHOD(otherFunction(), void());
};
TEST(TestMeTest, someTest)
{
MockBar bar;
MockFoo foo;
TestMe testMe(bar, foo);
EXPECT_CALL(bar, otherFunction());
EXPECT_EQ(0.2, testMe.FooBar());
}
This is basically same thing as use of templates. In this case dynamic polymorphism is used.
In case of template you got something similar so some people call it static polymorphism.
Both approaches have pros and cons and it is your decision which one is best in your case.

Answer 3

There is a solution to not introduce interfaces only for testing purposes (:
Link time substitution.
Rules:
Foo and Bar are in a static lib (there can be separate libs for Foo and Bar)
Don't link these libs to test exec.
Create a mock implementation that will be linked to test exec:
Hpp file:
#pragma once
#include <gmock/gmock.h>
class FooMock
{
FooMock();
~FooMock();
MOCK_METHOD0(foo, void());
};
Cpp file:
#include "Foo.hpp"
#include "FooMock.hpp"
namespace
{
FooMock* fooMock;
}
FooMock::FooMock()
{
assert(!fooMock);
fooMock = this;
}
FooMock::~FooMock()
{
fooMock = nullptr;
}
// Implement real Foo::foo
void Foo::foo()
{
// call FooMock::foo
fooMock->foo();
}
Disadvantage is that it won't work for multithread tests.
Hope it helps.

Answer 4

Depending on the size and performance constraints of the embedded platform introducing interfaces for the sole purpose of unit testing can be a bad idea. For small systems I favor the approach of type-aliasing classes which represent some kind of processor peripheral. I guess that's also what "Foo" and "Bar" in your example represent.
The right type alias for the current target can be chosen by using architecture predefines
struct Uart1 {};
struct Uart1Mock {};
#ifdef __x86_64__
using SensorUart = Uart1Mock;
#else
using SensorUart = Uart1;
#endif
The application code then simply uses SensorUart, no matter if the class depends on an actual serial port or simply uses standard io.