cmake_minimum_required(VERSION 3.14)
project(gtest_demo)

# 配置C++标准，与gtest编译版本保持一致
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Windows平台特殊配置：避免覆盖父项目的编译器/运行时设置
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)

# 引入FetchContent模块，自动拉取gtest源码
include(FetchContent)
FetchContent_Declare(
  googletest
  GIT_REPOSITORY https://github.com/google/googletest.git
  GIT_TAG        v1.15.2  # 替换为最新稳定版本
)
FetchContent_MakeAvailable(googletest)

# 1. 待测试的业务代码（示例：math模块）
add_library(math STATIC math.cpp math.h)

# 2. 测试可执行文件
add_executable(math_test math_test.cpp)
# 链接gtest核心库、内置main函数库、待测试业务库
target_link_libraries(math_test PRIVATE math GTest::gtest GTest::gtest_main)

# 3. 集成到CTest，自动发现测试用例
include(GoogleTest)
gtest_discover_tests(math_test)

// math.h
#ifndef MATH_H
#define MATH_H
int add(int a, int b);
int multiply(int a, int b);
#endif

// math.cpp
#include "math.h"
int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

// math_test.cpp
#include <gtest/gtest.h>
#include "math.h"

// 加法测试套件
TEST(AddTest, PositiveNumber) {
    EXPECT_EQ(add(1, 2), 3);
    EXPECT_EQ(add(100, 200), 300);
}

TEST(AddTest, NegativeNumber) {
    EXPECT_EQ(add(-1, -2), -3);
    EXPECT_EQ(add(-1, 2), 1);
}

// 乘法测试套件
TEST(MultiplyTest, ZeroInput) {
    EXPECT_EQ(multiply(0, 5), 0);
    EXPECT_EQ(multiply(5, 0), 0);
}

TEST(MultiplyTest, PositiveNumber) {
    EXPECT_EQ(multiply(3, 4), 12);
}

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

// 定义测试固件
class QueueTest : public ::testing::Test {
protected:
    // 每个测试用例都会拥有独立的queue实例
    std::queue<int> q;

    // 每个测试用例执行前调用
    void SetUp() override {
        // 初始化队列：每个用例启动时都有3个初始元素
        q.push(1);
        q.push(2);
        q.push(3);
    }

    // 每个测试用例执行后调用
    void TearDown() override {
        // 清理队列，释放资源
        while (!q.empty()) q.pop();
    }

    // 整个测试套件执行前调用一次
    static void SetUpTestSuite() {
        // 套件级初始化：如打开文件、连接数据库、加载全局配置等
    }

    // 整个测试套件执行后调用一次
    static void TearDownTestSuite() {
        // 套件级清理：关闭文件、断开数据库连接等
    }
};

// 使用TEST_F宏，第一个参数必须是测试固件类名
TEST_F(QueueTest, PushElement) {
    // 直接访问固件的protected成员q
    q.push(4);
    EXPECT_EQ(q.size(), 4);
    EXPECT_EQ(q.back(), 4);
}

TEST_F(QueueTest, PopElement) {
    q.pop();
    EXPECT_EQ(q.size(), 2);
    EXPECT_EQ(q.front(), 2);
}

TEST_F(QueueTest, GetFrontElement) {
    EXPECT_EQ(q.front(), 1);
}

#include <gtest/gtest.h>

int main(int argc, char **argv) {
    // 必须调用：初始化gtest，解析命令行参数
    testing::InitGoogleTest(&argc, argv);

    // 此处可添加全局初始化代码：如初始化日志、加载全局配置、初始化第三方库等

    // 运行所有测试用例，返回值：0=全部通过，非0=存在失败用例
    int ret = RUN_ALL_TESTS();

    // 此处可添加全局清理代码

    return ret;
}

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

int add(int a, int b) { return a + b; }

// 定义参数化固件：参数为tuple<a, b, 预期结果>
class AddParamTest : public ::testing::TestWithParam<std::tuple<int, int, int>> {
};

