Google Test的各种断言整理

[TOC]
本文对Google Test的各种断言整理.

从官网翻译整理.

布尔断言

Fatal	Nonfatal	说明
ASSERT_TRUE(condition)	EXPECT_TRUE(condition)	断言 condition 为 true
ASSERT_FALSE(condition)	EXPECT_FALSE(condition)	断言 condition 为 false

二进制断言

Fatal	Nonfatal	说明
ASSERT_EQ(expected, actual)	EXPECT_EQ(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

说明：

• EQ：EQual
• NE：Not Equal
• LT：Less Than
• LE：Less Equal
• GT：Greater Than
• GE：Greater Equal

比较值都可以是任意编译器能识别的可比较类型,当然包括指针,但是注意空指针比较:使用EXPECT_EQ(ptr, nullptr) 而不是 EXPECT_EQ(ptr, NULL),这个规则对于其他比较类的断言也适用.
适用于字符串 std::string .但不适用于C string,如果传入的值为C string的话只比较内存地址不比较实际值.

字符串断言

Fatal	Nonfatal	说明
ASSERT_STREQ(expected, actual)	EXPECT_STREQ(expected, actual)	两个C string相同
ASSERT_STRNE(str1, str2)	EXPECT_STRNE(str1, str2)	两个C string不相同
ASSERT_STRCASEEQ(exp, act)	EXPECT_STRCASEEQ(exp, act)	忽略大小写，两个C string相同
ASSERT_STRCASENE(str1, str2)	EXPECT_STRCASENE(str1, str2)	忽略大小写，两个C string不相同

不支持std::string,如需要使用.c_str()函数转成C类型的字符串格式.

浮点数断言

包括FLOAT与DOUBLE.
| Fatal | Nonfatal | 说明 |
| — | — | — |
| ASSERT_FLOAT_EQ(exp, act) | EXPECT_FLOAT_EQ(exp, act) | 两个float数值相等 |
| ASSERT_DOUBLE_EQ(exp, act) | EXPECT_DOUBLE_EQ(exp, act) | 两个double数值相等 |
| ASSERT_NEAR(val1, val2, abs_err) | EXPECT_NEAR(val1, val2, abs_err) | val1和val2的差距不超过abs_err |

一般使用NEAR容错率更高.

异常断言

Fatal	Nonfatal	说明
ASSERT_THROW(stmt, exc_type)	EXPECT_THROW(stmt, exc_type)	stmt抛出了exc_type类型的异常
ASSERT_ANY_THROW(stmt)	EXPECT_ANY_THROW(stmt)	stmt抛出了任意类型的异常
ASSERT_NO_THROW(stmt)	EXPECT_NO_THROW(stmt)	stmt没有抛出异常

泛化断言(Generalized Assertion)

Fatal	Nonfatal	说明
EXPECT_THAT(value,matcher)	ASSERT_THAT(value,matcher)	value是否与matcher所规定的规则是否匹配

这个功能借助了built-in matchers 库.

查看既存的Matchers Reference.

自定义规则Writing New Matchers Quickly.

使用案例如下:

#include "gmock/gmock.h"

using ::testing::AllOf;//满足所有规则
using ::testing::Gt;//大于
using ::testing::Lt;//小于
using ::testing::MatchesRegex;//正则匹配
using ::testing::StartsWith;//字符串开头

...
EXPECT_THAT(value1, StartsWith("Hello"));
EXPECT_THAT(value2, MatchesRegex("Line \\d+"));
ASSERT_THAT(value3, AllOf(Gt(5), Lt(10)));

谓词断言(Predicate Assertions)

EXPECT_PRED*

EXPECT_PRED1(pred,val1)
EXPECT_PRED2(pred,val1,val2)
EXPECT_PRED3(pred,val1,val2,val3)
EXPECT_PRED4(pred,val1,val2,val3,val4)
EXPECT_PRED5(pred,val1,val2,val3,val4,val5)

ASSERT_PRED1(pred,val1)
ASSERT_PRED2(pred,val1,val2)
ASSERT_PRED3(pred,val1,val2,val3)
ASSERT_PRED4(pred,val1,val2,val3,val4)
ASSERT_PRED5(pred,val1,val2,val3,val4,val5)

pred为谓词函数,valn为函数的参数,最多支持五个参数.

// 两数是否互为质数
bool MutuallyPrime(int m, int n) { ... }
...
const int a = 3;
const int b = 4;
const int c = 10;
...
EXPECT_PRED2(MutuallyPrime, a, b);  // Succeeds
EXPECT_PRED2(MutuallyPrime, b, c);  // Fails

失败的错误信息如下:

MutuallyPrime(b, c) is false, where
b is 4
c is 10

谓词函数不支持函数推断,因此对于重载函数以及模板函数必须显式指定

//IsPositive有两个重载函数
EXPECT_PRED1(static_cast<bool (*)(int)>(IsPositive), 5);
EXPECT_PRED1(static_cast<bool (*)(double)>(IsPositive), 3.14);

//IsNegative是模板函数
template <typename T>
bool IsNegative(T x) {
  return x < 0;
}
//必须显式指定模板参数类型
EXPECT_PRED1(IsNegative<int>, -5);

EXPECT_PRED_FORMAT*

可以自定义错误信息输出的格式.

EXPECT_PRED_FORMAT1(pred_formatter,val1)
EXPECT_PRED_FORMAT2(pred_formatter,val1,val2)
EXPECT_PRED_FORMAT3(pred_formatter,val1,val2,val3)
EXPECT_PRED_FORMAT4(pred_formatter,val1,val2,val3,val4)
EXPECT_PRED_FORMAT5(pred_formatter,val1,val2,val3,val4,val5)

ASSERT_PRED_FORMAT1(pred_formatter,val1)
ASSERT_PRED_FORMAT2(pred_formatter,val1,val2)
ASSERT_PRED_FORMAT3(pred_formatter,val1,val2,val3)
ASSERT_PRED_FORMAT4(pred_formatter,val1,val2,val3,val4)
ASSERT_PRED_FORMAT5(pred_formatter,val1,val2,val3,val4,val5)

pred_formatter 是一个 predicate-formatter.

例子如下:

// 返回最小公约数
int SmallestPrimeCommonDivisor(int m, int n) { ... }
// 是否互质
bool MutuallyPrime(int m, int n) { ... }
// 如果不互质,求出最小公约数并进行格式化打印.
testing::AssertionResult AssertMutuallyPrime(const char* m_expr,
                                             const char* n_expr,
                                             int m,
                                             int n) {
  if (MutuallyPrime(m, n)) return testing::AssertionSuccess();
  //自定义打印
  return testing::AssertionFailure() << m_expr << " and " << n_expr
      << " (" << m << " and " << n << ") are not mutually prime, "
      << "as they have a common divisor " << SmallestPrimeCommonDivisor(m, n);
}
...
const int a = 3;
const int b = 4;
const int c = 10;
...
EXPECT_PRED_FORMAT2(AssertMutuallyPrime, a, b);  // Succeeds
EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c);  // Fails

