测试参考

此页面列出了 GoogleTest 提供的用于编写测试程序的功能。要使用它们，请添加 #include <gtest/gtest.h>。

宏

GoogleTest 定义了以下用于编写测试的宏。

TEST

TEST(TestSuiteName, TestName) {
  ... statements ...
}

在测试套件 *TestSuiteName* 中定义一个名为 *TestName* 的单独测试，该测试由给定的语句组成。

参数 *TestSuiteName* 和 *TestName* 都必须是有效的 C++ 标识符，并且不能包含下划线 ( _ )。不同测试套件中的测试可以具有相同的单个名称。

测试体内的语句可以是任何被测试的代码。测试体内使用的断言决定测试的结果。

TEST_F

TEST_F(TestFixtureName, TestName) {
  ... statements ...
}

定义一个名为 *TestName* 的单独测试，该测试使用测试夹具类 *TestFixtureName*。测试套件名称为 *TestFixtureName*。

参数 *TestFixtureName* 和 *TestName* 都必须是有效的 C++ 标识符，并且不能包含下划线 ( _ )。 *TestFixtureName* 必须是测试夹具类的名称——请参阅测试夹具。

测试体内的语句可以是任何被测试的代码。测试体内使用的断言决定测试的结果。

TEST_P

TEST_P(TestFixtureName, TestName) {
  ... statements ...
}

定义一个名为 *TestName* 的单独的值参数化测试，该测试使用测试夹具类 *TestFixtureName*。测试套件名称为 *TestFixtureName*。

参数 *TestFixtureName* 和 *TestName* 都必须是有效的 C++ 标识符，并且不能包含下划线 ( _ )。 *TestFixtureName* 必须是值参数化测试夹具类的名称——请参阅值参数化测试。

测试体内的语句可以是任何被测试的代码。在测试体内，可以使用 GetParam() 函数访问测试参数（参见 WithParamInterface）。例如

TEST_P(MyTestSuite, DoesSomething) {
  ...
  EXPECT_TRUE(DoSomething(GetParam()));
  ...
}

断言用于测试体中以确定测试的结果。

另请参阅 INSTANTIATE_TEST_SUITE_P。

INSTANTIATE_TEST_SUITE_P

INSTANTIATE_TEST_SUITE_P(InstantiationName,TestSuiteName,param_generator)
INSTANTIATE_TEST_SUITE_P(InstantiationName,TestSuiteName,param_generator,name_generator)

实例化值参数化的测试套件 *TestSuiteName*（使用 TEST_P 定义）。

参数 *InstantiationName* 是测试套件实例化的唯一名称，用于区分多个实例化。在测试输出中，实例化名称将作为前缀添加到测试套件名称 *TestSuiteName*。如果 *InstantiationName* 为空 ( INSTANTIATE_TEST_SUITE_P(, ...) )，则不添加前缀。

参数 *param_generator* 是以下 GoogleTest 提供的用于生成测试参数的函数之一，全部在 ::testing 命名空间中定义

参数生成器	行为
`Range(begin, end [, step])`	产生值 `{begin, begin+step, begin+step+step, ...}`。这些值不包括 `end`。`step` 默认为 1。
`Values(v1, v2, ..., vN)`	产生值 `{v1, v2, ..., vN}`。
`ValuesIn(container)` 或 `ValuesIn(begin,end)`	从 C 样式数组、STL 样式容器或迭代器范围 `[begin, end)` 产生值。
`Bool()`	产生序列 `{false, true}`。
`Combine(g1, g2, ..., gN)`	生成作为 `std::tuple` n 元组，由给定 n 个生成器 `g1`、`g2`、…、`gN` 生成的值的所有组合（笛卡尔积）。
`ConvertGenerator<T>(g)` 或 `ConvertGenerator(g, func)`	产生由生成器 `g` 生成的值，从 `T` 进行 `static_cast`。(注意：`T` 可能不是你期望的。参见使用 ConvertGenerator 下文。) 第二个重载使用 `func` 执行转换。

可选的最后一个参数 *name_generator* 是一个函数或仿函数，用于基于测试参数生成自定义测试名称后缀。该函数必须接受 TestParamInfo<class ParamType> 类型的参数，并返回一个 std::string。测试名称后缀只能包含字母数字字符和下划线。 GoogleTest 提供 PrintToStringParamName，或者可以使用自定义函数进行更多控制

INSTANTIATE_TEST_SUITE_P(
    MyInstantiation, MyTestSuite,
    testing::Values(...),
    [](const testing::TestParamInfo<MyTestSuite::ParamType>& info) {
      // Can use info.param here to generate the test suffix
      std::string name = ...
      return name;
    });

有关更多信息，请参阅值参数化测试。

另请参阅 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST。

使用 `ConvertGenerator`

上表中列出的函数似乎返回创建所需类型的值的生成器，但通常情况并非如此。相反，它们通常返回转换为所需生成器的工厂对象。这提供了一些灵活性，允许您指定类型的值，这些类型与夹具类所需的实际参数类型不同，但可以隐式转换为夹具类所需的实际参数类型。

