TestFramework.hpp

浏览该文件的文档.

 
 
#pragma once
 
// 兼容 GoogleTest 的传递包含：以前很多测试在未显式 include 的情况下使用了这些
// 标准库头（例如 std::set<char*>）。内置框架在 gtest/gtest.h 处被包含，因此需
// 提供等价的标准库头，以免测试因其先前依赖 gtest 的传递包含而编译失败。
#include <string>
#include <vector>
#include <sstream>
#include <functional>
#include <utility>
#include <memory>
#include <map>
#include <set>
#include <deque>
#include <list>
#include <tuple>
#include <algorithm>
#include <type_traits>
#include <typeinfo>
#include <iomanip>
#include <iosfwd>
#include <iostream>
#include <iterator>
#include <streambuf>
#include <locale>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cstdint>
#include <cstddef>
#include <cmath>
#include <limits>
#include <exception>
 
// 彩色标签的平台支持：Windows（含 Win7）用经典控制台 API，POSIX 用 ANSI。
// 用 WIN32_LEAN_AND_MEAN / NOMINMAX 尽量限制其可能污染到测试代码的宏。
#ifdef _WIN32
#  ifndef WIN32_LEAN_AND_MEAN
#    define WIN32_LEAN_AND_MEAN
#  endif
#  ifndef NOMINMAX
#    define NOMINMAX
#  endif
#  include <windows.h>
#else
#  include <unistd.h>
#endif
 
