GoogleTest 使用指南｜断言

原创于 2025-09-04 00:15:00 发布 · 1.2k 阅读

22 ·

CC 4.0 BY-SA版权

文章标签：

#单元测试 #C++ #断言

C++ 专栏收录该内容

28 篇文章

订阅专栏

GoogleTest 使用指南｜断言

ASSERT vs EXPECT

断言的宏可以理解为分为两类，一类是 ASSERT 系列，一类是 EXPECT 系列。

一个直观的解释就是：

ASSERT_* 系列的断言，当检查点失败时，退出当前函数（注意：并非退出当前案例）。
EXPECT_* 系列的断言，当检查点失败时，继续往下执行。

ASSERT_* 示例：

// ASSERT_* - 失败时立即终止当前测试
TEST(AssertTest, StopsOnFailure) {
    ASSERT_EQ(1, 2);  // 失败，下面的代码不会执行
    std::cout << "This won't print" << std::endl;
    ASSERT_EQ(2, 2);  // 不会执行到这里
}

EXPECT_* 示例：

// EXPECT_* - 失败后继续执行，记录所有失败
TEST(ExpectTest, ContinuesOnFailure) {
    EXPECT_EQ(1, 2);  // 失败，但继续执行
    std::cout << "This will print" << std::endl;
    EXPECT_EQ(2, 2);  // 会执行并通过
    EXPECT_EQ(3, 4);  // 会执行并失败
}  // 测试结束时报告2个失败

何时使用 ASSERT 或 EXPECT：

使用 ASSERT 检查前置条件
使用 EXPECT 检查多个独立的条件

示例：

TEST(FileTest, ReadFile) {
    File* file = OpenFile("data.txt");
    
    // 如果文件打开失败，后续测试无意义
    ASSERT_NE(file, nullptr);

    EXPECT_EQ(file->GetSize(), 1024);
    EXPECT_EQ(file->GetType(), FileType::TEXT);
    EXPECT_TRUE(file->IsReadable());
    
    delete file;
}

布尔断言

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_TRUE(condition);	EXPECT_TRUE(condition);	condition is true
ASSERT_FALSE(condition);	EXPECT_FALSE(condition);	condition is false

示例：

TEST(BooleanAssertions, TrueFalse) {
    bool is_valid = true;
    bool is_empty = false;
    
    // 检查 true
    EXPECT_TRUE(is_valid);
    EXPECT_TRUE(10 > 5);
    EXPECT_TRUE(std::string("hello").length() > 0);
    
    // 检查 false
    EXPECT_FALSE(is_empty);
    EXPECT_FALSE(5 > 10);
    EXPECT_FALSE(std::string("").length() > 0);
    
    // 实际应用
    std::vector<int> vec = {1, 2, 3};
    EXPECT_FALSE(vec.empty());
    EXPECT_TRUE(std::find(vec.begin(), vec.end(), 2) != vec.end());
    
    // 条件表达式
    int x = 10;
    EXPECT_TRUE(x > 0 && x < 20);
    EXPECT_FALSE(x < 0 || x > 100);
}

基本值比较断言

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_EQ(expected, actual);	EXPECT_EQ(expected, actual);	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

相等性断言示例：

TEST(BasicAssertions, EqualityComparisons) {
    int a = 5, b = 5, c = 10;
    
    // 相等
    EXPECT_EQ(a, b);  // a == b
    ASSERT_EQ(2 + 2, 4);
    
    // 不相等
    EXPECT_NE(a, c);  // a != c
    ASSERT_NE(10, 20);
    
    // 对于指针比较
    int* p1 = &a;
    int* p2 = &a;
    int* p3 = &b;
    EXPECT_EQ(p1, p2);  // 比较指针值
    EXPECT_NE(p1, p3);
    
    // 对于自定义类型，需要定义 operator==
    class Point {
    public:
        int x, y;
        bool operator==(const Point& other) const {
            return x == other.x && y == other.y;
        }
    };
    
    Point pt1{1, 2}, pt2{1, 2}, pt3{3, 4};
    EXPECT_EQ(pt1, pt2);
    EXPECT_NE(pt1, pt3);
}

