Google C++ Mocking Framework for Dummies 翻译

最新推荐文章于 2023-11-21 00:00:11 发布

cankykong1

最新推荐文章于 2023-11-21 00:00:11 发布

阅读量1.3k

点赞数

分类专栏： Chromium Google

Google 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

Chromium

2 篇文章 0 订阅

订阅专栏

Google Mock启蒙篇(Google C++ Mocking Framework for Dummies 翻译)

原文链接:http://quweiprotoss.blog.163.com/blog/static/4088288320111022103331960/

Google C++ Mocking Framework for Dummies

Google Mock启蒙篇

Version: 0.07< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" />

作者：adrian alexander

译者：Koala++ /屈伟

What Is Google C++ Mocking Framework

当你写一个原型或是测试的时候，直接去依赖真实的对象通常是不可行的或是不明智的。Mock对象实现与真实对象有着相同的接口，但你可以去指定Mock对象在运行时它做什么(比如，调用哪个函数，以什么顺序，调用多少次，使用什么参数，返回内容是什么，等等 )。

注意：Fake对象和Mock对象两个术语很容易混淆。在测试驱动开发( TDD )语境下，Fake对象和Mock对象是区别很大的两个概念。

l Fakes是有具体实现的，但通常是一些走了捷径的实现，所以它不能真正的用于发布产品中。比如一个在内存中的文件系统就是一个Fake的例子。

l Mocks是一些有期望( expections )预先编程的对象，期望形成了有着期望结果的调用的一个特化。

上面所解释也许太过抽象，但别担心，最重要的就是记住：Mock可以使你检查它与使用它的代码之间的交互。其实，当你开始使用Mocks之后，Fakes和Mocks之间的区别会马上清晰起来。

Google C++ Mocking Framework (或简称Google Mock )是一个用于创建Mock类使用这些类的库(有时我们也将它称为框架，让它听起来更酷一些 )。它和Java世界中的jMock和EasyMock功能相同。

使用Google Mock有下面三个基本步骤：

1. 使用简单的宏来描述你想Mock的接口，这些宏会自动扩展成你的Mock类的实现。

2. 创建一些Mock对象，并用一种直观的语法去指定Mock对象的期望和行为。

3. 用这些Mock对象测试代码。Google Mock会捕获那些违反期望的冲突。

Why Google Mock?

虽然Mock对象可以帮助你在测试中去除不必要的依赖，并使测试更快更可靠，但是在C++中用Mocks却比较难。

l 它需要你自己去实现Mocks。这项工作通常无聊并且易错。无怪大家都尽可能不去做这种件事。

l 这些自己实现的Mocks质量有一点……，嗯，不可预测。你可能见过一些写的很精巧的Mocks，但你也可能看到一些匆忙间hack出来的Mocks，这些Mocks中充斥着各种怪异的限制。

l 你在使用一个Mock所获得的经验无法在下一个Mock中使用。

相反，Java和Python程序员有一些很好的Mock框架，它们可以自动创建Mocks。结果，在Java和Python世界Mocking是被证明是一种高效的技术，并被广泛地使用。

Google Mock就是为帮助C++程序员解决Mock问题而生的。它受jMock和EasyMock的启发，但在设计时思虑了C++的特性。如果下面的任一问题困扰着你，那么Google Mock将成为你的朋友。

l 你被一个优化了一部分的设计困住了，你希望可以做一些原型设计，以免时间不够了。但原型设计在C++中绝对不可能称之为快。

