下載Google C++ Mocking Framework，解壓...
發現它自帶了Google Test的全部源代碼，也就是說有了這個那個Google Test就不用去下載了
注意，Google Mock的編譯對編譯器的C++支持要求很高，并且需要有tr1的支持。

 

Linux/Unix下的GCC編譯:
 注意：Google Mock的Readme里說它要求4.0版以上(不過版本低也沒事，畢竟gcc是支持C++標準最好的編譯器了，見Mingw3.45的安裝)
 傳統過程: ./configure make
 
Windows:
Windows下的編譯器自帶tr1的還不多，我知道的也就BCB2009了，所以需要去下載一個Boost下來，好在gmock只用到了幾個簡單功能，所以不用編譯Boost，直接包含Boost的目錄,以及\boost\tr1\tr1即可。

VC2005 SP1:
 打開msvc目錄里的sln工程
 設置包含路徑，加入Boost, 加入Boost\tr1\tr1, 加入gtest所在路徑
 編譯，搞定(跟著MS就是好混啊)

Mingw3.45:
 主要是google test要作一點修改,同樣過幾天可以到www.cppprog.com下載

注:google mock文檔說要gcc4.0以上版本，而現在Mingw還沒出4.0以上的穩定版，所以我在3.45版里發現使用時需要屏蔽gmock-matcher.h里的template<typename T> Matcher<T>::Matcher<T value>才行(在175行和1675行)。不過這樣就有個缺點，象EXPECT_CALL(turtle, Turn(90))就得改成EXPECT_CALL(turtle, Turn(Eq(90)))了。
 
