话题 - Gtest用例失败后自动重跑失败用例

Gtest用例失败后自动重跑失败用例
```cpp
#include "gtest/gtest.h"
#include "iostream"
#include "vector"
#include "string"
#include "unordered_set"

// 存储失败的测试用例信息
struct FailedTest {
    std::string test_case;
    std::string test_name;

// 用于哈希集合
    bool operator==(const FailedTest& other) const {
        return test_case == other.test_case && test_name == other.test_name;
    }
};

// 为FailedTest实现哈希函数，用于unordered_set
namespace std {
    template<> struct hash<FailedTest> {
        size_t operator()(const FailedTest& ft) const {
            return hash<string>()(ft.test_case) ^ (hash<string>()(ft.test_name) << 1);
        }
    };
}

// 自定义监听器：收集失败用例并输出详细信息
class RetryListener : public testing::EmptyTestEventListener {
private:
    std::unordered_set<FailedTest> failed_tests_;
    const testing::TestInfo* current_test_info_;

public:
    RetryListener() : current_test_info_(nullptr) {}

// 测试开始时记录当前测试信息
    void OnTestStart(const testing::TestInfo& test_info) override {
        current_test_info_ = &test_info;
    }

// 捕获测试失败
    void OnTestPartResult(const testing::TestPartResult& result) override {
        if (!result.passed() && current_test_info_ != nullptr) {
            std::cerr << "\n===== 测试失败详情 =====" << std::endl;
            std::cerr << "测试用例: " << current_test_info_->test_case_name() << std::endl;
            std::cerr << "测试名称: " << current_test_info_->name() << std::endl;
            std::cerr << "文件位置: " << result.file_name() << ":" << result.line_number() << std::endl;
            std::cerr << "错误信息: " << result.message() << std::endl;
            std::cerr << "=========================\n" << std::endl;

// 记录失败的测试用例
            failed_tests_.insert({
                current_test_info_->test_case_name(), 
                current_test_info_->name()
            });
        }
    }

// 提供获取失败用例列表的接口
    std::vector<FailedTest> GetFailedTests() const {
        return std::vector<FailedTest>(failed_tests_.begin(), failed_tests_.end());
    }

// 清空失败用例列表
    void ClearFailedTests() {
        failed_tests_.clear();
    }

// 获取失败用例数量
    size_t GetFailedCount() const {
        return failed_tests_.size();
    }
};

// 运行指定的测试用例
std::unordered_set<FailedTest> RunSpecificTests(const std::vector<FailedTest>& tests, RetryListener* listener) {
    if (tests.empty()) {
        return {};
    }

// 构建测试过滤字符串
    std::string filter;
    for (size_t i = 0; i < tests.size(); ++i) {
        if (i > 0) {
            filter += ":";
        }
        filter += tests[i].test_case + "." + tests[i].test_name;
    }

// 设置测试过滤条件
    testing::GTEST_FLAG(filter) = filter;
    std::cout << "\n===== 开始重跑失败用例: " << filter << " =====" << std::endl;

// 清空监听器之前的记录
    listener->ClearFailedTests();
    
    // 运行过滤后的测试
    RUN_ALL_TESTS();
    
    // 返回本次重跑中仍然失败的用例
    std::vector<FailedTest> failed = listener->GetFailedTests();
    return std::unordered_set<FailedTest>(failed.begin(), failed.end());
}

int main(int argc, char **argv) {
    testing::InitGoogleTest(&argc, argv);
    
    // 创建并添加自定义监听器
    RetryListener* listener = new RetryListener();
    testing::TestEventListeners& listeners = testing::UnitTest::GetInstance()->listeners();
    // 保存默认监听器，稍后恢复
    testing::TestEventListener* default_listener = listeners.Release(listeners.default_result_printer());
    listeners.Append(listener);
    listeners.Append(default_listener); // 恢复默认监听器

// 首次运行所有测试
    std::cout << "===== 首次运行所有测试 =====" << std::endl;
    RUN_ALL_TESTS();

// 获取首次失败的用例
    std::vector<FailedTest> first_failures = listener->GetFailedTests();
    size_t initial_failure_count = first_failures.size();
    
    if (initial_failure_count == 0) {
        std::cout << "\n===== 测试完成 =====" << std::endl;
        std::cout << "所有测试用例均通过，无需重跑" << std::endl;
        return 0;
    }

std::cout << "\n首次运行失败用例数: " << initial_failure_count << std::endl;

// 只重跑一次失败的用例
    std::unordered_set<FailedTest> final_failures = RunSpecificTests(first_failures, listener);
    
    // 输出最终结果
    std::cout << "\n===== 测试完成 =====" << std::endl;
    std::cout << "首次失败用例数: " << initial_failure_count << std::endl;
    std::cout << "重跑后仍失败的用例数: " << final_failures.size() << std::endl;

if (!final_failures.empty()) {
        std::cout << "最终失败的用例:" << std::endl;
        for (const auto& ft : final_failures) {
            std::cout << "  " << ft.test_case << "." << ft.test_name << std::endl;
        }
    }

// 如果有最终失败的用例，返回非零值
    return final_failures.empty() ? 0 : 1;
}

```

	南柯	2023
	cxlove	1970
	vainner	1763
4	1000310428赵成帅	1718
5	XiaoWen	1710
6	1000380213洪伟焕	1701
7	weiben	1684
8	Jungle.Wei	1678
9	1100310131曾翔宇	1664
10	hongwh	1653