安装和使用

  1. 安装 gtest: 你可以从其 GitHub 仓库 获取 gtest 的源代码并安装。对于一些操作系统，你也可以使用包管理器来安装 gtest。例如，在 Ubuntu 上，你可以使用 apt-get 命令来安装 gtest：
sudo apt-get install libgtest-dev
  1. 写测试用例:
#include <gtest/gtest.h>
TEST(AddTest, PositiveNumbers) {
    EXPECT_EQ(add(1, 2), 3);
    EXPECT_EQ(add(10, 20), 30);
}
// main 可加可不加，不加的话需要在编译的时候加 -lgtest_main
int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}
  1. 编译并运行测试: 使用 g++ 编译器编译你的测试代码，并链接 gtest 的库。然后运行生成的二进制文件。
g++ -std=c++11 your_test_file.cpp -lgtest -lgtest_main -pthread -o your_test_binary
./your_test_binary

语法

常用的断言

  • EXPECT_TRUE(condition): 检查条件是否为真。
  • EXPECT_FALSE(condition): 检查条件是否为假。
  • EXPECT_EQ(val1, val2): 检查两个值是否相等。
  • EXPECT_NE(val1, val2): 检查两个值是否不相等。
  • EXPECT_LT(val1, val2): 检查 val1 是否小于 val2。
  • EXPECT_LE(val1, val2): 检查 val1 是否小于或等于 val2。
  • EXPECT_GT(val1, val2): 检查 val1 是否大于 val2。
  • EXPECT_GE(val1, val2): 检查 val1 是否大于或等于 val2。

测试

后续完善上面的部分

这是免去多个

#include <gtest/gtest.h>

// 待测试的函数：检查一个数是否为质数
bool IsPrime(int n) {
    if (n <= 1) return false;
    for (int i = 2; i < n; ++i) {
        if (n % i == 0) return false;
    }
    return true;
}

// 参数化测试类的定义
// IsPrimeParamTest 是一个参数化测试类，它从 ::testing::TestWithParam<int> 类派生。
// 这意味着测试参数的类型是 int。
class IsPrimeParamTest : public ::testing::TestWithParam<int> {
};

// 参数化测试用例的定义
// 使用 TEST_P 宏定义一个名为 ExpectTrueReturn 的参数化测试用例。
// 这个测试用例使用 GetParam() 函数获取测试参数，
// 并使用 EXPECT_TRUE 断言检查 IsPrime 函数的返回值。
TEST_P(IsPrimeParamTest, ExpectTrueReturn) {
    int n = GetParam();
    EXPECT_TRUE(IsPrime(n));
}

// 定义测试数据
// 使用 INSTANTIATE_TEST_CASE_P 宏定义测试数据。
// 这个宏接受三个参数：
// 1. 测试实例的前缀。在这个例子中，测试实例的前缀是 TrueReturn。
// 2. 参数化测试类的名称。在这个例子中，参数化测试类的名称是 IsPrimeParamTest。
// 3. 测试数据。在这个例子中，测试数据是一组整数：2, 3, 5, 7, 11, 13。
//    这些整数将分别作为测试参数传递给 ExpectTrueReturn 测试用例。
INSTANTIATE_TEST_CASE_P(TrueReturn, IsPrimeParamTest, ::testing::Values(2, 3, 5, 7, 11, 13));

// main 函数
// 在 main 函数中，我们初始化 gtest 并运行所有测试用例。
int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

如果你要测试的是字符串，可以修改 IsPrimeParamTest 类的定义，让它从 ::testing::TestWithParamstd::string 类派生。

下面是一个测试字符串连接函数的例子：

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

// 待测试的函数：连接两个字符串
std::string Concatenate(const std::string& a, const std::string& b) {
    return a + b;
}

// 参数化测试类的定义
// ConcatenateParamTest 是一个参数化测试类，它从 ::testing::TestWithParam<std::tuple<std::string, std::string, std::string>> 类派生。
// 这意味着测试参数的类型是 std::tuple<std::string, std::string, std::string>。
class ConcatenateParamTest : public ::testing::TestWithParam<std::tuple<std::string, std::string, std::string>> {
};

// 参数化测试用例的定义
// 使用 TEST_P 宏定义一个名为 ExpectCorrectResult 的参数化测试用例。
// 这个测试用例使用 GetParam() 函数获取测试参数，
// 并使用 EXPECT_EQ 断言检查 Concatenate 函数的返回值。
TEST_P(ConcatenateParamTest, ExpectCorrectResult) {
    auto params = GetParam();
    const std::string& a = std::get<0>(params);
    const std::string& b = std::get<1>(params);
    const std::string& expected = std::get<2>(params);
    EXPECT_EQ(Concatenate(a, b), expected);
}

// 定义测试数据
// 使用 INSTANTIATE_TEST_CASE_P 宏定义测试数据。
// 这个宏接受三个参数：
// 1. 测试实例的前缀。在这个例子中，测试实例的前缀是 CorrectResult。
// 2. 参数化测试类的名称。在这个例子中，参数化测试类的名称是 ConcatenateParamTest。
// 3. 测试数据。在这个例子中，测试数据是一组字符串元组：
//    ("hello", "world", "helloworld"),
//    ("foo", "bar", "foobar"),
//    ("", "baz", "baz")。
//    这些元组将分别作为测试参数传递给 ExpectCorrectResult 测试用例。
INSTANTIATE_TEST_CASE_P(CorrectResult, ConcatenateParamTest, ::testing::Values(
    std::make_tuple("hello", "world", "helloworld"),
    std::make_tuple("foo", "bar", "foobar"),
    std::make_tuple("", "baz", "baz")
));

// main 函数
// 在 main 函数中，我们初始化 gtest 并运行所有测试用例。
int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}