我如何检查一次测试中有多少个``期望_*`呼叫失败

Question

我有一个集成测试，类似于：

TEST(foo, test_many_foos) {
   foo_builder sut;
   sut.set_some_params();
   sut.run();
   for (const auto foo : sut) {
      EXPECT_TRUE(some_check(foo));
   }

   // TODO: Print a summary of how many EXPECT_TRUEs failed
}

有没有一种方法可以打印出测试结束时所有EXPECT调用结果的摘要？

Answer 1

您可以使用自定义事件侦听器来增强Google测试。您可以定义自己的侦听器类，并让其跟踪EXPECT_*()调用每个测试失败的次数：

class ExpectListener : public ::testing::EmptyTestEventListener {
    int nFailures;
    // Called before a test starts.
    virtual void OnTestStart(const ::testing::TestInfo& test_info) {
        nFailures = 0;
        printf("*** Test %s.%s starting.n",
               test_info.test_case_name(),
               test_info.name());
    }
    // Called after a failed assertion or a SUCCEED() invocation.
    virtual void OnTestPartResult(const ::testing::TestPartResult& test_part_result) {
        if (test_part_result.nonfatally_failed()) {nFailures++;}
        printf("%s in %s:%dn%sn",
               test_part_result.failed() ? "*** Failure" : "Success",
               test_part_result.file_name(),
               test_part_result.line_number(),
               test_part_result.summary());
    }
    // Called after a test ends.
    virtual void OnTestEnd(const ::testing::TestInfo& test_info) {
        printf("*** Test %s.%s ending with %d failures.n",
               test_info.test_case_name(),
               test_info.name(),
               nFailures);
    }
};

现在只需用此自定义侦听器替换Google Test的默认侦听器：

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    ::testing::TestEventListeners& listeners = ::testing::UnitTest::GetInstance()->listeners();
    delete listeners.Release(listeners.default_result_printer());
    listeners.Append(new ExpectListener);
    return RUN_ALL_TESTS();
}

您只需要设置一次（在main()中）;然后，所有测试将跟踪他们经历的非致命失败的数量。当然，如果您想调整测试消息或跟踪更多信息，则可以进一步自定义此听众。

Answer 2

我想到的解决方案（我不完全满意）是要执行以下操作：

class stream_counter
{
public:
    explicit stream_counter(int *val) : val_(val) {}
    void                         increment_count() const { ++*val_; }
private:
    int *val_;
};
std::ostream &operator<<(std::ostream &os, const stream_counter &sc)
{
    sc.increment_count();
    return os;
}
TEST(foo, test_many_foos) {
   foo_builder sut;
   sut.set_some_params();
   sut.run();
   int n_failures = 0;
   for (const auto foo : sut) {
      EXPECT_TRUE(some_check(foo)) << stream_counter{&n_failures};
   }
   if(n_failures > 0) {
      std::cout << "There were " << n_failures << " failures" << std::endl;
   }
}

这将滥用operator <<行为IOF EXPECT_*，如果支票失败，则允许在错误流中打印消息。stream_counter只需包装一个整数并将其递增，如果将对象流到std::ostream

不是最干净的解决方案，而是我想要的。

Answer 3

TEST(foo, test_many_foos) {
   foo_builder sut;
   sut.set_some_params();
   sut.run();
   auto n_failures = 0;
   for (const auto foo : sut) {
      auto const result = some_check(foo);
      EXPECT_TRUE(result);
      if (!result) ++n_failures;
   }
   if(n_failures > 0) {
      std::cout << "There were " << n_failures << " failures" << std::endl;
   }
}

但是，这意味着Expect_true（）将打印有关"结果"的内容，而不是" some_check（foo）"。