例如，你可以对需要 int 参数的夹具执行以下操作

INSTANTIATE_TEST_SUITE_P(MyInstantiation, MyTestSuite,
    testing::Values(1, 1.2));  // Yes, Values() supports heterogeneous argument types.

似乎很明显 1.2——一个 double——将被转换为一个 int，但实际上它需要一些涉及前一段描述的间接寻址的模板技巧。

如果你的参数类型不能从生成的类型隐式转换，而是显式可转换的呢？不会有自动转换，但你可以通过应用 ConvertGenerator<T> 来强制它。编译器可以自动推断目标类型（你的夹具的参数类型），但由于前面提到的间接寻址，它无法确定生成的类型应该是什么。你需要通过显式提供类型 T 来告诉它。因此，T 不应该是你的夹具的参数类型，而应该是工厂对象支持的中间类型，并且可以 static_cast 到夹具的参数类型

// The fixture's parameter type.
class MyParam {
 public:
  // Explicit converting ctor.
  explicit MyParam(const std::tuple<int, bool>& t);
  ...
};

INSTANTIATE_TEST_SUITE_P(MyInstantiation, MyTestSuite,
    ConvertGenerator<std::tuple<int, bool>>(Combine(Values(0.1, 1.2), Bool())));

在此示例中，Combine 支持 std::tuple<int, bool>> 对象的生成（即使第一个元组元素提供的值是 doubles），并且由于调用 ConvertGenerator，这些 tuples 被转换为 MyParam 对象。

对于无法从生成的类型转换的参数类型，你可以提供一个执行转换的可调用对象。该可调用对象接受生成的类型的对象，并返回夹具的参数类型的对象。生成的类型通常可以由编译器从可调用对象的调用签名中推断出来，因此通常不需要显式指定它（但请参阅下面的警告）。

// The fixture's parameter type.
class MyParam {
 public:
  MyParam(int, bool);
  ...
};

INSTANTIATE_TEST_SUITE_P(MyInstantiation, MyTestSuite,
    ConvertGenerator(Combine(Values(1, 1.2), Bool()),
        [](const std::tuple<int i, bool>& t){
          const auto [i, b] = t;
          return MyParam(i, b);
        }));

该可调用对象可以是任何可用于使用适当的调用签名初始化 std::function 的东西。请注意，可调用对象的返回对象被 static_cast 到夹具的参数类型，因此它不必是该确切类型，只需要可转换为该类型即可。

警告： 考虑以下示例。

INSTANTIATE_TEST_SUITE_P(MyInstantiation, MyTestSuite,
    ConvertGenerator(Values(std::string("s")), [](std::string_view s) { ... }));

string 参数被复制到 Values 返回的工厂对象中。然后，由于从 lambda 推断出的生成类型是 string_view，因此工厂对象会产生一个持有引用该 string 的 string_view 的生成器。不幸的是，当调用此生成器时，工厂对象已经消失，并且 string_view 悬空。

要克服此问题，你可以显式指定生成的类型： ConvertGenerator<std::string>(Values(std::string("s")), [](std::string_view s) { ... })。或者，你可以更改 lambda 的签名以采用 std::string 或 const std::string& （后者不会让你留下悬空引用，因为类型推导会去除引用和 const ）。

TYPED_TEST_SUITE

TYPED_TEST_SUITE(TestFixtureName,Types) TYPED_TEST_SUITE(TestFixtureName,Types,NameGenerator)

定义一个基于测试夹具TestFixtureName的类型化测试套件。测试套件名称为TestFixtureName。

参数TestFixtureName是一个夹具类模板，由类型参数化，例如

template <typename T>
class MyFixture : public testing::Test {
 public:
  ...
  using List = std::list<T>;
  static T shared_;
  T value_;
};

参数Types是一个Types对象，表示要运行测试的类型列表，例如

using MyTypes = ::testing::Types<char, int, unsigned int>;
TYPED_TEST_SUITE(MyFixture, MyTypes);

类型别名（using或typedef）对于TYPED_TEST_SUITE宏的正确解析是必要的。

可选的第三个参数NameGenerator允许指定一个类，该类公开一个模板化的静态函数GetName(int)。例如

class NameGenerator {
 public:
  template <typename T>
  static std::string GetName(int) {
    if constexpr (std::is_same_v<T, char>) return "char";
    if constexpr (std::is_same_v<T, int>) return "int";
    if constexpr (std::is_same_v<T, unsigned int>) return "unsignedInt";
  }
};
TYPED_TEST_SUITE(MyFixture, MyTypes, NameGenerator);

另请参阅TYPED_TEST和类型化测试以获取更多信息。

TYPED_TEST

TYPED_TEST(TestSuiteName, TestName) {
  ... statements ...
}

在类型化测试套件TestSuiteName中定义一个名为TestName的单独的类型化测试。必须使用TYPED_TEST_SUITE定义测试套件。

在测试主体中，特殊名称TypeParam指的是类型参数，而TestFixture指的是夹具类。请参见以下示例