namespace ast {
namespace testing {
 
class Test {
public:
    virtual ~Test() {}
    virtual void SetUp() {}
    virtual void TearDown() {}
    virtual void TestBody() = 0;
};
 
// 兼容 GoogleTest 的开关访问方式：testing::GTEST_FLAG(name) 展开为裸标识符
// FLAGS_gtest_<name>（与 GoogleTest 相同的技巧），从而保留调用方书写的
// "testing::" 前缀。采用内部链接，每个翻译单元各有一份副本；每个测试
// 可执行文件都是单一翻译单元。
static bool FLAGS_gtest_catch_exceptions = true;
 
#define GTEST_FLAG(name) FLAGS_gtest_##name
 
inline void InitGoogleTest(int* argc, char** argv) {
    (void)argc;
    (void)argv;
}
 
namespace internal {
 
enum class TagColor { kDefault, kGreen, kRed, kYellow, kCyan, kMagenta };
 
#ifdef _WIN32
// 缓存控制台输出句柄与原始属性，避免每次查询。
struct ConsoleInfo {
    bool is_console = false;
    HANDLE handle = INVALID_HANDLE_VALUE;
    WORD saved = 0;
};
inline const ConsoleInfo& console_info() {
    static ConsoleInfo info = []() -> ConsoleInfo {
        ConsoleInfo ci;
        ci.handle = GetStdHandle(STD_OUTPUT_HANDLE);
        DWORD mode = 0;
        CONSOLE_SCREEN_BUFFER_INFO csi;
        if (ci.handle != INVALID_HANDLE_VALUE &&
            GetConsoleMode(ci.handle, &mode) &&
            GetConsoleScreenBufferInfo(ci.handle, &csi)) {
            ci.is_console = true;
            ci.saved = csi.wAttributes;
        }
        return ci;
    }();
    return info;
}
#else
inline bool stdout_is_tty() { return ::isatty(::fileno(stdout)) != 0; }
#endif
 
inline void begin_color(TagColor c) {
#ifdef _WIN32
    const ConsoleInfo& ci = console_info();
    if (!ci.is_console) return;
    WORD attr = ci.saved;
    switch (c) {
        case TagColor::kGreen:   attr = FOREGROUND_GREEN | FOREGROUND_INTENSITY; break;
        case TagColor::kRed:     attr = FOREGROUND_RED   | FOREGROUND_INTENSITY; break;
        case TagColor::kYellow:  attr = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; break;
        case TagColor::kCyan:    attr = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY; break;
        case TagColor::kMagenta: attr = FOREGROUND_RED   | FOREGROUND_BLUE | FOREGROUND_INTENSITY; break;
        case TagColor::kDefault: break;
    }
    SetConsoleTextAttribute(ci.handle, attr);
#else
    if (!stdout_is_tty()) return;
    switch (c) {
        case TagColor::kGreen:   std::fputs("\033[32m", stdout); break;
        case TagColor::kRed:     std::fputs("\033[31m", stdout); break;
        case TagColor::kYellow:  std::fputs("\033[33m", stdout); break;
        case TagColor::kCyan:    std::fputs("\033[36m", stdout); break;
        case TagColor::kMagenta: std::fputs("\033[35m", stdout); break;
        case TagColor::kDefault: break;
    }
#endif
}
 
inline void end_color() {
#ifdef _WIN32
    const ConsoleInfo& ci = console_info();
    if (!ci.is_console) return;
    SetConsoleTextAttribute(ci.handle, ci.saved);
#else
    if (!stdout_is_tty()) return;
    std::fputs("\033[0m", stdout);
#endif
}
 
inline void emit_tag(TagColor c, const char* tag) {
    begin_color(c);
    std::fputs(tag, stdout);
    std::fflush(stdout);
    end_color();
}
 
struct TestCase {
    std::string suite;
    std::string name;
    std::function<void()> run;
    int failures = 0;
    bool skipped = false;
    std::vector<std::string> trace;  
};
 
inline std::vector<TestCase>& registry() {
    static std::vector<TestCase> list;
    return list;
}
 
inline TestCase*& current_test() {
    static TestCase* t = nullptr;
    return t;
}
 
struct TestRegistrar {
    TestRegistrar(const char* suite, const char* name, std::function<void()> run) {
        TestCase t;
        t.suite = suite;
        t.name = name;
        t.run = std::move(run);
        registry().push_back(std::move(t));
    }
};
 
struct FatalTestException {};
 
struct SkippedTestException {};
 
inline void report_current_failure(const std::string& msg) {
    if (TestCase* t = current_test()) {
        ++t->failures;
        for (size_t i = 0; i < t->trace.size(); ++i) {
            std::fprintf(stderr, "  %s\n", t->trace[i].c_str());
        }
    }
    std::fputs(msg.c_str(), stderr);
    std::fputc('\n', stderr);
}
 
inline void mark_skipped() {
    if (TestCase* t = current_test()) {
        t->skipped = true;
    }
}
 
// 若某个类型的值可流式输出则输出之，否则为空操作。避免对未定义 operator<<
// 的自定义类型使用 "<<" 时报编译错误。
template <typename T>
auto stream_value(std::ostream& os, const T& v, int) -> decltype(os << v, void()) {
    os << v;
}
template <typename T>
void stream_value(std::ostream&, const T&, long) {}
 
class ScopedTrace {
public:
    ScopedTrace(const char* file, int line, const std::string& msg) {
        if (TestCase* t = current_test()) {
            t->trace.push_back(std::string(file) + ":" + std::to_string(line) + ": " + msg);
        }
    }
    ~ScopedTrace() {
        if (TestCase* t = current_test()) {
            if (!t->trace.empty()) t->trace.pop_back();
        }
    }
};
 
class SkipHelper {
public:
    template <typename T>
    SkipHelper& operator<<(const T& v) {
        stream_value(stream_, v, 0);
        return *this;
    }
 
    ~SkipHelper() noexcept(false) {
        (void)stream_.str();  // 读取流，避免 stream_ 因只写不读而被告警
        mark_skipped();
        throw SkippedTestException();
    }
 
private:
    std::ostringstream stream_;
};
 
class FailHelper {
public:
    FailHelper(const char* file, int line) : file_(file), line_(line) {}
 
    template <typename T>
    FailHelper& operator<<(const T& v) {
        stream_value(stream_, v, 0);
        return *this;
    }
 
