Catch2

1. Project Overview

1.1 basic information

1.2 Project Positioning

Catch2 is a modern C unit testing framework that covers three test paradigms: unit testing, TDD (test-driven development), and BDD (behavior-driven development), with built-in micro-benchmarking capabilities. Its design philosophy is "make writing tests as simple as writing natural language"-developers only need to master the two core assertion macros of' REQUIRE' and' CHECK' to start working. the framework automatically decomposes assertion expressions through c expression template technology, and outputs clear expected values and actual values when it fails.

Catch2 is positioned as a developer experience-first testing framework , emphasizing:

-Very low start-up threshold: Download two files to integrate, zero external dependencies

-The test code itself is a document: the test case is named as a free-format string, and tags management is supported.

-Compile to Library Mode to Improve Performance:v3 version no longer encourages the use of header-only, but changes to CMake static library integration to greatly improve the compilation speed of large-scale projects.

-Modern C syntax: takes full advantage of C 14/17 features, does not support legacy compilers

1.3 development process

2. Core Competence

2.1 Natural Expression Assertion System (Natural Expression Decomposition)

Catch2's most iconic innovation. Whereas traditional testing frameworks require a large number of specialized assertion macros (ASSERT_EQ, ASSERT_NE, ASSERT_LT, ASSERT_GT, ASSERT_TRUE, etc.), Catch2 covers almost all scenarios with just two core macros:

REQUIRE( Factorial(3) == 6 );   // 致命断言，失败则终止当前测试
CHECK( Fib(10) == 55 );         // 非致命断言，失败后继续执行

• Key Mechanism :Catch2 "decomposes" the expression 'a = = B 'at compile time through C operator overloading and expression templates, so that when the test fails, it can automatically output * the actual values of the left and right operands:

Example.cpp:9: FAILED:
  REQUIRE( Factorial(0) == 1 )
with expansion:
  0 == 1

Assertion Macro Family Bucket:

2.2 Test Case and Section Mechanism (Replacing Traditional Fixture)

Catch2 provides a unique Section mechanism to replace the SetUp/TearDown Fixture mode of the traditional xUnit framework:

TEST_CASE("vectors can be sized and resized", "[vector]") {
    std::vector v(5);     // setup 代码

    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
}

Section core features:

-When every'SECTION' is triggered, the TEST_CASE is executed from the beginning, and the context entered by each section is a newly constructed object

-Section can be nested arbitrarily to form a test path tree, which is executed in a depth-first manner.

-Completely eliminates the state leakage problem in the traditional 'SetUp()'/'TearDown()'

-The traditional Test Fixture (TEST_CASE_METHOD **) is also supported to meet scenarios that require class-level shared initialization.

2.3 BDD Style Test

Catch2 natively supports behavior-driven development (BDD) style test organization:

SCENARIO("User withdraws money from ATM", "[atm]") {
    GIVEN("an account with $100 balance") {
        Account account(100);

        WHEN("withdrawing $60") {
            account.withdraw(60);
            THEN("balance is $40") {
                REQUIRE(account.balance() == 40);
            }
        }
        WHEN("withdrawing $200") {
            THEN("exception is thrown") {
                REQUIRE_THROWS(account.withdraw(200));
            }
        }
    }
}

This makes Catch2 especially valuable for teams that need to work with non-developers (e. g., QA, BA)-the test specifications themselves are executable documents.

2.4 Tags-Driven Test Screening

Test cases can be categorized by free string labels and filtered flexibly at runtime:

TEST_CASE("Fast computation test", "[fast][math][core]") { ... }
TEST_CASE("Slow integration test", "[slow][io][integration]") { ... }

The command line runtime supports flexible filtering:

./tests "[fast]"                    # 只运行标有 [fast] 的测试
./tests "[core],[integration]"       # 运行标有 [core] 或 [integration] 的
./tests "~[slow]"                   # 排除 [slow] 标签的测试