l 你的测试很慢可能它们依赖很多库或是使用很多资源(比如，数据库）。

l 你的测试很脆弱，因为它所依赖的资源不可靠。

l 你想测试你的代码处理失败的情况，但是很难产生一个失败。

l 你需要保证你的模块与别的模块以正确的方式交互，但很难看到交互的过程，你只能看到最终运行的结果，这无论如何都是尴尬的。

l 你想要“Mock out”你的依赖，但是这些依赖还没有Mock实现，坦白地讲，就算是有，你看到这些手写的Mocks也会头痛。

我们推荐你在以下面的方式使用Google Mock:

l 作为一个设计工具，因为它可以让你更早更频繁地试验你的接口设计。更多的迭代会产生更好的设计。

l 作为一个测试工具，它可以解除外围的依赖，并可以查看你的模板与其它模块的交互。

Get Started

使用Google Mock很容易！在你的C++源文件中，只需要写上#include “gtest/gtest.h”和“gmock/gmock.h”，你就可以开始你的Goole Mock之旅了。

A Case for Mock Turtles

让我们看一个例子。假设你在开发一个图形程序，它依赖一个类似Logo(译注：初一我学的第一门计算机语言，每次我听到它名字都会激动万分，虽然它的命令我几乎忘光了 )的API来绘图，你怎么去测试你的程序是正确的呢？嗯，你可以运行它，然后比较你屏幕上的结果和目标屏幕截图，但是必需要承认的是：这种测试很麻烦，并且健壮性不足(如果你升级了你的显卡，这个显卡有更好的抗锯齿能力，那你需要把你用的图形文件都换了 )。如果你的测试都是这样的，那你会很痛苦的。幸运的是，你知道依赖注入并且知道该如何去做：不要让你的程序直接去调用绘图API，而应该将API封装成一个接口( Turtle，译注：Logo语言中的图标像是一个海龟，在Doc时代这完全是骗小朋友的，它就是一个没有尾巴的箭头)，并针对接口编程。

classTurtle {

...

virtual ~Turtle() {}

virtualvoidPenUp() = 0;

virtualvoidPenDown() = 0;

virtualvoidForward(int distance) = 0;

virtualvoidTurn(int degrees) = 0;

virtualvoidGoTo(int x,int y) = 0;

virtualintGetX() const = 0;

virtualintGetY() const = 0;

};

注意：Turtle类的析构函数必须是虚函数，因为在随后的介绍中要继承这个类。

你可以通过PenUp()和PenDown()来控制光标的移动是否会留下痕迹，并用Forward()，Turn()，和Goto()来控制它的移动，GetX()和GetY()会告诉你当前光标的位置。

你的程序通常会使用这个接口的真实实现。但在测试中，你可以使用一个Mock实现来代替。这可以让你更早地检查你的程序调用哪些绘图API，使用什么参数，以什么顺序调用。这样的测试更健壮(这样的测试不会因为你的新显卡在反锯齿性上表现不同而失败 )，并且这种代码更容易去理解和维护(测试的目标是用代码表示，而不是用一些二进制图形去表示)，而且会运行的非常非常快。

Writing the Mock Class

如果你需要的Mocks已经有好心人实现了，那你很走运。但是如果你发现需要自己要去实现Mock类，也别紧张，Google Mock已经将这个任务变成了一个有趣的游戏(嗯，算是吧)。

How to Define It

这里以Turtle接口为例子，下面是你需要去做的几个步骤：

1. 继承Turtle类得到MockTurtle类。

2. 从Turtle类中选一个虚函数(也可用模板Mock非虚函数，但那涉及的知识就多了一些 )，数一下这个函数有几个参数。

3. 在MockTurtle的public:部分，写上MOCK_METHODn(); (如果你要Mock一个const函数，就写MOCK_CONST_METHODn )，其中n是函数中的参数个数，如果你真的连数数都能数错，那编译器会坦白地告诉你这个丢脸的事实。

4. 这一步终于是能看到意义的一步了：你把函数名作为宏的第一个参数，然后将函数定义中除函数名以外的部分作为宏的第二个参数。

5. 重复上述步骤，直到你想Mock的虚函数都Mock了。

在完成上述步骤后，你得到的是类似下面的代码：

#include"gmock/gmock.h" // Brings in Google Mock.

classMockTurtle :publicTurtle {

public:

...

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());

};

你不需要再在别的地方去定义这些Mock函数了，MOCK_METHOD*宏会帮你产生这些函数定义。这很简单！一旦掌握了它的诀窍，你可以产生大量的Mock类，可能快到连源代码管理工具都处理不过来。

