c++ 单元测试打桩技巧总结(stub、mock)

最新推荐文章于 2024-08-08 07:32:11 发布
置顶 最新推荐文章于 2024-08-08 07:32:11 发布
阅读量3.5w 收藏 151
点赞数 21
文章标签： c++ unit test stub mock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coolxv_6533/article/details/79550197
版权

这里写图片描述

Stub API 源码地址： https://github.com/coolxv/cpp-stub

说明：
- 只适用linux，和windows的x86、x64架构
- access private function相关方法基于C++11（参考：https://github.com/martong/access_private）
- replace function相关方法基于C++03
- windows和linux的用法会稍微不同，原因是获取不同类型函数地址的方法不同，且调用约定有时不一样

不可以打桩的情况：
- 不可以对exit函数打桩，编译器做了特殊优化
- 不可以对纯虚函数打桩，纯虚函数没有地址
- static声明的普通内部函数不能打桩，内部函数地址不可见（解析ELF或许可以获得函数地址）

普通函数打桩（非static）

//for linux and windows
#include<iostream>
#include "stub.h"
using namespace std;
int foo(int a)
{   
    cout<<"I am foo"<<endl;
    return 0;
}
int foo_stub(int a)
{   
    cout<<"I am foo_stub"<<endl;
    return 0;
}


int main()
{
    Stub stub;
    stub.set(foo, foo_stub);
    foo(1);
    return 0;
}

实例成员函数打桩

//for linux，__cdecl
#include<iostream>
#include "stub.h"
using namespace std;
class A{
    int i;
public:
    int foo(int a){
        cout<<"I am A_foo"<<endl;
        return 0;
    }
};

int foo_stub(void* obj, int a)
{   
    A* o= (A*)obj;
    cout<<"I am foo_stub"<<endl;
    return 0;
}


int main()
{
    Stub stub;
    stub.set(ADDR(A,foo), foo_stub);
    A a;
    a.foo(1);
    return 0;
}

//for windows，__thiscall
#include<iostream>
#include "stub.h"
using namespace std;
class A{
    int i;
public:
    int foo(int a){
        cout<<"I am A_foo"<<endl;
        return 0;
    }
};


class B{
public:
    int foo_stub(int a){
        cout<<"I am foo_stub"<<endl;
        return 0;
    }
};

int main()
{
    Stub stub;
    stub.set(ADDR(A,foo), ADDR(B,foo_stub));
    A a;
    a.foo(1);
    return 0;
}

静态成员函数打桩

//for linux and windows
#include<iostream>
#include "stub.h"
using namespace std;
class A{
    int i;
public:
    static int foo(int a){
        cout<<"I am A_foo"<<endl;
        return 0;
    }
};

int foo_stub(int a)
{   
    cout<<"I am foo_stub"<<endl;
    return 0;
}


int main()
{
    Stub stub;
    stub.set(ADDR(A,foo), foo_stub);

    A::foo(1);
    return 0;
}

模板函数打桩

//for linux，__cdecl
#include<iostream>
#include "stub.h"
using namespace std;
class A{
public:
   template<typename T>
   int foo(T a)
   {   
        cout<<"I am A_foo"<<endl;
        return 0;
   }
};

int foo_stub(void* obj, int x)
{   
    A* o= (A*)obj;
    cout<<"I am foo_stub"<<endl;
    return 0;
}


int main()
{
    Stub stub;
    stub.set((int(A::*)(int))ADDR(A,foo), foo_stub);
    A a;
    a.foo(5);
    return 0;
}

//for windows，__thiscall
#include<iostream>
#include "stub.h"
using namespace std;
class A{
public:
   template<typename T>
   int foo(T a)
   {   
        cout<<"I am A_foo"<<endl;
        return 0;
   }
};


class B {
public:
    int foo_stub(int a) {
        cout << "I am foo_stub" << endl;
        return 0;
    }
};


int main()
{
    Stub stub;
    stub.set((int(A::*)(int))ADDR(A,foo), ADDR(B, foo_stub));
    A a;
    a.foo(5);
    return 0;
}

重载函数打桩

//for linux，__cdecl
#include<iostream>
#include "stub.h"
using namespace std;
class A{
    int i;
public:
    int foo(int a){
        cout<<"I am A_foo_int"<<endl;
        return 0;
    }
    int foo(double a){
        cout<<"I am A_foo-double"<<endl;
        return 0;
    }
};