TYPED_TEST(MyFixture, Example) {
  // Inside a test, refer to the special name TypeParam to get the type
  // parameter.  Since we are inside a derived class template, C++ requires
  // us to visit the members of MyFixture via 'this'.
  TypeParam n = this->value_;

  // To visit static members of the fixture, add the 'TestFixture::'
  // prefix.
  n += TestFixture::shared_;

  // To refer to typedefs in the fixture, add the 'typename TestFixture::'
  // prefix. The 'typename' is required to satisfy the compiler.
  typename TestFixture::List values;

  values.push_back(n);
  ...
}

有关更多信息，请参见类型化测试。

TYPED_TEST_SUITE_P

TYPED_TEST_SUITE_P(TestFixtureName)

定义一个基于测试夹具TestFixtureName的类型参数化测试套件。测试套件名称为TestFixtureName。

参数TestFixtureName是一个夹具类模板，由类型参数化。有关示例，请参见TYPED_TEST_SUITE。

另请参阅TYPED_TEST_P和类型参数化测试以获取更多信息。

TYPED_TEST_P

TYPED_TEST_P(TestSuiteName, TestName) {
  ... statements ...
}

在类型参数化测试套件TestSuiteName中定义一个名为TestName的单独的类型参数化测试。必须使用TYPED_TEST_SUITE_P定义测试套件。

在测试主体中，特殊名称TypeParam指的是类型参数，而TestFixture指的是夹具类。有关示例，请参见TYPED_TEST。

另请参阅REGISTER_TYPED_TEST_SUITE_P和类型参数化测试以获取更多信息。

REGISTER_TYPED_TEST_SUITE_P

REGISTER_TYPED_TEST_SUITE_P(TestSuiteName,TestNames...)

注册测试套件TestSuiteName的类型参数化测试TestNames...。必须使用TYPED_TEST_SUITE_P和TYPED_TEST_P定义测试套件和测试。

例如

// Define the test suite and tests.
TYPED_TEST_SUITE_P(MyFixture);
TYPED_TEST_P(MyFixture, HasPropertyA) { ... }
TYPED_TEST_P(MyFixture, HasPropertyB) { ... }

// Register the tests in the test suite.
REGISTER_TYPED_TEST_SUITE_P(MyFixture, HasPropertyA, HasPropertyB);

另请参阅INSTANTIATE_TYPED_TEST_SUITE_P和类型参数化测试以获取更多信息。

INSTANTIATE_TYPED_TEST_SUITE_P

INSTANTIATE_TYPED_TEST_SUITE_P(InstantiationName,TestSuiteName,Types)

实例化类型参数化测试套件TestSuiteName。必须使用REGISTER_TYPED_TEST_SUITE_P注册测试套件。

参数InstantiationName是测试套件实例化的唯一名称，用于区分多个实例化。在测试输出中，实例化名称作为前缀添加到测试套件名称TestSuiteName。如果InstantiationName为空（INSTANTIATE_TYPED_TEST_SUITE_P(, ...)），则不会添加前缀。

参数Types是一个Types对象，表示要运行测试的类型列表，例如

using MyTypes = ::testing::Types<char, int, unsigned int>;
INSTANTIATE_TYPED_TEST_SUITE_P(MyInstantiation, MyFixture, MyTypes);

类型别名（using或typedef）对于INSTANTIATE_TYPED_TEST_SUITE_P宏的正确解析是必要的。

有关更多信息，请参见类型参数化测试。

FRIEND_TEST

FRIEND_TEST(TestSuiteName,TestName)

在一个类的主体中，声明一个单独的测试作为该类的友元，使测试能够访问私有类成员。

如果该类是在命名空间中定义的，那么为了成为该类的友元，测试夹具和测试必须在完全相同的命名空间中定义，而不能使用内联或匿名命名空间。

例如，如果类的定义如下所示

namespace my_namespace {

class MyClass {
  friend class MyClassTest;
  FRIEND_TEST(MyClassTest, HasPropertyA);
  FRIEND_TEST(MyClassTest, HasPropertyB);
  ... definition of class MyClass ...
};

}  // namespace my_namespace

那么测试代码应如下所示

namespace my_namespace {

class MyClassTest : public testing::Test {
  ...
};

TEST_F(MyClassTest, HasPropertyA) { ... }
TEST_F(MyClassTest, HasPropertyB) { ... }

}  // namespace my_namespace

有关更多信息，请参见测试私有代码。

SCOPED_TRACE

SCOPED_TRACE(message)

使当前文件名、行号和给定的消息message被添加到作用域内发生的每个断言失败的失败消息中。

有关更多信息，请参见向断言添加跟踪。

另请参见ScopedTrace类。

GTEST_SKIP

GTEST_SKIP()

阻止在运行时进一步执行测试。

可以在单个测试用例中或测试环境或测试夹具（从Environment或Test类派生的类）的SetUp()方法中使用。如果在全局测试环境SetUp()方法中使用，它将跳过测试程序中的所有测试。如果在测试夹具SetUp()方法中使用，它将跳过相应测试套件中的所有测试。

