组合匹配

组合某些匹配某些值，可以使用以下：

Matcher	使用描述
AllOf(m1, m2, …, mn)	参数必须匹配m1, … mn
AllOfArray({m0, m1, …, mn}) / AllOfArray(a_container) / AllOfArray(begin, end) / AllOfArray(array) / AllOfArray(array, count)	必须要和从初始化列表/STL容器/迭代器/可迭代的数组/C风格数组给定的参数匹配
AnyOf(m1, m2, …, mn)	匹配m1到mn中任意的，至少一个
AnyOfArray({m0, m1, …, mn}) / AnyOfArray(a_container) / AnyOfArray(begin, end) / AnyOfArray(array) / AnyOfArray(array, count)	用法同上，匹配任意一个就可以
Not(m)	不匹配m就可以
Conditional(cond, m1, m2)	如果cond为true则匹配m1，否则匹配m2

示例：

using ::testing::AllOf;
using ::testing::Gt;
using ::testing::HasSubstr;
using ::testing::Ne;
using ::testing::Not;
...
  // The argument must be > 5 and != 10.
  EXPECT_CALL(foo, DoThis(AllOf(Gt(5),Ne(10))));

  // The first argument must not contain sub-string "blah".
  EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")),NULL));

Matcher的类型转换

• TODO gMock提供函数 SafeMatcherCast<T>(m) 能够将m转换为Matcher<T>

重载函数的匹配

1. 通过Const()区分重载的const和非const函数

using ::testing::ReturnRef;

class MockFoo : public Foo {
  ...
  MOCK_METHOD(Bar&, GetBar, (), (override));
  MOCK_METHOD(const Bar&, GetBar, (), (const, override));
};
...
  MockFoo foo;
  Bar bar1, bar2;
  EXPECT_CALL(foo, GetBar()).WillOnce(ReturnRef(bar1));        // The non-const GetBar().
      
  EXPECT_CALL(Const(foo), GetBar()).WillOnce(ReturnRef(bar2));  // The const GetBar().
  // 对foo的调用都使用：Const(foo), 如：
  EXPECT_EQ(Const(foo).GetBar(), bar2);

2. 区分相同参数个数但不同参数类型，需要指定准确类型。
   第一种方式是使用Matcher<type>() TODO　
   第二种方法：使用TypedEq<type>, An<type>()等

using ::testing::An;
using ::testing::Matcher;
using ::testing::TypedEq;

class MockPrinter : public Printer {
 public:
  MOCK_METHOD(void, Print, (int n), (override));
  MOCK_METHOD(void, Print, (char c), (override));
};

TEST(PrinterTest, Print) {
  MockPrinter printer;

  EXPECT_CALL(printer, Print(An<int>()));            // void Print(int);
  EXPECT_CALL(printer, Print(Matcher<int>(Lt(5))));  // void Print(int);
  EXPECT_CALL(printer, Print(TypedEq<char>('a')));   // void Print(char);

  printer.Print(3);
  printer.Print(6);
  printer.Print('a');
}

基于参数执行不同的Actions

可以通过不同期望指定不同参数的Actions
示例代码：

TEST(test_matcher, mock_matcher01) {
  MockMatchFoo foo;
  EXPECT_CALL(foo, DoThis(_)).WillRepeatedly(Return(10));
  EXPECT_CALL(foo, DoThis(Lt(5))).WillRepeatedly(Return(20));

  EXPECT_EQ(foo.DoThis(2), 21);  // 参数值<5,会执行返回20的Action
  EXPECT_EQ(foo.DoThis(6), 12);  // 参数值>5，会调用参数为"_"的Acton
}

输出：

多个参数作为一个整体匹配

EXPECT_CALL的With方法可以让我们将所有参数作为一个整体来匹配。With的参数必须是Matcher<std::tuple<A1, ..., An>>（A1, … An是函数参数）

EXPECT_CALL(foo, InRange(Ne(0), _)).With(Lt());  // 第一个参数必须小于第二个参数，等价于：
EXPECT_CALL(foo, InRange(Ne(0), _)).With(AllArgs(Lt()));  // 但是这样更具有可读性

可以使用 Args<k1, …, kn>(m) 匹配n个参数

EXPECT_CALL(foo, Blah).With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt()))); // 第0个小于第1个，第1个小于第2个

gMock将n个参数作为一个std::tuple类型，所以如果是谓词的话需要声明成std::tuple类型。

将Matchers作为谓词使用

Matcher	Description
Matches(m)(value)
ExplainMatchResult(m, value, result_listener)
Value(value, m)	如果value和m匹配则为true

Matcher汇总

Matcher	Description
＿	可以是正确类型的任意值
A<type>()／An<type>()	类型type的任意值