    ~FailHelper() noexcept(false) {
        std::ostringstream os;
        os << file_ << ':' << line_ << ": Failure\n  FAIL()";
        const std::string extra = stream_.str();
        if (!extra.empty()) {
            os << "\n  Extra: " << extra;
        }
        report_current_failure(os.str());
        throw FatalTestException();
    }
 
private:
    const char* file_;
    int line_;
    std::ostringstream stream_;
};
 
class AssertionHelper {
public:
    AssertionHelper(bool ok, const char* file, int line, const char* expr, bool fatal)
        : ok_(ok), file_(file), line_(line), expr_(expr), fatal_(fatal) {}
 
    template <typename T>
    AssertionHelper& operator<<(const T& v) {
        if (!ok_) {
            stream_value(stream_, v, 0);
        }
        return *this;
    }
 
    explicit operator bool() const { return ok_; }
 
    // 可能抛出 FatalTestException（致命断言时），因此不声明为 noexcept。
    ~AssertionHelper() noexcept(false) {
        if (ok_) return;
        std::ostringstream os;
        os << file_ << ':' << line_ << ": Failure\n  Expression: " << expr_;
        const std::string extra = stream_.str();
        if (!extra.empty()) {
            os << "\n  Extra: " << extra;
        }
        report_current_failure(os.str());
        if (fatal_) {
            throw FatalTestException();
        }
    }
 
private:
    bool ok_;
    const char* file_;
    int line_;
    const char* expr_;
    bool fatal_;
    std::ostringstream stream_;
};
 
// 比较辅助函数。
 
inline bool streq(const char* a, const char* b) {
    if (!a || !b) return a == b;
    return std::strcmp(a, b) == 0;
}
template <typename A, typename B>
inline bool streq(const A& a, const B& b) {
    return std::string(a) == std::string(b);
}
 
inline bool double_eq(double a, double b) {
    if (a == b) return true;
    if (std::isnan(a) || std::isnan(b)) return std::isnan(a) && std::isnan(b);
    double scale = std::fabs(a);
    if (std::fabs(b) > scale) scale = std::fabs(b);
    if (scale < 1.0) scale = 1.0;
    return std::fabs(a - b) <= scale * 4.0 * std::numeric_limits<double>::epsilon();
}
 
inline bool is_near(double a, double b, double eps) {
    return std::fabs(a - b) <= std::fabs(eps);
}
 
inline int run_all_tests() {
    std::vector<TestCase>& list = registry();
    int total = 0, failed = 0, skipped = 0;
 
    for (size_t i = 0; i < list.size(); ++i) {
        TestCase& tc = list[i];
        ++total;
        tc.failures = 0;
        tc.skipped = false;
        current_test() = &tc;
 
        emit_tag(TagColor::kGreen, "[ RUN      ]");
        std::printf(" %s.%s\n", tc.suite.c_str(), tc.name.c_str());
        const bool caught = FLAGS_gtest_catch_exceptions;
        try {
            tc.run();
        } catch (const FatalTestException&) {
            // 致命断言（ASSERT_*）的内部控制流，始终吞掉，以便该测试按失败
            // 计数并让运行器继续执行其余测试。
        } catch (const SkippedTestException&) {
            // 跳过标记已由 GTEST_SKIP 写入，直接按跳过计数。
        } catch (const std::exception& e) {
            if (caught) {
                report_current_failure(std::string("stray exception: ") + e.what());
            } else {
                throw;
            }
        } catch (...) {
            if (caught) {
                report_current_failure("stray non-std exception");
            } else {
                throw;
            }
        }
        current_test() = nullptr;
 
        if (tc.skipped) {
            ++skipped;
            emit_tag(TagColor::kYellow, "[  SKIPPED ]");
            std::printf(" %s.%s\n", tc.suite.c_str(), tc.name.c_str());
        } else if (tc.failures > 0) {
            ++failed;
            emit_tag(TagColor::kRed, "[  FAILED  ]");
            std::printf(" %s.%s\n", tc.suite.c_str(), tc.name.c_str());
        } else {
            emit_tag(TagColor::kGreen, "[       OK ]");
            std::printf(" %s.%s\n", tc.suite.c_str(), tc.name.c_str());
        }
    }
 
    emit_tag(TagColor::kGreen, "\n[==========]");
    std::printf(" %d test(s) ran.\n", total);
    emit_tag(TagColor::kGreen, "[  PASSED  ]");
    std::printf(" %d test(s).\n", total - failed - skipped);
    if (skipped) {
        emit_tag(TagColor::kYellow, "[  SKIPPED ]");
        std::printf(" %d test(s).\n", skipped);
    }
    if (failed) {
        emit_tag(TagColor::kRed, "[  FAILED  ]");
        std::printf(" %d test(s).\n", failed);
    }
    return failed;
}
 
} // namespace internal
} // namespace testing
} // namespace ast
 
