2. 程式人生 > >c++ 單元測試打樁技巧總結(stub、mock)

c++ 單元測試打樁技巧總結(stub、mock)

阿新 • • 發佈：2019-01-24

這裡寫圖片描述

說明：
- 只適用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;
}

相關推薦

c++ 單元測試打樁技巧總結(stub、mock)

說明： - 只適用linux，和windows的x86、x64架構 - access private function相關方法基於C++11（參考：https://github.co

Google開源C++ 單元測試框架Google Test系列(gtest)之初始gtest

    下載           最新原始碼地址：https://github.com/google/googletest           V1.3和V1.

C# 單元測試（入門）

注：本文示例環境 VS2017XUnit 2.2.0 單元測試框架xunit.runner.visualstudio 2.2.0 測試執行工具Moq 4.7.10 模擬框架 什麼是單元測試？ 確保軟體應用程式按作者的期望執行操作，其中最好的一種方法是擁有自動化測試套件。 可以對軟體應用程式進行

玩轉Google開源C++單元測試框架Google Test系列(gtest)(總)

前段時間學習和了解了下Google的開源C++單元測試框架Google Test，簡稱gtest，非常的不錯。 我們原來使用的是自己實現的一套單元測試框架，在使用過程中，發現越來越多使用不便之處，而這樣不便之處，gtest恰恰很好的解決了。 其實gtest本身的實現並不複雜

Google開源C++單元測試框架Google Test系列(gtest)之斷言

     gtest中，斷言的巨集可以理解為分為兩類，一類是ASSERT系列，一類是EXPECT系列。一個直觀的解釋就是： ASSERT_* 系列的斷言，當檢查點失敗時，退出當前函式（注意：並非退出當前案例）。   EXPECT_* 系列的斷言，當檢查點失敗時，繼續往下

Google開源C++單元測試框架Google Test系列(gtest)之引數化

      在設計測試案例時，經常需要考慮給被測函式傳入不同的值的情況。我們之前的做法通常是寫一個通用方法，然後編寫在測試案例呼叫它。即使使用了通用方法，這樣的工作也是有很多重複性的，程式設計師都懶，都希望能夠少寫程式碼，多複用程式碼。      Google的程式設計師也

Google開源C++單元測試框架Google Test系列(gtest)之- 事件機制

gtest提供了多種事件機制，非常方便我們在案例之前或之後做一些操作。總結一下gtest的事件一共有3種： 全域性的，所有案例執行前後。 TestSuite級別的，在某一批案例中第一個案例前，最後一個案例執行後  TestCase級別的，每個TestCase前後。 全域

關於java專案單元測試報告的總結

#背景 由於公司需要制定一份單元測試報告的規範，於是研究了幾個生成報告的maven外掛，特此記錄一下 #生成報告外掛maven-surefire-plugin 1、此外掛是最簡單也最簡陋的一個生成報告外掛，它可以生成html、xml、txt型別的報告 2、配置

開放原始碼 C/C++ 單元測試工具，第 2 部分: 瞭解 CppUnit

https://www.ibm.com/developerworks/cn/aix/library/au-ctools2_cppunit/index.html 本文是討論開放原始碼單元測試工具的 系列文章 的第 2 篇，介紹非常受歡迎的 CppUnit — 最初由 Eri

C++單元測試一：並非看上去那麼簡單——幾個很實際的問題

理想與現實 為Java和C#做單元測試，基本上都有比較統一的工具、模式可用，IDE的支援也非常到位；可是到了C++這裡，一切就變的那樣的“不走尋常路”，各種單元測試框架盛行，例如CppUnit, CppUnitLite, CxxUnit,Google Test等等，以及微軟

CPPUTest 單元測試框架(針對 C 單元測試的使用說明)