int foo_stub_int(void* obj,int a)
{   
    A* o= (A*)obj;
    cout<<"I am foo_stub_int"<< a << endl;
    return 0;
}
int foo_stub_double(void* obj,double a)
{   
    A* o= (A*)obj;
    cout<<"I am foo_stub_double"<< a << endl;
    return 0;
}

int main()
{
    Stub stub;
    stub.set((int(A::*)(int))ADDR(A,foo), foo_stub_int);
    stub.set((int(A::*)(double))ADDR(A,foo), foo_stub_double);
    A a;
    a.foo(5);
    a.foo(1.1);
    return 0;
}

//for windows，__thiscall
#include<iostream>
#include "stub.h"
using namespace std;
class A{
    int i;
public:
    int foo(int a){
        cout<<"I am A_foo_int"<<endl;
        return 0;
    }
    int foo(double a){
        cout<<"I am A_foo-double"<<endl;
        return 0;
    }
};
class B{
    int i;
public:
    int foo_stub_int(int a)
    {
        cout << "I am foo_stub_int" << a << endl;
        return 0;
    }
    int foo_stub_double(double a)
    {
        cout << "I am foo_stub_double" << a << endl;
        return 0;
    }
};
int main()
{
    Stub stub;
    stub.set((int(A::*)(int))ADDR(A,foo), ADDR(B, foo_stub_int));
    stub.set((int(A::*)(double))ADDR(A,foo), ADDR(B, foo_stub_double));
    A a;
    a.foo(5);
    a.foo(1.1);
    return 0;
}

虚函数打桩

//for linux
#include<iostream>
#include "stub.h"
using namespace std;
class A{
public:
    virtual int foo(int a){
        cout<<"I am A_foo"<<endl;
        return 0;
    }
};

int foo_stub(void* obj,int a)
{   
    A* o= (A*)obj;
    cout<<"I am foo_stub"<<endl;
    return 0;
}


int main()
{
    typedef int (*fptr)(A*,int);
    fptr A_foo = (fptr)(&A::foo);   //获取虚函数地址
    Stub stub;
    stub.set(A_foo, foo_stub);
    A a;
    a.foo();
    return 0;
}

//for windows x86(32位)
#include<iostream>
#include "stub.h"
using namespace std;
class A {
public:
    virtual int foo(int a) {
        cout << "I am A_foo" << endl;
        return 0;
    }
};

class B {
public:
    int foo_stub(int a)
    {
        cout << "I am foo_stub" << endl;
        return 0;
    }
};



int main()
{
    unsigned long addr;
    _asm {mov eax, A::foo}
    _asm {mov addr, eax}
    Stub stub;
    stub.set(addr, ADDR(B, foo_stub));
    A a;
    a.foo(1);
    return 0;
}
//for windows x64(64位)，VS编译器不支持内嵌汇编。有解决方案自行搜索。

内联函数打桩

//for linux
//添加-fno-inline编译选项，禁止内联，能获取到函数地址，打桩参考上面。
//for windows
//添加/Ob0禁用内联展开。

第三方库私有成员函数打桩

//for linux
//被测代码添加-fno-access-private编译选项，禁用访问权限控制，成员函数都为公有的
//无源码的动态库或静态库无法自己编译，需要特殊技巧获取函数地址
#include<iostream>
#include "stub.h"
using namespace std;
class A{
    int a;
    int foo(int x){
        cout<<"I am A_foo "<< a << endl;
        return 0;
    }
    static int b;
    static int bar(int x){
        cout<<"I am A_bar "<< b << endl;
        return 0;
    }
};


ACCESS_PRIVATE_FIELD(A, int, a);
ACCESS_PRIVATE_FUN(A, int(int), foo);
ACCESS_PRIVATE_STATIC_FIELD(A, int, b);
ACCESS_PRIVATE_STATIC_FUN(A, int(int), bar);