2.5 Matcher (matcher) system

Hamcrest-style based Matcher system for testing complex types and compound conditions:

Built-in Matcher:

-Strings: 'StartsWith', 'EndsWith', 'ContainsSubstring', 'Matches' (regular)

-Containers: 'Contains', 'VectorContains', 'UnorderedEquals'

-compound logic: by '& &', '| |', '! 'Free combination

REQUIRE_THAT(response, 
    StatusCode(200) && 
    Header("Content-Type", ContainsSubstring("application/json"))
);

Custom Matcher (old and new API styles) is supported, and v3.15 supports the 'constexpr' Matcher.

2.6 Data Generator (Data Generators) and Type Parametric Testing

Supports data-driven and type-parameterized testing:

-Data generator: The'GENERATE' macro provides multiple input values for test cases, and the framework automatically generates a test path for each value

-Type parameterization test:'TEMPLATE_TEST_CASE' and 'TEMPLATE_PRODUCT_TEST_CASE', using the same test logic to verify multiple types

-Both can be used at the same time to achieve full coverage of the Cartesian product of type × data.

TEMPLATE_TEST_CASE("Numeric types support addition", "[math]", int, float, double) {
    TestType a = GENERATE(1, 2, 5, 10);
    TestType b = GENERATE(0, 1);
    REQUIRE(add(a, b) == a + b);
}

2.7 Micro Benchmark (Micro-benchmarking)

Catch2 v2.9.0 has built-in benchmarking capabilities without introducing external dependencies such as Google Benchmark:

TEST_CASE("Sorting benchmark") {
    BENCHMARK("std::sort random vector") {
        std::vector v(1000);
        std::generate(v.begin(), v.end(), std::rand);
        std::sort(v.begin(), v.end());
        return v;   // 返回值防止编译器优化掉测试代码
    };
}

Core competencies include:

-Automatic clock resolution detection and warm-up (warmup)

-Multi-stage estimation → run → analysis

-Support 'BENCHMARK_ADVANCED fine control timer

-Native Reporter output

2.8 Reporting System (Reporters) Integration with CI/CD

Catch2 has built-in 9 Reporter, which supports enabling multiple Reporter output to different targets at the same time:

Custom Reporter (inherited from 'StreamingReporterBase' or 'CumulativeReporterBase') and Event Listener(Event Listeners) are supported to precisely control the output format and content.

2.9 Other Key Features

-Log macro:'INFO', 'WARN', 'FAIL', 'CAPTURE', etc., to output context information when the test is running.

-Skip tests at runtime:'SKIP' macro can dynamically skip tests based on runtime conditions

-CMake Auto Registration: Provides CMake scripts to automatically register tests to CTest

-Debugger Integration: Automatically breakpoint to debugger in case of failure

-Custom main(): supports user-defined main function, flexible control program entry

-Thread safety assertion:v3.15 assertion macros no longer need the '_THREAD_SAFE' suffix, the default thread safety

-Conan/Vcpkg/Bazel support: full coverage of mainstream package managers

3. Technical Architecture

Overall 3.1 Architecture

Catch2 v3 uses the modular library architecture and compiles it as a static library instead of header-only. The core architecture is as follows:

┌──────────────────────────────────────────────┐
│              TEST_CASE / SCENARIO             │  ← 用户测试代码层
├──────────────────────────────────────────────┤
│  Assertion  │  Matcher  │  Generator  │ Bench │  ← 测试工具层
│   Macros    │  System   │   System   │ mark  │
├──────────────────────────────────────────────┤
│        Expression Decomposition Engine        │  ← 表达式分解引擎
├──────────────┬───────────────────────────────┤
│  Test Case   │     Section Tracker           │  ← 测试运行核心
│   Registry   │     (Tree Walker)             │
├──────────────┴───────────────────────────────┤
│       Reporter System + Event Bus            │  ← 输出/事件层
├──────────────────────────────────────────────┤
│  CLI Parser  │  Config  │  CMake Integration │  ← 基础设施层
└──────────────────────────────────────────────┘

