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

理想與現實
為Java和C#做單元測試，基本上都有比較統一的工具、模式可用，IDE的支持也非常到位；可是到
了C++這里，一切就變的那樣的“不走尋常路”，各種單元測試框架盛行，例如CppUnit,?
CppUnitLite, CxxUnit,Google Test等等，以及微軟在VS2012中也加入了對原生C++代碼單元測
試的支持MSTest。面對如此諸多的測試框架，選擇哪一個其實無所謂，只要順手就好，用習慣了
，什么都好；因為，單元測試的代碼總歸還是要自己來寫——無論你用哪一個框架。
以前寫過不少代碼，可是都沒怎么注意單元測試，現在終于認真對待起來，就開始在網絡上搜尋資
料，看看各種框架下的單元測試如何寫。幸運的是，這方面的資料真不少，很多框架也都會帶有示
例或者文檔告訴你怎么寫；不幸的是，這些文檔或者示例都太遠離工程實踐，他們一般遵循一個這
樣的模式：寫出一個待測類CMyClass，定義一定的成員變量和方法，然后給出針對CMyClass的
測試類如CMyClassTest；呵呵，看起來示例是夠好了，可是很少涉及到這樣的實際問題：?
工程實踐中，一個項目往往有很多類，而且相互之間，總有這或多或少的依賴、包含等關系；
?實際的測試項目，該如何組織被測代碼和測試代碼（注意，這里所說的組織不是指單元測試數據
如何組織，而是指工程中的測試代碼和產品代碼的組織）
?被測代碼如何引入測試工程中
?一個測試工程如何測試多個被測類
實際的代碼
好吧，我們來看一下一個“較為”實際的工程以及我在為該工程編寫單元測試過程中所遇到的問題
；該工程的代碼來自于boost.asio中的一個示例代碼：
http://www.boost.org/doc/libs/1_53_0/doc/html/boost_asio/example/chat/chat_server.cpp，

我把該cpp中的幾個類分拆開了，放在一個VisualStudio 2012工程中，代碼結構看起來是：
其中幾個主要類Message，ChatSession，ChatRoom之間的關系如下圖：
在我做單元測試過程中，首先從軟柿子Message入手，然后為ChatRoom寫UT。所以，先把這兩
個類的相關代碼貼上來；其實貼不貼代碼無關緊要，上面的類圖已經可以說明問題，不過為了方便

較真，還是貼出來吧。

Message類代碼

/// Message.h #pragma once /// class represents the message transferred between the client and the server /// the message consists of two part: header + message body /// the header part, 4 bytes, stores the length of the message body /// the max length of the message box is : 512 class Message { public: enum { HeaderLength = 4, MaxBodyLength = 511 }; public: Message(void); ~Message(void); public: void EncodeHeader(); bool DecodeHeader(); const char* Data() const; char* Data() ; const char* Body() const; char* Body() ; int SetData(const char* src, const int srclength); int Length() const; int BodyLength()const; void Reset(); private: void CheckBodyLength(); private: /// stores the whole message char Data_[HeaderLength + MaxBodyLength + 1]; /// the body length int BodyLength_; }; /// Message.cpp #include "Message.h" #include <cstdio> #include <boost/lexical_cast.hpp> #include <algorithm> #include "TraceLog.h" Message::Message(void) { Reset(); } Message::~Message(void) { } void Message::CheckBodyLength() { BodyLength_ = BodyLength_ > MaxBodyLength ? MaxBodyLength : BodyLength_; } void Message::EncodeHeader() { /// Check the body length CheckBodyLength(); /// wirte the body length to the message header /// we make sure that the buffer is enough after we call CheckBodyLength() ::_snprintf_s( Data_, HeaderLength, HeaderLength, "%d", BodyLength_ ); } bool Message::DecodeHeader() { int bodyLength = 0; bool ret = false; /// get the message body length from the message try { char buf[HeaderLength + 1] = ""; std::strncat( buf, Data_, HeaderLength ); bodyLength = boost::lexical_cast<int> (buf); if( bodyLength > MaxBodyLength ) { bodyLength = MaxBodyLength; } else { ret = true; } } catch(boost::bad_lexical_cast& e) { /// cast error happens bodyLength = 0; TraceLog::WriteLine("Message::DecodeHeader(),error:%s, orinal message:%s", e.what(), Data_ ); } /// set the value and return BodyLength_ = bodyLength; return ret; } char* Message::Data() { return Data_ ; } const char* Message::Data() const { return Data_ ; } char* Message::Body() { return Data_ + HeaderLength; } const char* Message::Body() const { return Data_ + HeaderLength; } int Message::SetData(const char* src, const int srclength) { /// check the length of source int length = srclength; if( length > MaxBodyLength ) { length = MaxBodyLength; } /// copy the data into the local buffer /// std::snprintf is unavailable in this c++ compiler int ret = ::_snprintf_s(Data_+HeaderLength, MaxBodyLength + 1, length, "%s", src ); /// set the length of the message body BodyLength_ = length; /// return the length of copied return ret; } int Message::Length() const { return BodyLength_ + HeaderLength; } int Message::BodyLength() const { return BodyLength_; } void Message::Reset() { BodyLength_ = 0; /// just for using the lamda std::for_each(Data_, Data_ + HeaderLength + MaxBodyLength + 1, [](char& p) { p = '\0'; } ); }
??