与断言类似，GTEST_SKIP允许将自定义消息流式传输到其中。

有关更多信息，请参见跳过测试执行。

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(TestSuiteName)

允许值参数化测试套件TestSuiteName不被实例化。

默认情况下，每个没有相应INSTANTIATE_TEST_SUITE_P调用的TEST_P调用都会在测试套件GoogleTestVerification中导致测试失败。 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST抑制给定测试套件的此失败。

类和类型

GoogleTest定义了以下类和类型，以帮助编写测试。

AssertionResult

testing::AssertionResult

一个指示断言是否成功的类。

当断言不成功时，AssertionResult对象存储一个非空的失败消息，可以使用该对象的message()方法检索该消息。

要创建此类的实例，请使用工厂函数AssertionSuccess()或AssertionFailure()。

AssertionException

testing::AssertionException

可以从TestEventListener::OnTestPartResult抛出的异常。

EmptyTestEventListener

testing::EmptyTestEventListener

提供TestEventListener接口中所有方法的空实现，以便子类只需要覆盖它关心的那些方法。

Environment

testing::Environment

表示全局测试环境。参见全局设置和拆卸。

受保护的方法

SetUp

virtual void Environment::SetUp()

覆盖此方法以定义如何设置环境。

TearDown

virtual void Environment::TearDown()

覆盖此方法以定义如何拆卸环境。

ScopedTrace

testing::ScopedTrace

此类的实例会导致跟踪包含在ScopedTrace实例生命周期范围内代码生成的每个测试失败消息中。效果随着实例的销毁而撤消。

ScopedTrace构造函数具有以下形式

template <typename T>
ScopedTrace(const char* file, int line, const T& message)

用法示例

testing::ScopedTrace trace("file.cc", 123, "message");

生成的跟踪包括给定的源文件路径和行号以及给定的消息。 message参数可以是任何可以流式传输到std::ostream的内容。

另请参见SCOPED_TRACE。

Test

testing::Test

所有测试都从中继承的抽象类。 Test不可复制。

公共方法

SetUpTestSuite

static void Test::SetUpTestSuite()

执行测试套件中所有测试的共享设置。 GoogleTest在运行测试套件中的第一个测试之前调用SetUpTestSuite()。

TearDownTestSuite

static void Test::TearDownTestSuite()

执行测试套件中所有测试的共享拆卸。 GoogleTest在运行测试套件中的最后一个测试之后调用TearDownTestSuite()。

HasFatalFailure

static bool Test::HasFatalFailure()

当且仅当当前测试有致命失败时返回true。

HasNonfatalFailure

static bool Test::HasNonfatalFailure()

当且仅当当前测试有非致命失败时返回true。

HasFailure

static bool Test::HasFailure()

当且仅当当前测试有任何失败（致命或非致命）时返回true。

IsSkipped

static bool Test::IsSkipped()

当且仅当当前测试被跳过时返回 true。

RecordProperty

static void Test::RecordProperty(const std::string& key, const std::string& value)
static void Test::RecordProperty(const std::string& key, int value)

为当前测试、测试套件或整个测试程序的调用记录属性。仅记录给定键的最后一个值。

键必须是有效的 XML 属性名称，并且不能与 GoogleTest 已经使用的属性名称冲突（name、file、line、status、time、classname、type_param 和 value_param）。

RecordProperty 是 public static，因此可以从不是测试夹具成员的实用程序函数中调用它。

在测试的生命周期内（从其构造函数开始到其析构函数结束）对 RecordProperty 的调用在 XML 中输出为 <testcase> 元素的属性。从夹具的 SetUpTestSuite 或 TearDownTestSuite 方法记录的属性作为相应 <testsuite> 元素的属性记录。在全局上下文中（在调用 RUN_ALL_TESTS 之前或之后，或从已注册的 Environment 对象的 SetUp/TearDown 方法中）对 RecordProperty 的调用作为 <testsuites> 元素的属性输出。

受保护的方法

SetUp

virtual void Test::SetUp()

重写此方法以执行测试夹具设置。 GoogleTest 在运行每个单独的测试之前调用 SetUp()。

TearDown

virtual void Test::TearDown()

重写此方法以执行测试夹具拆卸。 GoogleTest 在运行每个单独的测试之后调用 TearDown()。

TestWithParam

testing::TestWithParam<T>

一个方便的类，它同时继承自 Test 和 WithParamInterface<T>。

TestSuite

表示一个测试套件。 TestSuite 不可复制。

公共方法

name

const char* TestSuite::name() const

获取测试套件的名称。

type_param

const char* TestSuite::type_param() const

返回参数类型的名称，如果这不是类型化或类型参数化的测试套件，则返回 NULL。参见类型化测试和类型参数化测试。

should_run

bool TestSuite::should_run() const

如果此测试套件中的任何测试应运行，则返回 true。

successful_test_count

int TestSuite::successful_test_count() const

获取此测试套件中成功的测试数。

skipped_test_count