3.2 Key Components Details

3.2.1 Expression Decomposition Engine (Expression Decomposition Engine)

The core technology innovation of Catch2. Using C operator overloads ('= =', '!=', '<', '>', '<=', '>=', etc.) and expression template techniques:

1. compile time: the expression 'a = = B 'is decomposed into the operation tree' ExprLhs(a) = = ExprRhs (B)'
2. Runtime: The macro captures the value of each operand (serialized as a string via 'Catch::StringMaker')
3. On failure: Output the actual value of the left and right operands of the complete expression.

Restriction: Expressions containing '& &' or '| |' cannot be decomposed (because these operators cannot be overloaded while maintaining short-circuit semantics). Parentheses or multiple independent assertions are required.

3.2.2 Section Tree Traversal (Section Tracker)

Section mechanism is implemented as a depth-first tree path walker:

-TEST_CASE as root node, each 'SECTION' as child node

-Each time it is executed, the framework tracks whether the current path has been executed

-One complete test run for each leaf node

-Path selection is done by 'Catch::RunContext' and 'Catch::SectionTracker' collaboration

3.2.3 Test Case Self-Registration Mechanism

Catch2 uses C static initialization to realize automatic registration of test cases:

-The TEST_CASE macro is expanded to generate a static object, and its constructor calls 'Catch::AutoReg' to register the test function to the global'TestCaseRegistry'

-No need to manually write any registration code other than 'RUN_ALL_TESTS()'

-In v3 release, the CMake integration script further automatically registers Catch2 tests to CTest

3.2.4 Reporter System and Event Bus

Event-driven architecture is used in the Reporter system:

-Catch2 defines 20 Reporter events ('testCaseStarting', 'assertionEnded', 'sectionEnded', 'benchmarkPreparing', etc.)

-Each Reporter selectively handles events of interest

-Support multi-Reporter parallel output to different files/streams

-Two base classes, 'StreamingReporterBase' (streaming output) and 'CumulativeReporterBase' (output after aggregation)

3.2.5 CMake Integration

Catch2 v3 takes CMake as a first-class build system:

-Provide 'Catch2::Catch2' and 'Catch2::Catch2WithMain' two CMake Target

-Automatic test registration: Automatically scan and register to CTest through the 'catch_discover_tests()'CMake function

-Supports all mainstream integration methods such as 'FetchContent', find_package, and add_subdirectory

-Compilation options are controlled by both CMake variables and C macros

4. Market positioning and competition analysis

4.1 Competitive Landscape

4.2 Differentiation Advantage

Catch2 has unique competitive advantages in the following dimensions:

1. Natural Expression Decomposition: This is Catch2's signature capability. Google Test requires special macros such as ASSERT_EQ(a, B), while Catch2 uses REQUIRE(a = = B) '. The output when the test fails is clear and intuitive, greatly reducing the time to locate the problem.

1. Section mechanism vs Fixture class: SetUp/TearDown mode of traditional Fixture is prone to state leakage and code duplication. Catch2's Section mechanism TEST_CASE from the beginning every time it enters a section, ensuring that test isolation is naturally established and the test intent is clear at a glance.

1. Unification of BDD and TDD:Catch2 is the only mainstream C framework that natively supports both traditional TDD (TEST_CASE) and BDD('SCENARIO'/'GIVEN'/'WHEN'/'THEN') styles, suitable for teams that need to collaborate with non-technical stakeholders.

1. Built-in benchmark test :Google Test needs to introduce additional Google Benchmark,Catch2 a library to solve unit test benchmark test, reduce the complexity of project dependency.

1. Business-friendly BSL protocol : as loose as MIT/BSD, no GPL infection risk, suitable for enterprise closed-source projects.

4.3 target user group