小提示：如果连定义对你来说工作量都太大，你可以在scripts/generator目录下找到一个gmock_gen.py工具，这个命令行工具需要安装Python 2.4。你将C++文件名和抽象类名作为参数传入这个工具，它会打印Mock类的定义给你。但是因为C++的复杂性，这个脚本还是可能出错，但当它不出错的时候，还是很方便的。更多的细节在用户文档中。

Where to Put It

当你定义一个Mock类，你需要决定把它的定义放到哪。一些人把它放到一个*_test.cc文件中。当这个接口(就叫Foo吧)是由同一个人或是同一团队维护时，这没什么问题。但如果不是，当Foo的维护者修改了它，你的测试就会编译不通过(你总不能指望Foo的维护者去修改每个使用Foo的测试测试吧 )。

所以，经验法则是：如果你需要Mock Foo并且它由别人维护时，在Foo包中定义Mock类(更好的做法是在测试包中定义它，这样可以将测试代码更清晰地独立出来)，把它放到mock_foo.h中。那么每个想使用Mock Foo类的都可以在他们的测试代码中引用它。如果Foo改变了，那么只需要改一份MockFoo的代码，并且只有依赖这个变动函数的测试代码需要做相应的修改。

另一种做法是：你可以在Foo之上引入一个FooAdaptor层，并针对FooAdaptor这个新接口编程。因为你对FooAdaptor有控制权，你可以很容易地将Foo的改变隐藏掉。虽然这意味着在开始有更大的工作量，但认真构造的适配器接口会使你的代码更容易开发，也有更高的可读性，因为你构造的适配器接口FooAdaptor会比Foo更适合于你的特定领域开发。

Using Mocks in Tests

当你完成Mock类的定义之后，使用它是很简单的。典型的流程如下：

1. 引用那些你需要使用的Google Mock有关的命名空间(这样你就不用每次都把命名空间加到前面，请牢记，使用命名空间是一个好主意，并且对你的健康大有裨益)。

2. 创建一些Mock对象。

3. 对它们指定你的期望(一个函数要被调用多少次？用什么参数？它返回什么？等等 )。

4. 用这些Mocks来测试一些代码。你可以选择Google Test Assertions来检查返回。如果一个Mock函数被调用次数多于期望，或是使用了错误的参数，你会马上得到一个错误提示。

5. 当一个Mock对象被析构时，Google Mock会自动检查在它上面的所有的期望是否都已经满足了。

下面是一个例子：

#include"path/to/mock-turtle.h"

#include"gmock/gmock.h"

#include"gtest/gtest.h"

using ::testing::AtLeast; // #1

TEST(PainterTest, CanDrawSomething) {

MockTurtle turtle; // #2

EXPECT_CALL(turtle, PenDown()) // #3

.Times(AtLeast(1));

Painter painter(&turtle); // #4

EXPECT_TRUE(painter.DrawCircle(0, 0, 10));

} // #5

intmain(int argc,char** argv) {

// The following line must be executed to initialize Google Mock

// (and Google Test) before running the tests.

::testing::InitGoogleMock(&argc, argv);

return RUN_ALL_TESTS();

}

正如你所猜测的一样，这个测试是检查PenDown()是否被调用了至少一次。如果Painter对象并没有调用这个函数，你的测试就会失败，提示信息类似如下：

path/to/my_test.cc:119: Failure

Actual function call count doesn't match this expectation:

Actually: never called;

Expected: called at least once.

技巧1：如果你从一个Emacs Buffer运行这个测试程序，你可以在错误信息的行号上敲Enter键，就可以直接跳到期望失败的那一行了。

技巧2：如果你的Mock对象永不释放，最后的检查是不会发生的。所以当你在堆上分配Mock对象时，你用内存泄露工具检查你的测试是一个好主意(译注：推荐valgrind )。

重要提示：Google Mock要求期望在Mock函数被调用之前就设置好，否则行为将是未定义的。特别是你绝不能在Mock函数调用中间插入EXPECT_CALL()。

这意味着EXPECT_CALL()应该被理解为一个调用在未来的期望，而不是已经被调用过函数的期望。为什么Google Mock要以这种方式工作呢？嗯……，在前面指定期望可以让Google Mock在异常发生时马上可以提示，这时候上下文(栈信息，等等 )还是有效的。这样会使调试更容易。