int TestSuite::skipped_test_count() const

获取此测试套件中跳过的测试数。

failed_test_count

int TestSuite::failed_test_count() const

获取此测试套件中失败的测试数。

reportable_disabled_test_count

int TestSuite::reportable_disabled_test_count() const

获取将在 XML 报告中报告的已禁用测试的数量。

disabled_test_count

int TestSuite::disabled_test_count() const

获取此测试套件中已禁用的测试数。

reportable_test_count

int TestSuite::reportable_test_count() const

获取将在 XML 报告中打印的测试数。

test_to_run_count

int TestSuite::test_to_run_count() const

获取此测试套件中应运行的测试数。

total_test_count

int TestSuite::total_test_count() const

获取此测试套件中所有测试的数量。

Passed

bool TestSuite::Passed() const

当且仅当测试套件通过时返回 true。

Failed

bool TestSuite::Failed() const

当且仅当测试套件失败时返回 true。

elapsed_time

TimeInMillis TestSuite::elapsed_time() const

返回经过的时间，以毫秒为单位。

start_timestamp

TimeInMillis TestSuite::start_timestamp() const

获取测试套件的开始时间，从 UNIX 纪元开始的毫秒数。

GetTestInfo

const TestInfo* TestSuite::GetTestInfo(int i) const

返回所有测试中第 i 个测试的 TestInfo。i 的范围可以从 0 到 total_test_count() - 1。如果 i 不在该范围内，则返回 NULL。

ad_hoc_test_result

const TestResult& TestSuite::ad_hoc_test_result() const

返回 TestResult，其中包含在执行 SetUpTestSuite 和 TearDownTestSuite 期间记录的测试属性。

TestInfo

testing::TestInfo

存储有关测试的信息。

公共方法

test_suite_name

const char* TestInfo::test_suite_name() const

返回测试套件名称。

name

const char* TestInfo::name() const

返回测试名称。

type_param

const char* TestInfo::type_param() const

返回参数类型的名称，如果这不是类型化或类型参数化的测试，则返回 NULL。参见类型化测试和类型参数化测试。

value_param

const char* TestInfo::value_param() const

返回值参数的文本表示形式，如果这不是值参数化的测试，则返回 NULL。参见值参数化测试。

file

const char* TestInfo::file() const

返回定义此测试的文件名。

line

int TestInfo::line() const

返回定义此测试的行号。

is_in_another_shard

bool TestInfo::is_in_another_shard() const

如果此测试不应运行，因为它位于另一个分片中，则返回 true。

should_run

bool TestInfo::should_run() const

如果此测试应该运行，即如果测试未禁用（或者它已禁用但已指定 also_run_disabled_tests 标志）并且其全名与用户指定的过滤器匹配，则返回 true。

GoogleTest 允许用户按其全名过滤测试。只有与过滤器匹配的测试才会运行。有关更多信息，请参见运行测试的子集。

is_reportable

bool TestInfo::is_reportable() const

当且仅当此测试将出现在 XML 报告中时返回 true。

result

const TestResult* TestInfo::result() const

返回测试的结果。参见 TestResult。

TestParamInfo

testing::TestParamInfo<T>

描述值参数化测试的参数。类型 T 是参数的类型。

包含字段 param 和 index，分别保存参数的值及其整数索引。

UnitTest

testing::UnitTest

此类包含有关测试程序的信息。

UnitTest 是一个单例类。当首次调用 UnitTest::GetInstance() 时，将创建唯一的实例。此实例永远不会被删除。

UnitTest 不可复制。

公共方法

GetInstance

static UnitTest* UnitTest::GetInstance()

获取单例 UnitTest 对象。首次调用此方法时，将构造并返回一个 UnitTest 对象。连续调用将返回同一对象。

original_working_dir

const char* UnitTest::original_working_dir() const

返回第一次执行 TEST() 或 TEST_F() 时的当前工作目录。UnitTest 对象拥有该字符串。

current_test_suite

const TestSuite* UnitTest::current_test_suite() const

返回当前正在运行的测试的 TestSuite 对象，如果没有测试正在运行，则返回 NULL。

current_test_info

const TestInfo* UnitTest::current_test_info() const

返回当前正在运行的测试的 TestInfo 对象，如果没有测试正在运行，则返回 NULL。

random_seed

int UnitTest::random_seed() const

返回当前测试运行开始时使用的随机种子。

successful_test_suite_count

int UnitTest::successful_test_suite_count() const

获取成功的测试套件的数量。

failed_test_suite_count

int UnitTest::failed_test_suite_count() const

获取失败的测试套件的数量。

total_test_suite_count

int UnitTest::total_test_suite_count() const

获取所有测试套件的数量。

test_suite_to_run_count

int UnitTest::test_suite_to_run_count() const

获取包含至少一个应运行的测试的所有测试套件的数量。

successful_test_count

int UnitTest::successful_test_count() const

获取成功的测试的数量。

skipped_test_count

int UnitTest::skipped_test_count() const

获取跳过的测试的数量。

failed_test_count

int UnitTest::failed_test_count() const