// 定义参数化测试逻辑
TEST_P(AddParamTest, MultiInputVerify) {
    // 获取当前测试参数
    int a = std::get<0>(GetParam());
    int b = std::get<1>(GetParam());
    int expect = std::get<2>(GetParam());
    // 执行断言
    EXPECT_EQ(add(a, b), expect);
}

// 实例化测试套件，批量传入多组参数
INSTANTIATE_TEST_SUITE_P(
    AddParamGroup,  // 实例名，自定义即可
    AddParamTest,   // 参数化固件类名
    ::testing::Values( // 多组测试参数
        std::make_tuple(1, 2, 3),
        std::make_tuple(-1, -2, -3),
        std::make_tuple(-1, 2, 1),
        std::make_tuple(0, 5, 5),
        std::make_tuple(100, 200, 300)
    )
);

#include <gtest/gtest.h>
#include <vector>
#include <string>

// 定义测试用例结构体
struct AddTestCase {
    int a;
    int b;
    int expect;
    std::string case_name; // 用例名，用于测试报告展示
};

class AddStructParamTest : public ::testing::TestWithParam<AddTestCase> {
};

TEST_P(AddStructParamTest, MultiInputVerify) {
    const auto& param = GetParam();
    EXPECT_EQ(add(param.a, param.b), param.expect);
}

// 实例化，同时自定义用例名，方便调试和报告查看
INSTANTIATE_TEST_SUITE_P(
    AddStructGroup,
    AddStructParamTest,
    ::testing::ValuesIn(std::vector<AddTestCase>{
        {1, 2, 3, "positive_number"},
        {-1, -2, -3, "negative_number"},
        {0, 5, 5, "zero_input"},
        {INT_MAX, 1, INT_MAX + 1, "int_overflow"}
    }),
    // 自定义用例名生成函数
    [](sslocal://flow/file_open?url=const+%3A%3Atesting%3A%3ATestParamInfo%3CAddTestCase%3E%26+info&flow_extra=eyJsaW5rX3R5cGUiOiJjb2RlX2ludGVycHJldGVyIn0=) {
        return info.param.case_name;
    }
);

#include <gtest/gtest.h>
#include <cstdio>
#include <cstdlib>
#include <cassert>

void check_null_ptr(int* ptr) {
    if (ptr == nullptr) {
        fprintf(stderr, "fatal error: ptr is null\n");
        abort(); // 终止进程
    }
}

void exit_with_code(int code) {
    exit(code);
}

// 死亡测试套件名建议以DeathTest结尾，gtest会优先执行，避免父进程状态影响
TEST(CheckPtrDeathTest, NullPtrCrash) {
    // 验证传入空指针时，进程终止，且stderr输出匹配正则
    ASSERT_DEATH(check_null_ptr(nullptr), "fatal error: ptr is null");
}

TEST(ExitCodeTest, VerifyExitCode) {
    // 验证进程正常退出，退出码为0
    ASSERT_EXIT(exit_with_code(0), ::testing::ExitedWithCode(0), "");
    // 验证进程正常退出，退出码为1
    ASSERT_EXIT(exit_with_code(1), ::testing::ExitedWithCode(1), "");
}

# 只执行AddTest套件下的所有用例
./math_test --gtest_filter=AddTest.*

# 执行AddTest和MultiplyTest套件的所有用例
./math_test --gtest_filter=AddTest.*:MultiplyTest.*

# 执行所有用例，排除Negative相关的用例
./math_test --gtest_filter=*-*Negative*

# 只执行单个用例
./math_test --gtest_filter=AddTest.PositiveNumber

#include <gtest/gtest.h>
#include <chrono>
#include <cstdio>

// 自定义监听器：统计测试用例执行时间
class TimeStatListener : public ::testing::EmptyTestEventListener {
private:
    std::chrono::steady_clock::time_point case_start_time;

    // 钩子：测试套件开始前调用
    void OnTestSuiteStart(const ::testing::TestSuite& test_suite) override {
        printf("===== Test Suite [%s] start =====\n", test_suite.name());
    }

