1
2
EXPECT_PRED_FORMAT2(testing::FloatLE, val1, val2);
EXPECT_PRED_FORMAT2(testing::DoubleLE, val1, val2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
template <typename T>
class FooType {
 public:
  T BarString(const T& input1, const T& input2);
  T BarInt(const T& input1, const T& input2);
};

template <typename T>
T FooType<T>::BarString(const T& input1, const T& input2) {
  testing::StaticAssertTypeEq<std::string, T>();
  return input1 + " " + input2;
};

template <typename T>
T FooType<T>::BarInt(const T& input1, const T& input2) {
  testing::StaticAssertTypeEq<int, T>();
  return input1 + input2;
};

TEST(Value, type_check) {
  // 类型检查
  FooType<std::string> foo_type_string;
  std::cout << foo_type_string.BarString("hello", "gtest") << std::endl;
  FooType<int> foo_type_int;
  std::cout << foo_type_int.BarInt(21, 22) << std::endl;
}

1
current value: i = 0.89999999999761268

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <gtest/gtest.h>
#include <iostream>

class GlobalEvent : public testing::Environment
{
public:
    virtual void SetUp()
    {
        std::cout << "Before all cases" << std::endl;
    }
    virtual void TearDown()
    {
        std::cout << "After all cases" << std::endl;
    }
};

TEST(GlobalEventTest, FirstTest) {
    std::cout << "First test" << std::endl;
}

TEST(GlobalEventTest, SecondTest) {
    std::cout << "Second test" << std::endl;
}

int main(int argc, char** argv)
{
    testing::AddGlobalTestEnvironment(new GlobalEvent);
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <gtest/gtest.h>
#include <iostream>

class TestSuiteEvent : public testing::Test
{
public:
    static void SetUpTestCase()
    {
        std::cout << "Before first test in TestSuite" << std::endl;
    }
    static void TearDownTestCase()
    {
        std::cout << "After last test in TestSuite" << std::endl;
    }
};

TEST_F(TestSuiteEvent, FirstTest) {
    std::cout << "First test in TestSuite" << std::endl;
}

TEST_F(TestSuiteEvent, SecondTest) {
    std::cout << "Second test in TestSuite" << std::endl;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <gtest/gtest.h>
#include <iostream>

class TestCaseEvent : public testing::Test
{
public:
    virtual void SetUp()   // 注意这里不是静态的
    {
        std::cout << "Before each test case" << std::endl;
    }
    virtual void TearDown() // 注意这里不是静态的
    {
        std::cout << "After each test case" << std::endl;
    }
};

TEST_F(TestCaseEvent, FirstTest) {
    std::cout << "First test case" << std::endl;
}

TEST_F(TestCaseEvent, SecondTest) {
    std::cout << "Second test case" << std::endl;
}

1
2
3
4
5
// function need to test
bool IsOdd(iunt n){
    if(n%2 == 1) return true;
    else return false;
}

1
2
3
4
TEST_P(IsOddParamTest, HandleTrueReturn) {
    int n =  GetParam(); // 获取一个数值
    EXPECT_TRUE(IsOdd(n));
}

1
INSTANTIATE_TEST_CASE_P(TrueReturn, IsOddParamTest, testing::Values(3, 5, 11, 23, 17));

1
2
3
4
5
6
template <typename T>
class QueueTest : public testing::Test {
 public:
  typedef std::queue<T> Queue;
  typedef std::list<T> List;
};

1
TYPED_TEST_SUITE_P(QueueTest);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
TYPED_TEST_P(QueueTest, DefaultConstructor) {
  typename TestFixture::Queue q0;
  EXPECT_EQ(0u, q0.size());
}

TYPED_TEST_P(QueueTest, Enqueue) {
  typename TestFixture::Queue q0;
  typename TestFixture::List expected;
  
  for (int i = 0; i < 10; ++i) {
    q0.push(i);
    expected.push_back(i);
  }
  EXPECT_EQ(10u, q0.size());
}

1
2
REGISTER_TYPED_TEST_SUITE_P(QueueTest,
                           DefaultConstructor, Enqueue);

1
2
3
4
typedef testing::Types<int, char, unsigned int> MyTypes;
INSTANTIATE_TYPED_TEST_SUITE_P(My,        // 实例化名称前缀
                              QueueTest,  // 测试套件名称
                              MyTypes);   // 类型列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <gtest/gtest.h>
#include <queue>
#include <list>

template <typename T>
class QueueTest : public testing::Test {
 public:
  typedef std::queue<T> Queue;
  typedef std::list<T> List;
};

TYPED_TEST_SUITE_P(QueueTest);

TYPED_TEST_P(QueueTest, DefaultConstructor) {
  typename TestFixture::Queue q0;
  EXPECT_EQ(0u, q0.size());
}

TYPED_TEST_P(QueueTest, Enqueue) {
  typename TestFixture::Queue q0;
  for (int i = 0; i < 10; ++i) {
    q0.push(static_cast<TypeParam>(i));
  }
  EXPECT_EQ(10u, q0.size());
}

// 注册所有的测试用例
REGISTER_TYPED_TEST_SUITE_P(QueueTest,
                           DefaultConstructor, Enqueue);

// 在一个地方实例化
typedef testing::Types<int, char, unsigned int> MyTypes;
INSTANTIATE_TYPED_TEST_SUITE_P(My, QueueTest, MyTypes);

// 也可以在另一个地方用不同的类型再次实例化
typedef testing::Types<float, double> FloatTypes;
INSTANTIATE_TYPED_TEST_SUITE_P(Float, QueueTest, FloatTypes);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <gtest/gtest.h>
#include <vector>

template <typename T>
class ContainerTest : public testing::Test {
 public:
  typedef std::vector<T> Container;
};

typedef testing::Types<int, float, double> NumericTypes;
TYPED_TEST_SUITE(ContainerTest, NumericTypes);

TYPED_TEST(ContainerTest, PushBackMultipleValues) {
  typename TestFixture::Container container;
  
  // 测试多个数值
  std::vector<TypeParam> test_values = {
    static_cast<TypeParam>(1),
    static_cast<TypeParam>(2),
    static_cast<TypeParam>(3)
  };
  
  for (const auto& value : test_values) {
    container.push_back(value);
  }
  
  EXPECT_EQ(test_values.size(), container.size());
  for (size_t i = 0; i < test_values.size(); ++i) {
    EXPECT_EQ(test_values[i], container[i]);
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <gtest/gtest.h>
#include <tuple>

// 定义一个测试类，同时接受类型和数值参数
template <typename T>
class MathTest : public testing::TestWithParam<std::tuple<T, T, T>> {
 public:
  T GetFirst() { return std::get<0>(this->GetParam()); }
  T GetSecond() { return std::get<1>(this->GetParam()); }
  T GetExpected() { return std::get<2>(this->GetParam()); }
};

// 为不同类型实例化测试
typedef MathTest<int> MathTestInt;
typedef MathTest<float> MathTestFloat;

TEST_P(MathTestInt, Addition) {
  EXPECT_EQ(GetExpected(), GetFirst() + GetSecond());
}

TEST_P(MathTestFloat, Addition) {
  EXPECT_FLOAT_EQ(GetExpected(), GetFirst() + GetSecond());
}

// 为 int 类型提供测试数据
INSTANTIATE_TEST_SUITE_P(
  IntValues,
  MathTestInt,
  testing::Values(
    std::make_tuple(1, 2, 3),
    std::make_tuple(5, 7, 12),
    std::make_tuple(-1, 1, 0)
  )
);

// 为 float 类型提供测试数据
INSTANTIATE_TEST_SUITE_P(
  FloatValues,
  MathTestFloat,
  testing::Values(
    std::make_tuple(1.1f, 2.2f, 3.3f),
    std::make_tuple(0.5f, 0.5f, 1.0f)
  )
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <gtest/gtest.h>

// 定义一个宏来简化多类型测试的定义
#define DEFINE_TYPED_PARAM_TEST(TestName, TypeName) \
  typedef testing::TestWithParam<std::pair<TypeName, TypeName>> TestName##TypeName; \
  TEST_P(TestName##TypeName, Operation) { \
    auto param = GetParam(); \
    TypeName a = param.first; \
    TypeName b = param.second; \
    EXPECT_GT(a + b, a); \
    EXPECT_GT(a + b, b); \
  }

// 为不同类型定义测试
DEFINE_TYPED_PARAM_TEST(ArithmeticTest, int)
DEFINE_TYPED_PARAM_TEST(ArithmeticTest, double)

// 为每种类型提供测试数据
INSTANTIATE_TEST_SUITE_P(
  IntPairs,
  ArithmeticTestint,
  testing::Values(
    std::make_pair(1, 2),
    std::make_pair(10, 20),
    std::make_pair(-5, 10)
  )
);

INSTANTIATE_TEST_SUITE_P(
  DoublePairs,
  ArithmeticTestdouble,
  testing::Values(
    std::make_pair(1.5, 2.5),
    std::make_pair(10.1, 20.2),
    std::make_pair(-5.5, 10.5)
  )
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <gtest/gtest.h>

// 定义一个更复杂的测试场景
class ComplexParamTest : public testing::TestWithParam<
  std::tuple<int,           // 容器大小
             std::string,   // 操作类型
             bool>>         // 是否预期成功
{
 public:
  int GetSize() { return std::get<0>(GetParam()); }
  std::string GetOperation() { return std::get<1>(GetParam()); }
  bool ShouldSucceed() { return std::get<2>(GetParam()); }
};

TEST_P(ComplexParamTest, ContainerOperations) {
  std::vector<int> container;
  
  // 根据参数初始化容器
  for (int i = 0; i < GetSize(); ++i) {
    container.push_back(i);
  }
  
  if (GetOperation() == "pop" && !container.empty()) {
    container.pop_back();
    EXPECT_EQ(ShouldSucceed(), container.size() == GetSize() - 1);
  } else if (GetOperation() == "clear") {
    container.clear();
    EXPECT_EQ(ShouldSucceed(), container.empty());
  }
}

INSTANTIATE_TEST_SUITE_P(
  ComplexScenarios,
  ComplexParamTest,
  testing::Combine(
    testing::Values(0, 5, 10),              // 容器大小
    testing::Values("pop", "clear"),        // 操作类型
    testing::Bool()                         // 预期结果
  )
);