获取失败的测试的数量。

reportable_disabled_test_count

int UnitTest::reportable_disabled_test_count() const

获取将在 XML 报告中报告的已禁用测试的数量。

disabled_test_count

int UnitTest::disabled_test_count() const

获取禁用的测试的数量。

reportable_test_count

int UnitTest::reportable_test_count() const

获取将在 XML 报告中打印的测试数。

total_test_count

int UnitTest::total_test_count() const

获取所有测试的数量。

test_to_run_count

int UnitTest::test_to_run_count() const

获取应该运行的测试的数量。

start_timestamp

TimeInMillis UnitTest::start_timestamp() const

获取测试程序开始的时间，从 UNIX 纪元开始的毫秒数。

elapsed_time

TimeInMillis UnitTest::elapsed_time() const

获取经过的时间，以毫秒为单位。

Passed

bool UnitTest::Passed() const

当且仅当单元测试通过时返回 true（即，所有测试套件都通过了）。

Failed

bool UnitTest::Failed() const

当且仅当单元测试失败时返回 true（即，某些测试套件失败或者所有测试之外的某些内容失败）。

GetTestSuite

const TestSuite* UnitTest::GetTestSuite(int i) const

获取所有测试套件中第 i 个测试套件的 TestSuite 对象。i 的范围可以从 0 到 total_test_suite_count() - 1。如果 i 不在该范围内，则返回 NULL。

ad_hoc_test_result

const TestResult& UnitTest::ad_hoc_test_result() const

返回 TestResult，其中包含在各个测试套件之外记录的有关测试失败和属性的信息。

listeners

TestEventListeners& UnitTest::listeners()

返回可用于跟踪 GoogleTest 内部事件的事件监听器列表。参见 TestEventListeners。

TestEventListener

testing::TestEventListener

用于跟踪测试执行的接口。下面的方法按照相应事件触发的顺序排列。

公共方法

OnTestProgramStart

virtual void TestEventListener::OnTestProgramStart(const UnitTest& unit_test)

在任何测试活动开始之前触发。

OnTestIterationStart

virtual void TestEventListener::OnTestIterationStart(const UnitTest& unit_test, int iteration)

在每次测试迭代开始之前触发。如果设置了 GTEST_FLAG(repeat)，则可能有多次迭代。 iteration 是迭代索引，从 0 开始。

OnEnvironmentsSetUpStart

virtual void TestEventListener::OnEnvironmentsSetUpStart(const UnitTest& unit_test)

在每次测试迭代的环境设置开始之前触发。

OnEnvironmentsSetUpEnd

virtual void TestEventListener::OnEnvironmentsSetUpEnd(const UnitTest& unit_test)

在每次测试迭代的环境设置结束后触发。

OnTestSuiteStart

virtual void TestEventListener::OnTestSuiteStart(const TestSuite& test_suite)

在测试套件开始之前触发。

OnTestStart

virtual void TestEventListener::OnTestStart(const TestInfo& test_info)

在测试开始之前触发。

OnTestPartResult

virtual void TestEventListener::OnTestPartResult(const TestPartResult& test_part_result)

在断言失败或调用 SUCCEED() 之后触发。如果您想从此函数抛出异常以跳到下一个测试，则它必须是 AssertionException 或继承自它。

OnTestEnd

virtual void TestEventListener::OnTestEnd(const TestInfo& test_info)

在测试结束后触发。

OnTestSuiteEnd

virtual void TestEventListener::OnTestSuiteEnd(const TestSuite& test_suite)

在测试套件结束后触发。

OnEnvironmentsTearDownStart

virtual void TestEventListener::OnEnvironmentsTearDownStart(const UnitTest& unit_test)

在每次测试迭代的环境拆卸开始之前触发。

OnEnvironmentsTearDownEnd

virtual void TestEventListener::OnEnvironmentsTearDownEnd(const UnitTest& unit_test)

在每次测试迭代的环境拆卸结束后触发。

OnTestIterationEnd

virtual void TestEventListener::OnTestIterationEnd(const UnitTest& unit_test, int iteration)

在每次测试迭代完成后触发。

OnTestProgramEnd

virtual void TestEventListener::OnTestProgramEnd(const UnitTest& unit_test)

在所有测试活动结束后触发。

TestEventListeners

testing::TestEventListeners

允许用户添加侦听器以跟踪 GoogleTest 中的事件。

公共方法

Append

void TestEventListeners::Append(TestEventListener* listener)

将事件侦听器追加到列表的末尾。 GoogleTest 承担侦听器的所有权（即，它将在测试程序完成后删除该侦听器）。

Release

TestEventListener* TestEventListeners::Release(TestEventListener* listener)

从列表中删除给定的事件侦听器并返回它。然后，删除侦听器成为调用者的责任。如果在列表中未找到侦听器，则返回 NULL。

default_result_printer

TestEventListener* TestEventListeners::default_result_printer() const

返回负责默认控制台输出的标准侦听器。可以从侦听器列表中删除以关闭默认控制台输出。请注意，使用 Release() 从侦听器列表中删除此对象会将所有权转移给调用方，并使此函数下次返回 NULL。