// 兼容 GoogleTest 的词法别名：把 "testing" 映射到 ast::testing，
// 使既有测试中 testing::Test / testing::InitGoogleTest() 等无需改动。
namespace testing = ast::testing;
 
inline int RUN_ALL_TESTS() { return ::testing::internal::run_all_tests(); }
 
// -----------------------------------------------------------------------------
// 公开宏
// -----------------------------------------------------------------------------
 
#define GTEST_SKIP() (::testing::internal::SkipHelper())
 
#define AST_TRACE_CONCAT_(a, b) a##b
#define AST_TRACE_CONCAT(a, b) AST_TRACE_CONCAT_(a, b)
#define SCOPED_TRACE(message) \
    ::testing::internal::ScopedTrace AST_TRACE_CONCAT(_gtest_scoped_trace_, __LINE__)(__FILE__, __LINE__, (message))
 
#define SUCCEED() do { } while (0)
 
#define FAIL() (::testing::internal::FailHelper(__FILE__, __LINE__))
 
// 展开为临时 AssertionHelper，从而支持 "<<" 链式输出，并由析构函数上报结果。
#define AST_GTEST_ASSERT_(expr, exprtext, fatal) \
    (::testing::internal::AssertionHelper((expr), __FILE__, __LINE__, (exprtext), (fatal)))
 
#define EXPECT_EQ(a, b) AST_GTEST_ASSERT_((a) == (b), #a " == " #b, false)
#define ASSERT_EQ(a, b) AST_GTEST_ASSERT_((a) == (b), #a " == " #b, true)
#define EXPECT_NE(a, b) AST_GTEST_ASSERT_((a) != (b), #a " != " #b, false)
#define ASSERT_NE(a, b) AST_GTEST_ASSERT_((a) != (b), #a " != " #b, true)
#define EXPECT_LT(a, b) AST_GTEST_ASSERT_((a) < (b), #a " < " #b, false)
#define ASSERT_LT(a, b) AST_GTEST_ASSERT_((a) < (b), #a " < " #b, true)
#define EXPECT_GT(a, b) AST_GTEST_ASSERT_((a) > (b), #a " > " #b, false)
#define ASSERT_GT(a, b) AST_GTEST_ASSERT_((a) > (b), #a " > " #b, true)
#define EXPECT_LE(a, b) AST_GTEST_ASSERT_((a) <= (b), #a " <= " #b, false)
#define ASSERT_LE(a, b) AST_GTEST_ASSERT_((a) <= (b), #a " <= " #b, true)
#define EXPECT_GE(a, b) AST_GTEST_ASSERT_((a) >= (b), #a " >= " #b, false)
#define ASSERT_GE(a, b) AST_GTEST_ASSERT_((a) >= (b), #a " >= " #b, true)
 
#define EXPECT_TRUE(v) AST_GTEST_ASSERT_(static_cast<bool>(v), #v, false)
#define ASSERT_TRUE(v) AST_GTEST_ASSERT_(static_cast<bool>(v), #v, true)
#define EXPECT_FALSE(v) AST_GTEST_ASSERT_(!static_cast<bool>(v), #v, false)
#define ASSERT_FALSE(v) AST_GTEST_ASSERT_(!static_cast<bool>(v), #v, true)
 