大小比较断言示例：

TEST(BasicAssertions, RelationalComparisons) {
    int small = 5, medium = 10, large = 15;
    
    // 小于
    EXPECT_LT(small, medium);   // small < medium
    ASSERT_LT(5, 10);
    
    // 小于等于
    EXPECT_LE(small, medium);   // small <= medium
    EXPECT_LE(10, 10);          // 相等也满足
    
    // 大于
    EXPECT_GT(large, medium);   // large > medium
    ASSERT_GT(100, 50);
    
    // 大于等于
    EXPECT_GE(large, medium);   // large >= medium
    EXPECT_GE(10, 10);          // 相等也满足
    
    // 组合使用验证范围
    int value = 50;
    EXPECT_GE(value, 0);
    EXPECT_LE(value, 100);
    // 或者
    EXPECT_TRUE(value >= 0 && value <= 100);
}

字符串断言

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_STREQ(str1, str2);	EXPECT_STREQ(str1, str2);	the two C strings have the same content
ASSERT_STRNE(str1, str2);	EXPECT_STRNE(str1, str2);	the two C strings have different content
ASSERT_STRCASEEQ(str1, str2);	EXPECT_STRCASEEQ(str1, str2);	the two C strings have the same content, ignoring case
ASSERT_STRCASENE(str1, str2);	EXPECT_STRCASENE(str1, str2);	the two C strings have different content, ignoring case

比较内容，而不是指针。

C 字符串断言示例：

TEST(StringAssertions, CStrings) {
    const char* str1 = "Hello";
    const char* str2 = "Hello";
    const char* str3 = "World";
    const char* str4 = "hello";
    const char* null_str = nullptr;
    
    // C字符串相等（比较内容，不是指针）
    EXPECT_STREQ(str1, str2);  // 内容相同
    EXPECT_STREQ("Test", "Test");
    
    // C字符串不相等
    EXPECT_STRNE(str1, str3);  // 内容不同
    EXPECT_STRNE("Hello", "World");
    
    // 忽略大小写比较
    EXPECT_STRCASEEQ(str1, str4);  // "Hello" == "hello" (忽略大小写)
    EXPECT_STRCASENE("Hello", "World");  // 忽略大小写仍不相等
    
    // 处理 nullptr
    EXPECT_STREQ(null_str, nullptr);  // 两个都是 nullptr
    // EXPECT_STREQ(str1, nullptr);  // 会失败
}

STREQ 和 STRNE 同时支持 char* 和 wchar_t* 类型，STRCASEEQ 和 STRCASENE 只接收 char* 类型。

C++ string 断言示例：

TEST(StringAssertions, CppStrings) {
    std::string str1 = "Hello";
    std::string str2 = "Hello";
    std::string str3 = "World";
    std::string empty = "";
    
    // 使用 EQ/NE 比较 std::string
    EXPECT_EQ(str1, str2);
    EXPECT_NE(str1, str3);
    EXPECT_EQ(empty, "");
    
    // 子字符串检查
    EXPECT_TRUE(str1.find("ell") != std::string::npos);
    EXPECT_TRUE(str1.starts_with("Hel"));  // C++20
    EXPECT_TRUE(str1.ends_with("lo"));     // C++20
    
    // 正则表达式匹配（使用 matcher）
    using ::testing::MatchesRegex;
    EXPECT_THAT(str1, MatchesRegex("H.*o"));
}

当使用 Bazel 和 Abseil 构建时，GoogleTest 使用 RE2 语法。否则，对于 POSIX 系统（Linux、Cygwin、Mac）， GoogleTest 将使用 POSIX 扩展正则表达式语法。

下面是 GoogleTest 支持的正则表达式语法：