int foo_stub(void* obj, int x)
{   
    A* o= (A*)obj;
    cout<<"I am foo_stub"<<endl;
    return 0;
}
int bar_stub(int x)
{   
    cout<<"I am bar_stub"<<endl;
    return 0;
}
int main()
{
    A a;

    auto &A_a = access_private_field::Aa(a);
    auto &A_b = access_private_static_field::A::Ab();
    A_a = 1;
    A_b = 10;

    call_private_fun::Afoo(a,1);
    call_private_static_fun::A::Abar(1);

    auto A_foo= get_private_fun::Afoo();
    auto A_bar = get_private_static_fun::A::Abar();

    Stub stub;
    stub.set(A_foo, foo_stub);
    stub.set(A_bar, bar_stub);

    call_private_fun::Afoo(a,1);
    call_private_static_fun::A::Abar(1);
    return 0;
}
//for windows，__thiscall
#include<iostream>
#include "stub.h"
using namespace std;
class A{
    int a;
    int foo(int x){
        cout<<"I am A_foo "<< a << endl;
        return 0;
    }
    static int b;
    static int bar(int x){
        cout<<"I am A_bar "<< b << endl;
        return 0;
    }
};


ACCESS_PRIVATE_FIELD(A, int, a);
ACCESS_PRIVATE_FUN(A, int(int), foo);
ACCESS_PRIVATE_STATIC_FIELD(A, int, b);
ACCESS_PRIVATE_STATIC_FUN(A, int(int), bar);
class B {
public:
    int foo_stub(int x)
    {
        cout << "I am foo_stub" << endl;
        return 0;
    }
};
int bar_stub(int x)
{   
    cout<<"I am bar_stub"<<endl;
    return 0;
}