    // 钩子：测试套件结束后调用
    void OnTestSuiteEnd(const ::testing::TestSuite& test_suite) override {
        printf("===== Test Suite [%s] end, total tests: %d, passed: %d =====\n\n",
               test_suite.name(),
               test_suite.total_test_count(),
               test_suite.successful_test_count());
    }

    // 钩子：单个测试用例开始前调用
    void OnTestStart(const ::testing::TestInfo& test_info) override {
        printf("Test [%s.%s] start\n", test_info.test_suite_name(), test_info.name());
        case_start_time = std::chrono::steady_clock::now();
    }

    // 钩子：单个测试用例结束后调用
    void OnTestEnd(const ::testing::TestInfo& test_info) override {
        auto end_time = std::chrono::steady_clock::now();
        auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - case_start_time).count();
        printf("Test [%s.%s] end, result: %s, duration: %ld ms\n",
               test_info.test_suite_name(),
               test_info.name(),
               test_info.result()->Passed() ? "PASS" : "FAIL",
               duration_ms);
    }
};

int main(int argc, char **argv) {
    testing::InitGoogleTest(&argc, argv);

    // 注册自定义监听器
    auto& listeners = testing::UnitTest::GetInstance()->listeners();
    listeners.Append(new TimeStatListener);

    return RUN_ALL_TESTS();
}

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <string>

// 1. 定义依赖接口
class Database {
public:
    virtual ~Database() = default;
    virtual bool queryUser(int id, std::string& name) = 0;
    virtual int getUserCount() = 0;
};

// 2. 定义Mock类，实现接口
class MockDatabase : public Database {
public:
    // MOCK_METHOD宏格式：MOCK_METHOD(返回值类型, 函数名, (参数列表), (修饰符))
    MOCK_METHOD(bool, queryUser, (int id, std::string& name), (override));
    MOCK_METHOD(int, getUserCount, (), (override));
};

// 3. 待测试的业务类：依赖Database接口
class UserService {
public:
    explicit UserService(Database* db) : db_(db) {}

    std::string getUserName(int id) {
        std::string name;
        if (db_->queryUser(id, name)) {
            return name;
        }
        return "unknown";
    }

    int getUserTotal() {
        return db_->getUserCount();
    }

private:
    Database* db_;
};

// 4. 测试用例
TEST(UserServiceTest, GetUserName_Success) {
    MockDatabase mock_db;
    UserService service(&mock_db);

    // 设置预期：调用queryUser(1, _)，返回true，并给第二个参数赋值"Alice"
    EXPECT_CALL(mock_db, queryUser(1, testing::_))
        .WillOnce(testing::DoAll(
            testing::SetArgReferee<1>("Alice"),
            testing::Return(true)
        ));

    // 执行测试并断言
    EXPECT_EQ(service.getUserName(1), "Alice");
}

TEST(UserServiceTest, GetUserName_UserNotExist) {
    MockDatabase mock_db;
    UserService service(&mock_db);

    // 设置预期：调用queryUser(2, _)，返回false
    EXPECT_CALL(mock_db, queryUser(2, testing::_))
        .WillOnce(testing::Return(false));

    EXPECT_EQ(service.getUserName(2), "unknown");
}

TEST(UserServiceTest, GetUserTotal_ReturnCount) {
    MockDatabase mock_db;
    UserService service(&mock_db);

    // 设置预期：调用getUserCount()，返回100
    EXPECT_CALL(mock_db, getUserCount())
        .WillOnce(testing::Return(100));

    EXPECT_EQ(service.getUserTotal(), 100);
}

struct Point {
    int x;
    int y;
    // 重载==运算符，用于ASSERT_EQ比较
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
};

// 重载<<运算符，用于断言失败时打印值
std::ostream& operator<<(std::ostream& os, const Point& p) {
    os << "Point(" << p.x << ", " << p.y << ")";
    return os;
}