Expression	Meaning
c	matches any literal character c
\d	matches any decimal digit
\D	matches any character that’s not a decimal digit
\f	matches \f
\n	matches \n
\r	matches \r
\s	matches any ASCII whitespace, including \n
\S	matches any character that’s not a whitespace
\t	matches \t
\v	matches \v
\w	matches any letter, _, or decimal digit
\W	matches any character that \w doesn’t match
\c	matches any literal character c, which must be a punctuation
.	matches any single character except \n
A?	matches 0 or 1 occurrences of A
A*	matches 0 or many occurrences of A
A+	matches 1 or many occurrences of A
^	matches the beginning of a string (not that of each line)
$	matches the end of a string (not that of each line)
xy	matches x followed by y

浮点数断言

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_FLOAT_EQ(expected, actual);	EXPECT_FLOAT_EQ(expected, actual);	the two float values are almost equal
ASSERT_DOUBLE_EQ(expected, actual);	EXPECT_DOUBLE_EQ(expected, actual);	the two double values are almost equal
ASSERT_NEAR(val1, val2, abs_error);	EXPECT_NEAR(val1, val2, abs_error);	the difference between val1 and val2 doesn’t exceed the given absolute error

基本浮点数比较示例：

TEST(FloatingPointAssertions, BasicComparisons) {
    float f1 = 1.0f / 3.0f;
    float f2 = 0.333333f;
    
    double d1 = 1.0 / 3.0;
    double d2 = 0.333333333333;
    
    // float 比较（使用 ULP - Units in the Last Place）
    EXPECT_FLOAT_EQ(f1, f2);  // 允许小误差
    EXPECT_FLOAT_EQ(1.0f, 1.0f);
    
    // double 比较
    EXPECT_DOUBLE_EQ(d1, d2);  // 允许小误差
    EXPECT_DOUBLE_EQ(1.0, 1.0);
    
    // 指定绝对误差范围
    EXPECT_NEAR(f1, f2, 0.0001);  // |f1 - f2| < 0.0001
    EXPECT_NEAR(d1, d2, 0.000001);
    
    // 实际计算示例
    float result = std::sqrt(2.0f) * std::sqrt(2.0f);
    EXPECT_NEAR(result, 2.0f, 0.00001);  // 不能用 EXPECT_EQ
}

特殊浮点值示例：

TEST(FloatingPointAssertions, SpecialValues) {
    double inf = std::numeric_limits<double>::infinity();
    double nan = std::numeric_limits<double>::quiet_NaN();
    
    // 无穷大
    EXPECT_DOUBLE_EQ(inf, inf);
    EXPECT_TRUE(std::isinf(inf));
    
    // NaN 的特殊处理
    // EXPECT_DOUBLE_EQ(nan, nan);  // 会失败！NaN != NaN
    EXPECT_TRUE(std::isnan(nan));
    
    // 检查是否为有限值
    EXPECT_TRUE(std::isfinite(1.0));
    EXPECT_FALSE(std::isfinite(inf));
    EXPECT_FALSE(std::isfinite(nan));
}

显示返回成功或失败

直接返回成功：SUCCEED();

返回失败：

Fatal assertion	Nonfatal assertion
FAIL();	ADD_FAILURE();

示例：

TEST(ExplicitTest, Demo)
{
	// None Fatal Asserton，继续往下执行
    ADD_FAILURE() << "Sorry";
    // FAIL(); // Fatal Assertion，不往下执行该案例
    SUCCEED();
}

异常断言

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_THROW(statement, exception_type);	EXPECT_THROW(statement, exception_type);	statement throws an exception of the given type
ASSERT_ANY_THROW(statement);	EXPECT_ANY_THROW(statement);	statement throws an exception of any type
ASSERT_NO_THROW(statement);	EXPECT_NO_THROW(statement);	statement doesn’t throw any exception

基本异常断言示例：

