A modern, C++-native, test framework for unit-tests, TDD and BDD - using C++14, C++17 and later (C++11 support is in v2.x branch, and C++03 on the Catch1.x branch)
Go to file
Martin Hořeňovský fe483c056d
Improve performance of JUnit reporter when handling passing assertions
This is done by no longer requiring all assertions to be seen
by the JUnit reporter. Since the JUnit reporter never outputs
all assertions, even with `-s`, the only difference from storing
passing assertions in the `CumulativeReporterBase` was some
bookkeeping in deciding which sections are relevant to the output.

Given `TEST_CASE` that just runs many passing assertions, e.g.

```
TEST_CASE( "PERFORMANCE_TEST_CASE", "[.]" ) {
    for (size_t i = 0; i < 1000'000'000; ++i) {
        REQUIRE( i == i );
    }
}
```

the new JUnit reporter will finish in 5:47, using up ~7.7 MB of RAM.
The old JUnit reporter would finish in 0:30, due to bad_alloc
after using up 14.5 GB of RAM (the system has 16 GB total).

If the total number of assertions is lowered to 10M, the old
implementation uses up ~7.1 GB of RAM and finishes in 12 minutes.
The new implementation still needs only ~7.7 MB of RAM, and finishes
in 4 minutes.

There is a slight downside in that the output is slightly different;
the new implementation will include the `TEST_CASE` level section
in output, even if it does not have its own assertion. In other words,
given a `TEST_CASE` like this

```
TEST_CASE( "JsonWriter", "[JSON][JsonWriter]" ) {
    std::stringstream stream;
    SECTION( "Newly constructed JsonWriter does nothing" ) {
        Catch::JsonValueWriter writer{ stream };
        REQUIRE( stream.str() == "" );
    }

    SECTION( "Calling writeObject will create an empty pair of braces" ) {
        { auto writer = Catch::JsonValueWriter{ stream }.writeObject(); }
        REQUIRE( stream.str() == "{\n}" );
    }
}
```

the new implementation will output 3 `testcase` tags, 2 for the explicit
 `SECTION`s with tests, and 1 for the top level section.

However, this can be worked-around if required, and the performance
improvement is such that it is worth changing the current output,
even if it needs to be fixed in the future.

