为什么需要catch
在catch的文档指出，对于C++单元测试框架，目前已经有 Google Test, Boost.Test, CppUnit, Cute, 以及其它的一些，那么catch有什么优势呢，文档主要列举了以下这些优势：
-简单易用：只需要下载catch.hpp,包含到你的工程就可以了。
不依赖外部库：只要你可以编译C++11，有C++的标准库就可以了
-测试case可以分割为sections: 每个setcion都是独立的运行单元
-提供了BDD式的测试模式：可以使用Given-When-Then section来做BDD测试
-只用一个核心的assertion宏来做比较。用标准的C++运算符来做比较，但是可以分解表达式，记录表达式等号左侧和右侧的值
-可以用任何形式的字符串给测试命名，不用担名字是否合法。
其它一些关键特性有：
可以给test case打tag, 因而可以很容易的只跑某个tag组的test cases
输出通过reporter对象完成，支持基本的文本和XML格式输出测试结果，也支持自定义reporter
支持JUnit xml输出，这样可以和第三方工具整合，如CI服务器等
提供默认的main()函数，用户也可以使用自己的main()函数
提供一个命令行解析工具，用户在使用自己的main()函数的时候可以添加命令行参数
catch软件可以做自测试
提供可选的assertion宏，可以报告错误但不终止test case
通过内置的Approx()语法支持可控制精度的浮点数比较
通过Matchers支持各种形式的比较，也支持自定义的比较方法
目前，有这些开源库均使用catch作为测试框架。下面分别介绍catch的一些关键特性：
简单易用
Catch是一个header-only的开源库，这意味着你只需要把一个头文件放到系统或者你的工程的某个目录，编译的时候指向它就可以了。
下面用一个中的小例子说明如何使用Catch，假设你写了一个求阶乘的函数：
int Factorial( int number ) {
return number <= 1 ? number : Factorial( number - 1 ) * number;
}
为了简单起见，将被测函数和要测试代码放在一个文件中，你只需要在这个函数之前加入两行：
#define CATCH_CONFIG_MAIN
#include
第一行的作用是由catch提供一个main函数，第二行的作用是包含测试所需要的头文件，假设最后的文件为catchTest.cpp，假设相关的文件安装到了/usr/local/include下，下面这样编译就可以了：
g++ -std=c++11 -o catchTest catchTest.cpp -I/usr/local/include/
运行一下，结果为：
[qsun @T440p examples]$./catchTest
===============================================================================
No tests ran
那么如何加入一个test case呢，很简单：
TEST_CASE() {
REQUIRE(Factorial(2) == 2);
}
当然你也可以为你的TEST_CASE起名字，或者加标签：
TEST_CASE(”Test with number big than 0", "[tag1]") {
REQUIRE(Factorial(2) == 2);
}
”Test with number big than 0"是test case的名字，全局必须唯一, "tag1"是标签名，需要放在[]内部，一个test case可以有多个标签，多个test case可以使用相同的标签。REQUIRE是一个assert宏，用来判断是否相等。
命令行选项
以上面的这个简单程序为例，可以通过下面-？来查询命令行选项参数：
> [qsun @T440p examples]$./catchTest -?
Catch v2.6.1
usage:
catchTest [ ... ] options
where options are:
-?, -h, --help display usage information
-l, --list-tests list all/matching test cases
-t, --list-tags list all/matching tags
-s, --success include successful tests in
output
-b, --break break into debugger on failure
-e, --nothrow skip exception tests
-i, --invisibles show invisibles (tabs, newlines)
-o, --out output filename
-r, --reporter reporter to use (defaults to
console)
-n, --name suite name
-a, --abort abort at first failure
-x, --abortx abort after x failures
-w, --warn enable warnings
-d, --durations show test durations
-f, --input-file load test names to run from a
file
-#, --filenames-as-tags adds a tag for the filename
-c, --section specify section to run
-v, --verbosity set output verbosity
--list-test-names-only list all/matching test cases
names only
--list-reporters list all reporters
--order test case order (defaults to
decl)
--rng-seed <'time'|number> set a specific seed for random
numbers
--use-colour should output be colourised
--libidentify report name and version according
to libidentify standard
--wait-for-keypress waits for a keypress before
exiting
--benchmark-resolution-multiple multiple of clock resolution to
run benchmarks
For more detailed usage please see the project docs
一些比较常见的命令行选项的使用如下：
显示test case总体情况：
[qsun @T440p examples]$./catchTest -l
All available test cases:
Test with number big than 0
[tag1]
1 test case
示所有的标签（tags）:
[qsun @T440p examples]$./catchTest -t
All available tags:
1 [tag1]
1 tag
运行某个tag下的所有test cases:
[qsun @T440p examples]$./catchTest [tag1]
===============================================================================
All tests passed (1 assertion in 1 test case)
运行某个名字的test case:
[qsun @T440p examples]$./catchTest "Test with number big than 0"
===============================================================================
All tests passed (1 assertion in 1 test case)
Sections
一般的测试框架都采用基于类的test fixture, 通常需要定义setup()和teardown()函数（或者在构造/析构函数中做类似的事情）。catch不仅全面支持test fixture模式，还提供了一种section机制：每个section都是独立运行单元，比如下面：
TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
std::vector v( 5 );
REQUIRE( v.size() == 5 );
REQUIRE( v.capacity() >= 5 );
SECTION( "resizing bigger changes size and capacity" ) {
v.resize( 10 );
REQUIRE( v.size() == 10 );
REQUIRE( v.capacity() >= 10 );
}
SECTION( "resizing smaller changes size but not capacity" ) {
v.resize( 0 );
REQUIRE( v.size() == 0 );
REQUIRE( v.capacity() >= 5 );
}
SECTION( "reserving bigger changes capacity but not size" ) {
v.reserve( 10 );
REQUIRE( v.size() == 5 );
REQUIRE( v.capacity() >= 10 );
}
SECTION( "reserving smaller does not change size or capacity" ) {
v.reserve( 0 );
REQUIRE( v.size() == 5 );
REQUIRE( v.capacity() >= 5 );
}
}
对于每个section来说，它都从test case的最开始运行，也就是说它们共享前半部分的代码，这样，在进入section之前，我们知道v的size为5，capacity大于5。根据section的实现，这些section不是并发执行的，而是每次执行一个section。
BDD-style
将test case和section重命名就可以得到一种BDD模式的测试，TDD（测试驱动开发）和BDD（行为驱动开发）是两种比较流行的开发模式。下面是一个例子：
SCENARIO( "vectors can be sized and resized", "[vector]" ) {
GIVEN( "A vector with some items" ) {
std::vector v( 5 );
REQUIRE( v.size() == 5 );
REQUIRE( v.capacity() >= 5 );
WHEN( "the size is increased" ) {
v.resize( 10 );
THEN( "the size and capacity change" ) {
REQUIRE( v.size() == 10 );
REQUIRE( v.capacity() >= 10 );
}
}
WHEN( "the size is reduced" ) {
v.resize( 0 );
THEN( "the size changes but not capacity" ) {
REQUIRE( v.size() == 0 );
REQUIRE( v.capacity() >= 5 );
}
}
WHEN( "more capacity is reserved" ) {
v.reserve( 10 );
THEN( "the capacity changes but not the size" ) {
REQUIRE( v.size() == 5 );
REQUIRE( v.capacity() >= 10 );
}
}
WHEN( "less capacity is reserved" ) {
v.reserve( 0 );
THEN( "neither size nor capacity are changed" ) {
REQUIRE( v.size() == 5 );
REQUIRE( v.capacity() >= 5 );
}
}
}
}
下面是编译和输出结果：
[qsun @T440p examples]$g++ -o 120-Bdd-ScenarioGivenWhenThen 120-Bdd-ScenarioGivenWhenThen.cpp 000-CatchMain.o
[qsun @T440p examples]$./120-Bdd-ScenarioGivenWhenThen --reporter compact --success
120-Bdd-ScenarioGivenWhenThen.cpp:12: passed: v.size() == 5 for: 5 == 5
120-Bdd-ScenarioGivenWhenThen.cpp:13: passed: v.capacity() >= 5 for: 5 >= 5
120-Bdd-ScenarioGivenWhenThen.cpp:19: passed: v.size() == 10 for: 10 == 10
120-Bdd-ScenarioGivenWhenThen.cpp:20: passed: v.capacity() >= 10 for: 10 >= 10
120-Bdd-ScenarioGivenWhenThen.cpp:12: passed: v.size() == 5 for: 5 == 5
120-Bdd-ScenarioGivenWhenThen.cpp:13: passed: v.capacity() >= 5 for: 5 >= 5
120-Bdd-ScenarioGivenWhenThen.cpp:27: passed: v.size() == 0 for: 0 == 0
120-Bdd-ScenarioGivenWhenThen.cpp:28: passed: v.capacity() >= 5 for: 5 >= 5
120-Bdd-ScenarioGivenWhenThen.cpp:12: passed: v.size() == 5 for: 5 == 5
120-Bdd-ScenarioGivenWhenThen.cpp:13: passed: v.capacity() >= 5 for: 5 >= 5
120-Bdd-ScenarioGivenWhenThen.cpp:35: passed: v.size() == 5 for: 5 == 5
120-Bdd-ScenarioGivenWhenThen.cpp:36: passed: v.capacity() >= 10 for: 10 >= 10
120-Bdd-ScenarioGivenWhenThen.cpp:12: passed: v.size() == 5 for: 5 == 5
120-Bdd-ScenarioGivenWhenThen.cpp:13: passed: v.capacity() >= 5 for: 5 >= 5
120-Bdd-ScenarioGivenWhenThen.cpp:43: passed: v.size() == 5 for: 5 == 5
120-Bdd-ScenarioGivenWhenThen.cpp:44: passed: v.capacity() >= 5 for: 5 >= 5
Passed 1 test case with 16 assertions.
也可以使用下面的两个宏来使用链式的WHEN和THEN
AND_WHEN( something )
AND_THEN( something )
作者的selftest中有相关的代码，如下：
/*
* Created by Phil on 29/11/2010.
* Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#include "catch2/catch.hpp"
namespace { namespace BDDTests {
#ifndef BDD_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
#define BDD_TEST_HELPERS_INCLUDED
inline bool itDoesThis() { return true; }
inline bool itDoesThat() { return true; }
namespace {
// a trivial fixture example to support SCENARIO_METHOD tests
struct Fixture {
Fixture()
: d_counter(0) {
}
int counter() {
return d_counter++;
}
int d_counter;
};
}
#endif
SCENARIO("Do that thing with the thing", "[Tags]") {
GIVEN("This stuff exists") {
// make stuff exist
AND_GIVEN("And some assumption") {
// Validate assumption
WHEN("I do this") {
// do this
THEN("it should do this") {
REQUIRE(itDoesThis());
AND_THEN("do that")REQUIRE(itDoesThat());
}
}
}
}
}
SCENARIO("Vector resizing affects size and capacity", "[vector][bdd][size][capacity]") {
GIVEN("an empty vector") {
std::vector v;
REQUIRE(v.size() == 0);
WHEN("it is made larger") {
v.resize(10);
THEN("the size and capacity go up") {
REQUIRE(v.size() == 10);
REQUIRE(v.capacity() >= 10);
AND_WHEN("it is made smaller again") {
v.resize(5);
THEN("the size goes down but the capacity stays the same") {
REQUIRE(v.size() == 5);
REQUIRE(v.capacity() >= 10);
}
}
}
}
WHEN("we reserve more space") {
v.reserve(10);
THEN("The capacity is increased but the size remains the same") {
REQUIRE(v.capacity() >= 10);
REQUIRE(v.size() == 0);
}
}
}
}
SCENARIO("This is a really long scenario name to see how the list command deals with wrapping",
"[very long tags][lots][long][tags][verbose]"
"[one very long tag name that should cause line wrapping writing out using the list command]"
"[anotherReallyLongTagNameButThisOneHasNoObviousWrapPointsSoShouldSplitWithinAWordUsingADashCharacter]") {
GIVEN("A section name that is so long that it cannot fit in a single console width")WHEN(
"The test headers are printed as part of the normal running of the scenario")THEN(
"The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent")SUCCEED(
"boo!");
}
SCENARIO_METHOD(Fixture,
"BDD tests requiring Fixtures to provide commonly-accessed data or methods",
"[bdd][fixtures]") {
const int before(counter());
GIVEN("No operations precede me") {
REQUIRE(before == 0);
WHEN("We get the count") {
const int after(counter());
THEN("Subsequently values are higher") {
REQUIRE(after > before);
}
}
}
}
}} // namespace BDDtests
从源码可以知道，上面的这些GIVEN, WHEN, THEN等最后其实都展开为SECTION宏:
// "BDD-style" convenience wrappers
#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
#define GIVEN( desc ) SECTION( std::string(" Given: ") + desc )
#define WHEN( desc ) SECTION( std::string(" When: ") + desc )
#define AND_WHEN( desc ) SECTION( std::string("And when: ") + desc )
#define THEN( desc ) SECTION( std::string(" Then: ") + desc )
#define AND_THEN( desc ) SECTION( std::string(" And: ") + desc )
Assertion Macros
上面其实已经提到了一些assertion宏，像REQUIRE等，这里全面的介绍下。
常用的有REQUIRE系列和CHECK系列：
REQUIRE( expression )
CHECK( expression )
REQUIRE宏在expression为false时将会终止当前test case, CHECK在expression为false时会给出警告信息但当前test case继续往下执行。
对应的还有：
REQUIRE_FALSE( expression )
CHECK_FALSE( expression )
REQUIRE_FALSE宏在expression为true时将会终止当前test case, CHECK_FALSE在expression为true时会给出警告信息但当前test case继续往下执行。
这里有一点要指出的是，对于：
CHECK(a == 1 && b == 2)
CHECK( a == 2 || b == 1 )
这样的语句，由于宏展开的原因，catch不能通过编译，需要在表达式的两端加上括号：
CHECK((a == 1 && b == 2))
CHECK((a == 2 || b == 1 ))
我们在最初求阶乘的例子上进行测试，代码如下：
TEST_CASE("Test with number big than 0", "[tag1]")
{
REQUIRE(Factorial(2) == 2);
// REQUIRE((Factorial(3) == 6) && (Factorial(4) == 24)); cannot compile
CHECK(Factorial(0) == 1);
REQUIRE((Factorial(3) == 6 && Factorial(4) == 24));
}
输出为：
[qsun @T440p examples]$./catchTest -r compact --success
catchTest.cpp:9: passed: Factorial(2) == 2 for: 2 == 2
catchTest.cpp:11: failed: Factorial(0) == 1 for: 0 == 1
catchTest.cpp:12: passed: (Factorial(3) == 6 && Factorial(4) == 24) for: true
Failed 1 test case, failed 1 assertion.
注意到，这里Factorial(0) == 1使用的是CHECK，由于0！= 1，故该测试失败，但因为我们用的是CHECK，故这里只是给出了警告信息，没有终止test case。
Floating point comparisons
catch2支持比较全面的浮点数比较，可能是作者在银行工作，这个测试框架也是针对作者写的银行业务的代码，这些代码对数值比较的要求较多。
具体的说catch2浮点数比较采用类Approx, Approx采用数值初始化，同时支持以下三种属性：
epsilon：相当于误差相对于原值的百分比值，比如epsilon=0.01,则意味着与其比较的值在该Approx值的%1的范围均视为相等。默认值为 std::numeric_limits::epsilon()*100
Approx target = Approx(100).epsilon(0.01);
100.0 == target; // Obviously true
200.0 == target; // Obviously still false
100.5 == target; // True, because we set target to allow up to 1% difference
margin: epsilon是一个相对的百分比值，margin是一个绝对值，其默认值为0。比如：
Approx target = Approx(100).margin(5);
100.0 == target; // Obviously true
200.0 == target; // Obviously still false
104.0 == target; // True, because we set target to allow absolute difference of at most 5
scale: 有时比较的两边采用不同的量级，采用scale后，Approx允许的误差为：（Approx::scale + Approx::value）* epsilon， 其默认值为0. 比如：
Approx target = Approx(100).scale(100).epsilon(0.01);
100.0 == target; // true
101.5 == target; // true
200.0 == target; // false
100.5 == target; // True, because we set target to allow up to 1% difference, and final target value is 100
Approx target1 = Approx(100).scale(100).margin(5);
100.0 == target1; // true
200.0 == target1; // false
104.0 == target1; // True, because we set target to allow absolute difference of at most 5
Exceptions
下面两个宏用来测试expression中没有异常抛出，满足条件则assertion为true
REQUIRE_NOTHROW( expression )
CHECK_NOTHROW( expression )
下面两个宏用来测试expression中有异常抛出，满足条件则assertion为true
REQUIRE_THROWS( expression )
CHECK_THROWS( expression )
下面两个宏用来测试expression中有某种类型的异常抛出，满足条件则assertion为true
REQUIRE_THROWS_AS( expression, exception type )
CHECK_THROWS_AS( expression, exception type )
下面两个宏用来测试expression中有异常名包含某个string的异常或符合某种string matcher的异常抛出，满足条件则assertion为true
REQUIRE_THROWS_WITH( expression, string or string matcher )
CHECK_THROWS_WITH( expression, string or string matcher )
例如：
REQUIRE_THROWS_WITH( openThePodBayDoors(), Contains( "afraid" ) && Contains( "can't do that" ) );
REQUIRE_THROWS_WITH( dismantleHal(), "My mind is going" );
下面两个宏用来测试expression中有某种类型且符合某种string matcher的异常抛出，满足条件则assertion为true
REQUIRE_THROWS_MATCHES( expression, exception type, matcher for given exception type )
CHECK_THROWS_MATCHES( expression, exception type, matcher for given exception type )
Matchers
Matchers顾名思义就是某个string或int或其它类型是否和Matcher所定义的条件match。
String matchers
内置的string matchers有StartsWith, EndsWith, Contains, Equals 和 Matches，前四个是常见的string或substring的比较：
例如，验证某个string是否以某个string结束：
using Catch::Matchers::EndsWith; // or Catch::EndsWith
std::string str = getStringFromSomewhere();
REQUIRE_THAT( str, EndsWith( "as a service" ) )
EndsWith也支持是否大小写采用大小写匹配：
REQUIRE_THAT( str, EndsWith( "as a service", Catch::CaseSensitive::No ) );
也支持多个Match串联：
REQUIRE_THAT( str,
EndsWith( "as a service" ) ||
(StartsWith( "Big data" ) && !Contains( "web scale" ) ) );
最后一个Matches是matchECMAScript类型的正则表达式，例如：
using Catch::Matchers::Matches;
REQUIRE_THAT(std::string("this string contains 'abc' as a substring"),
Matches("this string CONTAINS 'abc' as a substring", Catch::CaseSensitive::No));
Vector matchers
vector类型的match有Contains, VectorContains 和Equals. VectorContains判断某个vector内部是否有某个元素，Contains判断某个vector是否包含另外一个vector。
下面是来自selftest的一个例子：
TEST_CASE("Vector matchers", "[matchers][vector]") {
using Catch::Matchers::VectorContains;
using Catch::Matchers::Contains;
using Catch::Matchers::UnorderedEquals;
using Catch::Matchers::Equals;
std::vector v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
std::vector v2;
v2.push_back(1);
v2.push_back(2);
std::vector empty;
SECTION("Contains (element)") {
CHECK_THAT(v, VectorContains(1));
CHECK_THAT(v, VectorContains(2));
}
SECTION("Contains (vector)") {
CHECK_THAT(v, Contains(v2));
v2.push_back(3); // now exactly matches
CHECK_THAT(v, Contains(v2));
CHECK_THAT(v, Contains(empty));
CHECK_THAT(empty, Contains(empty));
}
SECTION("Contains (element), composed") {
CHECK_THAT(v, VectorContains(1) && VectorContains(2));
}
SECTION("Equals") {
// Same vector
CHECK_THAT(v, Equals(v));
CHECK_THAT(empty, Equals(empty));
// Different vector with same elements
v2.push_back(3);
CHECK_THAT(v, Equals(v2));
}
SECTION("UnorderedEquals") {
CHECK_THAT(v, UnorderedEquals(v));
CHECK_THAT(empty, UnorderedEquals(empty));
auto permuted = v;
std::next_permutation(begin(permuted), end(permuted));
REQUIRE_THAT(permuted, UnorderedEquals(v));
std::reverse(begin(permuted), end(permuted));
REQUIRE_THAT(permuted, UnorderedEquals(v));
}
}
程序运行结果为：
[qsun @T440p examples]$./catchTest [vector] --success -r compact
catchTest.cpp:51: passed: v, VectorContains(1) for: { 1, 2, 3 } Contains: 1
catchTest.cpp:52: passed: v, VectorContains(2) for: { 1, 2, 3 } Contains: 2
catchTest.cpp:55: passed: v, Contains(v2) for: { 1, 2, 3 } Contains: { 1, 2 }
catchTest.cpp:57: passed: v, Contains(v2) for: { 1, 2, 3 } Contains: { 1, 2, 3 }
catchTest.cpp:59: passed: v, Contains(empty) for: { 1, 2, 3 } Contains: { }
catchTest.cpp:60: passed: empty, Contains(empty) for: { } Contains: { }
catchTest.cpp:63: passed: v, VectorContains(1) && VectorContains(2) for: { 1, 2, 3 } ( Contains: 1 and Contains: 2 )
catchTest.cpp:69: passed: v, Equals(v) for: { 1, 2, 3 } Equals: { 1, 2, 3 }
catchTest.cpp:71: passed: empty, Equals(empty) for: { } Equals: { }
catchTest.cpp:75: passed: v, Equals(v2) for: { 1, 2, 3 } Equals: { 1, 2, 3 }
catchTest.cpp:78: passed: v, UnorderedEquals(v) for: { 1, 2, 3 } UnorderedEquals: { 1, 2, 3 }
catchTest.cpp:79: passed: empty, UnorderedEquals(empty) for: { } UnorderedEquals: { }
catchTest.cpp:83: passed: permuted, UnorderedEquals(v) for: { 1, 3, 2 } UnorderedEquals: { 1, 2, 3 }
catchTest.cpp:86: passed: permuted, UnorderedEquals(v) for: { 2, 3, 1 } UnorderedEquals: { 1, 2, 3 }
Floating point matchers
浮点数类型的matchers有两种: WithinULP 和 WithinAbs，WithinAbs比较两个浮点数是差的绝对值是否小于某个值；WithinULP做ULP类型的检查。
下面是一个例子：
TEST_CASE("Floating point matchers: float", "[matchers][ULP]") {
using Catch::Matchers::WithinAbs;
using Catch::Matchers::WithinULP;
SECTION("Margin") {
REQUIRE_THAT(1.f, WithinAbs(1.f, 0));
REQUIRE_THAT(0.f, WithinAbs(1.f, 1));
REQUIRE_THAT(0.f, !WithinAbs(1.f, 0.99f));
REQUIRE_THAT(0.f, !WithinAbs(1.f, 0.99f));
REQUIRE_THAT(0.f, WithinAbs(-0.f, 0));
REQUIRE_THAT(NAN, !WithinAbs(NAN, 0));
REQUIRE_THAT(11.f, !WithinAbs(10.f, 0.5f));
REQUIRE_THAT(10.f, !WithinAbs(11.f, 0.5f));
REQUIRE_THAT(-10.f, WithinAbs(-10.f, 0.5f));
REQUIRE_THAT(-10.f, WithinAbs(-9.6f, 0.5f));
}
SECTION("ULPs") {
REQUIRE_THAT(1.f, WithinULP(1.f, 0));
REQUIRE_THAT(1.1f, !WithinULP(1.f, 0));
REQUIRE_THAT(1.f, WithinULP(1.f, 0));
REQUIRE_THAT(-0.f, WithinULP(0.f, 0));
REQUIRE_THAT(NAN, !WithinULP(NAN, 123));
}
SECTION("Composed") {
REQUIRE_THAT(1.f, WithinAbs(1.f, 0.5) || WithinULP(1.f, 1));
REQUIRE_THAT(1.f, WithinAbs(2.f, 0.5) || WithinULP(1.f, 0));
REQUIRE_THAT(NAN, !(WithinAbs(NAN, 100) || WithinULP(NAN, 123)));
}
}
运行结果为：
[qsun @T440p examples]$./catchTest [ULP] --success -r compact
catchTest.cpp:95: passed: 1.f, WithinAbs(1.f, 0) for: 1.0f is within 0.0 of 1.0
catchTest.cpp:96: passed: 0.f, WithinAbs(1.f, 1) for: 0.0f is within 1.0 of 1.0
catchTest.cpp:98: passed: 0.f, !WithinAbs(1.f, 0.99f) for: 0.0f not is within 0.9900000095 of 1.0
catchTest.cpp:99: passed: 0.f, !WithinAbs(1.f, 0.99f) for: 0.0f not is within 0.9900000095 of 1.0
catchTest.cpp:101: passed: 0.f, WithinAbs(-0.f, 0) for: 0.0f is within 0.0 of -0.0
catchTest.cpp:102: passed: (__builtin_nanf ("")), !WithinAbs((__builtin_nanf ("")), 0) for: nanf not is within 0.0 of nan
catchTest.cpp:104: passed: 11.f, !WithinAbs(10.f, 0.5f) for: 11.0f not is within 0.5 of 10.0
catchTest.cpp:105: passed: 10.f, !WithinAbs(11.f, 0.5f) for: 10.0f not is within 0.5 of 11.0
catchTest.cpp:106: passed: -10.f, WithinAbs(-10.f, 0.5f) for: -10.0f is within 0.5 of -10.0
catchTest.cpp:107: passed: -10.f, WithinAbs(-9.6f, 0.5f) for: -10.0f is within 0.5 of -9.6000003815
catchTest.cpp:110: passed: 1.f, WithinULP(1.f, 0) for: 1.0f is within 0 ULPs of 1.0f
catchTest.cpp:111: passed: 1.1f, !WithinULP(1.f, 0) for: 1.1f not is within 0 ULPs of 1.0f
catchTest.cpp:114: passed: 1.f, WithinULP(1.f, 0) for: 1.0f is within 0 ULPs of 1.0f
catchTest.cpp:115: passed: -0.f, WithinULP(0.f, 0) for: -0.0f is within 0 ULPs of 0.0f
catchTest.cpp:117: passed: (__builtin_nanf ("")), !WithinULP((__builtin_nanf ("")), 123) for: nanf not is within 123 ULPs of nanf
catchTest.cpp:120: passed: 1.f, WithinAbs(1.f, 0.5) || WithinULP(1.f, 1) for: 1.0f ( is within 0.5 of 1.0 or is within 1 ULPs of 1.0f )
catchTest.cpp:121: passed: 1.f, WithinAbs(2.f, 0.5) || WithinULP(1.f, 0) for: 1.0f ( is within 0.5 of 2.0 or is within 0 ULPs of 1.0f )
catchTest.cpp:123: passed: (__builtin_nanf ("")), !(WithinAbs((__builtin_nanf ("")), 100) || WithinULP((__builtin_nanf ("")), 123)) for: nanf not ( is within 100.0 of nan or is within 123 ULPs of nanf )
Passed 1 test case with 18 assertions.
Custom matchers
通过继承MatchBase, 可以自定义用户的matcher, Catch::MatcherBase这里的T是用户想要做match的数据类型。同时还需要重写match和describe两个函数。
如下，是一个判断某个数是否在某个范围类的自定义matcher:
// The matcher class
class IntRange : public Catch::MatcherBase {
int m_begin, m_end;
public:
IntRange( int begin, int end ) : m_begin( begin ), m_end( end ) {}
// Performs the test for this matcher
virtual bool match( int const& i ) const override {
return i >= m_begin && i <= m_end;
}
// Produces a string describing what this matcher does. It should
// include any provided data (the begin/ end in this case) and
// be written as if it were stating a fact (in the output it will be
// preceded by the value under test).
virtual std::string describe() const {
std::ostringstream ss;
ss << "is between " << m_begin << " and " << m_end;
return ss.str();
}
};
// The builder function
inline IntRange IsBetween( int begin, int end ) {
return IntRange( begin, end );
}
// ...
// Usage
TEST_CASE("Integers are within a range")
{
CHECK_THAT( 3, IsBetween( 1, 10 ) );
CHECK_THAT( 100, IsBetween( 1, 10 ) );
}
运行上面的例子，结果为：
/**/TestFile.cpp:123: FAILED:
CHECK_THAT( 100, IsBetween( 1, 10 ) )
with expansion:
100 is between 1 and 10
作者：ithiker
来源：CSDN
原文：https://blog.csdn.net/ithiker/article/details/87909651
版权声明：本文为博主原创文章，转载请附上博文链接！