class Calculator {
public:
    double divide(double a, double b) {
        if (b == 0) {
            throw std::invalid_argument("Division by zero");
        }
        return a / b;
    }
    
    int factorial(int n) {
        if (n < 0) {
            throw std::domain_error("Negative input");
        }
        if (n > 20) {
            throw std::overflow_error("Input too large");
        }
        // 计算阶乘...
        return 1;  // 简化
    }
};

TEST(ExceptionAssertions, BasicExceptions) {
    Calculator calc;
    
    // 期望抛出特定类型的异常
    EXPECT_THROW(calc.divide(10, 0), std::invalid_argument);
    EXPECT_THROW(calc.factorial(-5), std::domain_error);
    
    // 期望抛出任何异常
    EXPECT_ANY_THROW(calc.divide(10, 0));
    EXPECT_ANY_THROW(calc.factorial(-1));
    
    // 期望不抛出异常
    EXPECT_NO_THROW(calc.divide(10, 2));
    EXPECT_NO_THROW(calc.factorial(5));
}

进阶示例 - 验证异常信息：

TEST(ExceptionAssertions, ExceptionMessage) {
    Calculator calc;
    
    // 使用 try-catch 验证异常消息
    try {
        calc.divide(10, 0);
        FAIL() << "Expected exception was not thrown";
    } catch (const std::invalid_argument& e) {
        EXPECT_STREQ(e.what(), "Division by zero");
    } catch (...) {
        FAIL() << "Wrong exception type";
    }
    
    // 使用 lambda 和断言宏
    auto throw_with_message = []() {
        throw std::runtime_error("Custom error message");
    };
    
    EXPECT_THROW({
        try {
            throw_with_message();
        } catch (const std::runtime_error& e) {
            EXPECT_STREQ(e.what(), "Custom error message");
            throw;  // 重新抛出以满足 EXPECT_THROW
        }
    }, std::runtime_error);
}

谓词断言

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_PRED1(pred1, val1);	EXPECT_PRED1(pred1, val1);	pred1(val1) returns true
ASSERT_PRED2(pred2, val1, val2);	EXPECT_PRED2(pred2, val1, val2);	pred2(val1, val2) returns true
…	…	…

GoogleTest 只提供 <= 5 个参数的谓词断言。

示例：

// 自定义谓词函数
bool IsEven(int n) {
    return n % 2 == 0;
}

bool IsInRange(int value, int min, int max) {
    return value >= min && value <= max;
}

TEST(PredicateAssertions, UnaryPredicates) {
    // 一元谓词
    EXPECT_PRED1(IsEven, 4);
    EXPECT_FALSE(IsEven(3));
    
    // 使用 lambda
    auto is_positive = [](int x) { return x > 0; };
    EXPECT_PRED1(is_positive, 10);
}

TEST(PredicateAssertions, BinaryPredicates) {
    // 二元谓词
    auto greater_than = [](int a, int b) { return a > b; };
    EXPECT_PRED2(greater_than, 10, 5);
    
    // 三元谓词
    EXPECT_PRED3(IsInRange, 200, 0, 100);
}

当失败时，返回错误信息：

error: IsInRange(value, min, max) evaluates to false, where
value evaluates to 200
min evaluates to 0
max evaluates to 100

如果对这样的输出不满意的话，还可以自定义输出格式，通过如下断言：

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_PRED_FORMAT1(pred_format1, val1);	EXPECT_PRED_FORMAT1(pred_format1, val1);	pred_format1(val1) is successful
ASSERT_PRED_FORMAT2(pred_format2, val1, val2);	EXPECT_PRED_FORMAT2(pred_format2, val1, val2);	pred_format2(val1, val2) is successful
…	…	…

示例：

// 自定义格式化函数
testing::AssertionResult AssertSumEquals(
    const char* a_expr,
    const char* b_expr,
    const char* sum_expr,
    int a,
    int b,
    int sum) {
    if (a + b == sum) {
        return testing::AssertionSuccess();
    }
    
    return testing::AssertionFailure()
        << a_expr << " + " << b_expr << " (" << a << " + " << b
        << ") does not equal " << sum_expr << " (" << sum << ")";
}

