gmock和cppfreemock原理学习

1.gmock用法

gmock（Google Mock）是 Google Test 的一个扩展库，专门用于 C++ 单元测试中的模拟（mocking）。它的核心原理是通过 继承和方法重载/覆盖 来模拟 C++ 中的虚函数，从而在测试中隔离依赖对象，使测试更加可控。

gmock 通过 C++ 的多态机制（虚函数表 vtable） 来替换待模拟类的方法，使测试代码可以控制这些方法的行为。

#include <gmock/gmock.h>

class ILogger {
public:
    virtual ~ILogger() = default;
    virtual void Log(const std::string& message) = 0;
};

class MockLogger : public ILogger {
public:
    // MOCK_METHOD(返回类型, 函数名, (参数列表), (限定符));
    // 1.负责定义虚函数的模拟版本，宏展开
    MOCK_METHOD(void, Log, (const std::string& message), (override));
};

// 2.定义mock类
MockLogger mock;
// 3.定义模拟函数期望行为
EXPECT_CALL(mock, Log("Hello")).Times(1);
mock.Log("Hello");  // 4.执行模拟函数，符合期望

MOCK_METHOD 实际上是一个 宏展开，它会生成：

• 一个虚函数的声明（覆盖基类）
• 一个 gmock 代理方法，用于在运行时控制行为

展开的代码类似于：

class MockLogger : public ILogger {
public:
    void Log(const std::string& message) override {
        // gmock 代理方法，用于检查调用
        gmock_Log(message);
    }

    // 由 gmock 生成的 "mock" 版本
    ::testing::MockFunction<void(const std::string&)> gmock_Log;
};

1.1 适用情况

（1）模拟依赖对象

• 当被测代码依赖某个类，而这个类访问数据库、文件系统、网络等，无法直接测试时，可用 gmock 进行模拟。

（2）验证某个方法是否被正确调用

• 例如：测试中 确保日志写入函数被调用，或者 确保某个 API 被正确触发。

2.EXPECT_CALL原理

EXPECT_CALL(mock, Method(args)) 主要用于：

1. 指定期望的调用次数（如 Times(1) 代表期望调用 1 次）。
2. 检查参数是否匹配（可以使用 Eq(5)、_（任意值）等）。
3. 指定返回值或行为（如 WillOnce(Return(10)) 表示返回 10）。

https://github.com/jwongzblog/myblog/blob/master/c++/单元测试Mock之c++-gmock实现原理.md

// 定义了一个obj.gmock_func.InternalExpectedAt(...)去调用
#define GMOCK_EXPECT_CALL_IMPL_(obj, call) \
    ((obj).gmock_##call).InternalExpectedAt(__FILE__, __LINE__, #obj, #call)
#define EXPECT_CALL(obj, call) GMOCK_EXPECT_CALL_IMPL_(obj, call)


// 会添加一个新的expectations
typedef std::vector<internal::linked_ptr<ExpectationBase> >  UntypedExpectations;
untyped_expectations_.push_back(untyped_expectation);


// willOnce，会添加到，它是TypedExpectation的成员函数
// 当调用的时候会从对应模拟中返回结果并删除
typedef std::vector<const void*> UntypedActions;
untyped_actions_.push_back(new Action<F>(action));

// 其实还是不太明白，具体执行流程是怎么样的。怎么就能invoke了。

3.cppfreemock

gmock只能模拟虚函数，对业务可能有入侵。cppfreemock可以支持mock非虚成员函数、静态成员函数、全局函数、重载函数、模板函数以及其他依赖库的函数时。它的原理是函数指针hook。

玩转单元测试之cppfreemock-CSDN博客

class Adder {
public:
    int add(int a, int b) const
    {
        return a + b;
    }
};

TEST(TestCppFreeMock, CaseStaticMemberFunction) 
{
    auto mock = MOCKER(&Adder::add);
    // 针对类的成员函数，要注意占位符会多出一个，即第一个为this指针
    // 而全局函数或者静态成员函数占位符个数等于实际参数个数
    EXPECT_CALL(*mock, MOCK_FUNCTION(_, _, _))
        .WillRepeatedly(Return(2));
    Adder adder;
    EXPECT_EQ(2, adder.add(1, 2));
    EXPECT_EQ(2, adder.add(12, 2));
    mock->RestoreToReal();
    EXPECT_EQ(14, g_func(12, 2));
}

3.1 函数指针hook

#include <iostream>
#include <functional>

class Foo {
public:
    int Bar() { return 42; }  // 目标函数
};

// 函数指针 Hook（初始指向真实方法）
std::function<int(Foo*)> Bar_Hook = [](Foo* obj) { return obj->Bar(); };

// Mock 版本
int MockBar(Foo* obj) {
    return 99;
}

int main() {
    Foo foo;
    
    // 替换 Hook，指向 Mock 版本
    Bar_Hook = MockBar;
    
    // 通过 Hook 调用
    std::cout << "Result: " << Bar_Hook(&foo) << std::endl; // 输出 99

    return 0;
}

• std::function<int(Foo*)> 作为 可变函数指针，用于调用 Foo::Bar。
• 初始时，Bar_Hook 绑定到原始 Bar()。
• 在测试时，替换 Bar_Hook 使其指向 MockBar()，这样所有调用都会执行 Mock 版本。

// 太牛了，还能这么搞，叹为观止。

函数指针 Hook 是一种通过修改函数指针的指向来改变函数行为的技术。它常用于拦截函数调用，在不修改原代码的情况下，替换成自定义的行为（如 Mock、日志、监控等）。C++ 中的函数指针 本质上是存储函数地址的变量，可以动态修改。Hook 技术 通过 更改函数指针的值，让程序调用一个新的（Mock）函数，而不是原始函数。

hook普通函数:

#include <iostream>
using namespace std;

// 原始函数
int OriginalFunction(int x) {
    return x * 2;
}

// 定义函数指针
int (*FunctionHook)(int) = OriginalFunction;

// Mock 版本
int MockFunction(int x) {
    return 100;  // 返回固定值
}

int main() {
    cout << "Before Hook: " << FunctionHook(10) << endl;  // 输出 20（调用原函数）

    // Hook：修改函数指针
    FunctionHook = MockFunction;

    cout << "After Hook: " << FunctionHook(10) << endl;  // 输出 100（调用 Mock 版本）

    return 0;
}

3.2 源码初探

// MOCKER的宏定义
#define MOCKER_INTERNAL(function, identity)                                                        \
    ::CppFreeMock::MockerCreator::GetMocker<::CppFreeMock::TypeForUniqMocker<identity>>(function,  \
                                                                                        #function)

// GetMocker会够造一个对应的函数指针，并且存储到map中
static const std::shared_ptr<M> DoGetMocker(F function, const std::string& functionName) {
    const void* address = reinterpret_cast<const void*>((std::size_t&)function);
                    SimpleSingleton<RestoreFunctions>::getInstance().push_back(
                std::bind(MockerCacheType::RestoreCachedMockFunctionToReal));
            MockerCacheType::getInstance().insert(
                {{address, CreateMocker<I>(function, functionName)}});
}