ChatRoom類代碼
/// ChatRoom.h ?
#pragma once ?
#include "ChatSession.h" ?
#include "Message.h" ?
#include <set> ?
#include <queue> ?
? ?
/// class that manages the clients ?
/// deliver the messages from one client to the others ?
? ?
class ChatRoom ?
{ ?
public: ?
? ? ? ChatRoom(void); ?
? ? ? ~ChatRoom(void); ?
? ?
public: ?
? ? ? /// a client joins in the room ?
? ? ? void Join(ChatParticipantPtr participant); ?
? ?
? ? ? /// a client leaves the room ?
? ? ? void leave(ChatParticipantPtr participant); ?
? ?
? ? ? /// deliver the message from one client to all of the users in the room ?
? ? ? void Deliver(const Message& msg); ?
? ?
private: ?
? ? ? /// all of the participants are stored here ?
? ? ? std::set<ChatParticipantPtr> Participants_; ?
? ?
? ? ? /// recent messages ?
? ? ? /// questions, how to synchronize this object in threads ?
? ? ? typedef std::deque<Message> MessageQueue; ?
? ? ? MessageQueue RecentMessages_; ?
? ? ? enum { MaxRecentMsgs = 100 }; ?
}; ?
? ?? ?
/// ChatRoom.cpp ?
#include "ChatRoom.h" ?
#include <boost/bind.hpp> ?
#include <algorithm> ?
#include "TraceLog.h" ?
? ?
ChatRoom::ChatRoom(void) ?
{ ?
} ?? ?
? ?
ChatRoom::~ChatRoom(void) ?
{ ?
} ?
? ?
/// a client joins in the room ?
void ChatRoom::Join(ChatParticipantPtr participant) ?
{ ?
? ? ? TraceLog::WriteLine("ChatRoom::Join(), a new user joins in"); ?
? ?
? ? ? /// add into the queue ?
? ? ? Participants_.insert( participant ); ?
? ?
? ? ? /// sending the recent message to the client ?
? ? ? std::for_each(RecentMessages_.begin(), RecentMessages_.end(), ?
? ? ? ? ? ? boost::bind( &ChatParticipant::Deliver, participant, _1 ) ); ?
} ? ??
? ?
/// a client leaves the room ?
void ChatRoom::leave(ChatParticipantPtr participant) ?
{ ?
? ? ? TraceLog::WriteLine("ChatRoom::leave(), a user leaves"); ?
? ?
? ? ? /// remove it from the queue ?
? ? ? Participants_.erase( participant ); ?
} ? ??
? ?
/// deliver the message from one client to all of the users in the room ?
void ChatRoom::Deliver(const Message& msg) ?
{ ?
? ? ? TraceLog::WriteLine("ChatRoom::Deliver(), %s", msg.Body() ); ?
? ?
? ? ? /// add the msg to queue ?
? ? ? RecentMessages_.push_back( msg ); ?
? ?
? ? ? /// check the length ?
? ? ? while( RecentMessages_.size() > MaxRecentMsgs ) ?
? ? ? { ?
? ? ? ? ? ? RecentMessages_.pop_front(); ?
? ? ? } ?
? ?
? ? ? /// deliver the msg to clients ?
? ? ? std::for_each(Participants_.begin(), Participants_.end(), ?
? ? ? ? ? ? boost::bind( &ChatParticipant::Deliver, _1, boost::ref(msg) ) ); ?
} ?

開始單元測試
由于到手了VisualStudio 2012,這貨已經原始支持了C++Native代碼的單元測試，就用這貨開始做
UT吧。

如何引入被測代碼
好了，我們開始單元測試。首先創建一個C++單元測試的工程，這個很easy。接著我們就要讓測
試工程能夠“看到”被測的代碼，這如何搞呢？有這樣幾種方法：

如果被測代碼是靜態庫或者動態庫，包含對應的.h文件，讓測試工程鏈接DLL及LIB，這樣測試工
程。
或者，讓測試工程鏈接對應的obj文件，直接編譯進測試工程
或者，直接把被測是的代碼，如上述的Message.h和Message.cpp包含進測試工程（注意這里不
要拷貝一份Message.h和Message.cpp，用“Add->ExsitingItem”將他們包含進去，這樣只保
留一份代碼）
?或者在單元測試代碼文件，如TestMessage.cpp中直接用#include把Message.h和Message.cpp
包含進來，如：?
? ? ? ? ? ? ? ?#include "../ChatroomServer/ChatRoom.h"


? ? ? ? ? ? ? ?#include "../ChatroomServer/ChatRoom.cpp"


上面這幾種方法，其實原理都是一樣的，反正就是讓測試工程能夠看到到被測的代碼，我們使用把


被測代碼引入測試工程的方法，這樣測試工程的代碼結構看起來是這樣：


Ok，現在在測試工程里面，可以看到Message類的聲明和定義了，然后你的單元測試代碼，該怎


么寫，就怎么寫了。


一個測試工程只能測一個類嗎？
使用VS2012中的單元測試框架，寫完了對Message的的單元測試，在TestExplorer中RunAll，一


切正常；好了，至此，一切還算順利，那我們繼續吧，來對ChatRoom類編寫單元測試；


繼續按照前面的方法，我們很容易讓測試工程看到ChatRoom的被測代碼；然而從ChatRoom的


實現來看，這個類和Message類有著關聯關系，而且在ChatRoom的方法中，也的確使用了


Message類的方法，從單元測試的角度來看，我們應該將他們倆之間的關系隔斷，從而保證我們


只對ChatRoom進行測試，那這樣，我們就需要Mock一份Message的實現。


可是問題來了，由于之前我們在測試Message類的時候，已經引入了Message.cpp文件，使得測


試工程中，已經有了一份Message的實現，那么我們如何再能為Message提供一份“偽”實現呢


？？（使用其他幾種引入方式，結果都是一樣的）


是的，慣用的DependencyInjection在這里不起作用。查了不少資料，也沒找到一個像樣的說明


如何解決這個問題；現在唯一可以采用的，就是在一個測試工程里面，只測試一個被測類，雖然可


以工作，但是，未免又過于繁瑣和“愚蠢”，那聰明的方法，又是什么呢？不瞞你說，這正是目前


困擾我的問題之一。


追加一個后記：


其實，在關于如何為Message提供一份“偽”實現的問題上，原來想法是在測試工程中包含


Message的頭文件，然后在測試工程里面，直接寫Message::Message()等方法，事實上是在測試


工程里面定義一個Message的實現；這樣由于我們已經引入了Message的真正實現，從而必然導


致鏈接器報符號重復定義的錯誤，因此，這種思路并不可行，故而強迫我去創建另外一個工程；后


來想一想，其實也不必真的去創建一個新工程，他們是可以在一個工程里面完成的，方法是新建一


個MockMessage類，讓他從Message繼承下來，然后重新定義自己想Mock的方法就可以了。但


是，這種方法創建出來的Mock，還是真的Mock嗎，他首先已經是一個“真”的Message了啊？
========

C/C++單元測試理論精要（一）

http://blog.csdn.net/easytdd/article/details/5484405


內容介紹


? ? 本系列文章根據《單元測試與VU2.6應用》視頻講座的理論部分整理而成，主要討論四個問題


：為什么需要單元測試？怎樣征服可測性難題？怎樣才能高效率測試？怎樣保證測試效果？重點闡


述單元測試的關鍵問題，不是一般概念，適合于對單元測試有一定了解的讀者。


? ? 在選擇工具和實施單元測試前，我們應該對相關理論有一個系統的了解，特別是將會遇到哪些


難題，如何解決，要心里有數，否則的話，很可能勞民傷財，半途而廢。如果只會測試加法函數或


者三角形函數之類的獨立小程序，就以為可以做單元測試了，那就像一個人剛學會走路，就去長途


跋涉。


? ? 本文介紹的是針對企業項目的單元測試。企業項目具有兩個特點：項目復雜，時間緊張。項目


復雜，意味著測試時會遇到很多難題；時間緊張，要求我們不但要保證測試效果，還要盡可能高效


率。本文不是泛泛而談，而是針對企業項目的兩個特點，努力揭示本質性的問題，并提出解決辦法