TEST(FormattedPredicates, CustomFormat) {
    EXPECT_PRED_FORMAT3(AssertSumEquals, 2, 3, 5);
    // EXPECT_PRED_FORMAT3(AssertSumEquals, 2, 3, 6);  
    // 失败消息: "2 + 3 (2 + 3) does not equal 6 (6)"
}

死亡断言

DEATH

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_DEATH(statement, regex);	EXPECT_DEATH(statement, regex);	断言给定的语句会以某种原因导致进程终止，并且终止时输出的错误信息（通常是 stderr）匹配给定的正则表达式

工作原理：

GoogleTest 会 fork 出一个子进程。
在该子进程中执行 statement。
如果子进程如预期般终止（例如，由于信号或 _exit），并且其 stderr 输出匹配 regex，则断言成功。
如果子进程正常执行完毕没有终止，或者终止信息不匹配 regex，则断言失败。

示例：

void FunctionThatAborts(int x) {
  if (x < 0) {
    abort(); // 终止进程，通常会产生 "Aborted" 之类的输出
  }
}

void FunctionWithAssert(int x) {
  assert(x >= 0); // 如果 NDEBUG 未定义，assert 失败会终止程序
}

TEST(DeathTest, ExpectDeathExample) {
  // 测试 abort()
  EXPECT_DEATH(FunctionThatAborts(-1), "Aborted|abort|Assertion");

  // 测试 assert() 失败 (需确保在 Debug 模式下编译，未定义 NDEBUG)
#ifndef NDEBUG
  EXPECT_DEATH(FunctionWithAssert(-1), "assertion.*failed");
#endif

  // 测试一个会导致除零错误的语句
  EXPECT_DEATH({
      int a = 1 / 0; // 通常会产生 "Floating point exception" 或类似信息
  }, "Floating|division|exception");
}

DEBUG_DEATH

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_DEBUG_DEATH(statement, regex);	EXPECT_DEBUG_DEATH(statement, regex);	条件性的死亡测试宏

EXPECT_DEBUG_DEATH 的行为会根据编译模式（Debug 或 Release）而改变：

在 Debug 模式（未定义 NDEBUG）下：行为与 EXPECT_DEATH 完全一样，会执行死亡测试。
在 Release 模式（定义了 NDEBUG）下：不会执行死亡测试，而是直接跳过。语句根本不会运行。

这主要为了解决一个常见问题：assert() 宏在 Release 模式下的行为。

我们知道：

在 Debug 模式：assert(condition) 会在条件为假时终止程序。
在 Release 模式（定义了 NDEBUG）：assert() 宏会被预处理器完全移除，代码根本不会执行。

示例：

// 一个使用 assert 进行参数检查的函数
void ProcessValue(int* ptr, int value) {
  assert(ptr != nullptr);    // Debug 模式检查，Release 模式无此检查
  assert(value >= 0 && value <= 100); // 值域检查
  
  *ptr = value * 2;
}

TEST(DebugDeathTest, TestAssertBehavior) {
  int result;
  
  // 测试空指针断言 - 只在 Debug 模式下进行
  EXPECT_DEBUG_DEATH(ProcessValue(nullptr, 42), "assertion.*failed");
  
  // 测试越界值断言 - 只在 Debug 模式下进行  
  EXPECT_DEBUG_DEATH(ProcessValue(&result, -1), "assertion.*failed");
  EXPECT_DEBUG_DEATH(ProcessValue(&result, 101), "assertion.*failed");
  
  // 正常的测试用例 - 在所有模式下都运行
  ProcessValue(&result, 50);
  EXPECT_EQ(result, 100);
}

// 测试 abort() - 这个在任何模式下都会终止，所以用 EXPECT_DEATH
void FunctionThatAborts() {
  abort();
}