要承认的是，这个测试没有展示出Google Mock有什么强大之处。你完全可以不用Google Mock来得到相同的效果。但是别急，在下面的展示中，我会让你看到Google Mock的强大，它可以让你用Mock做非常多的事。

Using Google Mock with Any Testing Framework

如果你在用别的测试框架而不是Google Test(比如，CppUnit或CxxUnit)，只需要把上节中的main函数改成下面这样：

intmain(int argc,char** argv) {

// The following line causes Google Mock to throw

// an exception on failure, which will be interpreted

// by your testing framework as a test failure.

::testing::GTEST_FLAG(throw_on_failure) = true;

::testing::InitGoogleMock(&argc, argv);

... whatever your testing framework requires ...

}

这种方法中有一个catch：它可以让Google Mock从Mock对象的析构函数中抛出一个异常。但有一些编译器，这会让测试程序崩溃(译注：可以参考Effect C++第三版的Item 8)。虽然你仍然可以注意到注意失败了，但这绝不是一个优雅的失败方式。

一个更好的方法是用Google Test的event listener API来以合理的方式报告一个测试失败给你的测试框架。你需要实现OnTestPartResult()函数这个事件监听接口，但实现它也很简单。

如果上面的方法对你来说工作量太大，我建议你还是用Google Test吧，它与Google Mock可以无缝结合。如果你有什么Google Test满足不了你测试需求的原因，请告诉我们。

Setting Expectations

成功地使用Mock对象的关键是在它上面设置合适的期望。如果你设置的期望太过严格，你的测试可能会因为无关的改变而失败。如果你把期望设置的太过松驰，bugs可能会溜过去。而你需要的是你的测试可以刚好捕获你想要捕获的那一种bug。Google Mock提供了一些方法可以让你的测试尺度刚好( just right )。

General Syntax

在Goolge Mock中，我们用EXPECT_CALL()宏来设置一个Mock函数上的期望。一般语法是：

EXPECT_CALL(mock_object, method(matchers))< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" />

.Times(cardinality)

.WillOnce(action)

.WillRepeatedly(action);

这个宏有两个参数：第一个是Mock对象，第二个参数是函数和它的参数。注意两个参数是用逗号( , )分隔的，而不是句号( . )。

这个宏可以跟一些可选子句，这些子句可以提供关于期望更多的信息。我们将会在下面的小节中介绍每个子句有什么意义。

这些语法设计的一个目的是让它们读起来像是英语。比如你可能会直接猜出下面的代码是有什么含义

using ::testing::Return;...

EXPECT_CALL(turtle, GetX())

.Times(5)

.WillOnce(Return(100))

.WillOnce(Return(150))

.WillRepeatedly(Return(200));

公布答案，turtle对象的GetX()方法会被调用5次，它第一次返回100，第二次返回150，然后每次返回200。许多人喜欢称这种语法方式为特定领域语言( Domain-Specific Language (DSL) )。

注意：为什么我们要用宏来实现呢？有两个原因：第一，它让期望更容易被认出来(无论是grep还是人去阅读 )，第二，它允许Google Mock可以得到失败期望在源文件的位置，从而使Debug更容易。

Matchers: What Arguments Do We Expect?

当一个Mock函数需要带参数时，我们必须指定我们期望的参数的是什么；比如：

// Expects the turtle to move forward by 100 units.

EXPECT_CALL(turtle, Forward(100));

有时你可能不想指定的太精确(还记得前面测试不应太严格吗？指定的太精确会导致测试健壮性不足，并影响测试的本意。所以我们鼓励你只指定那些必须要指定的参数，不要多，也不要少 )。如果你只关心Forward是否会被调用，而不关心它用什么参数，你可以写_作为参数，它的意义是“任意”参数。

using ::testing::_;

...

// Expects the turtle to move forward.

EXPECT_CALL(turtle, Forward(_));

_是我们称为Matchers的一个例子，一个matcher是像一个断言，它可测试一个参数是否是我们期望的。你可用在EXPECT_CALL()中任何写函数参数期望的地方用matcher。

一个内置的matchers可以在CheatSheet中找到，比如，下面是Ge( greater than or equal ) matcher的应用。