，對于常識性的問題，將比較簡略的帶過。使用的工具是Visual Unit 2.6，本文主要不是介紹工具


，而是介紹問題所在和解決辦法，涉及到工具，只是為了具體的展示解決辦法，也為了說明，這些


辦法都是可行的，并非空談。


第1章 為什么需要單元測試？
1.1 從代碼特性看單元測試的必要性


? ? 代碼有一個很基本的特性，是什么呢？對數據分類處理。一個判定，就是一次分類。如果判定


中又嵌套了判定的話，分類次數就會翻倍。循環判定也是一種分類。


? ? 如果一個分類遺漏的話，也就是說，某種輸入沒有處理，會怎么樣呢？一個Bug誕生了！如果


一個分類的處理不正確，又會怎么樣呢？又一個Bug誕生了！


? ? 一個函數要做到沒有錯誤，要保證兩點：分類完整，也就是各類可能輸入都要考慮到；


處理正確，也就是每一類輸入都要進行正確的處理。做到了這兩點，就可以說，函數的功能邏輯是


正確的。函數的功能邏輯就是對數據的分類以及處理。


? ? 那么，怎樣才能全面地檢測程序的功能邏輯呢？調試，是臨時的，不做記錄，另一方面，調試


的工作方式是攔截數據，并不是所有輸入分類都能攔截得到的，如果一個函數有十類輸入，調試能


覆蓋五六個就不錯了。系統測試，不針對具體的函數，無法做到對具體函數的輸入分類覆蓋。要全


面地檢測程序的功能邏輯，必須把輸入分類全部列出來。并檢測程序是否處理了這些輸入，處理是


否正確。這就是單元測試。


說明
本系列文章根據《單元測試與VU2.6應用》視頻講座的理論部分整理而成，PPT及視頻下載：
PPT下載：http://download.csdn.net/source/2246006
視頻part1: http://download.csdn.net/source/2246273
視頻part2: http://download.csdn.net/source/2246345
視頻part3: http://download.csdn.net/source/2246364
本系列文章及視頻講座介紹的是單元測試理論的精要部分，詳細內容請閱讀《C/C++單元測試實


用教程》?
========

玩轉Google開源C++單元測試框架Google Test系列(gtest)之八 - 打造自己的單元測試框架

http://www.cnblogs.com/coderzh/archive/2009/04/12/1434155.html
一、前言


上一篇我們分析了gtest的一些內部實現，總的來說整體的流程并不復雜。本篇我們就嘗試編寫一


個精簡版本的C++單元測試框架：nancytest ，通過編寫這個簡單的測試框架，將有助于我們理


解gtest。


二、整體設計


使用最精簡的設計，我們就用兩個類，夠簡單吧：


1. TestCase類
包含單個測試案例的信息。?


2. UnitTest類


負責所有測試案例的執行，管理。


三、TestCase類


TestCase類包含一個測試案例的基本信息，包括：測試案例名稱，測試案例執行結果，同時還提


供了測試案例執行的方法。我們編寫的測試案例都繼承自TestCase類。


復制代碼
class TestCase
{
public:
? ? TestCase(const char* case_name) : testcase_name(case_name){}


? ? // 執行測試案例的方法
? ? virtual void Run() = 0;


? ? int nTestResult; // 測試案例的執行結果?
? ? const char* testcase_name; // 測試案例名稱
};
復制代碼
?


四、UnitTest類


我們的UnitTest類和gtest的一樣，是一個單件。我們的UnitTest類的邏輯非常簡單：


1. 整個進程空間保存一個UnitTest 的單例。


2. 通過RegisterTestCase()將測試案例添加到測試案例集合testcases_中。


3. 執行測試案例時，調用UnitTest::Run()，遍歷測試案例集合testcases_，調用案例的Run()方法


復制代碼
class UnitTest
{
public:
? ? // 獲取單例
? ? static UnitTest* GetInstance();?


? ? // 注冊測試案例
? ? TestCase* RegisterTestCase(TestCase* testcase);
? ??
? ? // 執行單元測試
? ? int Run();


? ? TestCase* CurrentTestCase; // 記錄當前執行的測試案例
? ? int nTestResult; // 總的執行結果
? ? int nPassed; // 通過案例數
? ? int nFailed; // 失敗案例數
protected:
? ? std::vector<TestCase*> testcases_; // 案例集合
};
復制代碼
下面是UnitTest類的實現：


復制代碼
UnitTest* UnitTest::GetInstance()
{
? ? static UnitTest instance;
? ? return &instance;
}


TestCase* UnitTest::RegisterTestCase(TestCase* testcase)
{
? ? testcases_.push_back(testcase);
? ? return testcase;
}


int UnitTest::Run()
{
? ? nTestResult = 1;
? ? for (std::vector<TestCase*>::iterator it = testcases_.begin();
? ? ? ? it != testcases_.end(); ++it)
? ? {
? ? ? ? TestCase* testcase = *it;
? ? ? ? CurrentTestCase = testcase;
? ? ? ? std::cout << green << "======================================"?


<< std::endl;
? ? ? ? std::cout << green << "Run TestCase:" << testcase->testcase_name << std::endl;
? ? ? ? testcase->Run();
? ? ? ? std::cout << green << "End TestCase:" << testcase->testcase_name << std::endl;
? ? ? ? if (testcase->nTestResult)
? ? ? ? {
? ? ? ? ? ? nPassed++;
? ? ? ? }
? ? ? ? else
? ? ? ? {
? ? ? ? ? ? nFailed++;
? ? ? ? ? ? nTestResult = 0;
? ? ? ? }
? ? }


? ? std::cout << green << "======================================"?


<< std::endl;
? ? std::cout << green << "Total TestCase : " << nPassed + nFailed << std::endl;
? ? std::cout << green << "Passed : " << nPassed << std::endl;
? ? std::cout << red << "Failed : " << nFailed << std::endl;
? ? return nTestResult;
}
復制代碼
五、NTEST宏


接下來定一個宏NTEST，方便我們寫我們的測試案例的類。


復制代碼
#define TESTCASE_NAME(testcase_name) \
? ? testcase_name##_TEST