TEST(DebugDeathTest, TestAbort) {
  // abort() 在任何模式下都有效，所以用普通的 EXPECT_DEATH
  EXPECT_DEATH(FunctionThatAborts(), "Aborted|abort");
}

EXIT

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_EXIT(statement, predicate, regex);	EXPECT_EXIT(statement, predicate, regex);	断言给定的语句会以某种原因导致进程终止，并且终止时退出状态码匹配 predicate，输出的错误信息（通常是 stderr）匹配 regex

参数解释：

statement：要测试的语句。
predicate：一个函数或可调用对象，用于检查进程的退出状态。它接受一个 int 参数（退出状态码），并返回 bool（true 表示匹配期望）。
regex：与 EXPECT_DEATH 一样，用于匹配 stderr 输出的正则表达式。

GoogleTest 提供了一些方便的包装函数作为 predicate：

::testing::ExitedWithCode(exit_code)：进程正常退出，并且退出码等于 exit_code。
例如： exit(3) 会被 ExitedWithCode(3) 匹配。
::testing::KilledBySignal(signal_number)：进程被指定的信号杀死。
例如： abort() 通常会发送 SIGABRT 信号，可被 KilledBySignal(SIGABRT) 匹配。

示例：

void ExitWithFailure() {
  std::cerr << "Critical error occurred!" << std::endl;
  exit(EXIT_FAILURE); // 通常 EXIT_FAILURE 是 1
}

void AbortProgram() {
  abort(); // 发送 SIGABRT 信号终止自己
}

TEST(DeathTest, ExpectExitExample) {
  // 测试程序是否以 EXIT_FAILURE (通常是1) 退出，并且输出特定信息
  EXPECT_EXIT(ExitWithFailure(),
              ::testing::ExitedWithCode(EXIT_FAILURE),
              "Critical error");

  // 测试程序是否因为 SIGABRT 信号而终止
  // abort() 不会产生退出码，而是被信号杀死，所以要用 KilledBySignal
  EXPECT_EXIT(AbortProgram(),
              ::testing::KilledBySignal(SIGABRT),
              ""); // 这里不关心输出，所以用空字符串匹配

  // 你也可以使用自定义的谓词函数
  EXPECT_EXIT(exit(42),
              [](int exit_status) { return exit_status == 42; },
              "");
}

Windows HRESULT 断言

GoogleTest 专门为 Windows COM 编程设计的自定义断言宏。

这个宏用于验证 HRESULT 类型的值是否表示成功。在 COM 编程中，HRESULT 是一个 32 位的值，用于表示操作的成功或失败状态。

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_HRESULT_SUCCEEDED(expression);	EXPECT_HRESULT_SUCCEEDED(expression);	expression is a success HRESULT
ASSERT_HRESULT_FAILED(expression);	EXPECT_HRESULT_FAILED(expression);	expression is a failure HRESULT

示例：

#include <gtest/gtest.h>
#include <windows.h>
#include <comdef.h> // 用于 _com_error

class COMTest : public ::testing::Test {
protected:
    void SetUp() override {
        // 初始化 COM（如果需要）
        CoInitialize(nullptr);
    }
    
    void TearDown() override {
        CoUninitialize();
    }
};

TEST_F(COMTest, TestCOMCreation) {
    IUnknown* pUnknown = nullptr;
    
    // 测试成功的 COM 调用
    HRESULT hr = CoCreateInstance(CLSID_StdComponentCategoriesMgr, 
                                 nullptr, 
                                 CLSCTX_INPROC_SERVER, 
                                 IID_PPV_ARGS(&pUnknown));
    
    ASSERT_HRESULT_SUCCEEDED(hr);
    ASSERT_NE(pUnknown, nullptr);
    
    pUnknown->Release();
}