default_xml_generator

TestEventListener* TestEventListeners::default_xml_generator() const

返回负责由 --gtest_output=xml 标志控制的默认 XML 输出的标准侦听器。可以由想要关闭由此标志控制的默认 XML 输出并用自定义输出替换它的用户从侦听器列表中删除。请注意，使用 Release() 从侦听器列表中删除此对象会将所有权转移给调用方，并使此函数下次返回 NULL。

TestPartResult

testing::TestPartResult

一个可复制的对象，表示测试部分（即断言或显式 FAIL()、ADD_FAILURE() 或 SUCCESS()）的结果。

公共方法

type

Type TestPartResult::type() const

获取测试部分的结果。

返回类型 Type 是一个枚举，定义如下

enum Type {
  kSuccess,          // Succeeded.
  kNonFatalFailure,  // Failed but the test can continue.
  kFatalFailure,     // Failed and the test should be terminated.
  kSkip              // Skipped.
};

file_name

const char* TestPartResult::file_name() const

获取测试部分发生的源文件的名称，如果未知，则返回 NULL。

line_number

int TestPartResult::line_number() const

获取测试部分发生的源文件中的行号，如果未知，则返回 -1。

summary

const char* TestPartResult::summary() const

获取失败消息的摘要。

message

const char* TestPartResult::message() const

获取与测试部分关联的消息。

skipped

bool TestPartResult::skipped() const

当且仅当跳过测试部分时才返回 true。

passed

bool TestPartResult::passed() const

当且仅当测试部分通过时才返回 true。

nonfatally_failed

bool TestPartResult::nonfatally_failed() const

当且仅当测试部分非致命性失败时才返回 true。

fatally_failed

bool TestPartResult::fatally_failed() const

当且仅当测试部分致命性失败时才返回 true。

failed

bool TestPartResult::failed() const

当且仅当测试部分失败时才返回 true。

TestProperty

testing::TestProperty

一个可复制的对象，表示用户指定的测试属性，该属性可以作为键/值字符串对输出。

公共方法

key

const char* key() const

获取用户提供的键。

value

const char* value() const

获取用户提供的值。

SetValue

void SetValue(const std::string& new_value)

设置一个新值，覆盖之前的值。

TestResult

testing::TestResult

包含有关单个测试结果的信息。

TestResult 不可复制。

公共方法

total_part_count

int TestResult::total_part_count() const

获取所有测试部分的数量。这是成功测试部分的数量与失败测试部分的数量之和。

test_property_count

int TestResult::test_property_count() const

返回测试属性的数量。

Passed

bool TestResult::Passed() const

当且仅当测试通过时才返回 true（即，没有测试部分失败）。

Skipped

bool TestResult::Skipped() const

当且仅当跳过测试时才返回 true。

Failed

bool TestResult::Failed() const

当且仅当测试失败时才返回 true。

HasFatalFailure

bool TestResult::HasFatalFailure() const

当且仅当测试致命性失败时才返回 true。

HasNonfatalFailure

bool TestResult::HasNonfatalFailure() const

当且仅当测试具有非致命性失败时才返回 true。

elapsed_time

TimeInMillis TestResult::elapsed_time() const

返回经过的时间，以毫秒为单位。

start_timestamp

TimeInMillis TestResult::start_timestamp() const

获取测试用例开始的时间，以自 UNIX 纪元开始的毫秒数表示。

GetTestPartResult

const TestPartResult& TestResult::GetTestPartResult(int i) const

返回所有结果中第 i 个测试部分结果的 TestPartResult。i 的范围可以从 0 到 total_part_count() - 1。如果 i 不在该范围内，则中止程序。

GetTestProperty

const TestProperty& TestResult::GetTestProperty(int i) const

返回第 i 个测试属性的 TestProperty 对象。i 的范围可以从 0 到 test_property_count() - 1。如果 i 不在该范围内，则中止程序。

TimeInMillis

testing::TimeInMillis

一种表示毫秒时间的整数类型。

Types

testing::Types<T...>

表示类型列表，用于类型化测试和类型参数化测试。

模板参数 T... 可以是任意数量的类型，例如

testing::Types<char, int, unsigned int>

有关更多信息，请参见类型化测试和类型参数化测试。

WithParamInterface

testing::WithParamInterface<T>

所有值参数化测试都继承自的纯接口类。

值参数化测试 fixture 类必须同时继承自 Test 和 WithParamInterface。在大多数情况下，这仅意味着继承自 TestWithParam，但更复杂的测试层次结构可能需要在不同的级别继承自 Test 和 WithParamInterface。

此接口为参数类型 T 定义类型别名 ParamType，并支持通过 GetParam() 方法访问测试参数值

static const ParamType& GetParam()

有关更多信息，请参阅值参数化测试。

Functions

GoogleTest 定义了以下函数来帮助编写和运行测试。

InitGoogleTest

