gMock Cheat Sheet 官方文档机翻

最新推荐文章于 2023-05-14 23:20:37 发布

蜗牛抱抱

最新推荐文章于 2023-05-14 23:20:37 发布

阅读量496

点赞数

分类专栏： C++ 文章标签： googletest

本文链接：https://blog.youkuaiyun.com/viphl/article/details/129837743

版权

C++ 专栏收录该内容

5 篇文章

订阅专栏

gMock Cheat Sheet 官方文档机翻

Defining a Mock Class

Mocking a Normal Class {#MockClass}

Given

class Foo {
 public:
  virtual ~Foo();
  virtual int GetSize() const = 0;
  virtual string Describe(const char* name) = 0;
  virtual string Describe(int type) = 0;
  virtual bool Process(Bar elem, int count) = 0;
};

(note that ~Foo() must be virtual) we can define its mock as

(注意~Foo() 必须为虚函数)我们可以将其mock定义为

#include "gmock/gmock.h"

class MockFoo : public Foo {
 public:
  MOCK_METHOD(int, GetSize, (), (const, override));
  MOCK_METHOD(string, Describe, (const char* name), (override));
  MOCK_METHOD(string, Describe, (int type), (override));
  MOCK_METHOD(bool, Process, (Bar elem, int count), (override));
};

To create a “nice” mock, which ignores all uninteresting calls, a “naggy” mock, which warns on all uninteresting calls, or a “strict” mock, which treats them as failures:

要创建一个“好的”mock，它会忽略所有无趣的调用;要创建一个“唠叨的”mock，它会对所有无趣的调用发出警告;要创建一个“严格的”mock，它会把失败当成失败:

using ::testing::NiceMock;
using ::testing::NaggyMock;
using ::testing::StrictMock;

NiceMock<MockFoo> nice_foo;      // The type is a subclass of MockFoo.
NaggyMock<MockFoo> naggy_foo;    // The type is a subclass of MockFoo.
StrictMock<MockFoo> strict_foo;  // The type is a subclass of MockFoo.

{: .callout .note}
Note: A mock object is currently naggy by default. We may make it nice by default in the future.

注意: 模拟对象当前默认是 naggy。将来我们可能会把它设置为默认值。

Mocking a Class Template {#MockTemplate}

Class templates can be mocked just like any class.

类模板可以像任何类一样被模拟。

To mock

template <typename Elem>
class StackInterface {
 public:
  virtual ~StackInterface();
  virtual int GetSize() const = 0;
  virtual void Push(const Elem& x) = 0;
};

(note that all member functions that are mocked, including ~StackInterface() must be virtual).

(注意，所有被模拟的成员函数，包括~StackInterface()，必须是虚函数)。

template <typename Elem>
class MockStack : public StackInterface<Elem> {
 public:
  MOCK_METHOD(int, GetSize, (), (const, override));
  MOCK_METHOD(void, Push, (const Elem& x), (override));
};

Specifying Calling Conventions for Mock Functions / 指定模拟函数的调用约定

If your mock function doesn’t use the default calling convention, you can specify it by adding Calltype(convention) to MOCK_METHOD’s 4th parameter.

如果你的mock函数没有使用默认的调用约定，你可以通过在 MOCK_METHOD 的第四个参数中添加 Calltype(convention) 来指定它。

For example,

  MOCK_METHOD(bool, Foo, (int n), (Calltype(STDMETHODCALLTYPE)));
  MOCK_METHOD(int, Bar, (double x, double y),
              (const, Calltype(STDMETHODCALLTYPE)));

where STDMETHODCALLTYPE is defined by <objbase.h> on Windows.

其中STDMETHODCALLTYPE在Windows上由<objbase.h>定义。

Using Mocks in Tests {#UsingMocks} / 在测试中使用 MOCK

The typical work flow is:

典型的工作流程如下：

Import the gMock names you need to use. All gMock symbols are in the
testing namespace unless they are macros or otherwise noted.

导入需要使用的gMock名称。所有gMock符号都在testing命名空间中，除非它们是宏或其他说明。
Create the mock objects.

创建 mock 对象。
Optionally, set the default actions of the mock objects.

可选地，设置模拟对象的默认操作。
Set your expectations on the mock objects (How will they be called? What
will they do?).

在模拟对象上设置你的期望(它们将如何被调用?他们会做什么?)
Exercise code that uses the mock objects; if necessary, check the result
using googletest assertions.

练习使用模拟对象的代码;如有必要，使用googletest断言检查结果。
When a mock object is destructed, gMock automatically verifies that all
expectations on it have been satisfied.

当mock对象被析构时，gMock会自动验证它是否满足预期。

Here’s an example:

using ::testing::Return;                          // #1

TEST(BarTest, DoesThis) {
  MockFoo foo;                                    // #2

  ON_CALL(foo, GetSize())                         // #3
      .WillByDefault(Return(1));
  // ... other default actions ...

  EXPECT_CALL(foo, Describe(5))                   // #4
      .Times(3)
      .WillRepeatedly(Return("Category 5"));
  // ... other expectations ...

  EXPECT_EQ(MyProductionFunction(&foo), "good");  // #5
}                                                 // #6

Setting Default Actions {#OnCall}

gMock has a built-in default action for any function that returns void,
bool, a numeric value, or a pointer. In C++11, it will additionally returns
the default-constructed value, if one exists for the given type.

对于任何返回void、bool、数值或指针的函数，gMock都有一个内置的默认操作。在c++ 11中，如果给定类型存在默认构造的值，它还会返回默认构造的值。

To customize the default action for functions with return type T, use
DefaultValue<T>. For example:

要为返回类型为’T’的函数定制默认操作，请使用’DefaultValue<T>'。例如:

  // Sets the default action for return type std::unique_ptr<Buzz> to
  // creating a new Buzz every time.
  //将返回类型std::unique_ptr<Buzz>的默认操作设置为每次创建一个新的嗡嗡声。  
  DefaultValue<std::unique_ptr<Buzz>>::SetFactory(
      [] { return std::make_unique<Buzz>(AccessLevel::kInternal); });

  // When this fires, the default action of MakeBuzz() will run, which
  // will return a new Buzz object.
  // 触发这个事件时，MakeBuzz()的默认操作将运行，返回一个新的Buzz对象。
  EXPECT_CALL(mock_buzzer_, MakeBuzz("hello")).Times(AnyNumber());

  auto buzz1 = mock_buzzer_.MakeBuzz("hello");
  auto buzz2 = mock_buzzer_.MakeBuzz("hello");
  EXPECT_NE(buzz1, nullptr);
  EXPECT_NE(buzz2, nullptr);
  EXPECT_NE(buzz1, buzz2);

  // Resets the default action for return type std::unique_ptr<Buzz>,
  // to avoid interfere with other tests.
  // 重置返回类型std::unique_ptr<Buzz>的默认操作，以避免干扰其他测试。
  DefaultValue<std::unique_ptr<Buzz>>::Clear();

To customize the default action for a particular method of a specific mock object, use ON_CALL. ON_CALL has a similar syntax to EXPECT_CALL, but it is used for setting default behaviors when you
do not require that the mock method is called. See Knowing When to Expect for a more detailed discussion.

要为特定模拟对象的特定方法定制默认操作，请使用’ ON_CALL’。ON_CALL的语法与EXPECT_CALL类似，但它用于设置默认行为不要求调用mock方法。更详细的讨论请参阅Knowing When to Expect。

Setting Expectations {#ExpectCall}

See EXPECT_CALL in the Mocking Reference.

Matchers {#MatcherList}

See the Matchers Reference.

Actions {#ActionList}

See the Actions Reference.

Cardinalities {#CardinalityList}

See the Times clause of
EXPECT_CALL in the Mocking Reference.

Expectation Order

By default, expectations can be matched in any order. If some or all expectations must be matched in a given order, you can use the

默认情况下，期望可以按任何顺序匹配。如果部分或全部期望必须按照给定的顺序匹配，则可以使用

After clause or
InSequence clause of
EXPECT_CALL, or use an InSequence object.

Verifying and Resetting a Mock / 验证和重置 Mock

gMock will verify the expectations on a mock object when it is destructed, or you can do it earlier:

当 mock 对象被析构时，gMock会验证 mock 对象的 expectations(期望)，或者你也可以更早地这样做:

using ::testing::Mock;
...
// Verifies and removes the expectations on mock_obj;
// returns true if and only if successful.
// 验证并移除对mock_obj的期望;当且仅当成功时返回true。
Mock::VerifyAndClearExpectations(&mock_obj);
...
// Verifies and removes the expectations on mock_obj;
// also removes the default actions set by ON_CALL();
// returns true if and only if successful.
// 验证并移除mock_obj的期望;也会移除ON_CALL()设置的默认操作;当且仅当成功时返回true。
Mock::VerifyAndClear(&mock_obj);

Do not set new expectations after verifying and clearing a mock after its use.Setting expectations after code that exercises the mock has undefined behavior.See Using Mocks in Tests for more information.

不要在验证和清除mock之后设置新的期望。在执行mock的代码之后设置期望具有未定义的行为。有关更多信息，请参阅 Using Mocks in Tests 。

You can also tell gMock that a mock object can be leaked and doesn’t need to be verified:

你还可以告诉gMock一个mock对象可能会被泄漏，并且不需要验证:

Mock::AllowLeak(&mock_obj);

Mock Classes

gMock defines a convenient mock class template

gMock定义了一个方便的模拟类模板

class MockFunction<R(A1, ..., An)> {
 public:
  MOCK_METHOD(R, Call, (A1, ..., An));
};

See this recipe for one application of
it.

Flags

Flag	Description
`--gmock_catch_leaked_mocks=0`	Don’t report leaked mock objects as failures./不要将泄漏的模拟对象报告为失败。
`--gmock_verbose=LEVEL`	Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages./ 设置谷歌模拟消息的默认详细级别(’ info ‘、’ warning ‘或’ error ')。