TEST_F(COMTest, TestCOMFailure) {
    IUnknown* pUnknown = nullptr;
    
    // 测试一个应该失败的 COM 调用（使用无效的 CLSID）
    HRESULT hr = CoCreateInstance(CLSID_NULL, // 无效的 CLSID
                                 nullptr, 
                                 CLSCTX_INPROC_SERVER, 
                                 IID_PPV_ARGS(&pUnknown));
    
    // 这个断言应该会失败，并提供详细的错误信息
    ASSERT_HRESULT_SUCCEEDED(hr); // 这会显示具体的 HRESULT 错误值
}

这个宏是 Windows 平台特有的，需要包含 Windows 头文件和链接相应的库。

Matcher 断言（高级）

GoogleTest 中最强大、最灵活的断言机制。EXPECT_THAT 配合 Matcher 是 GoogleTest 的"瑞士军刀"。

Matcher 是一个描述期望值的谓词对象，它知道如何检查一个值是否满足特定条件，并能生成友好的错误消息。

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_THAT(actual_value, matcher);	EXPECT_THAT(actual_value, matcher);	断言 actual_value 满足 matcher 所描述的条件

与传统断言相比，Matcher 断言提供了：

更丰富的比较能力
更清晰的错误消息
可组合的复杂条件
更好的可读性

通用比较 Matcher

EXPECT_THAT(value, Eq(42));      // 等于 ==
EXPECT_THAT(value, Ne(0));       // 不等于 !=  
EXPECT_THAT(value, Gt(40));      // 大于 >
EXPECT_THAT(value, Ge(42));      // 大于等于 >=
EXPECT_THAT(value, Lt(50));      // 小于 <
EXPECT_THAT(value, Le(42));      // 小于等于 <=

浮点数比较 Matcher

double result = CalculateSomething();
EXPECT_THAT(result, DoubleEq(3.14));     // 精确相等
EXPECT_THAT(result, NanSensitiveDoubleEq(3.14)); // 处理NaN
EXPECT_THAT(result, DoubleNear(3.14, 0.01)); // 近似相等，误差0.01

字符串 Matcher

std::string str = "Hello GoogleTest";
EXPECT_THAT(str, StartsWith("Hello"));
EXPECT_THAT(str, EndsWith("GoogleTest"));
EXPECT_THAT(str, Contains("Google"));
EXPECT_THAT(str, HasSubstr("Test"));
EXPECT_THAT(str, MatchesRegex("Hello.*Test")); // 正则匹配

容器 Matcher

std::vector<int> vec = {1, 2, 3, 4, 5};
std::map<std::string, int> map = {{"a", 1}, {"b", 2}};

EXPECT_THAT(vec, Contains(3));                   // 包含元素
EXPECT_THAT(vec, ElementsAre(1, 2, 3, 4, 5));   // 精确序列匹配
EXPECT_THAT(vec, UnorderedElementsAre(5, 4, 3, 2, 1)); // 无序包含
EXPECT_THAT(vec, SizeIs(5));                     // 大小检查

EXPECT_THAT(map, Contains(Key("a")));            // 包含键
EXPECT_THAT(map, Contains(Pair("b", 2)));        // 包含键值对

指针和引用 Matcher

int x = 42;
int* ptr = &x;
EXPECT_THAT(ptr, NotNull());                    // 非空指针
EXPECT_THAT(ptr, Pointee(Eq(42)));              // 指针指向的值
EXPECT_THAT(x, Ref(x));                         // 是同一对象的引用

组合 Matcher

using ::testing::AllOf;  // 所有条件都满足（AND）
using ::testing::AnyOf;  // 任一条件满足（OR）
using ::testing::Not;    // 条件不满足（NOT）

int value = 42;
EXPECT_THAT(value, AllOf(Gt(40), Lt(50)));        // 40 < value < 50
EXPECT_THAT(value, AnyOf(Eq(40), Eq(42), Eq(44))); // value是40,42或44
EXPECT_THAT(value, Not(Lt(40)));                  // value不小于40