void testing::InitGoogleTest(int* argc, char** argv)
void testing::InitGoogleTest(int* argc, wchar_t** argv)
void testing::InitGoogleTest()

初始化 GoogleTest。必须在调用 RUN_ALL_TESTS() 之前调用此方法。特别是，它会解析命令行以查找 GoogleTest 识别的标志。只要看到 GoogleTest 标志，就会从 argv 中删除，并且 *argc 会递减。请记住，argv 必须以 NULL 指针终止（即 argv[argc] 为 NULL），这已经是传递给 main 的默认 argv 的情况。

不返回值。而是更新 GoogleTest 标志变量。

InitGoogleTest(int* argc, wchar_t** argv) 重载可以在以 UNICODE 模式编译的 Windows 程序中使用。

无参数的 InitGoogleTest() 重载可以在没有 argc/argv 的 Arduino/嵌入式平台上使用。

AddGlobalTestEnvironment

Environment* testing::AddGlobalTestEnvironment(Environment* env)

向测试程序添加一个测试环境。必须在调用 RUN_ALL_TESTS() 之前调用。有关更多信息，请参阅全局设置和拆卸。

另请参见 Environment。

RegisterTest

template <typename Factory>
TestInfo* testing::RegisterTest(const char* test_suite_name, const char* test_name,
                                  const char* type_param, const char* value_param,
                                  const char* file, int line, Factory factory)

使用框架动态注册测试。

factory 参数是一个工厂可调用对象（可移动构造）或函数指针，用于创建 Test 对象的新实例。它将所有权交给调用者。可调用对象的签名是 Fixture*()，其中 Fixture 是测试的测试夹具类。使用相同 test_suite_name 注册的所有测试必须返回相同的夹具类型。这会在运行时进行检查。

框架将从工厂推断夹具类，并将为其调用 SetUpTestSuite 和 TearDownTestSuite 方法。

必须在调用 RUN_ALL_TESTS() 之前调用，否则行为未定义。

有关更多信息，请参阅以编程方式注册测试。

RUN_ALL_TESTS

int RUN_ALL_TESTS()

在 main() 中使用此函数来运行所有测试。如果所有测试都成功，则返回 0，否则返回 1。

RUN_ALL_TESTS() 应该在命令行被 InitGoogleTest() 解析后调用。

此函数以前是一个宏；因此，它位于全局命名空间中，并具有全大写名称。

AssertionSuccess

AssertionResult testing::AssertionSuccess()

创建一个成功的断言结果。请参阅 AssertionResult。

AssertionFailure

AssertionResult testing::AssertionFailure()

创建一个失败的断言结果。使用 << 运算符来存储失败消息

testing::AssertionFailure() << "My failure message";

请参阅 AssertionResult。

StaticAssertTypeEq

testing::StaticAssertTypeEq<T1, T2>()

用于类型相等性的编译时断言。当且仅当 T1 和 T2 是同一类型时才编译。它返回的值是无关紧要的。

有关更多信息，请参阅类型断言。

PrintToString

std::string testing::PrintToString(x)

使用 GoogleTest 的值打印机打印任何值 x。

有关更多信息，请参阅教 GoogleTest 如何打印您的值。

PrintToStringParamName

std::string testing::PrintToStringParamName(TestParamInfo<T>& info)

一个内置的参数化测试名称生成器，它返回在 info.param 上调用 PrintToString 的结果。当测试参数是 std::string 或 C 字符串时不起作用。有关更多信息，请参阅为值参数化测试参数指定名称。

另请参见 TestParamInfo 和 INSTANTIATE_TEST_SUITE_P。

GoogleTest

测试参考

宏

TEST

TEST_F

TEST_P

INSTANTIATE_TEST_SUITE_P

使用 ConvertGenerator

TYPED_TEST_SUITE

TYPED_TEST

TYPED_TEST_SUITE_P

TYPED_TEST_P

REGISTER_TYPED_TEST_SUITE_P

INSTANTIATE_TYPED_TEST_SUITE_P

FRIEND_TEST

SCOPED_TRACE

GTEST_SKIP

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST

类和类型

AssertionResult

AssertionException

EmptyTestEventListener

Environment

受保护的方法

SetUp

TearDown

ScopedTrace

Test

公共方法

SetUpTestSuite

TearDownTestSuite

HasFatalFailure

HasNonfatalFailure

HasFailure

IsSkipped

RecordProperty

受保护的方法

SetUp

TearDown

TestWithParam

TestSuite

公共方法

name

type_param

should_run

successful_test_count

skipped_test_count

failed_test_count

reportable_disabled_test_count

disabled_test_count

reportable_test_count

test_to_run_count

total_test_count

Passed

Failed

elapsed_time

start_timestamp

GetTestInfo

ad_hoc_test_result

TestInfo

公共方法

test_suite_name

name

type_param

value_param

file

line

is_in_another_shard

should_run

is_reportable

result

TestParamInfo

UnitTest

公共方法

GetInstance

original_working_dir

current_test_suite

current_test_info

random_seed

successful_test_suite_count

使用 `ConvertGenerator`