如何让Google Test监测程序终止以标记测试失败？

当std::thread未执行join或detach就被销毁时，会触发std::terminate终止程序，但Google Test默认不会捕获该事件，导致测试直接退出且未标记失败。以下是两种可行的解决思路：

方案一：自定义std::terminate处理函数，让GTest捕获终止事件 #

通过替换默认的终止处理函数，在程序触发std::terminate时主动标记测试失败，而非直接崩溃退出。

1. 定义自定义终止处理函数

#include <stdexcept>
#include <gtest/gtest.h>

void custom_terminate_handler() {
    // 向GTest报告失败
    ADD_FAILURE() << "程序因未正确join线程触发std::terminate";
    // 恢复默认终止处理函数（可选，根据需求调整）
    std::set_terminate(std::get_terminate());
    // 抛出异常，让GTest框架捕获并处理
    throw std::runtime_error("std::terminate triggered");
}

2. 全局注册终止处理函数
   通过GTest的全局测试环境统一设置，避免每个测试用例重复配置：

class TerminateMonitoringEnv : public testing::Environment {
public:
    void SetUp() override {
        default_handler_ = std::get_terminate();
        std::set_terminate(custom_terminate_handler);
    }

    void TearDown() override {
        std::set_terminate(default_handler_);
    }

private:
    std::terminate_handler default_handler_;
};

// 注册全局环境
testing::Environment* const terminate_env =
    testing::AddGlobalTestEnvironment(new TerminateMonitoringEnv);

3. 测试效果
   修改后的测试用例无需额外改动，执行时会捕获终止事件并标记为失败：

#include <thread>
using namespace std::literals::chrono_literals;

TEST(ThreadDeathTest, death) {
    std::thread t([] {
        std::this_thread::sleep_for(2s);
    });
    // 退出作用域销毁线程，触发terminate
}

执行输出示例：

$ ctmltest --gtest_filter=ThreadDeathTest.death
Note: Google Test filter = ThreadDeathTest.death
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from ThreadDeathTest
[ RUN      ] ThreadDeathTest.death
unknown file: Failure
C++ exception with description "std::terminate triggered" thrown in the test body.
[  FAILED  ] ThreadDeathTest.death (0 ms)
[----------] 1 test from ThreadDeathTest (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test run.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] ThreadDeathTest.death

 1 FAILED TEST

方案二：封装RAII风格线程类，从根源避免问题 #

实现一个自动管理线程生命周期的类，在析构时强制检查并处理未join的线程，彻底避免触发std::terminate：

class SafeThread {
public:
    template<typename Callable, typename... Args>
    explicit SafeThread(Callable&& func, Args&&... args)
        : thread_(std::forward<Callable>(func), std::forward<Args>(args)) {}

    ~SafeThread() {
        if (thread_.joinable()) {
            // 析构时自动join，也可根据需求改为detach
            thread_.join();
        }
    }

    // 保留std::thread的核心接口
    void join() { thread_.join(); }
    void detach() { thread_.detach(); }
    bool joinable() const { return thread_.joinable(); }

    // 禁用拷贝，允许移动
    SafeThread(const SafeThread&) = delete;
    SafeThread& operator=(const SafeThread&) = delete;
    SafeThread(SafeThread&&) noexcept = default;
    SafeThread& operator=(SafeThread&&) noexcept = default;

private:
    std::thread thread_;
};

测试中使用SafeThread替代std::thread，即使忘记手动join，析构时也会自动处理：

TEST(ThreadTest, safe) {
    SafeThread t([] {
        std::this_thread::sleep_for(2s);
    });
    // 析构时自动join，无terminate风险
}

注意事项 #

• 自定义终止处理函数需考虑线程安全，因为std::terminate可能在多线程场景下被调用。
• 方案一适合检测现有代码中的问题，方案二更适合在开发阶段预防问题。

内容的提问来源于stack exchange，提问作者Hendrik