using ::testing::Ge;...

EXPECT_CALL(turtle, Forward(Ge(100)));

这个测试是检查turtle是否被告知要至少前进至少100个单位。

Cardinalities: How Many Times Will It Be Called?

在EXPECT_CALL()之后第一个我们可以指定的子句是Times()。我们称Times的参数为cardinality，因为它是指这个函数应该被调用多少次。Times可以让我们指定一个期望多次，而不用去写一次次地写这个期望。更重要的是，cardinality可以是“模糊”的，就像matcher一样。它可以让测试者更准确地表达他测试的目的。

一个有趣的特例是我们指定Times(0)。你也许已经猜到了，它是指函数在指定参数下不应该被调用，如果这个函数被调用了，Google Mock会报告一个Google Test失败。

我们已经见过AtLeast(n)这个模糊cardinalities的例子了。你可以在CheatSheet中找一个内置cardinalities列表。

Times()子句可以省略。如果你省略Times()，Google Mock会推断出cardinality的值是什么。这个规则很容易记：

l 如果在EXPECT_CALL中既没有WillOnce()也没有WillRepeatedly()，那推断出的cardinality就是Times(1)。

l 如果有n个WillOnce()，但没有WillRepeatedl()，其中n >= 1，那么cardinality就是Times(n)。

l 如果有n个WillOnce()，和一个WillRepeatedly()，其中n >= 0，那么cardinality就是Times(AtLeast(n))。

小测试：如果一个函数期望被调用2次，但被调用了4次，你认为会发生什么呢？

Actions: What Should It Do?

请记住一个Mock对象其实是没有实现的。是我们这些用户去告诉它当一个函数被调用时它应该做什么。这在Google Mock中是很简单的。

首先，如果Mock函数的返回类型是一个指针或是内置类型，那这个函数是有默认行为的(一个void函数直接返回，bool函数返回false，其它函数返回0 )。如果你不想改变它，那这种行为就会被应用。

其次，如果一个Mock函数没有默认行为，或默认行为不适合你，你可以用WillOnce来指定每一次的返回值是什么，最后可以选用WillRepeatedly来结束。比如：

using ::testing::Return;...

EXPECT_CALL(turtle, GetX())

.WillOnce(Return(100))

.WillOnce(Return(200))

.WillOnce(Return(300));

上面的意思是turtle.GetX()会被调用恰好3次，并分别返回100，200，300。

using ::testing::Return;...

EXPECT_CALL(turtle, GetY())

.WillOnce(Return(100))

.WillOnce(Return(200))

.WillRepeatedly(Return(300));

上面的意思是指turtle.GetY()将至少被调用2次，第一次返回100，第二次返回200，从第三次以后都返回300。

当然，你如果你明确写上Times()，Google Mock不会去推断cardinality了。如果你指定的cardinality大于WillOnce()子句的个数时会发生什么呢？嗯，当WillOnce()用完了之后，Google Mock会每次对函数采用默认行为。

我们在WillOnce()里除了写Return()我们还能做些什么呢？你可以用ReturnRef( variable )，或是调用一个预先定义好的函数，自己在Others中找吧。

重要提示：EXPECT_CALL()只对行为子句求一次值，尽管这个行为可能出现很多次。所以你必须小心这种副作用。下面的代码的结果可能与你想的不太一样。

int n = 100;

EXPECT_CALL(turtle, GetX())

.Times(4)

.WillRepeatedly(Return(n++));

它并不是依次返回100，101，102...，而是每次都返回100，因为n++只会被求一次值。类似的，Return(new Foo)当EXPECT_CALL()求值时只会创建一个Foo对象，所以它会每次都返回相同的指针。如果你希望每次都看到不同的结果，你需要定义一个自定义行为，我们将在CookBook中指导你。

现在又是一个小测验的时候了！你认为下面的代码是什么意思？

using ::testing::Return;...

EXPECT_CALL(turtle, GetY())

.Times(4)

.WillOnce(Return(100));