#define NANCY_TEST_(testcase_name) \
class TESTCASE_NAME(testcase_name) : public TestCase \
{ \
public: \
? ? TESTCASE_NAME(testcase_name)(const char* case_name) : TestCase(case_name){}; \
? ? virtual void Run(); \
private: \
? ? static TestCase* const testcase_; \
}; \
\
TestCase* const TESTCASE_NAME(testcase_name) \
? ? ::testcase_ = UnitTest::GetInstance()->RegisterTestCase( \
? ? ? ? new TESTCASE_NAME(testcase_name)(#testcase_name)); \
void TESTCASE_NAME(testcase_name)::Run()


#define NTEST(testcase_name) \
? ? NANCY_TEST_(testcase_name)
復制代碼
?


六、RUN_ALL_TEST宏


然后是執行所有測試案例的一個宏：


#define RUN_ALL_TESTS() \
? ? UnitTest::GetInstance()->Run();
七、斷言的宏EXPECT_EQ?


這里，我只寫一個簡單的EXPECT_EQ ：


復制代碼
#define EXPECT_EQ(m, n) \
? ? if (m != n) \
? ? { \
? ? ? ? UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
? ? ? ? std::cout << red << "Failed" << std::endl; \
? ? ? ? std::cout << red << "Expect:" << m << std::endl; \
? ? ? ? std::cout << red << "Actual:" << n << std::endl; \
? ? }
復制代碼
?


八、案例Demo


夠簡單吧，再來看看案例怎么寫：


復制代碼
#include "nancytest.h"


int Foo(int a, int b)
{
? ? return a + b;
}


NTEST(FooTest_PassDemo)
{
? ? EXPECT_EQ(3, Foo(1, 2));
? ? EXPECT_EQ(2, Foo(1, 1));
}


NTEST(FooTest_FailDemo)
{
? ? EXPECT_EQ(4, Foo(1, 2));
? ? EXPECT_EQ(2, Foo(1, 2));
}


int _tmain(int argc, _TCHAR* argv[])
{
? ? return RUN_ALL_TESTS();
}
復制代碼


整個一山寨版gtest，呵。執行一下，看看結果怎么樣：


九、總結?


本篇介紹性的文字比較少，主要是我們在上一篇深入解析gtest時已經將整個流程弄清楚了，而現


在編寫的nancytest又是其非常的精簡版本，所有直接看代碼就可以完全理解。希望通過這個


Demo，能夠讓大家對gtest有更加直觀的了解。回到開篇時所說的，我們沒有必要每個人都造一


個輪子，因為gtest已經非常出色的為我們做好了這一切。如果我們每個人都寫一個自己的框架的


話，一方面我們要付出大量的維護成本，一方面，這個框架也許只能對你有用，無法讓大家從中受


益。
gtest正是這么一個優秀C++單元測試框架，它完全開源，允許我們一起為其貢獻力量，并能讓更


多人從中受益。如果你在使用gtest過程中發現gtest不能滿足你的需求時（或發現BUG），gtest


的開發人員非常急切的想知道他們哪來沒做好，或者是gtest其實有這個功能，但是很多用戶都不


知道。所以你可以直接聯系gtest的開發人員，或者你直接在這里回帖，我會將您的意見轉告給


gtest的主要開發人員。
如果你是gtest的超級粉絲，原意為gtest貢獻代碼的話，加入他們吧。　　　


本Demo代碼下載：/Files/coderzh/Code/nancytest.rar?


本篇是該系列最后一篇，其實gtest還有更多東西值得我們去探索，本系列也不可能將gtest介紹完


全，還是那句話，想了解更多gtest相關的內容的話：


訪問官方主頁：http://code.google.com/p/googletest/


下載gtest源碼： http://code.google.com/p/googletest/downloads/list


系列鏈接：


1.玩轉Google開源C++單元測試框架Google Test系列(gtest)之一 - 初識gtest
2.玩轉Google開源C++單元測試框架Google Test系列(gtest)之二 - 斷言
3.玩轉Google開源C++單元測試框架Google Test系列(gtest)之三 - 事件機制


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


5.玩轉Google開源C++單元測試框架Google Test系列(gtest)之五 - 死亡測試?
6.玩轉Google開源C++單元測試框架Google Test系列(gtest)之六 - 運行參數


7.玩轉Google開源C++單元測試框架Google Test系列(gtest)之七 - 深入解析gtest
8.玩轉Google開源C++單元測試框架Google Test系列(gtest)之八 - 打造自己的單元測試框架
?
========

使用 Visual Studio 2015 對 C++ 代碼運行單元測試

http://blog.csdn.net/lxf200000/article/details/51100094


代碼寫多了，往往規模會越來越大，這時候就有必要保證代碼的穩定性了；不過我從網上看到的單


元測試貌似大多都是用的 JUnit, 難道 C++ 就沒有了嗎？我從網上找了一些方法試了下其實挺簡


單的。下面我以一個示例作說明。（如果你有準備好的待測代碼可直接看創建單元測試項目那里。


）


創建一個 Win32 空項目“stg”并添加下面的代碼用作測試。這里我創建了一個結構體用來表示


一個物體，有X，Y，半徑這些變量，還有一個用來表示另一個物體是否在它的半徑內的函數，是


則返回1，否則為0。


【stg.h】


[cpp] view plain copy
#pragma once ?
struct SpriteType ?
{ ?
? ? SpriteType(); ?
? ? void SetValue(float, float, float, float); ?
? ? int IsShotBy(SpriteType*); ?
private: ?
? ? float posX, posY, shotRadius, sensedRadius; ?
? ? float _temp0; ?
}; ?


【stg.cpp】


[cpp] view plain copy
#include<cmath> ?
#include"stg.h" ?
??
SpriteType::SpriteType() :posX(0.0f), posY(0.0f), shotRadius(0.0f), sensedRadius(0.0f) ?
{ ?
??
} ?
??
void SpriteType::SetValue(float x, float y, float rshot, float rsensor) ?
{ ?
? ? posX = x, posY = y, shotRadius = rshot, sensedRadius = rsensor; ?
} ?
??
int SpriteType::IsShotBy(SpriteType *pOtherSprite) ?
{ ?
? ? _temp0 = sqrtf((pOtherSprite->posX - posX)*(pOtherSprite->posX - posX) +?


(pOtherSprite->posY - posY)*(pOtherSprite->posY - posY)); ?
? ? return (int)(_temp0 < shotRadius); ?
} ?


（為了簡單我把 main 函數省略了。）
然后是創建單元測試項目。在這個解決方案中創建一個名為 stgTest 的單元測試工程（命名規則是


“項目名”+Test），


創建好后在引用中添加待測項目的引用（右鍵引用選擇“添加引用項目”），


點確定，它應該會出現在單元測試工程的引用中。


然后在“stg”項目上右鍵選擇屬性，將其配置類型改為靜態庫（你可以在測試完后改回為應用程


序）


接下來找到單元測試的代碼，其文件名默認為“unittest1.cpp”，最好也改為“stgTest.cpp”以


便區分；在這個代碼中有一個默認的方法“TestMethod1”，它是由宏“TEST_METHOD”定義


的一個函數，這個函數就是用來作測試的，運行測試時它里面的代碼會執行，測試結果由 Assert?


中的一系列函數決定。另外兩個


宏“TEST_METHOD_INITIALIZE”，“TEST_METHOD_CLEANUP”分別用于定義測試開始前與


結束后執行的函數，通常將函數名定義為“SetUp”和“TearDown”（或許是因為 JUnit 中就是


這樣的？）。這里我將默認的“TestMethod1”改為“TestShot”（命名規則為 Test+“函數名


”），然后包含頭文件 #include“..\stg\stg.h”，加入測試代碼后形成下面這個樣子：


【stgTest.cpp 中的部分代碼】


[cpp] view plain copy
namespace AmIShotTest ?
{ ? ? ? ??
? ? TEST_CLASS(UnitTest1) ?
? ? { ?
? ? private: ?
? ? ? ? SpriteType *s1, *s2; ?
? ? public: ?
? ? ? ? TEST_METHOD_INITIALIZE(SetUp) ?
? ? ? ? { ?
? ? ? ? ? ? s1 = new SpriteType(); ?
? ? ? ? ? ? s2 = new SpriteType(); ?
? ? ? ? ? ? Logger::WriteMessage("Test initialized.\n"); //用于輸出信息 ?
? ? ? ? } ?
??
? ? ? ? TEST_METHOD_CLEANUP(TearDown) ?
? ? ? ? { ?
? ? ? ? ? ? delete s1; ?
? ? ? ? ? ? delete s2; ?
? ? ? ? ? ? Logger::WriteMessage("Test completed.\n"); ?
? ? ? ? } ?
??
? ? ? ? TEST_METHOD(TestShot) ?
? ? ? ? { ?
? ? ? ? ? ? s1->SetValue(2.0f, 3.0f, 1.2f, 1.5f); ?
? ? ? ? ? ? s2->SetValue(2.2f, 3.1f, 0.0f, 0.0f); ?
? ? ? ? ? ? Assert::AreEqual<int>(1, s1->IsShotBy(s2)); ?
? ? ? ? ? ? Logger::WriteMessage("Shot tested.\n"); ?
? ? ? ? } ?
? ? }; ?
} ?


上面 AreEqual 那句中，模板填入待測值的類型，第一個參數為預測值，第二個為實際運行的結果


，若相等則測試成功，否則為失敗。寫好代碼后選擇生成 stgTest 項目，然后在測試，窗口中打開


測試資源管理器，如果生成沒有問題就可以在這里看到測試項了，選擇運行即可。


既然學會了如何使用單元測試，那么以后寫代碼就不要忘了用哦！這樣你的代碼中的BUG就會越


來越少了！
========

輕松編寫 C++ 單元測試

http://www.ibm.com/developerworks/cn/linux/l-cn-cppunittest/
介紹全新單元測試框架組合： googletest 與 googlemock
googletest 與 googlemock 是 Google 公司于 2008 年發布的兩套用于單元測試的應用框架，本


文將向讀者介紹如何應用這兩套應用框架輕松編寫 C++ 單元測試代碼。以下討論基于 gtest-


1.2.1 及 gmock-1.0.0 。


單元測試概述
測試并不只是測試工程師的責任，對于開發工程師，為了保證發布給測試環節的代碼具有足夠好的


質量（ Quality ），為所編寫的功能代碼編寫適量的單元測試是十分必要的。
單元測試（ Unit Test ，模塊測試）是開發者編寫的一小段代碼，用于檢驗被測代碼的一個很小的


、很明確的功能是否正確，通過編寫單元測試可以在編碼階段發現程序編碼錯誤，甚至是程序設計


錯誤。
單元測試不但可以增加開發者對于所完成代碼的自信，同時，好的單元測試用例往往可以在回歸測


試的過程中，很好地保證之前所發生的修改沒有破壞已有的程序邏輯。因此，單元測試不但不會成


為開發者的負擔，反而可以在保證開發質量的情況下，加速迭代開發的過程。
對于單元測試框架，目前最為大家所熟知的是 JUnit 及其針對各語言的衍生產品， C++ 語言所對


應的 JUnit 系單元測試框架就是 CppUnit 。但是由于 CppUnit 的設計嚴格繼承自 JUnit ，而沒


有充分考慮 C++ 與 Java 固有的差異（主要是由于 C++ 沒有反射機制，而這是 JUnit 設計的基


礎），在 C++ 中使用 CppUnit 進行單元測試顯得十分繁瑣，這一定程度上制約了 CppUnit 的普


及。筆者在這里要跟大家介紹的是一套由 google 發布的開源單元測試框架（ Testing?


Framework ）： googletest 。


應用 googletest 編寫單元測試代碼
googletest 是由 Google 公司發布，且遵循 New BSD License （可用作商業用途）的開源項目


，并且 googletest 可以支持絕大多數大家所熟知的平臺。與 CppUnit 不同的是： googletest 可


以自動記錄下所有定義好的測試，不需要用戶通過列舉來指明哪些測試需要運行。
定義單元測試
在應用 googletest 編寫單元測試時，使用 TEST() 宏來聲明測試函數。如：
清單 1. 用 TEST() 宏聲明測試函數
TEST(GlobalConfigurationTest, configurationDataTest)?
?TEST(GlobalConfigurationTest, noConfigureFileTest)
分別針對同一程序單元 GlobalConfiguration 聲明了兩個不同的測試（Test）函數，以分別對配


置數據進行檢查（ configurationDataTest ），以及測試沒有配置文件的特殊情況（?


noConfigureFileTest ）。
實現單元測試
針對同一程序單元設計出不同的測試場景后（即劃分出不同的 Test 后），開發者就可以編寫單元


測試分別實現這些測試場景了。
在 googletest 中實現單元測試，可通過 ASSERT_* 和 EXPECT_* 斷言來對程序運行結果進行檢查


。 ASSERT_* 版本的斷言失敗時會產生致命失敗，并結束當前函數； EXPECT_* 版本的斷言失敗


時產生非致命失敗，但不會中止當前函數。因此， ASSERT_* 常常被用于后續測試邏輯強制依賴


的處理結果的斷言，如創建對象后檢查指針是否為空，若為空，則后續對象方法調用會失敗；而?


EXPECT_* 則用于即使失敗也不會影響后續測試邏輯的處理結果的斷言，如某個方法返回結果的多


個屬性的檢查。
googletest 中定義了如下的斷言：
表 1： googletest 定義的斷言（ Assert ）
基本斷言 二進制比較 字符串比較
ASSERT_TRUE(condition);
EXPECT_TRUE(condition);
condition為真
ASSERT_FALSE(condition);
EXPECT_FALSE(condition);
condition為假 ASSERT_EQ(expected,actual);
EXPECT_EQ(expected,actual);
expected==actual
ASSERT_NE(val1,val2);
EXPECT_NE(val1,val2);
val1!=val2
ASSERT_LT(val1,val2);
EXPECT_LT(val1,val2);
val1<val2
ASSERT_LE(val1,val2);
EXPECT_LE(val1,val2);
val1<=val2
ASSERT_GT(val1,val2);
EXPECT_GT(val1,val2);
val1>val2
ASSERT_GE(val1,val2);
EXPECT_GE(val1,val2);
val1>=val2 ASSERT_STREQ(expected_str,actual_str);
EXPECT_STREQ(expected_str,actual_str);
兩個 C 字符串有相同的內容
ASSERT_STRNE(str1,str2);
EXPECT_STRNE(str1,str2);
兩個 C 字符串有不同的內容
ASSERT_STRCASEEQ(expected_str,actual_str);
EXPECT_STRCASEEQ(expected_str,actual_str);
兩個 C 字符串有相同的內容，忽略大小寫
ASSERT_STRCASENE(str1,str2);
EXPECT_STRCASENE(str1,str2);
兩個 C 字符串有不同的內容，忽略大小寫
下面的實例演示了上面部分斷言的使用：
清單 2. 一個較完整的 googletest 單元測試實例
// Configure.h?
?#pragma once?


?#include <string>?
?#include <vector>?


?class Configure?
?{?
?private:?
? ? std::vector<std::string> vItems;?


?public:?
? ? int addItem(std::string str);?


? ? std::string getItem(int index);?


? ? int getSize();?
?};?


?// Configure.cpp?
?#include "Configure.h"?


?#include <algorithm>?


?/**?
?* @brief Add an item to configuration store. Duplicate item will be ignored?
?* @param str item to be stored?
?* @return the index of added configuration item?
?*/?
?int Configure::addItem(std::string str)?
?{?
std::vector<std::string>::const_iterator vi=std::find(vItems.begin(), vItems.end(), str);?
? ? if (vi != vItems.end())?
? ? ? ? return vi - vItems.begin();?


? ? vItems.push_back(str);?
? ? return vItems.size() - 1;?
?}?


?/**?
?* @brief Return the configure item at specified index.?
?* If the index is out of range, "" will be returned?
?* @param index the index of item?
?* @return the item at specified index?
?*/?
?std::string Configure::getItem(int index)?
?{?
? ? if (index >= vItems.size())?
? ? ? ? return "";?
? ? else?
? ? ? ? return vItems.at(index);?
?}?


?/// Retrieve the information about how many configuration items we have had?
?int Configure::getSize()?
?{?
? ? return vItems.size();?
?}?


?// ConfigureTest.cpp?
?#include <gtest/gtest.h>?


?#include "Configure.h"?


?TEST(ConfigureTest, addItem)?
?{?
? ? // do some initialization?
? ? Configure* pc = new Configure();?
? ??
? ? // validate the pointer is not null?
? ? ASSERT_TRUE(pc != NULL);?


? ? // call the method we want to test?
? ? pc->addItem("A");?
? ? pc->addItem("B");?
? ? pc->addItem("A");?


? ? // validate the result after operation?
? ? EXPECT_EQ(pc->getSize(), 2);?
? ? EXPECT_STREQ(pc->getItem(0).c_str(), "A");?
? ? EXPECT_STREQ(pc->getItem(1).c_str(), "B");?
? ? EXPECT_STREQ(pc->getItem(10).c_str(), "");?


? ? delete pc;?
?}
運行單元測試
在實現完單元測試的測試邏輯后，可以通過 RUN_ALL_TESTS() 來運行它們，如果所有測試成功，


該函數返回 0，否則會返回 1 。 RUN_ALL_TESTS() 會運行你鏈接到的所有測試――它們可以來自不


同的測試案例，甚至是來自不同的文件。
因此，運行 googletest 編寫的單元測試的一種比較簡單可行的方法是：
為每一個被測試的 class 分別創建一個測試文件，并在該文件中編寫針對這一 class 的單元測試；
編寫一個 Main.cpp 文件，并在其中包含以下代碼，以運行所有單元測試：
清單 3. 初始化 googletest 并運行所有測試
#include <gtest/gtest.h>?


?int main(int argc, char** argv) {?
? ? testing::InitGoogleTest(&argc, argv);?


? ? // Runs all tests using Google Test.?
? ? return RUN_ALL_TESTS();?
?}
最后，將所有測試代碼及 Main.cpp 編譯并鏈接到目標程序中。
此外，在運行可執行目標程序時，可以使用 --gtest_filter 來指定要執行的測試用例，如：
./foo_test 沒有指定filter，運行所有測試；
./foo_test --gtest_filter=* 指定filter為*，運行所有測試；
./foo_test --gtest_filter=FooTest.* 運行測試用例FooTest的所有測試；
./foo_test --gtest_filter=*Null*:*Constructor* 運行所有全名（即測試用例名 + “ . ” + 測試名


，如 GlobalConfigurationTest.noConfigureFileTest）含有"Null"或"Constructor"的測試；
./foo_test --gtest_filter=FooTest.*-FooTest.Bar 運行測試用例FooTest的所有測試，但不包括


FooTest.Bar。
這一特性在包含大量測試用例的項目中會十分有用。
回頁首
應用 googlemock 編寫 Mock Objects
很多 C++ 程序員對于 Mock Objects （模擬對象）可能比較陌生，模擬對象主要用于模擬整個應


用程序的一部分。在單元測試用例編寫過程中，常常需要編寫模擬對象來隔離被測試單元的“下游


”或“上游”程序邏輯或環境，從而達到對需要測試的部分進行隔離測試的目的。
例如，要對一個使用數據庫的對象進行單元測試，安裝、配置、啟動數據庫、運行測試，然后再卸


裝數據庫的方式，不但很麻煩，過于耗時，而且容易由于環境因素造成測試失敗，達不到單元測試


的目的。模仿對象提供了解決這一問題的方法：模仿對象符合實際對象的接口，但只包含用來“欺


騙”測試對象并跟蹤其行為的必要代碼。因此，其實現往往比實際實現類簡單很多。
為了配合單元測試中對 Mocking Framework 的需要， Google 開發并于 2008 年底開放了：?


googlemock 。與 googletest 一樣， googlemock 也是遵循 New BSD License （可用作商業


用途）的開源項目，并且 googlemock 也可以支持絕大多數大家所熟知的平臺。
注 1：在 Windows 平臺上編譯 googlemock
對于 Linux 平臺開發者而言，編譯 googlemock 可能不會遇到什么麻煩；但是對于 Windows 平


臺的開發者，由于 Visual Studio 還沒有提供 tuple （ C++0x TR1 中新增的數據類型）的實現，


編譯 googlemock 需要為其指定一個 tuple 類型的實現。著名的開源 C++ 程序庫 boost 已經提


供了 tr1 的實現，因此，在 Windows 平臺下可以使用 boost 來編譯 googlemock 。為此，需要


修改 %GMOCK_DIR%/msvc/gmock_config.vsprops ，設定其中 BoostDir 到 boost 所在的目


錄，如：
<UserMacro?
? ? Name="BoostDir"?
? ? Value="$(BOOST_DIR)"?
?/>
其中 BOOST_DIR 是一個環境變量，其值為 boost 庫解壓后所在目錄。
對于不希望在自己的開發環境上解包 boost 庫的開發者，在 googlemock 的網站上還提供了一個


從 boost 庫中單獨提取出來的 tr1 的實現，可將其下載后將解壓目錄下的 boost 目錄拷貝到?


%GMOCK_DIR% 下（這種情況下，請勿修改上面的配置項；建議對 boost 不甚了解的開發者采


用后面這種方式）。
在應用 googlemock 來編寫 Mock 類輔助單元測試時，需要：
編寫一個 Mock Class （如 class MockTurtle ），派生自待 Mock 的抽象類（如 class Turtle ）


；
對于原抽象類中各待 Mock 的 virtual 方法，計算出其參數個數 n ；
在 Mock Class 類中，使用 MOCK_METHODn() （對于 const 方法則需用?


MOCK_CONST_METHODn() ）宏來聲明相應的 Mock 方法，其中第一個參數為待 Mock 方法


的方法名，第二個參數為待 Mock 方法的類型。如下：
清單 4. 使用 MOCK_METHODn 聲明 Mock 方法
#include <gmock/gmock.h> ?// Brings in Google Mock.?


?class MockTurtle : public Turtle {?
? ? MOCK_METHOD0(PenUp, void());?
? ? MOCK_METHOD0(PenDown, void());?
? ? MOCK_METHOD1(Forward, void(int distance));?
? ? MOCK_METHOD1(Turn, void(int degrees));?
? ? MOCK_METHOD2(GoTo, void(int x, int y));?
? ? MOCK_CONST_METHOD0(GetX, int());?
? ? MOCK_CONST_METHOD0(GetY, int());?
?};
在完成上述工作后，就可以開始編寫相應的單元測試用例了。在編寫單元測試時，可通過?


ON_CALL 宏來指定 Mock 方法被調用時的行為，或 EXPECT_CALL 宏來指定 Mock 方法被調用


的次數、被調用時需執行的操作等，并對執行結果進行檢查。如下：
清單 5. 使用 ON_CALL 及 EXPECT_CALL 宏
using testing::Return; ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?// #1，必要的聲明


?TEST(BarTest, DoesThis) {?
? ? MockFoo foo; ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?// #2，創建 Mock 對象


? ? ON_CALL(foo, GetSize()) ? ? ? ? ? ? ? ? ? ? ? ? // #3，設定 Mock 對象默認的行為（可選）
? ? ? ? .WillByDefault(Return(1));?
? ? // ... other default actions ...?


? ? EXPECT_CALL(foo, Describe(5)) ? ? ? ? ? ? ? ? ? // #4，設定期望對象被訪問的方式及其響應
? ? ? ? .Times(3)?
? ? ? ? .WillRepeatedly(Return("Category 5"));?
? ? // ... other expectations ...?


? ? EXPECT_EQ("good", MyProductionFunction(&foo)); ?
? ? // #5，操作 Mock 對象并使用 googletest 提供的斷言驗證處理結果
?} ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
?// #6，當 Mock 對象被析構時， googlemock 會對結果進行驗證以判斷其行為是否與所有設定


的預期一致
其中， WillByDefault 用于指定 Mock 方法被調用時的默認行為； Return 用于指定方法被調用


時的返回值； Times 用于指定方法被調用的次數； WillRepeatedly 用于指定方法被調用時重復的


行為。
對于未通過 EXPECT_CALL 聲明而被調用的方法，或不滿足 EXPECT_CALL 設定條件的 Mock 方


法調用， googlemock 會輸出警告信息。對于前一種情況下的警告信息，如果開發者并不關心這


些信息，可以使用 Adapter 類模板 NiceMock 避免收到這一類警告信息。如下：
清單 6. 使用 NiceMock 模板
testing::NiceMock<MockFoo> nice_foo;
在筆者開發的應用中，被測試單元會通過初始化時傳入的上層應用的接口指針，產生大量的處理成


功或者失敗的消息給上層應用，而開發者在編寫單元測試時并不關心這些消息的內容，通過使用?


NiceMock 可以避免為不關心的方法編寫 Mock 代碼（注意：這些方法仍需在 Mock 類中聲明，


否則 Mock 類會被當作 abstract class 而無法實例化）。
與 googletest 一樣，在編寫完單元測試后，也需要編寫一個如下的入口函數來執行所有的測試：
清單 7. 初始化 googlemock 并運行所有測試
#include <gtest/gtest.h>?
?#include <gmock/gmock.h>?


?int main(int argc, char** argv) {?
? ? testing::InitGoogleMock(&argc, argv);?


? ? // Runs all tests using Google Test.?
? ? return RUN_ALL_TESTS();?
?}
下面的代碼演示了如何使用 googlemock 來創建 Mock Objects 并設定其行為，從而達到對核心


類 AccountService 的 transfer （轉賬）方法進行單元測試的目的。由于 AccountManager 類


的具體實現涉及數據庫等復雜的外部環境，不便直接使用，因此，在編寫單元測試時，我們用?


MockAccountManager 替換了具體的 AccountManager 實現。
清單 8. 待測試的程序邏輯
// Account.h?
?// basic application data class?
?#pragma once?


?#include <string>?


?class Account?
?{?
?private:?
? ? std::string accountId;?


? ? long balance;?


?public:?
? ? Account();?


? ? Account(const std::string& accountId, long initialBalance);?


? ? void debit(long amount);?


? ? void credit(long amount);?


? ? long getBalance() const;?


? ? std::string getAccountId() const;?
?};?


?// Account.cpp?
?#include "Account.h"?


?Account::Account()?
?{?
?}?


?Account::Account(const std::string& accountId, long initialBalance)?
?{?
? ? this->accountId = accountId;?
? ? this->balance = initialBalance;?
?}?


?void Account::debit(long amount)?
?{?
? ? this->balance -= amount;?
?}?


?void Account::credit(long amount)?
?{?
? ? this->balance += amount;?
?}?


?long Account::getBalance() const?
?{?
? ? return this->balance;?
?}?


?std::string Account::getAccountId() const?
?{?
? ? return accountId;?
?}?


?// AccountManager.h?
?// the interface of external services which should be mocked?
?#pragma once?


?#include <string>?


?#include "Account.h"?


?class AccountManager?
?{?
?public:?
? ? virtual Account findAccountForUser(const std::string& userId) = 0;?


? ? virtual void updateAccount(const Account& account) = 0;?
?};?


?// AccountService.h?
?// the class to be tested?
?#pragma once?


?#include <string>?


?#include "Account.h"?
?#include "AccountManager.h"?


?class AccountService?
?{?
?private:?
? ? AccountManager* pAccountManager;?


?public:?
? ? AccountService();?


? ? void setAccountManager(AccountManager* pManager);?
? ? void transfer(const std::string& senderId,?
? ? ? ? ? ? ? ?const std::string& beneficiaryId, long amount);?
?};?


?// AccountService.cpp?
?#include "AccountService.h"?


?AccountService::AccountService()?
?{?
? ? this->pAccountManager = NULL;?
?}?


?void AccountService::setAccountManager(AccountManager* pManager)?
?{?
? ? this->pAccountManager = pManager;?
?}?


?void AccountService::transfer(const std::string& senderId,?
? ? ? ? ? ? ? ? ? const std::string& beneficiaryId, long amount)?
?{?
? ? Account sender = this->pAccountManager->findAccountForUser(senderId);?


? ? Account beneficiary = this->pAccountManager->findAccountForUser(beneficiaryId);?


? ? sender.debit(amount);?


? ? beneficiary.credit(amount);?


? ? this->pAccountManager->updateAccount(sender);?


? ? this->pAccountManager->updateAccount(beneficiary);?
?}
清單 9. 相應的單元測試
// AccountServiceTest.cpp?
?// code to test AccountService?
?#include <map>?
?#include <string>?


?#include <gtest/gtest.h>?
?#include <gmock/gmock.h>?


?#include "../Account.h"?
?#include "../AccountService.h"?
?#include "../AccountManager.h"?


?// MockAccountManager, mock AccountManager with googlemock?
?class MockAccountManager : public AccountManager?
?{?
?public:?
? ? MOCK_METHOD1(findAccountForUser, Account(const std::string&));?


? ? MOCK_METHOD1(updateAccount, void(const Account&));?
?};?


?// A facility class acts as an external DB?
?class AccountHelper?
?{?
?private:?
? ? std::map<std::string, Account> mAccount;?
? ? ? ? ? ? ?// an internal map to store all Accounts for test?


?public:?
? ? AccountHelper(std::map<std::string, Account>& mAccount);?


? ? void updateAccount(const Account& account);?


? ? Account findAccountForUser(const std::string& userId);?
?};?


?AccountHelper::AccountHelper(std::map<std::string, Account>& mAccount)?
?{?
? ? this->mAccount = mAccount;?
?}?


?void AccountHelper::updateAccount(const Account& account)?
?{?
? ? this->mAccount[account.getAccountId()] = account;?
?}?


?Account AccountHelper::findAccountForUser(const std::string& userId)?
?{?
? ? if (this->mAccount.find(userId) != this->mAccount.end())?
? ? ? ? return this->mAccount[userId];?
? ? else?
? ? ? ? return Account();?
?}?


?// Test case to test AccountService?
?TEST(AccountServiceTest, transferTest)?
?{?
? ? std::map<std::string, Account> mAccount;?
? ? mAccount["A"] = Account("A", 3000);?
? ? mAccount["B"] = Account("B", 2000);?
? ? AccountHelper helper(mAccount);?


? ? MockAccountManager* pManager = new MockAccountManager();?


? ? // specify the behavior of MockAccountManager?
? ? // always invoke AccountHelper::findAccountForUser?
? ? ?// when AccountManager::findAccountForUser is invoked?
? ? EXPECT_CALL(*pManager, findAccountForUser(testing::_)).WillRepeatedly(?
? ? ? ? testing::Invoke(&helper, &AccountHelper::findAccountForUser));?


? ? // always invoke AccountHelper::updateAccount?
? ? //when AccountManager::updateAccount is invoked?
? ? EXPECT_CALL(*pManager, updateAccount(testing::_)).WillRepeatedly(?
? ? ? ? testing::Invoke(&helper, &AccountHelper::updateAccount));?


? ? AccountService as;?
? ? // inject the MockAccountManager object into AccountService?
? ? as.setAccountManager(pManager);?


? ? // operate AccountService?
? ? as.transfer("A", "B", 1005);?


? ? // check the balance of Account("A") and Account("B") to?
? ? //verify that AccountService has done the right job?
? ? EXPECT_EQ(1995, helper.findAccountForUser("A").getBalance());?
? ? EXPECT_EQ(3005, helper.findAccountForUser("B").getBalance());?


? ? delete pManager;?
?}?


?// Main.cpp?
?#include <gtest/gtest.h>?
?#include <gmock/gmock.h>?


?int main(int argc, char** argv) {?
? ? testing::InitGoogleMock(&argc, argv);?


? ? // Runs all tests using Google Test.?
? ? return RUN_ALL_TESTS();?
?}
注 2：上述范例工程詳見附件。要編譯該工程，請讀者自行添加環境變量 GTEST_DIR 、?


GMOCK_DIR ，分別指向 googletest 、 googlemock 解壓后所在目錄；對于 Windows 開發者


，還需要將 %GMOCK_DIR%/msvc/gmock_config.vsprops 通過 View->Property Manager 添


加到工程中，并將 gmock.lib 拷貝到工程目錄下。
通過上面的實例可以看出， googlemock 為開發者設定 Mock 類行為，跟蹤程序運行過程及結果


，提供了豐富的支持。但與此同時，應用程序也應該盡量降低應用代碼間的耦合度，使得單元測試


可以很容易對被測試單元進行隔離（如上例中， AccountService 必須提供了相應的方法以支持?


AccountManager 的替換）。關于如何通過應用設計模式來降低應用代碼間的耦合度，從而編寫


出易于單元測試的代碼，請參考本人的另一篇文章《應用設計模式編寫易于單元測試的代碼》（?


developerWorks ， 2008 年 7 月）。
注 3：此外，開發者也可以直接通過繼承被測試類，修改與外圍環境相關的方法的實現，達到對其


核心方法進行單元測試的目的。但由于這種方法直接改變了被測試類的行為，同時，對被測試類自


身的結構有一些要求，因此，適用范圍比較小，筆者也并不推薦采用這種原始的 Mock 方式來進


行單元測試。
回頁首
總結
Googletest 與 googlemock 的組合，很大程度上簡化了開發者進行 C++ 應用程序單元測試的編


碼工作，使得單元測試對于 C++ 開發者也可以變得十分輕松；同時， googletest 及?


googlemock 目前仍在不斷改進中，相信隨著其不斷發展，這一 C++ 單元測試的全新組合將變


得越來越成熟、越來越強大，也越來越易用。
========

總結

以上是生活随笔為你收集整理的C++单元测试学习总结9的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。