#define EXPECT_NEAR(a, b, eps) AST_GTEST_ASSERT_(::testing::internal::is_near((a), (b), (eps)), #a " near " #b, false)
#define ASSERT_NEAR(a, b, eps) AST_GTEST_ASSERT_(::testing::internal::is_near((a), (b), (eps)), #a " near " #b, true)
#define EXPECT_DOUBLE_EQ(a, b) AST_GTEST_ASSERT_(::testing::internal::double_eq((a), (b)), #a " == " #b, false)
#define ASSERT_DOUBLE_EQ(a, b) AST_GTEST_ASSERT_(::testing::internal::double_eq((a), (b)), #a " == " #b, true)
#define EXPECT_FLOAT_EQ(a, b) AST_GTEST_ASSERT_(::testing::internal::double_eq((double)(a), (double)(b)), #a " == " #b, false)
#define ASSERT_FLOAT_EQ(a, b) AST_GTEST_ASSERT_(::testing::internal::double_eq((double)(a), (double)(b)), #a " == " #b, true)
#define EXPECT_STREQ(a, b) AST_GTEST_ASSERT_(::testing::internal::streq((a), (b)), #a " == " #b, false)
#define ASSERT_STREQ(a, b) AST_GTEST_ASSERT_(::testing::internal::streq((a), (b)), #a " == " #b, true)
 
// 抛异常检查：此类检查无法使用 "<<" 流式输出，因此采用语句宏。
#define AST_GTEST_EXPECT_THROW_(stmt, ex, fatal) \
    do { \
        bool ok_ = false; \
        try { (void)(stmt); } \
        catch (const ex&) { ok_ = true; } \
        catch (...) {} \
        if (!ok_) { \
            ::testing::internal::report_current_failure( \
                std::string("Expected exception ") + #ex + " from: " + #stmt); \
            if (fatal) return; \
        } \
    } while (0)
#define EXPECT_THROW(stmt, ex) AST_GTEST_EXPECT_THROW_(stmt, ex, false)
#define ASSERT_THROW(stmt, ex) AST_GTEST_EXPECT_THROW_(stmt, ex, true)
 
#define AST_GTEST_EXPECT_NO_THROW_(stmt, fatal) \
    do { \
        try { (void)(stmt); } \
        catch (...) { \
            ::testing::internal::report_current_failure( \
                std::string("Unexpected exception from: ") + #stmt); \
            if (fatal) return; \
        } \
    } while (0)
#define EXPECT_NO_THROW(stmt) AST_GTEST_EXPECT_NO_THROW_(stmt, false)
#define ASSERT_NO_THROW(stmt) AST_GTEST_EXPECT_NO_THROW_(stmt, true)
 
// TEST：注册一个裸测试函数。
#define TEST(suite, name) \
    static void suite##_##name##_TestBody(); \
    static ::testing::internal::TestRegistrar suite##_##name##_Reg( \
        #suite, #name, [] { suite##_##name##_TestBody(); }); \
    static void suite##_##name##_TestBody()
 
// TEST_F：注册一个夹具（必须继承自 ::testing::Test）。测试类覆写 TestBody()；
// SetUp()/TearDown() 通过公开的基类接口调用，因此即使是私有覆写也能正确分发。
#define TEST_F(fixture, name) \
    class fixture##_##name##_Test : public fixture { \
    public: \
        void TestBody() override; \
    }; \
    static ::testing::internal::TestRegistrar fixture##_##name##_Reg( \
        #fixture, #name, [] { \
            std::unique_ptr<::testing::Test> obj_(new fixture##_##name##_Test()); \
            try { \
                obj_->SetUp(); \
                obj_->TestBody(); \
            } \
            catch (const ::testing::internal::FatalTestException&) {} \
            catch (const ::testing::internal::SkippedTestException&) {} \
            obj_->TearDown(); \
        }); \
    void fixture##_##name##_Test::TestBody()