PowerFake is a C++ library/tool for faking & mocking free functions and non-virtual member functions. Using PowerFake, you can mock non-virtual member functions and free functions with existing mocking frameworks. Currently, it provides seamless integration with FakeIt and Google Mock frameworks and makes all of their facilities available.
It is built on top of GNU Linker's --wrap option and linker scripts.
- Faking C/C++ free functions
- Faking static class member functions
- Faking non-virtual member functions of a class
- Faking non-virtual dispatch of virtual functions
- Faking private and protected member functions
- Provides access to private & protected member variables
- Provides control over the life time of faking/mocking
- Provides integration with FakeIt(https://github.com/eranpeer/FakeIt)
- Provides integration with Google Mock(https://github.com/google/googletest/)
Every function we want to override in tests should be marked as such for PowerFake,
which can happen in a single source file, which we call wrap.cpp using
WRAP_FUNCTION() and HIDE_FUNCTION() macros. Using HIDE_FUNCTION(), you'll lose
access to the original function, but you can also capture calls in the same
translation unit.
#include <powerfake.h>
#include <functinos_header.h>
WRAP_FUNCTION(std::string (float), overloaded2);
WRAP_FUNCTION(normal_func);
#ifdef HIDE_FUNCTION
HIDE_FUNCTION(called_by_normal_func);
#endif
WRAP_FUNCTION(STATIC(SampleClass, SampleClass::StaticFunc));
WRAP_FUNCTION(STATIC(SampleClass, PRIVATE(SampleClass::PrivateStaticFunc)));
WRAP_FUNCTION(SampleClass::CallThis);
WRAP_FUNCTION(int (int) const, SampleClass::OverloadedCall);
WRAP_FUNCTION(PFK_PRIVATE(SampleClass::SamplePrivate));
WRAP_FUNCTION(void (int), PRIVATE(SampleClass::OverloadedPrivate));
PowerFake needs build system integration. It provides CMake support itself
through bind_fakes() function:
add_library(mainlib STATIC ${main_sources}) # production code (test subject) as a library
add_library(wrap_lib STATIC wrap.cpp) # library containing WRAP_FUNCTION()/HIDE_FUNCTION() macros
# Test runner build
add_executable(test_runner ${test_sources})
target_link_libraries(samples wrap_lib mainlib)
bind_fakes(samples SUBJECT mainlib WRAPPERS wrap_lib CACHE)
TAG_PRIVATE(SamplePrivate, SampleClass::SamplePrivate);
TAG_PRIVATE(VirtualPrivate, SampleBase::CallPrivateVirtual);
TAG_PRIVATE(OverloadedPrivateInt, void (int), SampleClass::OverloadedPrivate);
void UseFakeIt()
{
PowerFakeIt<> pfk;
When(Function(pfk, normal_func)).Do([](int, const char **const *,
const std::string &, const char *(*)(const char *))
{
cout << "WOW :) " << endl;
});
normal_func(100, nullptr, string(), nullptr);
Verify(Function(pfk, normal_func).Using(100, nullptr, string(), nullptr)).Exactly(Once);
PowerFakeIt<SampleClass> pfk2;
When(Method(pfk2, CallThis)).Do([]() { cout << "WOW2" << endl; });
When(OverloadedMethod(pfk2, OverloadedCall, int())).Return(4);
When(ConstOverloadedMethod(pfk2, OverloadedCall, int(int))).Return(5);
When(PrivateMethod(pfk2, SamplePrivate)).Do([]() { cout << "Private WOW!" << endl; });
When(PrivateMethod(pfk2, OverloadedPrivateInt)).Do([](int) { cout << "Overloaded(int) Private WOW!" << endl; });
SampleClass s;
s.CallThis();
s.OverloadedCall();
s.CallSamplePrivate();
s.CallOverloadedPrivate(4);
Verify(Method(pfk2, CallThis)).Exactly(Once);
Using(pfk2).Verify(Method(pfk2, CallThis)
+ OverloadedMethod(pfk2, OverloadedCall, int()));
VerifyNoOtherInvocations(Method(pfk2, CallThis));
ExMock<SampleBase> mock;
Fake(PrivateMethod(mock, VirtualPrivate));
mock.get().CallNonPublics(30);
Verify(PrivateMethod(mock, VirtualPrivate)).Exactly(Once);
}
class MockFreeFunctions
{
public:
GPFK_MOCK_FUNCTION(void, normal_func, (int b, const char **const *c,
const std::string &d, const char *(*e)(const char *)));
GPFK_MOCK_FUNCTION(std::string, overloaded2, (int b));
};
class MockSample: public GPowerFake<SampleClass>
{
public:
GPFK_MOCK_METHOD(void, CallThis, (), (const));
GPFK_MOCK_METHOD(int, OverloadedCall, ());
// free functions can be mocked here too
GPFK_MOCK_FUNCTION(void, noexcept_func, ());
};
void GMockSamples()
{
MockSample mock;
MockFreeFunctions freemock;
EXPECT_CALL(mock, CallThis()).Times(AtLeast(1));
EXPECT_CALL(mock, OverloadedCall()).Times(AtLeast(1));
EXPECT_CALL(freemock, normal_func(1, nullptr, "", nullptr))
.Times(AtLeast(1));
EXPECT_CALL(freemock, overloaded2(_)).Times(AtLeast(1));
EXPECT_CALL(mock, noexcept_func()).Times(AtLeast(1));
normal_func(1, nullptr, "", nullptr);
noexcept_func();
SampleClass s;
s.CallThis();
s.OverloadedCall();
overloaded2(60);
}
TAG_PRIVATE(SamplePrivate, SampleClass::SamplePrivate);
void PowerFakeSamples()
{
overloaded(6.0F); // Real call
auto offk = MakeFake<void (float)>(overloaded,
[](float) { cout << "Fake called for overloaded(float)" << endl; }
);
overloaded(6.0F); // Fake call for overloaded free function
// For member functions, you can optionally access object's this ptr
auto ccfk = MakeFake(&SampleClass::CallThis,
[](SampleClass *this_ptr) { cout << "Fake called for SampleClass::CallThis for object: " << this_ptr << endl; }
);
auto oc2fk = MakeFake<int (int) const>(&SampleClass::OverloadedCall,
[](int) {
cout << "Fake called for SampleClass::OverloadedCall(int) const" << endl;
return 0;
}
);
SampleClass sc;
sc.CallThis();
sc.OverloadedCall();
SampleClass2 sc2;
sc2.CallThis(); // Real call
{
auto ct2fk = MakeFake<void (int)>(&SampleClass2::CallThis,
[](int) { cout << "Fake called for SampleClass2::CallThis" << endl; }
);
sc2.CallThis(4); // Fake call
{
auto ct2fk = MakeFake<void (int)>(&SampleClass2::CallThis,
[](int) { cout << "Nested Fake called for SampleClass2::CallThis" << endl; }
);
sc2.CallThis(4); // Nested fake call
}
sc2.CallThis(4); // Fake call
}
auto stfk = MakeFake(&SampleClass2::StaticFunc, []() { cout << "Faked call for StaticFunc" << endl; });
SampleClass::StaticFunc();
auto pfk = MakeFake<SamplePrivate>([]() { cout << "Faked call for SamplePrivate" << endl; });
sc2.CallSamplePrivate();
}
PowerFake can be either installed into an address and be used as an external dependency by projects; or be copied into another project's source directory and be used directly without any installation.
You can place powerfake source directory inside your project (e.g. in third_party/
directory), and then include() powerfake's EmbedPowerFake.cmake into your
own project's CMakeLists.txt:
include(${CMAKE_SOURCE_DIR}/third_party/powerfake/EmbedPowerFake.cmake)
You can also install PowerFake and use it using CMake's find_package(PowerFake)
in the CMakeLists.txt of your project. You can install PowerFake using
conventional cmake commands:
$ mkdir build
$ cd build
$ cmake ..
$ cmake --build . -j
$ cmake --install .
- Cannot fake constructors/destructors
- Cannot fake inlined functions
- Faking function calls in the same translation unit as the target function has some limitations
- Supported compilers: GCC, MinGW, and Clang (experimental)
- Supported linkers: LLD, GNU Linker
- Cannot work with GCC LTO, since ld's --wrap is not supported in this case
- Currently, it only provides CMake integration
- GNU Linker (ld) or LLVM Linker (lld)
- GCC or Clang with C++17 support
- CMake
- Boost Core
- Provide support for other build systems (e.g. QMake, Autotools, Meson)
- Integrate with more C++ mocking frameworks
- Support faking virtual functions with virtual dispatch