Closes #2897
2024-08-13 19:13:03 +02:00
.conan Improve Conan recipe support (#2831) 2024-03-12 22:59:28 +01:00
.github Update to macos-12 GHA image 2024-07-22 10:47:25 +02:00
CMake Explicitly silence Wnon-virtual-dtor in Decomposer and MatchExpr 2024-04-30 23:51:36 +02:00
data/artwork Use logo with bit of white background in README 2022-11-22 16:13:37 +01:00
docs Fix typo in test-cases-and-sections.md 2024-08-13 12:28:03 +02:00
examples TEST_CASE_PERSISTENT_FIXTURE: A new fixture macro for allowing persistent fixtures throughout a TEST_CASE (#2885) 2024-08-05 17:01:41 +02:00
extras Add optional argument to catch_discover_tests to set DYLD_FRAMEWORK_PATH (#2880) 2024-07-22 19:25:24 +02:00
fuzzing Add nice license headers to files in examples/ and fuzzing/ 2023-08-24 16:34:31 +02:00
src Improve performance of JUnit reporter when handling passing assertions 2024-08-13 19:13:03 +02:00
tests Improve performance of JUnit reporter when handling passing assertions 2024-08-13 19:13:03 +02:00
third_party fixing UB 2020-07-22 17:17:33 +02:00
tools Add test for handleFatalErrorCondition within JUnit reporter 2024-04-21 21:52:33 +02:00
.bazelrc Bazel support: Bump bazel-skylib version to 1.5.0 2023-12-28 23:44:26 +01:00
.clang-format Slightly better clang-format 2023-01-05 23:02:51 +01:00
.clang-tidy add .clang-tidy config 2024-03-01 21:24:45 +01:00
.gitattributes Update gitattributes 2018-07-23 10:15:52 +02:00
.gitignore Adding unapproved.txt files to gitignore 2024-07-19 22:21:09 +02:00
BUILD.bazel Introduce CATCH_CONFIG_PREFIX_MESSAGES to only prefix a few logging related macros. (#2544) 2023-07-19 17:04:43 +02:00
CMakeLists.txt v3.6.0 2024-05-05 20:58:18 +02:00
CMakePresets.json Add test scaffolding for catch_discover_tests 2023-06-14 21:14:33 +02:00
CODE_OF_CONDUCT.md Create CODE_OF_CONDUCT.md 2017-08-17 07:45:12 +01:00
Doxyfile Update Doxyfile for newer doxygen 2023-12-23 11:27:46 +01:00
LICENSE.txt Renamed licence file, license should now be detected by github 2017-03-20 08:59:25 +01:00
MODULE.bazel Bazel support: Update skylib version to 1.6.1 2024-07-22 10:21:44 +02:00
README.md Mention that the benchmarks are not run by default next to example 2022-12-18 21:42:40 +01:00
SECURITY.md Add SECURITY.md 2021-11-26 00:10:01 +01:00
WORKSPACE.bazel Bazel support: Update skylib version to 1.6.1 2024-07-22 10:21:44 +02:00
appveyor.yml Update AppVeyor exclusion branch pattern for Github Actions 2024-02-23 20:52:04 +01:00
codecov.yml Sweep out two leftover references to master 2020-10-23 23:02:44 +02:00
conanfile.py conanfile: fix cmake_target_name of Catch2::Catch2. 2024-04-20 14:31:04 +02:00
mdsnippets.json Add infrastructure for embedding code samples in docs. 2020-10-28 11:38:06 +01:00
meson.build v3.6.0 2024-05-05 20:58:18 +02:00
meson_options.txt Add option to disable building unit tests in Meson build file. 2023-05-26 10:05:06 -07:00

README.md

Catch2 logo

Github Releases Linux build status Linux build status MacOS build status Build Status Code Coverage Try online Join the chat in Discord: https://discord.gg/4CWS9zD

What is Catch2?

Catch2 is mainly a unit testing framework for C++, but it also provides basic micro-benchmarking features, and simple BDD macros.

Catch2's main advantage is that using it is both simple and natural. Test names do not have to be valid identifiers, assertions look like normal C++ boolean expressions, and sections provide a nice and local way to share set-up and tear-down code in tests.

Example unit test

#include <catch2/catch_test_macros.hpp>

#include <cstdint>

uint32_t factorial( uint32_t number ) {
    return number <= 1 ? number : factorial(number-1) * number;
}

TEST_CASE( "Factorials are computed", "[factorial]" ) {
    REQUIRE( factorial( 1) == 1 );
    REQUIRE( factorial( 2) == 2 );
    REQUIRE( factorial( 3) == 6 );
    REQUIRE( factorial(10) == 3'628'800 );
}

Example microbenchmark

#include <catch2/catch_test_macros.hpp>
#include <catch2/benchmark/catch_benchmark.hpp>

#include <cstdint>

uint64_t fibonacci(uint64_t number) {
    return number < 2 ? number : fibonacci(number - 1) + fibonacci(number - 2);
}

TEST_CASE("Benchmark Fibonacci", "[!benchmark]") {
    REQUIRE(fibonacci(5) == 5);

    REQUIRE(fibonacci(20) == 6'765);
    BENCHMARK("fibonacci 20") {
        return fibonacci(20);
    };

    REQUIRE(fibonacci(25) == 75'025);
    BENCHMARK("fibonacci 25") {
        return fibonacci(25);
    };
}

Note that benchmarks are not run by default, so you need to run it explicitly with the [!benchmark] tag.

Catch2 v3 has been released!

You are on the devel branch, where the v3 version is being developed. v3 brings a bunch of significant changes, the big one being that Catch2 is no longer a single-header library. Catch2 now behaves as a normal library, with multiple headers and separately compiled implementation.

The documentation is slowly being updated to take these changes into account, but this work is currently still ongoing.

For migrating from the v2 releases to v3, you should look at our documentation. It provides a simple guidelines on getting started, and collects most common migration problems.

For the previous major version of Catch2 look into the v2.x branch here on GitHub.

How to use it

This documentation comprises these three parts:

More