CPPUTest 雖然名稱上看起來是 C++ 的單元測試框架, 其實它也是支援測試 C 程式碼的. 本文主要介紹用CPPUTest來測試 C 程式碼. (C++沒用過, 平時主要用的是C) C++相關的內容都省略了. 本文基於 debian v7.6 x86_64. 1. CPPUTest 安裝 現在各

深入理解gtest：C/C++單元測試經驗談

GoogleC++TestingFramework（簡稱gtest，http：//code。google。com/p/googletest/）是Google公司釋出的一個開源C/C++單元測試框架，已被應用於多個開源專案及Google內部專案中，知名的例子包括ChromeWeb瀏覽器、LLVM編譯器架構、P

C++單元測試！寫的很好！！轉

      之前一直在尋找一種合適的方法來做C++單元測試，也嘗試了不少的方法。寫一點體會提供大家參考（不一定是最好的，但是我想還是能給大家一些啟發吧）。JAVA和C#都有強大的IDE支援，而且JAVA和C#的反射機制能夠使得Mock更加容易一些。但是由於C/C++語言的獨特性，單元測試的過程變得不那麼的順手

C++單元測試二：何時Mock及其是與非

什麼時候需要mock 在前面一部分（C++單元測試一：並非看上去那麼簡單——幾個很實際的問題），我遇到的問題是：一個單元測試工程只能測一個被測類（其實前文的後記部分也已指出，其實建立新工程也不是特別必要，可以讓Mock類從被測類繼承，但問題是這是真的Mock嗎？）； 那麼，

Gtest：死亡測試 玩轉Google開源C++單元測試框架Google Test系列(gtest)之五 - 死亡測試

轉自：玩轉Google開源C++單元測試框架Google Test系列(gtest)之五 - 死亡測試 一、前言 “死亡測試”名字比較恐怖，這裡的“死亡”指的的是程式的崩潰。通常在測試過程中，我們需要考慮各種各樣的輸入，有的輸入可能直接導致程式崩潰，這時我們就需要檢查程式是否按照預期的方式掛掉，這也就是所

Gtest：引數化 玩轉Google開源C++單元測試框架Google Test系列(gtest)之四 - 引數化

轉自：玩轉Google開源C++單元測試框架Google Test系列(gtest)之四 - 引數化 一、前言 在設計測試案例時，經常需要考慮給被測函式傳入不同的值的情況。我們之前的做法通常是寫一個通用方法，然後編寫在測試案例呼叫它。即使使用了通用方法，這樣的工作也是有很多重複性的，程式設計師都懶，都希望

C單元測試框架——CMockery簡介與示例

簡介 是google釋出的用於C單元測試的一個輕量級的框架。 主要特點： 免費且開源，google提供技術支援；輕量級的框架，使測試更加快速簡單；避免使用複雜的編譯器特性，對老版本的編譯器來講，相容性好;並不強制要求待測程式碼必須依賴C99標準，這一特性對許多嵌入式

使用指令碼語言 簡簡單單做C/C++單元測試(之一)

先介紹基本概念：單元測試（unit testing），是指對軟體中的最小可測試單元進行檢查和驗證。對於單元測試中單元的含義，一般來說，要根據實際情況去判定其具體含義，如C語言中單元指一個函式，Java裡單元指一個類，圖形化的軟體中可以指一個視窗或一個選單等。總的來說，單元就

Google C++ 單元測試 GTest

from : http://www.cnblogs.com/jycboy/p/6057677.html 一、設定一個新的測試專案   在用google test寫測試專案之前，需要先編譯gtest到library庫並將測試與其連結。我們為一些流行的構建系統提供了構建檔案: msvc/ for Visual

關於使用Visual Studio進行C++單元測試

關於使用Visual Studio進行C++單元測試 什麼是單元測試？單元測試（unit testing）在軟體開發領域有著悠久的歷史。在大多數有關單元測試的觀念中都有這麼一個共同的理念，即它們由一組獨立的測試構成，其中每個測試針對一個單獨的軟體元件。在過程式程式設計的程式碼中，“單元”一般來說指的就是函式