失败的case的格式化打印如下:

b and c (4 and 10) are not mutually prime, as they have a common divisor 2

类型断言(Type Assertions)

判断变量类型是否相同,用于类型测试以及类型参数测试.

::testing::StaticAssertTypeEq<T1, T2>();

注意保证模板类的成员函数或者一个模板函数,需要先实例化函数

template <typename T> class Foo {
 public:
  void Bar() { testing::StaticAssertTypeEq<int, T>(); }
};
void Test1() { Foo<bool> foo; } //永远不会执行测试
void Test2() { Foo<bool> foo; foo.Bar(); } //需要实例化

死亡断言(Death Assertions)

Fatal	Nonfatal	说明
EXPECT_DEATH(statement,matcher)	ASSERT_DEATH(statement,matcher)	验证statement因为非0 exit status 而产生的 stderr 是否匹配 matcher .
EXPECT_DEATH_IF_SUPPORTED(statement,matcher)	ASSERT_DEATH_IF_SUPPORTED(statement,matcher)	如果系统支持死亡测试,则等同于EXPECT_DEATH,否则等于空.
EXPECT_EXIT(statement,predicate,matcher)	ASSERT_EXIT(statement,predicate,matcher)	在EXPECT_DEATH基础上加入谓词函数定义statement与matcher的匹配过程.

成败断言

Explicit Success and Failure

Fatal	Nonfatal	说明
SUCCEED()	-	只代表某一处的成败,不像RUN_ALL_TESTS是全局的.暂时无用,不产生任何user-visible output.
FAIL()	ADD_FAILURE()	生成错误
-	ADD_FAILURE_AT(file_path,line_number)	在指定文件的指定位置生成错误

Windows HRESULT Assertions

例子如下:

CComPtr<IShellDispatch2> shell;
ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application"));
CComVariant empty;
ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty));

Fatal	Nonfatal	说明
EXPECT_HRESULT_SUCCEEDED(expression)	ASSERT_HRESULT_SUCCEEDED(expression)	判断是HRESULT
EXPECT_HRESULT_FAILED(expression)	ASSERT_HRESULT_FAILED(expression)	判断不是HRESULT