int main()
{
    A a;

    auto &A_a = access_private_field::Aa(a);
    auto &A_b = access_private_static_field::A::Ab();
    A_a = 1;
    A_b = 10;

    call_private_fun::Afoo(a,1);
    call_private_static_fun::A::Abar(1);

    auto A_foo= get_private_fun::Afoo();
    auto A_bar = get_private_static_fun::A::Abar();

    Stub stub;
    stub.set(A_foo, ADDR(B,foo_stub));
    stub.set(A_bar, bar_stub);

    call_private_fun::Afoo(a,1);
    call_private_static_fun::A::Abar(1);
    return 0;
}
coolxv_6533
关注
C++打桩测试
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-27 1387
一 问题的产生 当构造测试用例的数据，是在函数内部被另一个外部函数所使用时，我们需要忽略外部函数所带来的影响。 需要进行"打桩",举一个具体的例子 class DataGetter { public: ool Run（）； … private: … Client* m_ptr_client; … }; …… …… bool DataGetter::Run（） { … std::string da...
单元测试（四）单元测试之桩(stub)和模拟(mock)
AnndyR的专栏
02-09 5319
在做单元测试的时候，我们会发现我们要测试的方法会引用很多外部依赖的对象，比如：(发送邮件，网络通讯，记录Log, 文件系统 之类的)。 而我们没法控制这些外部依赖的对象。 为了解决这个问题，我们需要用到Stub和Mock来模拟这些外部依赖的对象,从而控制它们 　　实例 　　Analyze类会检查filename的长度，如果小于8，我们就会使用一个实现IWebService的类来记录错误
C++单元测试Gtest+Stub攻略
qq_33865609的博客
05-25 2576
笔者环境为linux环境(deepin),以下均在此环境进行。
cpp-stub 项目使用教程
最新发布
gitblog_00926的博客
08-08 1040
cpp-stub 项目使用教程 cpp-stubC++ unit test stub(not mock) and awesome.Surpported ISA x86,x86-64,arm64,arm32,arm thumb,mips64,riscv,loongarch64.项目地址:https://gitcode.com/gh_mirrors/cp/cpp-stub 1. 项目的目录结构及介绍...
Windows下C/C++单元测试两种打桩方法
飞鹤的程序员人生
03-09 2257
敏捷开发，非常强调效率。如果只顾着效率，代码质量必须很低，未来的维护成本必定大增，会得不偿失。 那么敏捷开发中，CodeReview和单元测试是保证代码质量的重要手段。 1. 问题 如下代码，通过宏开关来控制桩函数，虽然功能上能够达到打桩的效果，但是对待测代码增加了大量的宏，影响代码的可读性。 int Fun1() { return 12; } int Fun() { #ifdef STUB_...
ceph存储 C、C++白盒测试打桩小结
skdkjxy的专栏
06-19 1813
什么是桩       桩，或称桩代码，是指用来代替关联代码或者未实现代码的代码。如果函数B用B1来代替，那么，B称为原函数，B1称为桩函数。打桩就是编写或生成桩代码。       打桩的目的       打桩的目的主要有：隔离、补齐、控制。       隔离是指将测试任务从产品项目中分离出来，使之能够独立编译、链接，并独立运行。隔离的基本方法就是打桩，将测试任务之外的，并且与测试任务相关的代码，用...
C++单元测试--打桩测试
热门推荐
潇洒程序员的专栏
06-06 1万+
一 问题的产生 当构造测试用例的数据，是在函数内部被另一个外部函数所使用时，我们需要忽略外部函数所带来的影响。 需要进行“打桩”，举一个具体的例子 class DataGetter { public: ... bool Run(); ... private: ... Client* m_ptr_client; ... }; ..... ..... b
c++单元测试——打桩接口
qq_32008381的博客
12-03 435
Stub API 源码地址：https://github.com/coolxv/cpp-stub
单元测试，打桩问题
08-01 2564
先说一下我的问题，一直在做的程序没有单元测试的代码，现在希望增加单元测试功能。考察了一些平台和技术，记录一下。 我的程序的结构如下 程序包含a，b两个dll，其中b依赖a。现在希望对b进行单元测试。 a.dll的示例代码如下 struct s { int sa; int sb; int sc; }; class a{ public: a(int i) { }; void a...
C/C++/Linux函数函数插桩(打桩)指南
08-12
在具有一定规模的代码中(C 语言)，调用第三方动态库中的函数来完成一些功能，是很常见的工作场景。 假设现在有一项任务：需要在调用某个动态库中的某个函数的之前和之后，做一些额外的处理工作。 这样的需求一般称作：插桩，也就是对于一个指定的目标函数，新建一个包装函数，来完成一些额外的功能，如动态调试等。 本文主要讲解什么是打桩，以及编译阶段打桩、链接阶段打桩、执行阶段打桩三种方式。
打桩代码函数
08-24
打桩代码函数，c++版本的，希望对大家有帮助。
Linux C 动态打桩实现
08-01
C语言UT单元测试中需要实现动态，本代码实现了该功能，原理和网络上的描述一样，通过修改机器指令实现。 平台是Linux
cpp-stub 中文使用手册
02-04
单元测试打桩开源库 cpp-stub 使用手册 中文版本，这是从git上直接下载的，git上下载的源代码在arm上调用Stub.reset方法会引发段错误，在资源cpp-stub开源代码（下载地址：https://download.csdn.net/download/zhao_sh/15051839)有解决该bug的源代码下载。
cpp-stub 开源代码
02-04
这是一个单元测试打桩开源代码，在git上下载的代码在ARM平台上有一个BUG，使用stub.h中的reset方法时，会引起段错误，该资源对这个bug进行了修复。
Linux下开箱即用的C++单元测试demo示例，HOOK非虚函数依赖的单元测试
06-10
C/C++单元测试，非虚函数依赖得函数gtest+cppfreestub的demo示例，Linux下开箱即用。 整个工程带有完整的依赖，开箱即用。合适尝新的工程师入门体验~ 该资源是博文《非虚函数依赖如何单元测试》的随文示例demo，结合...
有效使用Mock编写java单元测试
01-27
Java单元测试对于开发人员质量保证至关重要，尤其当...Mock说白了就是打桩（Stub）或则模拟，当你调用一个不好在测试中创建的对象时，Mock框架为你模拟一个和真实对象类似的替身来完成相应的行为。使用如下方式在Mav
C语言单元测试（UT）用例编写——gtest+stub打桩
luronggui的博客
06-30 6844
【转载】https://blog.csdn.net/anranjingsi/article/details/ stub工具源码：https://github.com/coolxv/cpp-stub/tree/master/src 这里做下简单的背景介绍，ut的基础介绍：可以先去看下先去的文章：https://blog.csdn.net/anranjingsi/article/details/106084223 前面也使用过gtest+gmock框架给C/C++做单元测试，但gmock的使用有着明显的限制：1
python stub
08-05
在使用gRPC进行Python开发时，可以使用stub来进行客户端和服务端之间的通信。在上述引用中，提供了一个示例代码，展示了如何使用stub进行通信。 在这个示例中，首先需要导入必要的模块和生成的protos文件。然后，创建一个与服务端通信的channel，使用insecure_channel函数指定服务端的地址和端口。接下来，创建一个stub对象，该对象提供了与服务端定义的方法相对应的函数。最后，通过调用stub的方法来进行通信，例如在示例中调用了SayHello方法，并传入了一个HelloRequest对象作为参数。 需要注意的是，具体的代码实现可能会有所不同，取决于您的具体项目和protos文件的结构。可以根据实际情况进行适当的变动。 引用
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值