BCC:
BCC就比較郁悶了，有太多地方不兼容了，偶搞不定呀呀呀:-(

 

介紹:Google Mock是干什么的？
Google Mock的設計靈感來源于jMock和EasyMock，它的作用是幫你快速地做出一個接口的仿制品。如果你的設計依賴其它的類，而這些類還沒有完成或非常昂貴（如數據庫）；如果你要測試你的模塊與其它模塊是否能正確結合，并想了解其交互過程；那么Google Mock就能幫助你。

假設我們寫好了一個CPainter類，它可以畫各種圖形。但它用到了一個Turtle類，它是由別人寫的，而那小子光顧著和PLMM聊天了，現在還沒開始動筆呢~!@#$%
那么想測試這個CPainter只有兩個方法，一個是等那家伙把Turtle寫好，另一個是自己寫一個Turtle的仿制品出來用用先。
如果你選的是方法二，那么Google Mock就可以幫上忙了，假設Turtle定義如下:

1.           struct Turtle {   //這個功能可能是別人做的，現在還沒完工

2.             virtual ~Turtle(){};

3.             virtual void PenUp() = 0;  //起筆

4.             virtual void PenDown() = 0;//下筆

5.             virtual void Forward(int distance) = 0;  //前進

6.             virtual void Turn(int degrees) = 0;  //轉向

7.             virtual void GoTo(int x, int y) = 0; //直接移動到指定位置

8.             virtual int GetX() const = 0; //獲得當前位置

9.             virtual int GetY() const = 0;

10.       };

我們現在就用Google Mock寫一個Turtle仿制品:
首先加入包含文件
#include <gtest/gtest.h>
#include <gmock/gmock.h>

制作仿制品:

1.           struct MockTurtle : public Turtle {

2.             MOCK_METHOD0(PenUp, void());

3.             MOCK_METHOD0(PenDown, void());

4.             MOCK_METHOD1(Forward, void(int distance));

5.             MOCK_METHOD1(Turn, void(int degrees));

6.             MOCK_METHOD2(GoTo, void(int x, int y));

7.             MOCK_CONST_METHOD0(GetX, int());

8.             MOCK_CONST_METHOD0(GetY, int());

9.           };

它從Turtle繼承，把想要仿制的方法用MOCK_METHODn來定義（如果是const方法，則用MOCK_CONST_METHODn），這里的n是類方法的參數數量，第一個參數是方法名，第二個參數是此方法的函數類型（看看,不是類成員函數類型哦）

 

好了，我們不用寫一句代碼，Google Mock已經幫我們把Turtle的仿制品準備好了，我們只管調用就可以了。如果接口方法很多，你還可以用scripts/generator/里的gmock_gen.py來幫你做這些工作（你需要安裝Python 2.4）。這是一個命令行工具，你給它寫有抽象類定義的C++文件，它就給你一個相應的Mock類。

現在可以測試我們的CPainter了，假設我們寫的CPainter如下:

1.           //我們寫的繪圖類，因為要使用Turtle，要測試的這個繪圖類就得用上MockTurtle類了

2.           struct CPainter{

3.               CPainter():m_ptl(NULL){;}

4.               void SetTurtle(Turtle* ptl){

5.                   m_ptl = ptl;

6.               }

7.               void Square(int w) //畫正方形

8.               {

9.                   if(!m_ptl || w<=0) return;

10.               m_ptl->PenDown();

11.               m_ptl->Forward(w);

12.               m_ptl->Turn(90);

13.               m_ptl->Forward(w);

14.               m_ptl->Turn(90);

15.               m_ptl->Forward(w);

16.               m_ptl->Turn(90);

17.               m_ptl->Forward(w);

18.               m_ptl->Turn(90);

19.               m_ptl->PenUp();

20.           }

21.       private:

22.           Turtle *m_ptl;

23.       };

我們測試一下它畫正方形的功能是否正常:

1.           using testing::AtLeast;

2.           using testing::Return;

3.           using testing::_;

4.           using testing::Gt;

5.           using testing::Eq;

6.           TEST(PainterTest, SquareTest)

7.           {

8.               MockTurtle turtle;

9.               EXPECT_CALL(turtle, Forward(_)) //預計將不再調Forward(),是倒序的，看下一語句

10.               .Times(0);

11.           EXPECT_CALL(turtle, Forward(Gt(0))) //預計將會先調用四次Forward(),其中參數大于0,是倒序的

12.               .Times(4);

13.           EXPECT_CALL(turtle, Turn(90)) //預計將會調用四次Turn(90)

14.               .Times(4);

15.           EXPECT_CALL(turtle, PenUp());

16.           EXPECT_CALL(turtle, PenDown());

17.           CPainter pt;

18.           pt.SetTurtle(&turtle);

19.           pt.Square(10); //測試輸入10的情況，應該會調用四次Forward(10)和四次Turn(90)

20.           pt.Square(0);  //測試輸入0的情況，應該不會再調用Forward才對

21.       }

22.       int main(int argc, char* argv[])

23.       {

24.         testing::InitGoogleMock(&argc, argv);  //和Google Test使用方法一樣，具體參考<Google C++ Testing Framework使用介紹>

25.         int r = RUN_ALL_TESTS();

26.         std::cin.get(); 

27.         return r;

28.       }

運行，測試通過(不知為什么看到一片綠讓我想起了股市)

下面來解釋一下Google Mock新引入的斷言EXPECT_CALL，它就是整個Mock測試的關鍵：

EXPECT_CALL的語法是:
EXPECT_CALL(mock_object, method(matchers))
    .Times(cardinality)
    .WillOnce(action)
    .WillRepeatedly(action);

看一下這個測試：(EXPECT_EQ的使用見<Google C++ Testing Framework使用介紹>)

1.           TEST(PainterTest, CanDrawSomething) {

2.               MockTurtle turtle;

3.               EXPECT_CALL(turtle, GetX())  //這個是寫在前面地，就是說預計它應該會

4.                       .Times(AtLeast(5))      //調用至少5次

5.                   .WillOnce(Return(100))  //第一次調用GetX()就返回100

6.                   .WillOnce(Return(150))  //第二次調用GetX()就返回150

7.                   .WillRepeatedly(Return(200)) //接下來的所有調用就返回200

8.                   ;

9.               EXPECT_EQ(100, turtle.GetX());  //第一次運行turtle.GetX()，返回100

10.           EXPECT_EQ(150, turtle.GetX());  //第二次返回150

11.           EXPECT_EQ(200, turtle.GetX());  //第三次返回200

12.           EXPECT_EQ(200, turtle.GetX());  //第四次返回200

13.           EXPECT_EQ(20, turtle.GetX());   //第五次返回200，不信寫個20試試這次測試是什么結果?

14.       }

 

測試結果:

 

首先EXPECT_CALL是寫在所有對turtle的調用之前的，也就是說EXPECT_CALL是一個預測，在這個測試結束時預測必須和實際情況相同，否則就Google Test就會發表意見
這個測試看上去很直觀，意思是GetX至少會被調用5次，第一次調用時這個仿制品.GetX()返回100,第二次返回150,接下去就一直返回200。

 

怎樣測試帶參數的方法呢？

EXPECT_CALL(turtle, Forward(100)); 表示預計將會調用turtle.Forward(100)。
EXPECT_CALL(turtle, Forward(testing::_)); 表示預計將會調用turtle.Forward，里面的參數可以任意。
EXPECT_CALL(turtle, Forward(testing::Ge(100))); 表示預計將會調用turtle.Forward，而且里面的參數都會大于或等于100。

將會被調用多少次？即Times(cardinality)中的cardinality使用方法
test::AtLeast(n)表示至少會調用n次
test::AtMost(n)表示至多會調用n次
更多:http://code.google.com/p/googlemock/wiki/CheatSheet

如果不寫Times(cardinality)，Google Mock將會自己推斷出cardinality:

1.           如果既沒有WillOnce也沒有WillRepeatedly，那么相當于Times(1)

2.           有n個WillOnce但沒有WillRepeatedly，那么相當于Times(n)

3.           有n個WillOnce和一個WillRepeatedly，那么相當于Times(AtLeast(n))

多次預測:
假設有這樣一個測試:

1.           using testing::_;...

2.           EXPECT_CALL(turtle, Forward(_));  // #1

3.           EXPECT_CALL(turtle, Forward(10))  // #2

4.               .Times(2);

如果Forward(10)被調用了3次，那么第三次調用將被指出是一個錯誤，因為#2的測試不通過（說了是兩次嘛，怎么出現三次呢-_-）；如果第三次調用改成Forward(20)則沒有問題,因為這次與#1匹配了。
再次注意，預測優先級順序是反著來的，先對比#2再對比#1。

 

接順序預測:
默認對于多個不同的預測是沒有順序要求的，只要每個預測達到要求就可以。如果你想要精確指定順序，很簡單：

1.           using testing::InSequence;...

2.           TEST(FooTest, DrawsLineSegment) {

3.             ...

4.             {

5.               InSequence dummy;

6.               EXPECT_CALL(turtle, PenDown());

7.               EXPECT_CALL(turtle, Forward(100));

8.               EXPECT_CALL(turtle, PenUp());

9.             }

10.         Foo();

11.       }

所有在InSequence生存空間內放入的預測都將嚴格按順序測試，如果調用PenDown,Forward,PenUp的順序不致將報告錯誤。

所有的預測都是有“粘性”的

1.           using testing::Return;

2.           ...

3.           for (int i = n; i > 0; i--) {

4.             EXPECT_CALL(turtle, GetX())

5.                 .WillOnce(Return(10*i));

6.           }

如果你認為這段預測代表turtle.GetX()將被調用n次，而且依次是10,20,30...，錯！因為預測是有“粘性”的，第二次調用GetX時，還是與最后一次預測（也就是EXPECT_CALL(turtle, GetX()).WillOnce(Return(10))那次）匹配，結果當然是“超出預測的調用次數”；
正確的方法是明確指出預測不該存在粘性，另一種說法是當它們“吃飽”后就盡快“退役”:

1.           using testing::Return;

2.           ...

3.           for (int i = n; i > 0; i--) {

4.             EXPECT_CALL(turtle, GetX())

5.               .WillOnce(Return(10*i))

6.               .RetiresOnSaturation();

7.           }

另外，這種情況下我們還有更好一點的方法來指定序列：

1.           using testing::InSequence;

2.           using testing::Return;

3.           ...

4.           {

5.             InSequence s;

6.             for (int i = 1; i <= n; i++) {

7.               EXPECT_CALL(turtle, GetX())

8.                   .WillOnce(Return(10*i))

9.                   .RetiresOnSaturation();

10.         }

11.       }

發表于 @ 2008年12月30日 20:05:00|評論(5 )|收藏

唉，BS一下CSDN的Blog的書寫功能，把俺那么帥的排版弄得亂七八糟！

for mingw3.4.5的Google Mock已上傳至http://www.cppprog.com/2009/0101/25.html
如果需要大家可以去下載了

有個問題，如果使用了cin，cout，如何mock，比如在某個函數里頭使用了cin.get();為了單元測試的自動化進行，一般要把cin.get() mock掉，使其直接返回一個值。

to blkworm
你可以使用WillOnce(Invoke(func));的形式來mock。
把cin.get()放到func里調用。
具體使用可以看:
http://code.google.com/p/googlemock/wiki/CheatSheet
如果有空我可以試著去翻譯一哈，（不過這幾天很忙，要過年咯）

這個方法我看英文幫助了，已經知道，之所以在這里問問題，就是想知道有沒有更好的方法。試圖把所有的系統調用都封裝起來的做法，打樁的工作量未免太大了。
跟其他類的接口可以采用這種適配的方式進行，以實現松耦合，這在設計上是合理的，但是連系統調用也要通過適配的方式進行，未免要求太極端了。