5. Business Model

Catch2 is a pure community-driven open source project with no commercial company support **and no revenue sources such as subscriptions, technical support or enterprise editions.

⚠ Pre-sales warning : For enterprise customers who need SLA guarantee or 24/7 technical support, please inform that Catch2 is a pure community project. If customers have such needs, they can recommend using Google Test (with Google endorsement and larger community) or introducing third-party C test consulting services as a supplement.

6. Pre-sales entry point

6.1 Why do customers need it?

• Pain point 1:C test code is too wordy and difficult to maintain *

Traditional testing frameworks have a large number of proprietary assertion macros (ASSERT_EQ, ASSERT_NE, ASSERT_LT, ASSERT_TRUE,...), which are costly for new members to learn, and a poor test code reading experience.

→ Catch2 scheme: two macros ('REQUIRE'/'CHECK') natural C expressions, writing tests is as intuitive as writing assertions.

Pain point 2:Fixture mechanism leads to state coupling between tests

XUnit style SetUp/TearDown is prone to the problem of "test B depends on the side effect of test a" and debugging is painful.

→ Catch2 scheme: Section mechanism executes TEST_CASE from scratch every time, test isolation is guaranteed by the framework, and state leakage never occurs.

Pain Point 3: Test Code Disconnected from Product Specifications

Test naming is often forced to use a legal identifier ('TestVectorResize') that cannot be read by business people.

→ Catch2 scheme: free-form string named test BDD-style macro, test = executable specification document.

Pain Point 4: Project Dependency Inflation

A variety of testing tools such as unit testing frameworks, benchmark libraries, and Mock libraries are required.

→ Catch2 scenario: a library coverage test benchmark (Mock still requires trompeloeil, etc., but trompeloeil also integrates well with Catch2 natively).

Pain Point 5:CI/CD Output Format Incompatible

Different CI systems require different reporting formats and require additional conversion scripts.

→ Catch2 scheme: 9 Reporter cover JUnit/TAP/SonarQube/TeamCity/JSON, and multiple Reporter can be output in parallel at the same time.

6.2 Pre-sales Speech

Opening Speech

"what framework does your team currently use for C ++ unit testing? Google Test, Boost.Test, or self-developed? In fact, the C ++ community has a very interesting framework called Catch2, which is the second most popular testing framework for C ++ in JetBrains developer surveys and is used by Bloomberg and NASA. The biggest difference is that only two assertion macros are needed to cover 90% of your test scenarios , and the written test code reads like natural language."

Technical Comparison (vs Google Test)

"Google Test is indeed the most perfect ecology, but it has dozens of macros like" ASSERT_EQ "and" ASSERT_NE ", which team members need to remember and choose. Catch2 put C's '= =', '! The = ','<'operator is used directly in the assertion-'REQUIRE(result = = expected)'-the actual value of both sides is automatically output when the test fails. In addition, Catch2's Section mechanism solves two old problems of traditional Fixture: state leakage and code duplication."

Quick Trial Technique

"Catch2 integration is very simple-CMake is only one line of configuration, no additional dependencies are required. You can try it on a small module first, migrate two or three test cases from the existing framework, and see the effect in half an hour. If you think it is easy to use, you can gradually promote it."

Risk Honest Words

"Of course I also need to be honest and say that Catch2 is a community-maintained open source project with no commercial support. If you need Mocking function, you also need to use it with trompeloeil. However, it uses BSL protocol, and commercial closed-source projects are completely fine."

7. Risks and Challenges

8. One sentence conclusion

Catch2 is the framework for optimal development experience in C unit testing-turning the test code into a living specification document with two assertion macros, zero additional dependencies and modern C syntax, especially suitable for enterprise-level C projects that attach importance to code readability, team collaboration efficiency and test maintenance cost. However, its pure community maintenance attribute determines that it is more suitable for "small and refined" technical teams, not large organizations that need SLA guarantees.