显然，turtle.Get()期望被调用4次。但如果你认为它每次都会返回100，那你就要再考虑一下了！记住，每次调用都会消耗一个WillOnce()子句，消耗完之后，就会使用默认行为。所以正确的答案是turtle.GetY()第一次返回100，以后每次都返回0，因为0是默认行为的返回值。

Using Multiple Expectations

至今为止，我们只展示了如何使用单个期望。但是在现实中，你可能想指定来自不同Mock对象的Mock函数上的期望。

默认情况下，当一个Mock函数被调用时，Google Mock会通过定义顺序的逆序去查找期望，当找到一个与参数匹配的有效的期望时就停下来(你可以把这个它想成是“老的规则覆盖新的规则“)。如果匹配的期望不能再接受更多的调用时，你就会收到一个超出上界的失败，下面是一个例子：

using ::testing::_;...

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

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

.Times(2);

如果Forward(10)被连续调用3次，第3次调用它会报出一个错误，因为最后一个匹配期望(#2)已经饱和了。但是如果第3次的Forward(10)替换为Forward(20)，那它就不会报错，因数现在#1将会是匹配的期望了。

边注：为什么Google Mock会以逆序去匹配期望呢？原因是为了可以让用户开始时使用Mock对象的默认行为，或是一些比较松驰的匹配条件，然后写一些更明确的期望。所以，如果你在同一个函数上有两个期望，你当然是想先匹配更明确的期望，然后再匹配其它的，或是可以说明确的规则会隐藏更宽泛的规则。

Ordered vs Unordered Calls

默认情况下，即使是在前一个期望没有被匹配的情况下，一个期望仍然可以被匹配。换句话说，调用的匹配顺序不会按照期望指定的顺序去匹配。

有时，你可能想让所有的期望调用都以一个严格的顺序来匹配，这在Google Mock中是很容易的：

using ::testing::InSequence;...

TEST(FooTest, DrawsLineSegment) {

...

{

InSequence dummy;

EXPECT_CALL(turtle, PenDown());

EXPECT_CALL(turtle, Forward(100));

EXPECT_CALL(turtle, PenUp());

}

Foo();

}

创建InSequence的一个对象后，在这个对象作用域中的期望都会以顺序存放，并要求调用以这个顺序匹配。因为我们只是依赖这个对象的构造函数和析构函数来完成任务，所以对象的名字并不重要。

(如果你只是关心某些调用的相对顺序，而不是所有调用的顺序？可以指定一个任意的相对顺序吗？答案是...可以！如果你比较心急，你可以在CookBook中找到相关的细节。)

All Expectations Are Sticky (Unless Said Otherwise)

现在让我们做一个小测验，看你掌握Mock到什么程度了。你如何测试turtle恰好经过原点两次？

当你想出你的解法之后，看一下我们的答案比较一下(先自己想，别作弊 )。

using ::testing::_;...

EXPECT_CALL(turtle, GoTo(_, _)) // #1

.Times(AnyNumber());

EXPECT_CALL(turtle, GoTo(0, 0)) // #2

.Times(2);

假设turtle.GoTo(0,0)被调用了3次。在第3次，Google Mock会找到参数匹配期望#2。因为我们想要的是恰好经过原点两次，所以Google Mock会立即报告一个错误。上面的内容其实就是我们在“Using Multiple Expectations”中说过的。

上面的例子说明了Google Mock中默认情况下期望是严格的，即是指期望在达到它们指定的调用次数上界后仍然是有效的。这是一个很重要的规则，因为它影响着指定的意义，而且这种规则与许多别的Mock框架中是不一样的(我们为什么会设计的不一样？因为我们认为我们的规则会使一般的用例更容易表达和理解 )。

简单？让我看一下你是不是真懂了：下面的代码是什么意思：

using ::testing::Return;

...

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

EXPECT_CALL(turtle, GetX())

.WillOnce(Return(10*i));

}

如果你认为turtle.GetX()会被调用n次，并依次返回10, 20, 30, ...，唉，你还是再想想吧！问题是，我们都说过了，期望是严格的。所以第2次turtle.GetX()被调用时，最后一个EXPECT_CALL()会被匹配，所以马上会引起“超出上界”的错误。上面的代码其实没什么用途。