suffix`. This can be used to add a file extension to
the output file name e.g. ".xml".
+* `DISCOVERY_MODE mode`
+
+If specified allows control over when test discovery is performed.
+For a value of `POST_BUILD` (default) test discovery is performed at build time.
+For a value of `PRE_TEST` test discovery is delayed until just prior to test
+execution (useful e.g. in cross-compilation environments).
+``DISCOVERY_MODE`` defaults to the value of the
+``CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE`` variable if it is not passed when
+calling ``catch_discover_tests``. This provides a mechanism for globally
+selecting a preferred test discovery behavior.
### `ParseAndAddCatchTests.cmake`
@@ -373,7 +385,7 @@ install it to the default location, like so:
```
$ git clone https://github.com/catchorg/Catch2.git
$ cd Catch2
-$ cmake -Bbuild -H. -DBUILD_TESTING=OFF
+$ cmake -B build -S . -DBUILD_TESTING=OFF
$ sudo cmake --build build/ --target install
```
@@ -397,6 +409,24 @@ cd vcpkg
The catch2 port in vcpkg is kept up to date by microsoft team members and community contributors.
If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+## Installing Catch2 from Bazel
+
+Catch2 is now a supported module in the Bazel Central Registry. You only need to add one line to your MODULE.bazel file;
+please see https://registry.bazel.build/modules/catch2 for the latest supported version.
+
+You can then add `catch2_main` to each of your C++ test build rules as follows:
+
+```
+cc_test(
+ name = "example_test",
+ srcs = ["example_test.cpp"],
+ deps = [
+ ":example",
+ "@catch2//:catch2_main",
+ ],
+)
+```
+
---
[Home](Readme.md#top)
diff --git a/src/external/catch2/docs/command-line.md b/src/external/catch2/docs/command-line.md
index a15a2131..7e69bf12 100644
--- a/src/external/catch2/docs/command-line.md
+++ b/src/external/catch2/docs/command-line.md
@@ -85,43 +85,102 @@ Click one of the following links to take you straight to that option - or scroll
<test-spec> ...
-Test cases, wildcarded test cases, tags and tag expressions are all passed directly as arguments. Tags are distinguished by being enclosed in square brackets.
+By providing a test spec, you filter which tests will be run. If you call
+Catch2 without any test spec, then it will run all non-hidden test
+cases. A test case is hidden if it has the `[!benchmark]` tag, any tag
+with a dot at the start, e.g. `[.]` or `[.foo]`.
-If no test specs are supplied then all test cases, except "hidden" tests, are run.
-A test is hidden by giving it any tag starting with (or just) a period (```.```) - or, in the deprecated case, tagged ```[hide]``` or given name starting with `'./'`. To specify hidden tests from the command line ```[.]``` or ```[hide]``` can be used *regardless of how they were declared*.
+There are three basic test specs that can then be combined into more
+complex specs:
-Specs must be enclosed in quotes if they contain spaces. If they do not contain spaces the quotes are optional.
+ * Full test name, e.g. `"Test 1"`.
-Wildcards consist of the `*` character at the beginning and/or end of test case names and can substitute for any number of any characters (including none).
+ This allows only test cases whose name is "Test 1".
-Test specs are case insensitive.
+ * Wildcarded test name, e.g. `"*Test"`, or `"Test*"`, or `"*Test*"`.
-If a spec is prefixed with `exclude:` or the `~` character then the pattern matches an exclusion. This means that tests matching the pattern are excluded from the set - even if a prior inclusion spec included them. Subsequent inclusion specs will take precedence, however.
-Inclusions and exclusions are evaluated in left-to-right order.
+ This allows any test case whose name ends with, starts with, or contains
+ in the middle the string "Test". Note that the wildcard can only be at
+ the start or end.
-Test case examples:
+ * Tag name, e.g. `[some-tag]`.
+ This allows any test case tagged with "[some-tag]". Remember that some
+ tags are special, e.g. those that start with "." or with "!".
+
+
+You can also combine the basic test specs to create more complex test
+specs. You can:
+
+ * Concatenate specs to apply all of them, e.g. `[some-tag][other-tag]`.
+
+ This allows test cases that are tagged with **both** "[some-tag]" **and**
+ "[other-tag]". A test case with just "[some-tag]" will not pass the filter,
+ nor will test case with just "[other-tag]".
+
+ * Comma-join specs to apply any of them, e.g. `[some-tag],[other-tag]`.
+
+ This allows test cases that are tagged with **either** "[some-tag]" **or**
+ "[other-tag]". A test case with both will obviously also pass the filter.
+
+ Note that commas take precendence over simple concatenation. This means
+ that `[a][b],[c]` accepts tests that are tagged with either both "[a]" and
+ "[b]", or tests that are tagged with just "[c]".
+
+ * Negate the spec by prepending it with `~`, e.g. `~[some-tag]`.
+
+ This rejects any test case that is tagged with "[some-tag]". Note that
+ rejection takes precedence over other filters.
+
+ Note that negations always binds to the following _basic_ test spec.
+ This means that `~[foo][bar]` negates only the "[foo]" tag and not the
+ "[bar]" tag.
+
+Note that when Catch2 is deciding whether to include a test, first it
+checks whether the test matches any negative filters. If it does,
+the test is rejected. After that, the behaviour depends on whether there
+are positive filters as well. If there are no positive filters, all
+remaining non-hidden tests are included. If there are positive filters,
+only tests that match the positive filters are included.
+
+You can also match test names with special characters by escaping them
+with a backslash (`"\"`), e.g. a test named `"Do A, then B"` is matched
+by `"Do A\, then B"` test spec. Backslash also escapes itself.
+
+
+### Examples
+
+Given these TEST_CASEs,
```
-thisTestOnly Matches the test case called, 'thisTestOnly'
-"this test only" Matches the test case called, 'this test only'
-these* Matches all cases starting with 'these'
-exclude:notThis Matches all tests except, 'notThis'
-~notThis Matches all tests except, 'notThis'
-~*private* Matches all tests except those that contain 'private'
-a* ~ab* abc Matches all tests that start with 'a', except those that
- start with 'ab', except 'abc', which is included
-~[tag1] Matches all tests except those tagged with '[tag1]'
--# [#somefile] Matches all tests from the file 'somefile.cpp'
+TEST_CASE("Test 1") {}
+
+TEST_CASE("Test 2", "[.foo]") {}
+
+TEST_CASE("Test 3", "[.bar]") {}
+
+TEST_CASE("Test 4", "[.][foo][bar]") {}
```
-Names within square brackets are interpreted as tags.
-A series of tags form an AND expression whereas a comma-separated sequence forms an OR expression. e.g.:
+this is the result of these filters
+```
+./tests # Selects only the first test, others are hidden
+./tests "Test 1" # Selects only the first test, other do not match
+./tests ~"Test 1" # Selects no tests. Test 1 is rejected, other tests are hidden
+./tests "Test *" # Selects all tests.
+./tests [bar] # Selects tests 3 and 4. Other tests are not tagged [bar]
+./tests ~[foo] # Selects test 1, because it is the only non-hidden test without [foo] tag
+./tests [foo][bar] # Selects test 4.
+./tests [foo],[bar] # Selects tests 2, 3, 4.
+./tests ~[foo][bar] # Selects test 3. 2 and 4 are rejected due to having [foo] tag
+./tests ~"Test 2"[foo] # Selects test 4, because test 2 is explicitly rejected
+./tests [foo][bar],"Test 1" # Selects tests 1 and 4.
+./tests "Test 1*" # Selects test 1, wildcard can match zero characters
+```
-[one][two],[three]
-This matches all tests tagged `[one]` and `[two]`, as well as all tests tagged `[three]`
+_Note: Using plain asterisk on a command line can cause issues with shell
+expansion. Make sure that the asterisk is passed to Catch2 and is not
+interpreted by the shell._
-Test names containing special characters, such as `,` or `[` can specify them on the command line using `\`.
-`\` also escapes itself.
## Choosing a reporter to use
@@ -135,7 +194,8 @@ verbose and human-friendly output.
Reporters are also individually configurable. To pass configuration options
to the reporter, you append `::key=value` to the reporter specification
-as many times as you want, e.g. `--reporter xml::out=someFile.xml`.
+as many times as you want, e.g. `--reporter xml::out=someFile.xml` or
+`--reporter custom::colour-mode=ansi::Xoption=2`.
The keys must either be prefixed by "X", in which case they are not parsed
by Catch2 and are only passed down to the reporter, or one of options
@@ -306,14 +366,14 @@ There are currently two warnings implemented:
## Reporting timings
-d, --durations <yes/no>
-When set to ```yes``` Catch will report the duration of each test case, in milliseconds. Note that it does this regardless of whether a test case passes or fails. Note, also, the certain reporters (e.g. Junit) always report test case durations regardless of this option being set or not.
+When set to ```yes``` Catch will report the duration of each test case, in seconds with millisecond precision. Note that it does this regardless of whether a test case passes or fails. Note, also, the certain reporters (e.g. Junit) always report test case durations regardless of this option being set or not.
-D, --min-duration <value>
> `--min-duration` was [introduced](https://github.com/catchorg/Catch2/pull/1910) in Catch2 2.13.0
When set, Catch will report the duration of each test case that took more
-than <value> seconds, in milliseconds. This option is overridden by both
+than <value> seconds, in seconds with millisecond precision. This option is overridden by both
`-d yes` and `-d no`, so that either all durations are reported, or none
are.
diff --git a/src/external/catch2/docs/configuration.md b/src/external/catch2/docs/configuration.md
index d4421f3c..8a3ddfab 100644
--- a/src/external/catch2/docs/configuration.md
+++ b/src/external/catch2/docs/configuration.md
@@ -15,6 +15,7 @@
[Enabling stringification](#enabling-stringification)
[Disabling exceptions](#disabling-exceptions)
[Overriding Catch's debug break (`-b`)](#overriding-catchs-debug-break--b)
+[Static analysis support](#static-analysis-support)
Catch2 is designed to "just work" as much as possible, and most of the
configuration options below are changed automatically during compilation,
@@ -25,7 +26,8 @@ with the same name.
## Prefixing Catch macros
- CATCH_CONFIG_PREFIX_ALL
+ CATCH_CONFIG_PREFIX_ALL // Prefix all macros with CATCH_
+ CATCH_CONFIG_PREFIX_MESSAGES // Prefix only INFO, UNSCOPED_INFO, WARN and CAPTURE
To keep test code clean and uncluttered Catch uses short macro names (e.g. ```TEST_CASE``` and ```REQUIRE```). Occasionally these may conflict with identifiers from platform headers or the system under test. In this case the above identifier can be defined. This will cause all the Catch user macros to be prefixed with ```CATCH_``` (e.g. ```CATCH_TEST_CASE``` and ```CATCH_REQUIRE```).
@@ -264,6 +266,31 @@ The macro will be used as is, that is, `CATCH_BREAK_INTO_DEBUGGER();`
must compile and must break into debugger.
+## Static analysis support
+
+> Introduced in Catch2 3.4.0.
+
+Some parts of Catch2, e.g. `SECTION`s, can be hard for static analysis
+tools to reason about. Catch2 can change its internals to help static
+analysis tools reason about the tests.
+
+Catch2 automatically detects some static analysis tools (initial
+implementation checks for clang-tidy and Coverity), but you can override
+its detection (in either direction) via
+
+```
+CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT // force enables static analysis help
+CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT // force disables static analysis help
+```
+
+_As the name suggests, this is currently experimental, and thus we provide
+no backwards compatibility guarantees._
+
+**DO NOT ENABLE THIS FOR BUILDS YOU INTEND TO RUN.** The changed internals
+are not meant to be runnable, only "scannable".
+
+
+
---
[Home](Readme.md#top)
diff --git a/src/external/catch2/docs/contributing.md b/src/external/catch2/docs/contributing.md
index d9f87fc1..d21323d9 100644
--- a/src/external/catch2/docs/contributing.md
+++ b/src/external/catch2/docs/contributing.md
@@ -107,8 +107,7 @@ cmake -B debug-build -S . -DCMAKE_BUILD_TYPE=Debug --preset all-tests
cmake --build debug-build
# 4. Run the tests using CTest
-cd debug-build
-ctest -j 4 --output-on-failure -C Debug
+ctest -j 4 --output-on-failure -C Debug --test-dir debug-build
```
snippet source | anchor
diff --git a/src/external/catch2/docs/deprecations.md b/src/external/catch2/docs/deprecations.md
index 1fb79aaa..0b5bee13 100644
--- a/src/external/catch2/docs/deprecations.md
+++ b/src/external/catch2/docs/deprecations.md
@@ -35,6 +35,19 @@ being aborted (when using `--abort` or `--abortx`). It is however
**NOT** invoked for test cases that are [explicitly skipped using the `SKIP`
macro](skipping-passing-failing.md#top).
+
+### Non-const function for `TEST_CASE_METHOD`
+
+> Deprecated in Catch2 vX.Y.Z
+
+Currently, the member function generated for `TEST_CASE_METHOD` is
+not `const` qualified. In the future, the generated member function will
+be `const` qualified, just as `TEST_CASE_PERSISTENT_FIXTURE` does.
+
+If you are mutating the fixture instance from within the test case, and
+want to keep doing so in the future, mark the mutated members as `mutable`.
+
+
---
[Home](Readme.md#top)
diff --git a/src/external/catch2/docs/faq.md b/src/external/catch2/docs/faq.md
index 0f303ee5..80923d26 100644
--- a/src/external/catch2/docs/faq.md
+++ b/src/external/catch2/docs/faq.md
@@ -10,6 +10,7 @@
[Does Catch2 support running tests in parallel?](#does-catch2-support-running-tests-in-parallel)
[Can I compile Catch2 into a dynamic library?](#can-i-compile-catch2-into-a-dynamic-library)
[What repeatability guarantees does Catch2 provide?](#what-repeatability-guarantees-does-catch2-provide)
+[My build cannot find `catch2/catch_user_config.hpp`, how can I fix it?](#my-build-cannot-find-catch2catch_user_confighpp-how-can-i-fix-it)
## How do I run global setup/teardown only if tests will be run?
@@ -28,7 +29,7 @@ depending on how often the cleanup needs to happen.
## Why cannot I derive from the built-in reporters?
They are not made to be overridden, in that we do not attempt to maintain
-a consistent internal state if a member function is overriden, and by
+a consistent internal state if a member function is overridden, and by
forbidding users from using them as a base class, we can refactor them
as needed later.
@@ -83,12 +84,30 @@ and it is also generally repeatable across versions, but we might break
it from time to time. E.g. we broke repeatability with previous versions
in v2.13.4 so that test cases with similar names are shuffled better.
-Random generators currently rely on platform's stdlib, specifically
-the distributions from ``. We thus provide no extra guarantee
-above what your platform does. **Important: ``'s distributions
+Since Catch2 3.5.0 the random generators use custom distributions,
+that should be repeatable across different platforms, with few caveats.
+For details see the section on random generators in the [Generator
+documentation](generators.md#random-number-generators-details).
+
+Before this version, random generators relied on distributions from
+platform's stdlib. We thus can provide no extra guarantee on top of the
+ones given by your platform. **Important: ``'s distributions
are not specified to be repeatable across different platforms.**
+## My build cannot find `catch2/catch_user_config.hpp`, how can I fix it?
+
+`catch2/catch_user_config.hpp` is a generated header that contains user
+compile time configuration. It is generated by CMake/Meson/Bazel during
+build. If you are not using either of these, your three options are to
+
+1) Build Catch2 separately using build tool that will generate the header
+2) Use the amalgamated files to build Catch2
+3) Use CMake to configure a build. This will generate the header and you
+ can copy it into your own checkout of Catch2.
+
+
+
---
[Home](Readme.md#top)
diff --git a/src/external/catch2/docs/generators.md b/src/external/catch2/docs/generators.md
index 69d1a02d..eb1a255a 100644
--- a/src/external/catch2/docs/generators.md
+++ b/src/external/catch2/docs/generators.md
@@ -134,7 +134,7 @@ type, making their usage much nicer. These are
* `map(func, GeneratorWrapper&&)` for `MapGenerator` (map `U` to `T`)
* `chunk(chunk-size, GeneratorWrapper&&)` for `ChunkGenerator`
* `random(IntegerOrFloat a, IntegerOrFloat b)` for `RandomIntegerGenerator` or `RandomFloatGenerator`
-* `range(Arithemtic start, Arithmetic end)` for `RangeGenerator` with a step size of `1`
+* `range(Arithmetic start, Arithmetic end)` for `RangeGenerator` with a step size of `1`
* `range(Arithmetic start, Arithmetic end, Arithmetic step)` for `RangeGenerator` with a custom step size
* `from_range(InputIterator from, InputIterator to)` for `IteratorGenerator`
* `from_range(Container const&)` for `IteratorGenerator`
@@ -189,6 +189,45 @@ TEST_CASE("type conversion", "[generators]") {
}
```
+
+### Random number generators: details
+
+> This section applies from Catch2 3.5.0. Before that, random generators
+> were a thin wrapper around distributions from ``.
+
+All of the `random(a, b)` generators in Catch2 currently generate uniformly
+distributed number in closed interval \[a; b\]. This is different from
+`std::uniform_real_distribution`, which should return numbers in interval
+\[a; b) (but due to rounding can end up returning b anyway), but the
+difference is intentional, so that `random(a, a)` makes sense. If there is
+enough interest from users, we can provide API to pick any of CC, CO, OC,
+or OO ranges.
+
+Unlike `std::uniform_int_distribution`, Catch2's generators also support
+various single-byte integral types, such as `char` or `bool`.
+
+
+#### Reproducibility
+
+Given the same seed, the output from the integral generators is fully
+reproducible across different platforms.
+
+For floating point generators, the situation is much more complex.
+Generally Catch2 only promises reproducibility (or even just correctness!)
+on platforms that obey the IEEE-754 standard. Furthermore, reproducibility
+only applies between binaries that perform floating point math in the
+same way, e.g. if you compile a binary targetting the x87 FPU and another
+one targetting SSE2 for floating point math, their results will vary.
+Similarly, binaries compiled with compiler flags that relax the IEEE-754
+adherence, e.g. `-ffast-math`, might provide different results than those
+compiled for strict IEEE-754 adherence.
+
+Finally, we provide zero guarantees on the reproducibility of generating
+`long double`s, as the internals of `long double` varies across different
+platforms.
+
+
+
## Generator interface
You can also implement your own generators, by deriving from the
@@ -221,3 +260,21 @@ For full example of implementing your own generator, look into Catch2's
examples, specifically
[Generators: Create your own generator](../examples/300-Gen-OwnGenerator.cpp).
+
+### Handling empty generators
+
+The generator interface assumes that a generator always has at least one
+element. This is not always true, e.g. if the generator depends on an external
+datafile, the file might be missing.
+
+There are two ways to handle this, depending on whether you want this
+to be an error or not.
+
+ * If empty generator **is** an error, throw an exception in constructor.
+ * If empty generator **is not** an error, use the [`SKIP`](skipping-passing-failing.md#skipping-test-cases-at-runtime) in constructor.
+
+
+
+---
+
+[Home](Readme.md#top)
diff --git a/src/external/catch2/docs/limitations.md b/src/external/catch2/docs/limitations.md
index cc0ed05d..f5f60ba8 100644
--- a/src/external/catch2/docs/limitations.md
+++ b/src/external/catch2/docs/limitations.md
@@ -174,12 +174,18 @@ TEST_CASE("b") {
If you are seeing a problem like this, i.e. weird test paths that trigger only under Clang with `libc++`, or only under very specific version of `libstdc++`, it is very likely you are seeing this. The only known workaround is to use a fixed version of your standard library.
-### libstdc++, `_GLIBCXX_DEBUG` macro and random ordering of tests
+### Visual Studio 2022 -- can't compile assertion with the spaceship operator
-Running a Catch2 binary compiled against libstdc++ with `_GLIBCXX_DEBUG`
-macro defined with `--order rand` will cause a debug check to trigger and
-abort the run due to self-assignment.
-[This is a known bug inside libstdc++](https://stackoverflow.com/questions/22915325/avoiding-self-assignment-in-stdshuffle/23691322)
+[The C++ standard requires that `std::foo_ordering` is only comparable with
+a literal 0](https://eel.is/c++draft/cmp#categories.pre-3). There are
+multiple strategies a stdlib implementation can take to achieve this, and
+MSVC's STL has changed the strategy they use between two releases of VS 2022.
+
+With the new strategy, `REQUIRE((a <=> b) == 0)` no longer compiles under
+MSVC. Note that Catch2 can compile code using MSVC STL's new strategy,
+but only when compiled with a C++20 conforming compiler. MSVC is currently
+not conformant enough, but `clang-cl` will compile the assertion above
+using MSVC STL without problem.
+
+This change got in with MSVC v19.37](https://godbolt.org/z/KG9obzdvE).
-Workaround: Don't use `--order rand` when compiling against debug-enabled
-libstdc++.
diff --git a/src/external/catch2/docs/list-of-examples.md b/src/external/catch2/docs/list-of-examples.md
index a919408a..40d3f711 100644
--- a/src/external/catch2/docs/list-of-examples.md
+++ b/src/external/catch2/docs/list-of-examples.md
@@ -8,6 +8,7 @@
- Assertion: [REQUIRE, CHECK](../examples/030-Asn-Require-Check.cpp)
- Fixture: [Sections](../examples/100-Fix-Section.cpp)
- Fixture: [Class-based fixtures](../examples/110-Fix-ClassFixture.cpp)
+- Fixture: [Persistent fixtures](../examples/111-Fix-PersistentFixture.cpp)
- BDD: [SCENARIO, GIVEN, WHEN, THEN](../examples/120-Bdd-ScenarioGivenWhenThen.cpp)
- Listener: [Listeners](../examples/210-Evt-EventListeners.cpp)
- Configuration: [Provide your own output streams](../examples/231-Cfg-OutputStreams.cpp)
diff --git a/src/external/catch2/docs/logging.md b/src/external/catch2/docs/logging.md
index dbd4f912..79709386 100644
--- a/src/external/catch2/docs/logging.md
+++ b/src/external/catch2/docs/logging.md
@@ -114,6 +114,10 @@ Similar to `INFO`, but messages are not limited to their own scope: They are rem
The message is always reported but does not fail the test.
+**SUCCEED(** _message expression_ **)**
+
+The message is reported and the test case succeeds.
+
**FAIL(** _message expression_ **)**
The message is reported and the test case fails.
diff --git a/src/external/catch2/docs/matchers.md b/src/external/catch2/docs/matchers.md
index 14c15898..4b9445ae 100644
--- a/src/external/catch2/docs/matchers.md
+++ b/src/external/catch2/docs/matchers.md
@@ -50,25 +50,43 @@ Both of the string matchers used in the examples above live in the
`catch_matchers_string.hpp` header, so to compile the code above also
requires `#include `.
+### Combining operators and lifetimes
+
**IMPORTANT**: The combining operators do not take ownership of the
-matcher objects being combined. This means that if you store combined
-matcher object, you have to ensure that the matchers being combined
-outlive its last use. What this means is that the following code leads
-to a use-after-free (UAF):
+matcher objects being combined.
+
+This means that if you store combined matcher object, you have to ensure
+that the individual matchers being combined outlive the combined matcher.
+Note that the negation matcher from `!` also counts as combining matcher
+for this.
+Explained on an example, this is fine
```cpp
-#include
-#include
+CHECK_THAT(value, WithinAbs(0, 2e-2) && !WithinULP(0., 1));
+```
-TEST_CASE("Bugs, bugs, bugs", "[Bug]"){
- std::string str = "Bugs as a service";
+and so is this
+```cpp
+auto is_close_to_zero = WithinAbs(0, 2e-2);
+auto is_zero = WithinULP(0., 1);
- auto match_expression = Catch::Matchers::EndsWith( "as a service" ) ||
- (Catch::Matchers::StartsWith( "Big data" ) && !Catch::Matchers::ContainsSubstring( "web scale" ) );
- REQUIRE_THAT(str, match_expression);
-}
+CHECK_THAT(value, is_close_to_zero && !is_zero);
```
+but this is not
+```cpp
+auto is_close_to_zero = WithinAbs(0, 2e-2);
+auto is_zero = WithinULP(0., 1);
+auto is_close_to_but_not_zero = is_close_to_zero && !is_zero;
+
+CHECK_THAT(a_value, is_close_to_but_not_zero); // UAF
+```
+
+because `!is_zero` creates a temporary instance of Negation matcher,
+which the `is_close_to_but_not_zero` refers to. After the line ends,
+the temporary is destroyed and the combined `is_close_to_but_not_zero`
+matcher now refers to non-existent object, so using it causes use-after-free.
+
## Built-in matchers
@@ -192,15 +210,36 @@ The other miscellaneous matcher utility is exception matching.
#### Matching exceptions
-Catch2 provides a utility macro for asserting that an expression
-throws exception of specific type, and that the exception has desired
-properties. The macro is `REQUIRE_THROWS_MATCHES(expr, ExceptionType, Matcher)`.
+Because exceptions are a bit special, Catch2 has a separate macro for them.
+
+
+The basic form is
+
+```
+REQUIRE_THROWS_MATCHES(expr, ExceptionType, Matcher)
+```
+
+and it checks that the `expr` throws an exception, that exception is derived
+from the `ExceptionType` type, and then `Matcher::match` is called on
+the caught exception.
> `REQUIRE_THROWS_MATCHES` macro lives in `catch2/matchers/catch_matchers.hpp`
+For one-off checks you can use the `Predicate` matcher above, e.g.
+
+```cpp
+REQUIRE_THROWS_MATCHES(parse(...),
+ parse_error,
+ Predicate([] (parse_error const& err) -> bool { return err.line() == 1; })
+);
+```
-Catch2 currently provides two matchers for exceptions.
-These are:
+but if you intend to thoroughly test your error reporting, I recommend
+defining a specialized matcher.
+
+
+Catch2 also provides 2 built-in matchers for checking the error message
+inside an exception (it must be derived from `std::exception`):
* `Message(std::string message)`.
* `MessageMatches(Matcher matcher)`.
@@ -218,10 +257,7 @@ REQUIRE_THROWS_MATCHES(throwsDerivedException(), DerivedException, Message("De
REQUIRE_THROWS_MATCHES(throwsDerivedException(), DerivedException, MessageMatches(StartsWith("DerivedException")));
```
-Note that `DerivedException` in the example above has to derive from
-`std::exception` for the example to work.
-
-> the exception message matcher lives in `catch2/matchers/catch_matchers_exception.hpp`
+> the exception message matchers live in `catch2/matchers/catch_matchers_exception.hpp`
### Generic range Matchers
@@ -286,7 +322,7 @@ comparable. (e.g. you may compare `std::vector` to `std::array`).
`UnorderedRangeEquals` is similar to `RangeEquals`, but the order
does not matter. For example "1, 2, 3" would match "3, 2, 1", but not
"1, 1, 2, 3" As with `RangeEquals`, `UnorderedRangeEquals` compares
-the individual elements using using `operator==` by default.
+the individual elements using `operator==` by default.
Both `RangeEquals` and `UnorderedRangeEquals` optionally accept a
predicate which can be used to compare the containers element-wise.
diff --git a/src/external/catch2/docs/opensource-users.md b/src/external/catch2/docs/opensource-users.md
index 12b4551c..a02d0b98 100644
--- a/src/external/catch2/docs/opensource-users.md
+++ b/src/external/catch2/docs/opensource-users.md
@@ -95,6 +95,9 @@ A C++ client library for Consul. Consul is a distributed tool for discovering an
### [Reactive-Extensions/ RxCpp](https://github.com/Reactive-Extensions/RxCpp)
A library of algorithms for values-distributed-in-time.
+### [SFML](https://github.com/SFML/SFML)
+Simple and Fast Multimedia Library.
+
### [SOCI](https://github.com/SOCI/soci)
The C++ Database Access Library.
@@ -110,6 +113,12 @@ A header-only TOML parser and serializer for modern C++.
### [Trompeloeil](https://github.com/rollbear/trompeloeil)
A thread-safe header-only mocking framework for C++14.
+### [wxWidgets](https://www.wxwidgets.org/)
+Cross-Platform C++ GUI Library.
+
+### [xmlwrapp](https://github.com/vslavik/xmlwrapp)
+C++ XML parsing library using libxml2.
+
## Applications & Tools
### [App Mesh](https://github.com/laoshanxi/app-mesh)
@@ -137,7 +146,7 @@ Newsbeuter is an open-source RSS/Atom feed reader for text terminals.
A 2D, Zombie, RPG game which is being made on our own engine.
### [raspigcd](https://github.com/pantadeusz/raspigcd)
-Low level CLI app and library for execution of GCODE on Raspberry Pi without any additional microcontrolers (just RPi + Stepsticks).
+Low level CLI app and library for execution of GCODE on Raspberry Pi without any additional microcontrollers (just RPi + Stepsticks).
### [SpECTRE](https://github.com/sxs-collaboration/spectre)
SpECTRE is a code for multi-scale, multi-physics problems in astrophysics and gravitational physics.
diff --git a/src/external/catch2/docs/other-macros.md b/src/external/catch2/docs/other-macros.md
index 24a0fb6e..79990a6a 100644
--- a/src/external/catch2/docs/other-macros.md
+++ b/src/external/catch2/docs/other-macros.md
@@ -93,30 +93,6 @@ TEST_CASE("STATIC_CHECK showcase", "[traits]") {
## Test case related macros
-* `METHOD_AS_TEST_CASE`
-
-`METHOD_AS_TEST_CASE( member-function-pointer, description )` lets you
-register a member function of a class as a Catch2 test case. The class
-will be separately instantiated for each method registered in this way.
-
-```cpp
-class TestClass {
- std::string s;
-
-public:
- TestClass()
- :s( "hello" )
- {}
-
- void testCase() {
- REQUIRE( s == "hello" );
- }
-};
-
-
-METHOD_AS_TEST_CASE( TestClass::testCase, "Use class's method as a test case", "[class]" )
-```
-
* `REGISTER_TEST_CASE`
`REGISTER_TEST_CASE( function, description )` let's you register
diff --git a/src/external/catch2/docs/release-notes.md b/src/external/catch2/docs/release-notes.md
index 1fa37da4..5f2d92ae 100644
--- a/src/external/catch2/docs/release-notes.md
+++ b/src/external/catch2/docs/release-notes.md
@@ -2,6 +2,15 @@
# Release notes
**Contents**
+[3.7.1](#371)
+[3.7.0](#370)
+[3.6.0](#360)
+[3.5.4](#354)
+[3.5.3](#353)
+[3.5.2](#352)
+[3.5.1](#351)
+[3.5.0](#350)
+[3.4.0](#340)
[3.3.2](#332)
[3.3.1](#331)
[3.3.0](#330)
@@ -56,6 +65,200 @@
[Even Older versions](#even-older-versions)
+## 3.7.1
+
+### Improvements
+* Applied the JUnit reporter's optimization from last release to the SonarQube reporter
+* Suppressed `-Wuseless-cast` in `CHECK_THROWS_MATCHES` (#2904)
+* Standardize exit codes for various failures
+ * Running no tests is now guaranteed to exit with 2 (without the `--allow-running-no-tests` flag)
+ * All tests skipped is now always 4 (...)
+ * Assertion failures are now always 42
+ * and so on
+
+### Fixes
+* Fixed out-of-bounds access when the arg parser encounters single `-` as an argument (#2905)
+
+### Miscellaneous
+* Added `catch_config_prefix_messages.hpp` to meson build (#2903)
+* `catch_discover_tests` now supports skipped tests (#2873)
+ * You can get the old behaviour by calling `catch_discover_tests` with `SKIP_IS_FAILURE` option.
+
+
+## 3.7.0
+
+### Improvements
+* Slightly improved compile times of benchmarks
+* Made the resolution estimation in benchmarks slightly more precise
+* Added new test case macro, `TEST_CASE_PERSISTENT_FIXTURE` (#2885, #1602)
+ * Unlike `TEST_CASE_METHOD`, the same underlying instance is used for all partial runs of that test case
+* **MASSIVELY** improved performance of the JUnit reporter when handling successful assertions (#2897)
+ * For 1 test case and 10M assertions, the new reporter runs 3x faster and uses up only 8 MB of memory, while the old one needs 7 GB of memory.
+* Reworked how output redirects works.
+ * Combining a reporter writing to stdout with capturing reporter no longer leads to the capturing reporter seeing all of the other reporter's output.
+ * The file based redirect no longer opens up a new temporary file for each partial test case run, so it will not run out of temporary files when running many tests in single process.
+
+### Miscellaneous
+* Better documentation for matchers on thrown exceptions (`REQUIRE_THROWS_MATCHES`)
+* Improved `catch_discover_tests`'s handling of environment paths (#2878)
+ * It won't reorder paths in `DL_PATHS` or `DYLD_FRAMEWORK_PATHS` args
+ * It won't overwrite the environment paths for test discovery
+
+
+## 3.6.0
+
+### Fixes
+* Fixed Windows ARM64 build by fixing the preprocessor condition guarding use `_umul128` intrinsic.
+* Fixed Windows ARM64EC build by removing intrinsic pragma it does not understand. (#2858)
+ * Why doesn't the x64-emulation build mode understand x64 pragmas? Don't ask me, ask the MSVC guys.
+* Fixed the JUnit reporter sometimes crashing when reporting a fatal error. (#1210, #2855)
+ * The binary will still exit, but through the original error, rather than secondary error inside the reporter.
+ * The underlying fix applies to all reporters, not just the JUnit one, but only JUnit was currently causing troubles.
+
+### Improvements
+* Disable `-Wnon-virtual-dtor` in Decomposer and Matchers (#2854)
+* `precision` in floating point stringmakers defaults to `max_digits10`.
+ * This means that floating point values will be printed with enough precision to disambiguate any two floats.
+* Column wrapping ignores ansi colour codes when calculating string width (#2833, #2849)
+ * This makes the output much more readable when the provided messages contain colour codes.
+
+### Miscellaneous
+* Conan support improvements
+ * `compatibility_cppstr` is set to False. (#2860)
+ * This means that Conan won't let you mix library and project with different C++ standard settings.
+ * The implementation library CMake target name through Conan is properly set to `Catch2::Catch2` (#2861)
+* `SelfTest` target can be built through Bazel (#2857)
+
+
+## 3.5.4
+
+### Fixes
+* Fixed potential compilation error when asked to generate random integers whose type did not match `std::(u)int*_t`.
+ * This manifested itself when generating random `size_t`s on MacOS
+* Added missing outlined destructor causing `Wdelete-incomplete` when compiling against libstdc++ in C++23 mode (#2852)
+* Fixed regression where decomposing assertion with const instance of `std::foo_ordering` would not compile
+
+### Improvements
+* Reintroduced support for GCC 5 and 6 (#2836)
+ * As with VS2017, if they start causing trouble again, they will be dropped again.
+* Added workaround for targetting newest MacOS (Sonoma) using GCC (#2837, #2839)
+* `CATCH_CONFIG_DEFAULT_REPORTER` can now be an arbitrary reporter spec
+ * Previously it could only be a plain reporter name, so it was impossible to compile in custom arguments to the reporter.
+* Improved performance of generating 64bit random integers by 20+%
+
+### Miscellaneous
+* Significantly improved Conan in-tree recipe (#2831)
+* `DL_PATHS` in `catch_discover_tests` now supports multiple arguments (#2852, #2736)
+* Fixed preprocessor logic for checking whether we expect reproducible floating point results in tests.
+* Improved the floating point tests structure to avoid `Wunused` when the reproducibility tests are disabled (#2845)
+
+
+## 3.5.3
+
+### Fixes
+* Fixed OOB access when computing filename tag (from the `-#` flag) for file without extension (#2798)
+* Fixed the linking against `log` on Android to be `PRIVATE` (#2815)
+* Fixed `Wuseless-cast` in benchmarking internals (#2823)
+
+### Improvements
+* Restored compatibility with VS2017 (#2792, #2822)
+ * The baseline for Catch2 is still C++14 with some reasonable workarounds for specific compilers, so if VS2017 starts acting up again, the support will be dropped again.
+* Suppressed clang-tidy's `bugprone-chained-comparison` in assertions (#2801)
+* Improved the static analysis mode to evaluate arguments to `TEST_CASE` and `SECTION` (#2817)
+ * Clang-tidy should no longer warn about runtime arguments to these macros being unused in static analysis mode.
+ * Clang-tidy can warn on issues involved arguments to these macros.
+* Added support for literal-zero detectors based on `consteval` constructors
+ * This is required for compiling `REQUIRE((a <=> b) == 0)` against MSVC's stdlib.
+ * Sadly, MSVC still cannot compile this assertion as it does not implement C++20 correctly.
+ * You can use `clang-cl` with MSVC's stdlib instead.
+ * If for some godforsaken reasons you want to understand this better, read the two relevant commits: [`dc51386b9fd61f99ea9c660d01867e6ad489b403`](https://github.com/catchorg/Catch2/commit/dc51386b9fd61f99ea9c660d01867e6ad489b403), and [`0787132fc82a75e3fb255aa9484ca1dc1eff2a30`](https://github.com/catchorg/Catch2/commit/0787132fc82a75e3fb255aa9484ca1dc1eff2a30).
+
+### Miscellaneous
+* Disabled tests for FP random generator reproducibility on non-SSE2 x86 targets (#2796)
+* Modified the in-tree Conan recipe to support Conan 2 (#2805)
+
+
+## 3.5.2
+
+### Fixes
+* Fixed `-Wsubobject-linkage` in the Console reporter (#2794)
+* Fixed adding new CLI Options to lvalue parser using `|` (#2787)
+
+
+## 3.5.1
+
+### Improvements
+* Significantly improved performance of the CLI parsing.
+ * This includes the cost of preparing the CLI parser, so Catch2's binaries start much faster.
+
+### Miscellaneous
+* Added support for Bazel modules (#2781)
+* Added CMake option to disable the build reproducibility settings (#2785)
+* Added `log` library linking to the Meson build (#2784)
+
+
+## 3.5.0
+
+### Improvements
+* Introduced `CATCH_CONFIG_PREFIX_MESSAGES` to prefix only logging macros (#2544)
+ * This means `INFO`, `UNSCOPED_INFO`, `WARN` and `CAPTURE`.
+* Section hints in static analysis mode are now `const`
+ * This prevents Clang-Tidy from complaining about `misc-const-correctness`.
+* `from_range` generator supports C arrays and ranges that require ADL (#2737)
+* Stringification support for `std::optional` now also includes `std::nullopt` (#2740)
+* The Console reporter flushes output after writing benchmark runtime estimate.
+ * This means that you can immediately see for how long the benchmark is expected to run.
+* Added workaround to enable compilation with ICC 19.1 (#2551, #2766)
+* Compiling Catch2 for XBox should work out of the box (#2772)
+ * Catch2 should automatically disable getenv when compiled for XBox.
+* Compiling Catch2 with exceptions disabled no longer triggers `Wunused-function` (#2726)
+* **`random` Generators for integral types are now reproducible across different platforms**
+ * Unlike ``, Catch2's generators also support 1 byte integral types (`char`, `bool`, ...)
+* **`random` Generators for `float` and `double` are now reproducible across different platforms**
+ * `long double` varies across different platforms too much to be reproducible
+ * This guarantee applies only to platforms with IEEE 754 floats.
+
+### Fixes
+* UDL declaration inside Catch2 are now strictly conforming to the standard
+ * `operator "" _a` is UB, `operator ""_a` is fine. Seriously.
+* Fixed `CAPTURE` tests failing to compile in C++23 mode (#2744)
+* Fixed missing include in `catch_message.hpp` (#2758)
+* Fixed `CHECK_ELSE` suppressing failure from uncaught exceptions(#2723)
+
+### Miscellaneous
+* The documentation for specifying which tests to run through commandline has been completely rewritten (#2738)
+* Fixed installation when building Catch2 with meson (#2722, #2742)
+* Fixed `catch_discover_tests` when using custom reporter and `PRE_TEST` discovery mode (#2747)
+* `catch_discover_tests` supports multi-config CMake generator in `PRE_TEST` discovery mode (#2739, #2746)
+
+
+## 3.4.0
+
+### Improvements
+* `VectorEquals` supports elements that provide only `==` and not `!=` (#2648)
+* Catch2 supports compiling with IAR compiler (#2651)
+* Various small internal performance improvements
+* Various small internal compilation time improvements
+* XMLReporter now reports location info for INFO and WARN (#1251)
+ * This bumps up the xml format version to 3
+* Documented that `SKIP` in generator constructor can be used to handle empty generator (#1593)
+* Added experimental static analysis support to `TEST_CASE` and `SECTION` macros (#2681)
+ * The two macros are redefined in a way that helps the SA tools reason about the possible paths through a test case with sections.
+ * The support is controlled by the `CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT` option and autodetects clang-tidy and Coverity.
+* `*_THROWS`, `*_THROWS_AS`, etc now suppress warning coming from `__attribute__((warn_unused_result))` on GCC (#2691)
+ * Unlike plain `[[nodiscard]]`, this warning is not silenced by void cast. WTF GCC?
+
+### Fixes
+* Fixed `assertionStarting` events being sent after the expr is evaluated (#2678)
+* Errors in `TEST_CASE` tags are now reported nicely (#2650)
+
+### Miscellaneous
+* Bunch of improvements to `catch_discover_tests`
+ * Added DISCOVERY_MODE option, so the discovery can happen either post build or pre-run.
+ * Fixed handling of semicolons and backslashes in test names (#2674, #2676)
+* meson build can disable building tests (#2693)
+* meson build properly sets meson version 0.54.1 as the minimal supported version (#2688)
+
## 3.3.2
@@ -149,7 +352,7 @@
### Fixes
* Cleaned out some warnings and static analysis issues
- * Suppressed `-Wcomma` warning rarely occuring in templated test cases (#2543)
+ * Suppressed `-Wcomma` warning rarely occurring in templated test cases (#2543)
* Constified implementation details in `INFO` (#2564)
* Made `MatcherGenericBase` copy constructor const (#2566)
* Fixed serialization of test filters so the output roundtrips
@@ -352,7 +555,7 @@ v3 releases.
* Added `STATIC_CHECK` macro, similar to `STATIC_REQUIRE` (#2318)
* When deferred tu runtime, it behaves like `CHECK`, and not like `REQUIRE`.
* You can have multiple tests with the same name, as long as other parts of the test identity differ (#1915, #1999, #2175)
- * Test identity includes test's name, test's tags and and test's class name if applicable.
+ * Test identity includes test's name, test's tags and test's class name if applicable.
* Added new warning, `UnmatchedTestSpec`, to error on test specs with no matching tests
* The `-w`, `--warn` warning flags can now be provided multiple times to enable multiple warnings
* The case-insensitive handling of tags is now more reliable and takes up less memory
@@ -517,7 +720,7 @@ v3 releases.
* The `SECTION`(s) before the `GENERATE` will not be run multiple times, the following ones will.
* Added `-D`/`--min-duration` command line flag (#1910)
* If a test takes longer to finish than the provided value, its name and duration will be printed.
- * This flag is overriden by setting `-d`/`--duration`.
+ * This flag is overridden by setting `-d`/`--duration`.
### Fixes
* `TAPReporter` no longer skips successful assertions (#1983)
@@ -585,7 +788,7 @@ v3 releases.
### Fixes
* Fixed computation of benchmarking column widths in ConsoleReporter (#1885, #1886)
* Suppressed clang-tidy's `cppcoreguidelines-pro-type-vararg` in assertions (#1901)
- * It was a false positive trigered by the new warning support workaround
+ * It was a false positive triggered by the new warning support workaround
* Fixed bug in test specification parser handling of OR'd patterns using escaping (#1905)
### Miscellaneous
@@ -922,7 +1125,7 @@ v3 releases.
### Contrib
* `ParseAndAddCatchTests` has learned how to use `DISABLED` CTest property (#1452)
-* `ParseAndAddCatchTests` now works when there is a whitspace before the test name (#1493)
+* `ParseAndAddCatchTests` now works when there is a whitespace before the test name (#1493)
### Miscellaneous
diff --git a/src/external/catch2/docs/reporter-events.md b/src/external/catch2/docs/reporter-events.md
index 32a0ae50..015f67be 100644
--- a/src/external/catch2/docs/reporter-events.md
+++ b/src/external/catch2/docs/reporter-events.md
@@ -96,12 +96,12 @@ void assertionStarting( AssertionInfo const& assertionInfo );
void assertionEnded( AssertionStats const& assertionStats );
```
-`assertionStarting` is called after the expression is captured, but before
-the assertion expression is evaluated. This might seem like a minor
-distinction, but what it means is that if you have assertion like
-`REQUIRE( a + b == c + d )`, then what happens is that `a + b` and `c + d`
-are evaluated before `assertionStarting` is emitted, while the `==` is
-evaluated after the event.
+The `assertionStarting` event is emitted before the expression in the
+assertion is captured or evaluated and `assertionEnded` is emitted
+afterwards. This means that given assertion like `REQUIRE(a + b == c + d)`,
+Catch2 first emits `assertionStarting` event, then `a + b` and `c + d`
+are evaluated, then their results are captured, the comparison is evaluated,
+and then `assertionEnded` event is emitted.
## Benchmarking events
diff --git a/src/external/catch2/docs/reporters.md b/src/external/catch2/docs/reporters.md
index 496c61a9..20ef5e55 100644
--- a/src/external/catch2/docs/reporters.md
+++ b/src/external/catch2/docs/reporters.md
@@ -5,7 +5,7 @@ Reporters are a customization point for most of Catch2's output, e.g.
formatting and writing out [assertions (whether passing or failing),
sections, test cases, benchmarks, and so on](reporter-events.md#top).
-Catch2 comes with a bunch of reporters by default (currently 8), and
+Catch2 comes with a bunch of reporters by default (currently 9), and
you can also write your own reporter. Because multiple reporters can
be active at the same time, your own reporters do not even have to handle
all reporter event, just the ones you are interested in, e.g. benchmarks.
@@ -52,7 +52,7 @@ its machine-readable XML output to file `result-junit.xml`, and the
uses ANSI colour codes for colouring the output.
Using multiple reporters (or one reporter and one-or-more [event
-listeners](event-listener.md#top)) can have surprisingly complex semantics
+listeners](event-listeners.md#top)) can have surprisingly complex semantics
when using customization points provided to reporters by Catch2, namely
capturing stdout/stderr from test cases.
diff --git a/src/external/catch2/docs/skipping-passing-failing.md b/src/external/catch2/docs/skipping-passing-failing.md
index 4300d9d3..52bb18f7 100644
--- a/src/external/catch2/docs/skipping-passing-failing.md
+++ b/src/external/catch2/docs/skipping-passing-failing.md
@@ -9,7 +9,7 @@ In some situations it may not be possible to meaningfully execute a test case,
for example when the system under test is missing certain hardware capabilities.
If the required conditions can only be determined at runtime, it often
doesn't make sense to consider such a test case as either passed or failed,
-because it simply can not run at all.
+because it simply cannot run at all.
To properly express such scenarios, Catch2 provides a way to explicitly
_skip_ test cases, using the `SKIP` macro:
@@ -84,6 +84,12 @@ exit code, same as it does if no test cases have run. This behaviour can
be overridden using the [--allow-running-no-tests](command-line.md#no-tests-override)
flag.
+### `SKIP` inside generators
+
+You can also use the `SKIP` macro inside generator's constructor to handle
+cases where the generator is empty, but you do not want to fail the test
+case.
+
## Passing and failing test cases
diff --git a/src/external/catch2/docs/test-cases-and-sections.md b/src/external/catch2/docs/test-cases-and-sections.md
index acebcc51..14db55ae 100644
--- a/src/external/catch2/docs/test-cases-and-sections.md
+++ b/src/external/catch2/docs/test-cases-and-sections.md
@@ -48,7 +48,7 @@ For more detail on command line selection see [the command line docs](command-li
Tag names are not case sensitive and can contain any ASCII characters.
This means that tags `[tag with spaces]` and `[I said "good day"]`
are both allowed tags and can be filtered on. However, escapes are not
-supported however and `[\]]` is not a valid tag.
+supported and `[\]]` is not a valid tag.
The same tag can be specified multiple times for a single test case,
but only one of the instances of identical tags will be kept. Which one
@@ -231,7 +231,7 @@ TEMPLATE_TEST_CASE( "vectors can be sized and resized", "[vector][template]", in
> [Introduced](https://github.com/catchorg/Catch2/issues/1468) in Catch2 2.6.0.
-_template-type1_ through _template-typen_ is list of template template
+_template-type1_ through _template-typen_ is list of template
types which should be combined with each of _template-arg1_ through
_template-argm_, resulting in _n * m_ test cases. Inside the test case,
the resulting type is available under the name of `TestType`.
diff --git a/src/external/catch2/docs/test-fixtures.md b/src/external/catch2/docs/test-fixtures.md
index 9c9eaa18..653b50e0 100644
--- a/src/external/catch2/docs/test-fixtures.md
+++ b/src/external/catch2/docs/test-fixtures.md
@@ -1,9 +1,30 @@
# Test fixtures
-## Defining test fixtures
+**Contents**
+[Non-Templated test fixtures](#non-templated-test-fixtures)
+[Templated test fixtures](#templated-test-fixtures)
+[Signature-based parameterised test fixtures](#signature-based-parametrised-test-fixtures)
+[Template fixtures with types specified in template type lists](#template-fixtures-with-types-specified-in-template-type-lists)
-Although Catch allows you to group tests together as [sections within a test case](test-cases-and-sections.md), it can still be convenient, sometimes, to group them using a more traditional test fixture. Catch fully supports this too. You define the test fixture as a simple structure:
+## Non-Templated test fixtures
+
+Although Catch2 allows you to group tests together as
+[sections within a test case](test-cases-and-sections.md), it can still
+be convenient, sometimes, to group them using a more traditional test.
+Catch2 fully supports this too with 3 different macros for
+non-templated test fixtures. They are:
+
+| Macro | Description |
+|----------|-------------|
+|1. `TEST_CASE_METHOD(className, ...)`| Creates a uniquely named class which inherits from the class specified by `className`. The test function will be a member of this derived class. An instance of the derived class will be created for every partial run of the test case. |
+|2. `METHOD_AS_TEST_CASE(member-function, ...)`| Uses `member-function` as the test function. An instance of the class will be created for each partial run of the test case. |
+|3. `TEST_CASE_PERSISTENT_FIXTURE(className, ...)`| Creates a uniquely named class which inherits from the class specified by `className`. The test function will be a member of this derived class. An instance of the derived class will be created at the start of the test run. That instance will be destroyed once the entire test case has ended. |
+
+### 1. `TEST_CASE_METHOD`
+
+
+You define a `TEST_CASE_METHOD` test fixture as a simple structure:
```c++
class UniqueTestsFixture {
@@ -30,8 +51,116 @@ class UniqueTestsFixture {
}
```
-The two test cases here will create uniquely-named derived classes of UniqueTestsFixture and thus can access the `getID()` protected method and `conn` member variables. This ensures that both the test cases are able to create a DBConnection using the same method (DRY principle) and that any ID's created are unique such that the order that tests are executed does not matter.
+The two test cases here will create uniquely-named derived classes of
+UniqueTestsFixture and thus can access the `getID()` protected method
+and `conn` member variables. This ensures that both the test cases
+are able to create a DBConnection using the same method
+(DRY principle) and that any ID's created are unique such that the
+order that tests are executed does not matter.
+
+### 2. `METHOD_AS_TEST_CASE`
+
+`METHOD_AS_TEST_CASE` lets you register a member function of a class
+as a Catch2 test case. The class will be separately instantiated
+for each method registered in this way.
+
+```cpp
+class TestClass {
+ std::string s;
+
+public:
+ TestClass()
+ :s( "hello" )
+ {}
+
+ void testCase() {
+ REQUIRE( s == "hello" );
+ }
+};
+
+
+METHOD_AS_TEST_CASE( TestClass::testCase, "Use class's method as a test case", "[class]" )
+```
+
+This type of fixture is similar to [TEST_CASE_METHOD](#1-test_case_method) except in this
+case it will directly use the provided class to create an object rather than a derived
+class.
+
+### 3. `TEST_CASE_PERSISTENT_FIXTURE`
+
+> [Introduced](https://github.com/catchorg/Catch2/pull/2885) in Catch2 3.7.0
+
+`TEST_CASE_PERSISTENT_FIXTURE` behaves in the same way as
+[TEST_CASE_METHOD](#1-test_case_method) except that there will only be
+one instance created throughout the entire run of a test case. To
+demonstrate this have a look at the following example:
+
+```cpp
+class ClassWithExpensiveSetup {
+public:
+ ClassWithExpensiveSetup() {
+ // expensive construction
+ std::this_thread::sleep_for( std::chrono::seconds( 2 ) );
+ }
+
+ ~ClassWithExpensiveSetup() noexcept {
+ // expensive destruction
+ std::this_thread::sleep_for( std::chrono::seconds( 1 ) );
+ }
+
+ int getInt() const { return 42; }
+};
+
+struct MyFixture {
+ mutable int myInt = 0;
+ ClassWithExpensiveSetup expensive;
+};
+
+TEST_CASE_PERSISTENT_FIXTURE( MyFixture, "Tests with MyFixture" ) {
+
+ const int val = myInt++;
+
+ SECTION( "First partial run" ) {
+ const auto otherValue = expensive.getInt();
+ REQUIRE( val == 0 );
+ REQUIRE( otherValue == 42 );
+ }
+
+ SECTION( "Second partial run" ) { REQUIRE( val == 1 ); }
+}
+```
+
+This example demonstates two possible use-cases of this fixture type:
+1. Improve test run times by reducing the amount of expensive and
+redundant setup and tear-down required.
+2. Reusing results from the previous partial run, in the current
+partial run.
+
+This test case will be executed twice as there are two leaf sections.
+On the first run `val` will be `0` and on the second run `val` will be
+`1`. This demonstrates that we were able to use the results of the
+previous partial run in subsequent partial runs.
+
+Additionally, we are simulating an expensive object using
+`std::this_thread::sleep_for`, but real world use-cases could be:
+1. Creating a D3D12/Vulkan device
+2. Connecting to a database
+3. Loading a file.
+
+The fixture object (`MyFixture`) will be constructed just before the
+test case begins, and it will be destroyed just after the test case
+ends. Therefore, this expensive object will only be created and
+destroyed once during the execution of this test case. If we had used
+`TEST_CASE_METHOD`, `MyFixture` would have been created and destroyed
+twice during the execution of this test case.
+
+NOTE: The member function which runs the test case is `const`. Therefore
+if you want to mutate any member of the fixture it must be marked as
+`mutable` as shown in this example. This is to make it clear that
+the initial state of the fixture is intended to mutate during the
+execution of the test case.
+## Templated test fixtures
Catch2 also provides `TEMPLATE_TEST_CASE_METHOD` and
`TEMPLATE_PRODUCT_TEST_CASE_METHOD` that can be used together
@@ -93,7 +222,7 @@ _While there is an upper limit on the number of types you can specify
in single `TEMPLATE_TEST_CASE_METHOD` or `TEMPLATE_PRODUCT_TEST_CASE_METHOD`,
the limit is very high and should not be encountered in practice._
-## Signature-based parametrised test fixtures
+## Signature-based parameterised test fixtures
> [Introduced](https://github.com/catchorg/Catch2/issues/1609) in Catch2 2.8.0.
diff --git a/src/external/catch2/docs/tostring.md b/src/external/catch2/docs/tostring.md
index adce3cc7..b99b6742 100644
--- a/src/external/catch2/docs/tostring.md
+++ b/src/external/catch2/docs/tostring.md
@@ -75,7 +75,7 @@ CATCH_TRANSLATE_EXCEPTION( MyType const& ex ) {
Enums that already have a `<<` overload for `std::ostream` will convert to strings as expected.
If you only need to convert enums to strings for test reporting purposes you can provide a `StringMaker` specialisations as any other type.
-However, as a convenience, Catch provides the `REGISTER_ENUM` helper macro that will generate the `StringMaker` specialiation for you with minimal code.
+However, as a convenience, Catch provides the `REGISTER_ENUM` helper macro that will generate the `StringMaker` specialisation for you with minimal code.
Simply provide it the (qualified) enum name, followed by all the enum values, and you're done!
E.g.
diff --git a/src/external/catch2/docs/tutorial.md b/src/external/catch2/docs/tutorial.md
index 342c7381..fb5a5b37 100644
--- a/src/external/catch2/docs/tutorial.md
+++ b/src/external/catch2/docs/tutorial.md
@@ -16,7 +16,7 @@ Ideally you should be using Catch2 through its [CMake integration](cmake-integra
Catch2 also provides pkg-config files and two file (header + cpp)
distribution, but this documentation will assume you are using CMake. If
you are using the two file distribution instead, remember to replace
-the included header with `catch_amalgamated.hpp`.
+the included header with `catch_amalgamated.hpp` ([step by step instructions](migrate-v2-to-v3.md#how-to-migrate-projects-from-v2-to-v3)).
## Writing tests
@@ -119,7 +119,7 @@ This is best explained through an example ([code](../examples/100-Fix-Section.cp
```c++
TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
-
+ // This setup will be done 4 times in total, once for each section
std::vector v( 5 );
REQUIRE( v.size() == 5 );
@@ -152,11 +152,12 @@ TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
}
```
-For each `SECTION` the `TEST_CASE` is executed from the start. This means
+For each `SECTION` the `TEST_CASE` is **executed from the start**. This means
that each section is entered with a freshly constructed vector `v`, that
we know has size 5 and capacity at least 5, because the two assertions
-are also checked before the section is entered. Each run through a test
-case will execute one, and only one, leaf section.
+are also checked before the section is entered. This behaviour may not be
+ideal for tests where setup is expensive. Each run through a test case will
+execute one, and only one, leaf section.
Section can also be nested, in which case the parent section can be
entered multiple times, once for each leaf section. Nested sections are
diff --git a/src/external/catch2/docs/why-catch.md b/src/external/catch2/docs/why-catch.md
index 2c0178ca..b7367496 100644
--- a/src/external/catch2/docs/why-catch.md
+++ b/src/external/catch2/docs/why-catch.md
@@ -30,7 +30,7 @@ So what does Catch2 bring to the party that differentiates it from these? Apart
* Output is through modular reporter objects. Basic textual and XML reporters are included. Custom reporters can easily be added.
* JUnit xml output is supported for integration with third-party tools, such as CI servers.
* A default main() function is provided, but you can supply your own for complete control (e.g. integration into your own test runner GUI).
-* A command line parser is provided and can still be used if you choose to provided your own main() function.
+* A command line parser is provided and can still be used if you choose to provide your own main() function.
* Alternative assertion macro(s) report failures but don't abort the test case
* Good set of facilities for floating point comparisons (`Catch::Approx` and full set of matchers)
* Internal and friendly macros are isolated so name clashes can be managed
@@ -41,8 +41,8 @@ So what does Catch2 bring to the party that differentiates it from these? Apart
## Who else is using Catch2?
-A whole lot of people. According to the 2021 JetBrains C++ ecosystem survey,
-about 11% of C++ programmers use Catch2 for unit testing, making it the
+A whole lot of people. According to [the 2022 JetBrains C++ ecosystem survey](https://www.jetbrains.com/lp/devecosystem-2022/cpp/#Which-unit-testing-frameworks-do-you-regularly-use),
+about 12% of C++ programmers use Catch2 for unit testing, making it the
second most popular unit testing framework.
You can also take a look at the (incomplete) list of [open source projects](opensource-users.md#top)
diff --git a/src/external/catch2/examples/010-TestCase.cpp b/src/external/catch2/examples/010-TestCase.cpp
index 7ec208d5..9e5cd8cd 100644
--- a/src/external/catch2/examples/010-TestCase.cpp
+++ b/src/external/catch2/examples/010-TestCase.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 010-TestCase.cpp
// And write tests in the same file:
#include
diff --git a/src/external/catch2/examples/020-TestCase-1.cpp b/src/external/catch2/examples/020-TestCase-1.cpp
index cec55799..a9d87dbc 100644
--- a/src/external/catch2/examples/020-TestCase-1.cpp
+++ b/src/external/catch2/examples/020-TestCase-1.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 020-TestCase-1.cpp
#include
diff --git a/src/external/catch2/examples/020-TestCase-2.cpp b/src/external/catch2/examples/020-TestCase-2.cpp
index 3f5767b3..72dd0ffb 100644
--- a/src/external/catch2/examples/020-TestCase-2.cpp
+++ b/src/external/catch2/examples/020-TestCase-2.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 020-TestCase-2.cpp
// main() provided by Catch in file 020-TestCase-1.cpp.
diff --git a/src/external/catch2/examples/030-Asn-Require-Check.cpp b/src/external/catch2/examples/030-Asn-Require-Check.cpp
index 0d027ca9..62cd3cfc 100644
--- a/src/external/catch2/examples/030-Asn-Require-Check.cpp
+++ b/src/external/catch2/examples/030-Asn-Require-Check.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 030-Asn-Require-Check.cpp
// Catch has two natural expression assertion macro's:
diff --git a/src/external/catch2/examples/100-Fix-Section.cpp b/src/external/catch2/examples/100-Fix-Section.cpp
index cfbfa79f..7c8d8aa8 100644
--- a/src/external/catch2/examples/100-Fix-Section.cpp
+++ b/src/external/catch2/examples/100-Fix-Section.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 100-Fix-Section.cpp
// Catch has two ways to express fixtures:
diff --git a/src/external/catch2/examples/110-Fix-ClassFixture.cpp b/src/external/catch2/examples/110-Fix-ClassFixture.cpp
index 75c10da6..614c3797 100644
--- a/src/external/catch2/examples/110-Fix-ClassFixture.cpp
+++ b/src/external/catch2/examples/110-Fix-ClassFixture.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 110-Fix-ClassFixture.cpp
// Catch has two ways to express fixtures:
diff --git a/src/external/catch2/examples/111-Fix-PersistentFixture.cpp b/src/external/catch2/examples/111-Fix-PersistentFixture.cpp
new file mode 100644
index 00000000..2bef90ff
--- /dev/null
+++ b/src/external/catch2/examples/111-Fix-PersistentFixture.cpp
@@ -0,0 +1,74 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+// Fixture.cpp
+
+// Catch2 has three ways to express fixtures:
+// - Sections
+// - Traditional class-based fixtures that are created and destroyed on every
+// partial run
+// - Traditional class-based fixtures that are created at the start of a test
+// case and destroyed at the end of a test case (this file)
+
+// main() provided by linkage to Catch2WithMain
+
+#include
+
+#include
+
+class ClassWithExpensiveSetup {
+public:
+ ClassWithExpensiveSetup() {
+ // Imagine some really expensive set up here.
+ // e.g.
+ // setting up a D3D12/Vulkan Device,
+ // connecting to a database,
+ // loading a file
+ // etc etc etc
+ std::this_thread::sleep_for( std::chrono::seconds( 2 ) );
+ }
+
+ ~ClassWithExpensiveSetup() noexcept {
+ // We can do any clean up of the expensive class in the destructor
+ // e.g.
+ // destroy D3D12/Vulkan Device,
+ // disconnecting from a database,
+ // release file handle
+ // etc etc etc
+ std::this_thread::sleep_for( std::chrono::seconds( 1 ) );
+ }
+
+ int getInt() const { return 42; }
+};
+
+struct MyFixture {
+
+ // The test case member function is const.
+ // Therefore we need to mark any member of the fixture
+ // that needs to mutate as mutable.
+ mutable int myInt = 0;
+ ClassWithExpensiveSetup expensive;
+};
+
+// Only one object of type MyFixture will be instantiated for the run
+// of this test case even though there are two leaf sections.
+// This is useful if your test case requires an object that is
+// expensive to create and could be reused for each partial run of the
+// test case.
+TEST_CASE_PERSISTENT_FIXTURE( MyFixture, "Tests with MyFixture" ) {
+
+ const int val = myInt++;
+
+ SECTION( "First partial run" ) {
+ const auto otherValue = expensive.getInt();
+ REQUIRE( val == 0 );
+ REQUIRE( otherValue == 42 );
+ }
+
+ SECTION( "Second partial run" ) { REQUIRE( val == 1 ); }
+}
\ No newline at end of file
diff --git a/src/external/catch2/examples/120-Bdd-ScenarioGivenWhenThen.cpp b/src/external/catch2/examples/120-Bdd-ScenarioGivenWhenThen.cpp
index 99cdf9ab..345d53c3 100644
--- a/src/external/catch2/examples/120-Bdd-ScenarioGivenWhenThen.cpp
+++ b/src/external/catch2/examples/120-Bdd-ScenarioGivenWhenThen.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 120-Bdd-ScenarioGivenWhenThen.cpp
// main() provided by linkage with Catch2WithMain
diff --git a/src/external/catch2/examples/210-Evt-EventListeners.cpp b/src/external/catch2/examples/210-Evt-EventListeners.cpp
index 6cedb885..d05dfaaa 100644
--- a/src/external/catch2/examples/210-Evt-EventListeners.cpp
+++ b/src/external/catch2/examples/210-Evt-EventListeners.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 210-Evt-EventListeners.cpp
// Contents:
@@ -377,8 +385,7 @@ struct MyListener : Catch::EventListenerBase {
CATCH_REGISTER_LISTENER( MyListener )
// Get rid of Wweak-tables
-MyListener::~MyListener() {}
-
+MyListener::~MyListener() = default;
// -----------------------------------------------------------------------
// 3. Test cases:
diff --git a/src/external/catch2/examples/231-Cfg-OutputStreams.cpp b/src/external/catch2/examples/231-Cfg-OutputStreams.cpp
index b77c1273..5aee38bc 100644
--- a/src/external/catch2/examples/231-Cfg-OutputStreams.cpp
+++ b/src/external/catch2/examples/231-Cfg-OutputStreams.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 231-Cfg-OutputStreams.cpp
// Show how to replace the streams with a simple custom made streambuf.
@@ -14,7 +22,7 @@ class out_buff : public std::stringbuf {
std::FILE* m_stream;
public:
out_buff(std::FILE* stream):m_stream(stream) {}
- ~out_buff();
+ ~out_buff() override;
int sync() override {
int ret = 0;
for (unsigned char c : str()) {
diff --git a/src/external/catch2/examples/232-Cfg-CustomMain.cpp b/src/external/catch2/examples/232-Cfg-CustomMain.cpp
new file mode 100644
index 00000000..27040993
--- /dev/null
+++ b/src/external/catch2/examples/232-Cfg-CustomMain.cpp
@@ -0,0 +1,41 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+// 232-Cfg-CustomMain.cpp
+// Show how to use custom main and add a custom option to the CLI parser
+
+#include
+
+#include
+
+int main(int argc, char** argv) {
+ Catch::Session session; // There must be exactly one instance
+
+ int height = 0; // Some user variable you want to be able to set
+
+ // Build a new parser on top of Catch2's
+ using namespace Catch::Clara;
+ auto cli
+ = session.cli() // Get Catch2's command line parser
+ | Opt( height, "height" ) // bind variable to a new option, with a hint string
+ ["--height"] // the option names it will respond to
+ ("how high?"); // description string for the help output
+
+ // Now pass the new composite back to Catch2 so it uses that
+ session.cli( cli );
+
+ // Let Catch2 (using Clara) parse the command line
+ int returnCode = session.applyCommandLine( argc, argv );
+ if( returnCode != 0 ) // Indicates a command line error
+ return returnCode;
+
+ // if set on the command line then 'height' is now set at this point
+ std::cout << "height: " << height << '\n';
+
+ return session.run();
+}
diff --git a/src/external/catch2/examples/300-Gen-OwnGenerator.cpp b/src/external/catch2/examples/300-Gen-OwnGenerator.cpp
index 09643d6f..9cb02e39 100644
--- a/src/external/catch2/examples/300-Gen-OwnGenerator.cpp
+++ b/src/external/catch2/examples/300-Gen-OwnGenerator.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 300-Gen-OwnGenerator.cpp
// Shows how to define a custom generator.
@@ -13,7 +21,7 @@
namespace {
// This class shows how to implement a simple generator for Catch tests
-class RandomIntGenerator : public Catch::Generators::IGenerator {
+class RandomIntGenerator final : public Catch::Generators::IGenerator {
std::minstd_rand m_rand;
std::uniform_int_distribution<> m_dist;
int current_number;
diff --git a/src/external/catch2/examples/301-Gen-MapTypeConversion.cpp b/src/external/catch2/examples/301-Gen-MapTypeConversion.cpp
index ba55f65f..0a284483 100644
--- a/src/external/catch2/examples/301-Gen-MapTypeConversion.cpp
+++ b/src/external/catch2/examples/301-Gen-MapTypeConversion.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 301-Gen-MapTypeConversion.cpp
// Shows how to use map to modify generator's return type.
@@ -16,12 +24,12 @@ namespace {
// Returns a line from a stream. You could have it e.g. read lines from
// a file, but to avoid problems with paths in examples, we will use
// a fixed stringstream.
-class LineGenerator : public Catch::Generators::IGenerator {
+class LineGenerator final : public Catch::Generators::IGenerator {
std::string m_line;
std::stringstream m_stream;
public:
- LineGenerator() {
- m_stream.str("1\n2\n3\n4\n");
+ explicit LineGenerator( std::string const& lines ) {
+ m_stream.str( lines );
if (!next()) {
Catch::Generators::Detail::throw_generator_exception("Couldn't read a single line");
}
@@ -41,18 +49,19 @@ std::string const& LineGenerator::get() const {
// This helper function provides a nicer UX when instantiating the generator
// Notice that it returns an instance of GeneratorWrapper, which
// is a value-wrapper around std::unique_ptr>.
-Catch::Generators::GeneratorWrapper lines(std::string /* ignored for example */) {
+Catch::Generators::GeneratorWrapper
+lines( std::string const& lines ) {
return Catch::Generators::GeneratorWrapper(
- new LineGenerator()
- );
+ new LineGenerator( lines ) );
}
} // end anonymous namespace
TEST_CASE("filter can convert types inside the generator expression", "[example][generator]") {
- auto num = GENERATE(map([](std::string const& line) { return std::stoi(line); },
- lines("fake-file")));
+ auto num = GENERATE(
+ map( []( std::string const& line ) { return std::stoi( line ); },
+ lines( "1\n2\n3\n4\n" ) ) );
REQUIRE(num > 0);
}
diff --git a/src/external/catch2/examples/302-Gen-Table.cpp b/src/external/catch2/examples/302-Gen-Table.cpp
index 74319518..3cdb1430 100644
--- a/src/external/catch2/examples/302-Gen-Table.cpp
+++ b/src/external/catch2/examples/302-Gen-Table.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 302-Gen-Table.cpp
// Shows how to use table to run a test many times with different inputs. Lifted from examples on
// issue #850.
@@ -44,11 +52,11 @@ TEST_CASE("Table allows pre-computed test inputs and outputs", "[example][genera
/* Possible simplifications where less legacy toolchain support is needed:
*
- * - With libstdc++6 or newer, the make_tuple() calls can be ommitted
+ * - With libstdc++6 or newer, the make_tuple() calls can be omitted
* (technically C++17 but does not require -std in GCC/Clang). See
* https://stackoverflow.com/questions/12436586/tuple-vector-and-initializer-list
*
- * - In C++17 mode std::tie() and the preceding variable delcarations can be
+ * - In C++17 mode std::tie() and the preceding variable declarations can be
* replaced by structured bindings: auto [test_input, expected] = GENERATE(
* table({ ...
*/
diff --git a/src/external/catch2/examples/310-Gen-VariablesInGenerators.cpp b/src/external/catch2/examples/310-Gen-VariablesInGenerators.cpp
index 0339c5f1..5d24d45a 100644
--- a/src/external/catch2/examples/310-Gen-VariablesInGenerators.cpp
+++ b/src/external/catch2/examples/310-Gen-VariablesInGenerators.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 310-Gen-VariablesInGenerator.cpp
// Shows how to use variables when creating generators.
diff --git a/src/external/catch2/examples/311-Gen-CustomCapture.cpp b/src/external/catch2/examples/311-Gen-CustomCapture.cpp
index d12ee709..ee310383 100644
--- a/src/external/catch2/examples/311-Gen-CustomCapture.cpp
+++ b/src/external/catch2/examples/311-Gen-CustomCapture.cpp
@@ -1,3 +1,11 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
// 311-Gen-CustomCapture.cpp
// Shows how to provide custom capture list to the generator expression
diff --git a/src/external/catch2/examples/CMakeLists.txt b/src/external/catch2/examples/CMakeLists.txt
index f9933341..4647df1d 100644
--- a/src/external/catch2/examples/CMakeLists.txt
+++ b/src/external/catch2/examples/CMakeLists.txt
@@ -28,8 +28,10 @@ set( SOURCES_IDIOMATIC_EXAMPLES
030-Asn-Require-Check.cpp
100-Fix-Section.cpp
110-Fix-ClassFixture.cpp
+ 111-Fix-PersistentFixture.cpp
120-Bdd-ScenarioGivenWhenThen.cpp
210-Evt-EventListeners.cpp
+ 232-Cfg-CustomMain.cpp
300-Gen-OwnGenerator.cpp
301-Gen-MapTypeConversion.cpp
302-Gen-Table.cpp
@@ -42,8 +44,7 @@ set( TARGETS_IDIOMATIC_EXAMPLES ${BASENAMES_IDIOMATIC_EXAMPLES} )
foreach( name ${TARGETS_IDIOMATIC_EXAMPLES} )
- add_executable( ${name}
- ${EXAMPLES_DIR}/${name}.cpp )
+ add_executable( ${name} ${name}.cpp )
endforeach()
set(ALL_EXAMPLE_TARGETS
@@ -53,7 +54,7 @@ set(ALL_EXAMPLE_TARGETS
)
foreach( name ${ALL_EXAMPLE_TARGETS} )
- target_link_libraries( ${name} Catch2 Catch2WithMain )
+ target_link_libraries( ${name} Catch2WithMain )
endforeach()
diff --git a/src/external/catch2/extras/Catch.cmake b/src/external/catch2/extras/Catch.cmake
index bc553591..c1712885 100644
--- a/src/external/catch2/extras/Catch.cmake
+++ b/src/external/catch2/extras/Catch.cmake
@@ -35,8 +35,10 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
[TEST_LIST var]
[REPORTER reporter]
[OUTPUT_DIR dir]
- [OUTPUT_PREFIX prefix}
+ [OUTPUT_PREFIX prefix]
[OUTPUT_SUFFIX suffix]
+ [DISCOVERY_MODE ]
+ [SKIP_IS_FAILURE]
)
``catch_discover_tests`` sets up a post-build command on the test executable
@@ -123,15 +125,39 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
test executable and when the tests are executed themselves. This requires
cmake/ctest >= 3.22.
+ ``DL_FRAMEWORK_PATHS path...``
+ Specifies paths that need to be set for the dynamic linker to find libraries
+ packaged as frameworks on Apple platforms when running the test executable
+ (DYLD_FRAMEWORK_PATH). These paths will both be set when retrieving the list
+ of test cases from the test executable and when the tests are executed themselves.
+ This requires cmake/ctest >= 3.22.
+
+ ``DISCOVERY_MODE mode``
+ Provides control over when ``catch_discover_tests`` performs test discovery.
+ By default, ``POST_BUILD`` sets up a post-build command to perform test discovery
+ at build time. In certain scenarios, like cross-compiling, this ``POST_BUILD``
+ behavior is not desirable. By contrast, ``PRE_TEST`` delays test discovery until
+ just prior to test execution. This way test discovery occurs in the target environment
+ where the test has a better chance at finding appropriate runtime dependencies.
+
+ ``DISCOVERY_MODE`` defaults to the value of the
+ ``CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE`` variable if it is not passed when
+ calling ``catch_discover_tests``. This provides a mechanism for globally selecting
+ a preferred test discovery behavior without having to modify each call site.
+
+ ``SKIP_IS_FAILURE``
+ Disables skipped test detection.
+
#]=======================================================================]
#------------------------------------------------------------------------------
function(catch_discover_tests TARGET)
+
cmake_parse_arguments(
""
- ""
- "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX"
- "TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS"
+ "SKIP_IS_FAILURE"
+ "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX;DISCOVERY_MODE"
+ "TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS;DL_FRAMEWORK_PATHS"
${ARGN}
)
@@ -141,11 +167,20 @@ function(catch_discover_tests TARGET)
if(NOT _TEST_LIST)
set(_TEST_LIST ${TARGET}_TESTS)
endif()
-
- if (_DL_PATHS)
- if(${CMAKE_VERSION} VERSION_LESS "3.22.0")
- message(FATAL_ERROR "The DL_PATHS option requires at least cmake 3.22")
+ if(_DL_PATHS AND ${CMAKE_VERSION} VERSION_LESS "3.22.0")
+ message(FATAL_ERROR "The DL_PATHS option requires at least cmake 3.22")
+ endif()
+ if(_DL_FRAMEWORK_PATHS AND ${CMAKE_VERSION} VERSION_LESS "3.22.0")
+ message(FATAL_ERROR "The DL_FRAMEWORK_PATHS option requires at least cmake 3.22")
+ endif()
+ if(NOT _DISCOVERY_MODE)
+ if(NOT CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE)
+ set(CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE "POST_BUILD")
endif()
+ set(_DISCOVERY_MODE ${CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE})
+ endif()
+ if (NOT _DISCOVERY_MODE MATCHES "^(POST_BUILD|PRE_TEST)$")
+ message(FATAL_ERROR "Unknown DISCOVERY_MODE: ${_DISCOVERY_MODE}")
endif()
## Generate a unique name based on the extra arguments
@@ -153,45 +188,113 @@ function(catch_discover_tests TARGET)
string(SUBSTRING ${args_hash} 0 7 args_hash)
# Define rule to generate test list for aforementioned test executable
- set(ctest_include_file "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_include-${args_hash}.cmake")
- set(ctest_tests_file "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_tests-${args_hash}.cmake")
+ set(ctest_file_base "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}-${args_hash}")
+ set(ctest_include_file "${ctest_file_base}_include.cmake")
+ set(ctest_tests_file "${ctest_file_base}_tests.cmake")
+
get_property(crosscompiling_emulator
TARGET ${TARGET}
PROPERTY CROSSCOMPILING_EMULATOR
)
- add_custom_command(
- TARGET ${TARGET} POST_BUILD
- BYPRODUCTS "${ctest_tests_file}"
- COMMAND "${CMAKE_COMMAND}"
- -D "TEST_TARGET=${TARGET}"
- -D "TEST_EXECUTABLE=$"
- -D "TEST_EXECUTOR=${crosscompiling_emulator}"
- -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}"
- -D "TEST_SPEC=${_TEST_SPEC}"
- -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}"
- -D "TEST_PROPERTIES=${_PROPERTIES}"
- -D "TEST_PREFIX=${_TEST_PREFIX}"
- -D "TEST_SUFFIX=${_TEST_SUFFIX}"
- -D "TEST_LIST=${_TEST_LIST}"
- -D "TEST_REPORTER=${_REPORTER}"
- -D "TEST_OUTPUT_DIR=${_OUTPUT_DIR}"
- -D "TEST_OUTPUT_PREFIX=${_OUTPUT_PREFIX}"
- -D "TEST_OUTPUT_SUFFIX=${_OUTPUT_SUFFIX}"
- -D "TEST_DL_PATHS=${_DL_PATHS}"
- -D "CTEST_FILE=${ctest_tests_file}"
- -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
- VERBATIM
- )
+ if (NOT _SKIP_IS_FAILURE)
+ set(_PROPERTIES ${_PROPERTIES} SKIP_RETURN_CODE 4)
+ endif()
- file(WRITE "${ctest_include_file}"
- "if(EXISTS \"${ctest_tests_file}\")\n"
- " include(\"${ctest_tests_file}\")\n"
- "else()\n"
- " add_test(${TARGET}_NOT_BUILT-${args_hash} ${TARGET}_NOT_BUILT-${args_hash})\n"
- "endif()\n"
- )
+ if(_DISCOVERY_MODE STREQUAL "POST_BUILD")
+ add_custom_command(
+ TARGET ${TARGET} POST_BUILD
+ BYPRODUCTS "${ctest_tests_file}"
+ COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_TARGET=${TARGET}"
+ -D "TEST_EXECUTABLE=$"
+ -D "TEST_EXECUTOR=${crosscompiling_emulator}"
+ -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}"
+ -D "TEST_SPEC=${_TEST_SPEC}"
+ -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}"
+ -D "TEST_PROPERTIES=${_PROPERTIES}"
+ -D "TEST_PREFIX=${_TEST_PREFIX}"
+ -D "TEST_SUFFIX=${_TEST_SUFFIX}"
+ -D "TEST_LIST=${_TEST_LIST}"
+ -D "TEST_REPORTER=${_REPORTER}"
+ -D "TEST_OUTPUT_DIR=${_OUTPUT_DIR}"
+ -D "TEST_OUTPUT_PREFIX=${_OUTPUT_PREFIX}"
+ -D "TEST_OUTPUT_SUFFIX=${_OUTPUT_SUFFIX}"
+ -D "TEST_DL_PATHS=${_DL_PATHS}"
+ -D "TEST_DL_FRAMEWORK_PATHS=${_DL_FRAMEWORK_PATHS}"
+ -D "CTEST_FILE=${ctest_tests_file}"
+ -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
+ VERBATIM
+ )
+
+ file(WRITE "${ctest_include_file}"
+ "if(EXISTS \"${ctest_tests_file}\")\n"
+ " include(\"${ctest_tests_file}\")\n"
+ "else()\n"
+ " add_test(${TARGET}_NOT_BUILT-${args_hash} ${TARGET}_NOT_BUILT-${args_hash})\n"
+ "endif()\n"
+ )
- if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
+ elseif(_DISCOVERY_MODE STREQUAL "PRE_TEST")
+
+ get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL
+ PROPERTY GENERATOR_IS_MULTI_CONFIG
+ )
+
+ if(GENERATOR_IS_MULTI_CONFIG)
+ set(ctest_tests_file "${ctest_file_base}_tests-$.cmake")
+ endif()
+
+ string(CONCAT ctest_include_content
+ "if(EXISTS \"$\")" "\n"
+ " if(NOT EXISTS \"${ctest_tests_file}\" OR" "\n"
+ " NOT \"${ctest_tests_file}\" IS_NEWER_THAN \"$\" OR\n"
+ " NOT \"${ctest_tests_file}\" IS_NEWER_THAN \"\${CMAKE_CURRENT_LIST_FILE}\")\n"
+ " include(\"${_CATCH_DISCOVER_TESTS_SCRIPT}\")" "\n"
+ " catch_discover_tests_impl(" "\n"
+ " TEST_EXECUTABLE" " [==[" "$" "]==]" "\n"
+ " TEST_EXECUTOR" " [==[" "${crosscompiling_emulator}" "]==]" "\n"
+ " TEST_WORKING_DIR" " [==[" "${_WORKING_DIRECTORY}" "]==]" "\n"
+ " TEST_SPEC" " [==[" "${_TEST_SPEC}" "]==]" "\n"
+ " TEST_EXTRA_ARGS" " [==[" "${_EXTRA_ARGS}" "]==]" "\n"
+ " TEST_PROPERTIES" " [==[" "${_PROPERTIES}" "]==]" "\n"
+ " TEST_PREFIX" " [==[" "${_TEST_PREFIX}" "]==]" "\n"
+ " TEST_SUFFIX" " [==[" "${_TEST_SUFFIX}" "]==]" "\n"
+ " TEST_LIST" " [==[" "${_TEST_LIST}" "]==]" "\n"
+ " TEST_REPORTER" " [==[" "${_REPORTER}" "]==]" "\n"
+ " TEST_OUTPUT_DIR" " [==[" "${_OUTPUT_DIR}" "]==]" "\n"
+ " TEST_OUTPUT_PREFIX" " [==[" "${_OUTPUT_PREFIX}" "]==]" "\n"
+ " TEST_OUTPUT_SUFFIX" " [==[" "${_OUTPUT_SUFFIX}" "]==]" "\n"
+ " CTEST_FILE" " [==[" "${ctest_tests_file}" "]==]" "\n"
+ " TEST_DL_PATHS" " [==[" "${_DL_PATHS}" "]==]" "\n"
+ " TEST_DL_FRAMEWORK_PATHS" " [==[" "${_DL_FRAMEWORK_PATHS}" "]==]" "\n"
+ " CTEST_FILE" " [==[" "${CTEST_FILE}" "]==]" "\n"
+ " )" "\n"
+ " endif()" "\n"
+ " include(\"${ctest_tests_file}\")" "\n"
+ "else()" "\n"
+ " add_test(${TARGET}_NOT_BUILT ${TARGET}_NOT_BUILT)" "\n"
+ "endif()" "\n"
+ )
+
+ if(GENERATOR_IS_MULTI_CONFIG)
+ foreach(_config ${CMAKE_CONFIGURATION_TYPES})
+ file(GENERATE OUTPUT "${ctest_file_base}_include-${_config}.cmake" CONTENT "${ctest_include_content}" CONDITION $)
+ endforeach()
+ string(CONCAT ctest_include_multi_content
+ "if(NOT CTEST_CONFIGURATION_TYPE)" "\n"
+ " message(\"No configuration for testing specified, use '-C '.\")" "\n"
+ "else()" "\n"
+ " include(\"${ctest_file_base}_include-\${CTEST_CONFIGURATION_TYPE}.cmake\")" "\n"
+ "endif()" "\n"
+ )
+ file(GENERATE OUTPUT "${ctest_include_file}" CONTENT "${ctest_include_multi_content}")
+ else()
+ file(GENERATE OUTPUT "${ctest_file_base}_include.cmake" CONTENT "${ctest_include_content}")
+ file(WRITE "${ctest_include_file}" "include(\"${ctest_file_base}_include.cmake\")")
+ endif()
+ endif()
+
+ if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
# Add discovered tests to directory TEST_INCLUDE_FILES
set_property(DIRECTORY
APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
@@ -204,9 +307,7 @@ function(catch_discover_tests TARGET)
PROPERTY TEST_INCLUDE_FILE "${ctest_include_file}"
)
else()
- message(FATAL_ERROR
- "Cannot set more than one TEST_INCLUDE_FILE"
- )
+ message(FATAL_ERROR "Cannot set more than one TEST_INCLUDE_FILE")
endif()
endif()
diff --git a/src/external/catch2/extras/CatchAddTests.cmake b/src/external/catch2/extras/CatchAddTests.cmake
index beec3aed..399a839d 100644
--- a/src/external/catch2/extras/CatchAddTests.cmake
+++ b/src/external/catch2/extras/CatchAddTests.cmake
@@ -1,28 +1,6 @@
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
-set(prefix "${TEST_PREFIX}")
-set(suffix "${TEST_SUFFIX}")
-set(spec ${TEST_SPEC})
-set(extra_args ${TEST_EXTRA_ARGS})
-set(properties ${TEST_PROPERTIES})
-set(reporter ${TEST_REPORTER})
-set(output_dir ${TEST_OUTPUT_DIR})
-set(output_prefix ${TEST_OUTPUT_PREFIX})
-set(output_suffix ${TEST_OUTPUT_SUFFIX})
-set(dl_paths ${TEST_DL_PATHS})
-set(script)
-set(suite)
-set(tests)
-
-if(WIN32)
- set(dl_paths_variable_name PATH)
-elseif(APPLE)
- set(dl_paths_variable_name DYLD_LIBRARY_PATH)
-else()
- set(dl_paths_variable_name LD_LIBRARY_PATH)
-endif()
-
function(add_command NAME)
set(_args "")
# use ARGV* instead of ARGN, because ARGN splits arrays into multiple arguments
@@ -38,119 +16,196 @@ function(add_command NAME)
set(script "${script}${NAME}(${_args})\n" PARENT_SCOPE)
endfunction()
-# Run test executable to get list of available tests
-if(NOT EXISTS "${TEST_EXECUTABLE}")
- message(FATAL_ERROR
- "Specified test executable '${TEST_EXECUTABLE}' does not exist"
+function(catch_discover_tests_impl)
+
+ cmake_parse_arguments(
+ ""
+ ""
+ "TEST_EXECUTABLE;TEST_WORKING_DIR;TEST_OUTPUT_DIR;TEST_OUTPUT_PREFIX;TEST_OUTPUT_SUFFIX;TEST_PREFIX;TEST_REPORTER;TEST_SPEC;TEST_SUFFIX;TEST_LIST;CTEST_FILE"
+ "TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR;TEST_DL_PATHS;TEST_DL_FRAMEWORK_PATHS"
+ ${ARGN}
)
-endif()
-if(dl_paths)
- cmake_path(CONVERT "${dl_paths}" TO_NATIVE_PATH_LIST paths)
- set(ENV{${dl_paths_variable_name}} "${paths}")
-endif()
+ set(prefix "${_TEST_PREFIX}")
+ set(suffix "${_TEST_SUFFIX}")
+ set(spec ${_TEST_SPEC})
+ set(extra_args ${_TEST_EXTRA_ARGS})
+ set(properties ${_TEST_PROPERTIES})
+ set(reporter ${_TEST_REPORTER})
+ set(output_dir ${_TEST_OUTPUT_DIR})
+ set(output_prefix ${_TEST_OUTPUT_PREFIX})
+ set(output_suffix ${_TEST_OUTPUT_SUFFIX})
+ set(dl_paths ${_TEST_DL_PATHS})
+ set(dl_framework_paths ${_TEST_DL_FRAMEWORK_PATHS})
+ set(environment_modifications "")
+ set(script)
+ set(suite)
+ set(tests)
+
+ if(WIN32)
+ set(dl_paths_variable_name PATH)
+ elseif(APPLE)
+ set(dl_paths_variable_name DYLD_LIBRARY_PATH)
+ else()
+ set(dl_paths_variable_name LD_LIBRARY_PATH)
+ endif()
-execute_process(
- COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
- OUTPUT_VARIABLE output
- RESULT_VARIABLE result
- WORKING_DIRECTORY "${TEST_WORKING_DIR}"
-)
-if(NOT ${result} EQUAL 0)
- message(FATAL_ERROR
- "Error running test executable '${TEST_EXECUTABLE}':\n"
- " Result: ${result}\n"
- " Output: ${output}\n"
- )
-endif()
+ # Run test executable to get list of available tests
+ if(NOT EXISTS "${_TEST_EXECUTABLE}")
+ message(FATAL_ERROR
+ "Specified test executable '${_TEST_EXECUTABLE}' does not exist"
+ )
+ endif()
-string(REPLACE "\n" ";" output "${output}")
-
-# Run test executable to get list of available reporters
-execute_process(
- COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-reporters
- OUTPUT_VARIABLE reporters_output
- RESULT_VARIABLE reporters_result
- WORKING_DIRECTORY "${TEST_WORKING_DIR}"
-)
-if(NOT ${reporters_result} EQUAL 0)
- message(FATAL_ERROR
- "Error running test executable '${TEST_EXECUTABLE}':\n"
- " Result: ${reporters_result}\n"
- " Output: ${reporters_output}\n"
- )
-endif()
-string(FIND "${reporters_output}" "${reporter}" reporter_is_valid)
-if(reporter AND ${reporter_is_valid} EQUAL -1)
- message(FATAL_ERROR
- "\"${reporter}\" is not a valid reporter!\n"
+ if(dl_paths)
+ cmake_path(CONVERT "$ENV{${dl_paths_variable_name}}" TO_NATIVE_PATH_LIST env_dl_paths)
+ list(PREPEND env_dl_paths "${dl_paths}")
+ cmake_path(CONVERT "${env_dl_paths}" TO_NATIVE_PATH_LIST paths)
+ set(ENV{${dl_paths_variable_name}} "${paths}")
+ endif()
+
+ if(APPLE AND dl_framework_paths)
+ cmake_path(CONVERT "$ENV{DYLD_FRAMEWORK_PATH}" TO_NATIVE_PATH_LIST env_dl_framework_paths)
+ list(PREPEND env_dl_framework_paths "${dl_framework_paths}")
+ cmake_path(CONVERT "${env_dl_framework_paths}" TO_NATIVE_PATH_LIST paths)
+ set(ENV{DYLD_FRAMEWORK_PATH} "${paths}")
+ endif()
+
+ execute_process(
+ COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
+ OUTPUT_VARIABLE output
+ RESULT_VARIABLE result
+ WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
)
-endif()
+ if(NOT ${result} EQUAL 0)
+ message(FATAL_ERROR
+ "Error running test executable '${_TEST_EXECUTABLE}':\n"
+ " Result: ${result}\n"
+ " Output: ${output}\n"
+ )
+ endif()
-# Prepare reporter
-if(reporter)
- set(reporter_arg "--reporter ${reporter}")
-endif()
+ # Make sure to escape ; (semicolons) in test names first, because
+ # that'd break the foreach loop for "Parse output" later and create
+ # wrongly splitted and thus failing test cases (false positives)
+ string(REPLACE ";" "\;" output "${output}")
+ string(REPLACE "\n" ";" output "${output}")
+
+ # Prepare reporter
+ if(reporter)
+ set(reporter_arg "--reporter ${reporter}")
+
+ # Run test executable to check whether reporter is available
+ # note that the use of --list-reporters is not the important part,
+ # we only want to check whether the execution succeeds with ${reporter_arg}
+ execute_process(
+ COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} ${reporter_arg} --list-reporters
+ OUTPUT_VARIABLE reporter_check_output
+ RESULT_VARIABLE reporter_check_result
+ WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
+ )
+ if(${reporter_check_result} EQUAL 255)
+ message(FATAL_ERROR
+ "\"${reporter}\" is not a valid reporter!\n"
+ )
+ elseif(NOT ${reporter_check_result} EQUAL 0)
+ message(FATAL_ERROR
+ "Error running test executable '${_TEST_EXECUTABLE}':\n"
+ " Result: ${reporter_check_result}\n"
+ " Output: ${reporter_check_output}\n"
+ )
+ endif()
+ endif()
-# Prepare output dir
-if(output_dir AND NOT IS_ABSOLUTE ${output_dir})
- set(output_dir "${TEST_WORKING_DIR}/${output_dir}")
- if(NOT EXISTS ${output_dir})
- file(MAKE_DIRECTORY ${output_dir})
+ # Prepare output dir
+ if(output_dir AND NOT IS_ABSOLUTE ${output_dir})
+ set(output_dir "${_TEST_WORKING_DIR}/${output_dir}")
+ if(NOT EXISTS ${output_dir})
+ file(MAKE_DIRECTORY ${output_dir})
+ endif()
endif()
-endif()
-if(dl_paths)
- foreach(path ${dl_paths})
- cmake_path(NATIVE_PATH path native_path)
- list(APPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
- endforeach()
-endif()
+ if(dl_paths)
+ foreach(path ${dl_paths})
+ cmake_path(NATIVE_PATH path native_path)
+ list(PREPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
+ endforeach()
+ endif()
-# Parse output
-foreach(line ${output})
- set(test ${line})
- # Escape characters in test case names that would be parsed by Catch2
- set(test_name ${test})
- foreach(char , [ ])
- string(REPLACE ${char} "\\${char}" test_name ${test_name})
- endforeach(char)
- # ...add output dir
- if(output_dir)
- string(REGEX REPLACE "[^A-Za-z0-9_]" "_" test_name_clean ${test_name})
- set(output_dir_arg "--out ${output_dir}/${output_prefix}${test_name_clean}${output_suffix}")
+ if(APPLE AND dl_framework_paths)
+ foreach(path ${dl_framework_paths})
+ cmake_path(NATIVE_PATH path native_path)
+ list(PREPEND environment_modifications "DYLD_FRAMEWORK_PATH=path_list_prepend:${native_path}")
+ endforeach()
endif()
-
- # ...and add to script
- add_command(add_test
- "${prefix}${test}${suffix}"
- ${TEST_EXECUTOR}
- "${TEST_EXECUTABLE}"
- "${test_name}"
- ${extra_args}
- "${reporter_arg}"
- "${output_dir_arg}"
- )
- add_command(set_tests_properties
- "${prefix}${test}${suffix}"
- PROPERTIES
- WORKING_DIRECTORY "${TEST_WORKING_DIR}"
- ${properties}
- )
- if(environment_modifications)
- add_command(set_tests_properties
- "${prefix}${test}${suffix}"
- PROPERTIES
- ENVIRONMENT_MODIFICATION "${environment_modifications}")
- endif()
+ # Parse output
+ foreach(line ${output})
+ set(test "${line}")
+ # Escape characters in test case names that would be parsed by Catch2
+ # Note that the \ escaping must happen FIRST! Do not change the order.
+ set(test_name "${test}")
+ foreach(char \\ , [ ])
+ string(REPLACE ${char} "\\${char}" test_name "${test_name}")
+ endforeach(char)
+ # ...add output dir
+ if(output_dir)
+ string(REGEX REPLACE "[^A-Za-z0-9_]" "_" test_name_clean "${test_name}")
+ set(output_dir_arg "--out ${output_dir}/${output_prefix}${test_name_clean}${output_suffix}")
+ endif()
+
+ # ...and add to script
+ add_command(add_test
+ "${prefix}${test}${suffix}"
+ ${_TEST_EXECUTOR}
+ "${_TEST_EXECUTABLE}"
+ "${test_name}"
+ ${extra_args}
+ "${reporter_arg}"
+ "${output_dir_arg}"
+ )
+ add_command(set_tests_properties
+ "${prefix}${test}${suffix}"
+ PROPERTIES
+ WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
+ ${properties}
+ )
+
+ if(environment_modifications)
+ add_command(set_tests_properties
+ "${prefix}${test}${suffix}"
+ PROPERTIES
+ ENVIRONMENT_MODIFICATION "${environment_modifications}")
+ endif()
+
+ list(APPEND tests "${prefix}${test}${suffix}")
+ endforeach()
- list(APPEND tests "${prefix}${test}${suffix}")
-endforeach()
+ # Create a list of all discovered tests, which users may use to e.g. set
+ # properties on the tests
+ add_command(set ${_TEST_LIST} ${tests})
-# Create a list of all discovered tests, which users may use to e.g. set
-# properties on the tests
-add_command(set ${TEST_LIST} ${tests})
+ # Write CTest script
+ file(WRITE "${_CTEST_FILE}" "${script}")
+endfunction()
-# Write CTest script
-file(WRITE "${CTEST_FILE}" "${script}")
+if(CMAKE_SCRIPT_MODE_FILE)
+ catch_discover_tests_impl(
+ TEST_EXECUTABLE ${TEST_EXECUTABLE}
+ TEST_EXECUTOR ${TEST_EXECUTOR}
+ TEST_WORKING_DIR ${TEST_WORKING_DIR}
+ TEST_SPEC ${TEST_SPEC}
+ TEST_EXTRA_ARGS ${TEST_EXTRA_ARGS}
+ TEST_PROPERTIES ${TEST_PROPERTIES}
+ TEST_PREFIX ${TEST_PREFIX}
+ TEST_SUFFIX ${TEST_SUFFIX}
+ TEST_LIST ${TEST_LIST}
+ TEST_REPORTER ${TEST_REPORTER}
+ TEST_OUTPUT_DIR ${TEST_OUTPUT_DIR}
+ TEST_OUTPUT_PREFIX ${TEST_OUTPUT_PREFIX}
+ TEST_OUTPUT_SUFFIX ${TEST_OUTPUT_SUFFIX}
+ TEST_DL_PATHS ${TEST_DL_PATHS}
+ TEST_DL_FRAMEWORK_PATHS ${TEST_DL_FRAMEWORK_PATHS}
+ CTEST_FILE ${CTEST_FILE}
+ )
+endif()
diff --git a/src/external/catch2/extras/CatchShardTests.cmake b/src/external/catch2/extras/CatchShardTests.cmake
index 5e043cf0..68228f5a 100644
--- a/src/external/catch2/extras/CatchShardTests.cmake
+++ b/src/external/catch2/extras/CatchShardTests.cmake
@@ -46,7 +46,7 @@ function(catch_add_sharded_tests TARGET)
APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
)
- set(shard_impl_script_file "${CMAKE_CURRENT_LIST_DIR}/CatchShardTestsImpl.cmake")
+ set(shard_impl_script_file "${_CATCH_DISCOVER_SHARD_TESTS_IMPL_SCRIPT}")
add_custom_command(
TARGET ${TARGET} POST_BUILD
@@ -64,3 +64,11 @@ function(catch_add_sharded_tests TARGET)
endfunction()
+
+
+###############################################################################
+
+set(_CATCH_DISCOVER_SHARD_TESTS_IMPL_SCRIPT
+ ${CMAKE_CURRENT_LIST_DIR}/CatchShardTestsImpl.cmake
+ CACHE INTERNAL "Catch2 full path to CatchShardTestsImpl.cmake helper file"
+)
diff --git a/src/external/catch2/extras/ParseAndAddCatchTests.cmake b/src/external/catch2/extras/ParseAndAddCatchTests.cmake
index 4771e029..31fc193a 100644
--- a/src/external/catch2/extras/ParseAndAddCatchTests.cmake
+++ b/src/external/catch2/extras/ParseAndAddCatchTests.cmake
@@ -187,7 +187,7 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
if(result)
set(HiddenTagFound ON)
break()
- endif(result)
+ endif()
endforeach(label)
if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_LESS "3.9")
ParseAndAddCatchTests_PrintDebugMessage("Skipping test \"${CTestName}\" as it has [!hide], [.] or [.foo] label")
diff --git a/src/external/catch2/extras/catch_amalgamated.cpp b/src/external/catch2/extras/catch_amalgamated.cpp
index a81b1b6a..f45c18a0 100644
--- a/src/external/catch2/extras/catch_amalgamated.cpp
+++ b/src/external/catch2/extras/catch_amalgamated.cpp
@@ -1,3 +1,4 @@
+
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.txt or copy at
@@ -5,8 +6,8 @@
// SPDX-License-Identifier: BSL-1.0
-// Catch v3.3.2
-// Generated: 2023-02-26 10:28:48.270752
+// Catch v3.7.1
+// Generated: 2024-09-17 10:36:45.608896
// ----------------------------------------------------------
// This file is an amalgamation of multiple different files.
// You probably shouldn't edit it directly.
@@ -48,18 +49,99 @@ namespace Catch {
} // namespace Catch
+// Adapted from donated nonius code.
+
+
+#include
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last) {
+ if (!cfg.benchmarkNoAnalysis()) {
+ std::vector samples;
+ samples.reserve(static_cast(last - first));
+ for (auto current = first; current != last; ++current) {
+ samples.push_back( current->count() );
+ }
+
+ auto analysis = Catch::Benchmark::Detail::analyse_samples(
+ cfg.benchmarkConfidenceInterval(),
+ cfg.benchmarkResamples(),
+ samples.data(),
+ samples.data() + samples.size() );
+ auto outliers = Catch::Benchmark::Detail::classify_outliers(
+ samples.data(), samples.data() + samples.size() );
+
+ auto wrap_estimate = [](Estimate e) {
+ return Estimate {
+ FDuration(e.point),
+ FDuration(e.lower_bound),
+ FDuration(e.upper_bound),
+ e.confidence_interval,
+ };
+ };
+ std::vector samples2;
+ samples2.reserve(samples.size());
+ for (auto s : samples) {
+ samples2.push_back( FDuration( s ) );
+ }
+
+ return {
+ CATCH_MOVE(samples2),
+ wrap_estimate(analysis.mean),
+ wrap_estimate(analysis.standard_deviation),
+ outliers,
+ analysis.outlier_variance,
+ };
+ } else {
+ std::vector samples;
+ samples.reserve(static_cast(last - first));
+
+ FDuration mean = FDuration(0);
+ int i = 0;
+ for (auto it = first; it < last; ++it, ++i) {
+ samples.push_back(*it);
+ mean += *it;
+ }
+ mean /= i;
+
+ return SampleAnalysis{
+ CATCH_MOVE(samples),
+ Estimate{ mean, mean, mean, 0.0 },
+ Estimate{ FDuration( 0 ),
+ FDuration( 0 ),
+ FDuration( 0 ),
+ 0.0 },
+ OutlierClassification{},
+ 0.0
+ };
+ }
+ }
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+
namespace Catch {
namespace Benchmark {
namespace Detail {
+ struct do_nothing {
+ void operator()() const {}
+ };
+
BenchmarkFunction::callable::~callable() = default;
+ BenchmarkFunction::BenchmarkFunction():
+ f( new model{ {} } ){}
} // namespace Detail
} // namespace Benchmark
} // namespace Catch
+
#include
namespace Catch {
@@ -86,9 +168,11 @@ namespace Catch {
+#include
#include
+#include
#include
-#include
+#include
#include
@@ -96,139 +180,199 @@ namespace Catch {
#include
#endif
-namespace {
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ namespace {
+
+ template
+ static sample
+ resample( URng& rng,
+ unsigned int resamples,
+ double const* first,
+ double const* last,
+ Estimator& estimator ) {
+ auto n = static_cast( last - first );
+ Catch::uniform_integer_distribution dist( 0, n - 1 );
+
+ sample out;
+ out.reserve( resamples );
+ std::vector resampled;
+ resampled.reserve( n );
+ for ( size_t i = 0; i < resamples; ++i ) {
+ resampled.clear();
+ for ( size_t s = 0; s < n; ++s ) {
+ resampled.push_back( first[dist( rng )] );
+ }
+ const auto estimate =
+ estimator( resampled.data(), resampled.data() + resampled.size() );
+ out.push_back( estimate );
+ }
+ std::sort( out.begin(), out.end() );
+ return out;
+ }
-using Catch::Benchmark::Detail::sample;
-
- template
- sample resample(URng& rng, unsigned int resamples, std::vector::iterator first, std::vector::iterator last, Estimator& estimator) {
- auto n = static_cast(last - first);
- std::uniform_int_distribution dist(0, n - 1);
-
- sample out;
- out.reserve(resamples);
- std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
- std::vector resampled;
- resampled.reserve(n);
- std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[static_cast(dist(rng))]; });
- return estimator(resampled.begin(), resampled.end());
- });
- std::sort(out.begin(), out.end());
- return out;
- }
-
-
- double erf_inv(double x) {
- // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
- double w, p;
-
- w = -log((1.0 - x) * (1.0 + x));
-
- if (w < 6.250000) {
- w = w - 3.125000;
- p = -3.6444120640178196996e-21;
- p = -1.685059138182016589e-19 + p * w;
- p = 1.2858480715256400167e-18 + p * w;
- p = 1.115787767802518096e-17 + p * w;
- p = -1.333171662854620906e-16 + p * w;
- p = 2.0972767875968561637e-17 + p * w;
- p = 6.6376381343583238325e-15 + p * w;
- p = -4.0545662729752068639e-14 + p * w;
- p = -8.1519341976054721522e-14 + p * w;
- p = 2.6335093153082322977e-12 + p * w;
- p = -1.2975133253453532498e-11 + p * w;
- p = -5.4154120542946279317e-11 + p * w;
- p = 1.051212273321532285e-09 + p * w;
- p = -4.1126339803469836976e-09 + p * w;
- p = -2.9070369957882005086e-08 + p * w;
- p = 4.2347877827932403518e-07 + p * w;
- p = -1.3654692000834678645e-06 + p * w;
- p = -1.3882523362786468719e-05 + p * w;
- p = 0.0001867342080340571352 + p * w;
- p = -0.00074070253416626697512 + p * w;
- p = -0.0060336708714301490533 + p * w;
- p = 0.24015818242558961693 + p * w;
- p = 1.6536545626831027356 + p * w;
- } else if (w < 16.000000) {
- w = sqrt(w) - 3.250000;
- p = 2.2137376921775787049e-09;
- p = 9.0756561938885390979e-08 + p * w;
- p = -2.7517406297064545428e-07 + p * w;
- p = 1.8239629214389227755e-08 + p * w;
- p = 1.5027403968909827627e-06 + p * w;
- p = -4.013867526981545969e-06 + p * w;
- p = 2.9234449089955446044e-06 + p * w;
- p = 1.2475304481671778723e-05 + p * w;
- p = -4.7318229009055733981e-05 + p * w;
- p = 6.8284851459573175448e-05 + p * w;
- p = 2.4031110387097893999e-05 + p * w;
- p = -0.0003550375203628474796 + p * w;
- p = 0.00095328937973738049703 + p * w;
- p = -0.0016882755560235047313 + p * w;
- p = 0.0024914420961078508066 + p * w;
- p = -0.0037512085075692412107 + p * w;
- p = 0.005370914553590063617 + p * w;
- p = 1.0052589676941592334 + p * w;
- p = 3.0838856104922207635 + p * w;
- } else {
- w = sqrt(w) - 5.000000;
- p = -2.7109920616438573243e-11;
- p = -2.5556418169965252055e-10 + p * w;
- p = 1.5076572693500548083e-09 + p * w;
- p = -3.7894654401267369937e-09 + p * w;
- p = 7.6157012080783393804e-09 + p * w;
- p = -1.4960026627149240478e-08 + p * w;
- p = 2.9147953450901080826e-08 + p * w;
- p = -6.7711997758452339498e-08 + p * w;
- p = 2.2900482228026654717e-07 + p * w;
- p = -9.9298272942317002539e-07 + p * w;
- p = 4.5260625972231537039e-06 + p * w;
- p = -1.9681778105531670567e-05 + p * w;
- p = 7.5995277030017761139e-05 + p * w;
- p = -0.00021503011930044477347 + p * w;
- p = -0.00013871931833623122026 + p * w;
- p = 1.0103004648645343977 + p * w;
- p = 4.8499064014085844221 + p * w;
- }
- return p * x;
- }
-
- double standard_deviation(std::vector::iterator first, std::vector::iterator last) {
- auto m = Catch::Benchmark::Detail::mean(first, last);
- double variance = std::accumulate( first,
- last,
- 0.,
- [m]( double a, double b ) {
- double diff = b - m;
- return a + diff * diff;
- } ) /
- ( last - first );
- return std::sqrt( variance );
- }
+ static double outlier_variance( Estimate mean,
+ Estimate stddev,
+ int n ) {
+ double sb = stddev.point;
+ double mn = mean.point / n;
+ double mg_min = mn / 2.;
+ double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) );
+ double sg2 = sg * sg;
+ double sb2 = sb * sb;
+
+ auto c_max = [n, mn, sb2, sg2]( double x ) -> double {
+ double k = mn - x;
+ double d = k * k;
+ double nd = n * d;
+ double k0 = -n * nd;
+ double k1 = sb2 - n * sg2 + nd;
+ double det = k1 * k1 - 4 * sg2 * k0;
+ return static_cast( -2. * k0 /
+ ( k1 + std::sqrt( det ) ) );
+ };
+
+ auto var_out = [n, sb2, sg2]( double c ) {
+ double nc = n - c;
+ return ( nc / n ) * ( sb2 - nc * sg2 );
+ };
+
+ return (std::min)( var_out( 1 ),
+ var_out(
+ (std::min)( c_max( 0. ),
+ c_max( mg_min ) ) ) ) /
+ sb2;
+ }
-}
+ static double erf_inv( double x ) {
+ // Code accompanying the article "Approximating the erfinv
+ // function" in GPU Computing Gems, Volume 2
+ double w, p;
+
+ w = -log( ( 1.0 - x ) * ( 1.0 + x ) );
+
+ if ( w < 6.250000 ) {
+ w = w - 3.125000;
+ p = -3.6444120640178196996e-21;
+ p = -1.685059138182016589e-19 + p * w;
+ p = 1.2858480715256400167e-18 + p * w;
+ p = 1.115787767802518096e-17 + p * w;
+ p = -1.333171662854620906e-16 + p * w;
+ p = 2.0972767875968561637e-17 + p * w;
+ p = 6.6376381343583238325e-15 + p * w;
+ p = -4.0545662729752068639e-14 + p * w;
+ p = -8.1519341976054721522e-14 + p * w;
+ p = 2.6335093153082322977e-12 + p * w;
+ p = -1.2975133253453532498e-11 + p * w;
+ p = -5.4154120542946279317e-11 + p * w;
+ p = 1.051212273321532285e-09 + p * w;
+ p = -4.1126339803469836976e-09 + p * w;
+ p = -2.9070369957882005086e-08 + p * w;
+ p = 4.2347877827932403518e-07 + p * w;
+ p = -1.3654692000834678645e-06 + p * w;
+ p = -1.3882523362786468719e-05 + p * w;
+ p = 0.0001867342080340571352 + p * w;
+ p = -0.00074070253416626697512 + p * w;
+ p = -0.0060336708714301490533 + p * w;
+ p = 0.24015818242558961693 + p * w;
+ p = 1.6536545626831027356 + p * w;
+ } else if ( w < 16.000000 ) {
+ w = sqrt( w ) - 3.250000;
+ p = 2.2137376921775787049e-09;
+ p = 9.0756561938885390979e-08 + p * w;
+ p = -2.7517406297064545428e-07 + p * w;
+ p = 1.8239629214389227755e-08 + p * w;
+ p = 1.5027403968909827627e-06 + p * w;
+ p = -4.013867526981545969e-06 + p * w;
+ p = 2.9234449089955446044e-06 + p * w;
+ p = 1.2475304481671778723e-05 + p * w;
+ p = -4.7318229009055733981e-05 + p * w;
+ p = 6.8284851459573175448e-05 + p * w;
+ p = 2.4031110387097893999e-05 + p * w;
+ p = -0.0003550375203628474796 + p * w;
+ p = 0.00095328937973738049703 + p * w;
+ p = -0.0016882755560235047313 + p * w;
+ p = 0.0024914420961078508066 + p * w;
+ p = -0.0037512085075692412107 + p * w;
+ p = 0.005370914553590063617 + p * w;
+ p = 1.0052589676941592334 + p * w;
+ p = 3.0838856104922207635 + p * w;
+ } else {
+ w = sqrt( w ) - 5.000000;
+ p = -2.7109920616438573243e-11;
+ p = -2.5556418169965252055e-10 + p * w;
+ p = 1.5076572693500548083e-09 + p * w;
+ p = -3.7894654401267369937e-09 + p * w;
+ p = 7.6157012080783393804e-09 + p * w;
+ p = -1.4960026627149240478e-08 + p * w;
+ p = 2.9147953450901080826e-08 + p * w;
+ p = -6.7711997758452339498e-08 + p * w;
+ p = 2.2900482228026654717e-07 + p * w;
+ p = -9.9298272942317002539e-07 + p * w;
+ p = 4.5260625972231537039e-06 + p * w;
+ p = -1.9681778105531670567e-05 + p * w;
+ p = 7.5995277030017761139e-05 + p * w;
+ p = -0.00021503011930044477347 + p * w;
+ p = -0.00013871931833623122026 + p * w;
+ p = 1.0103004648645343977 + p * w;
+ p = 4.8499064014085844221 + p * w;
+ }
+ return p * x;
+ }
+
+ static double
+ standard_deviation( double const* first, double const* last ) {
+ auto m = Catch::Benchmark::Detail::mean( first, last );
+ double variance =
+ std::accumulate( first,
+ last,
+ 0.,
+ [m]( double a, double b ) {
+ double diff = b - m;
+ return a + diff * diff;
+ } ) /
+ ( last - first );
+ return std::sqrt( variance );
+ }
+
+ static sample jackknife( double ( *estimator )( double const*,
+ double const* ),
+ double* first,
+ double* last ) {
+ const auto second = first + 1;
+ sample results;
+ results.reserve( static_cast( last - first ) );
+
+ for ( auto it = first; it != last; ++it ) {
+ std::iter_swap( it, first );
+ results.push_back( estimator( second, last ) );
+ }
+
+ return results;
+ }
+
+
+ } // namespace
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
namespace Catch {
namespace Benchmark {
namespace Detail {
-#if defined( __GNUC__ ) || defined( __clang__ )
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
- bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
-#if defined( __GNUC__ ) || defined( __clang__ )
-# pragma GCC diagnostic pop
-#endif
-
- double weighted_average_quantile(int k, int q, std::vector::iterator first, std::vector::iterator last) {
+ double weighted_average_quantile( int k,
+ int q,
+ double* first,
+ double* last ) {
auto count = last - first;
double idx = (count - 1) * k / static_cast(q);
int j = static_cast(idx);
double g = idx - j;
std::nth_element(first, first + j, last);
auto xj = first[j];
- if ( directCompare( g, 0 ) ) {
+ if ( Catch::Detail::directCompare( g, 0 ) ) {
return xj;
}
@@ -236,6 +380,48 @@ namespace Catch {
return xj + g * (xj1 - xj);
}
+ OutlierClassification
+ classify_outliers( double const* first, double const* last ) {
+ std::vector copy( first, last );
+
+ auto q1 = weighted_average_quantile( 1, 4, copy.data(), copy.data() + copy.size() );
+ auto q3 = weighted_average_quantile( 3, 4, copy.data(), copy.data() + copy.size() );
+ auto iqr = q3 - q1;
+ auto los = q1 - ( iqr * 3. );
+ auto lom = q1 - ( iqr * 1.5 );
+ auto him = q3 + ( iqr * 1.5 );
+ auto his = q3 + ( iqr * 3. );
+
+ OutlierClassification o;
+ for ( ; first != last; ++first ) {
+ const double t = *first;
+ if ( t < los ) {
+ ++o.low_severe;
+ } else if ( t < lom ) {
+ ++o.low_mild;
+ } else if ( t > his ) {
+ ++o.high_severe;
+ } else if ( t > him ) {
+ ++o.high_mild;
+ }
+ ++o.samples_seen;
+ }
+ return o;
+ }
+
+ double mean( double const* first, double const* last ) {
+ auto count = last - first;
+ double sum = 0.;
+ while (first != last) {
+ sum += *first;
+ ++first;
+ }
+ return sum / static_cast(count);
+ }
+
+ double normal_cdf( double x ) {
+ return std::erfc( -x / std::sqrt( 2.0 ) ) / 2.0;
+ }
double erfc_inv(double x) {
return erf_inv(1.0 - x);
@@ -257,50 +443,77 @@ namespace Catch {
return result;
}
+ Estimate
+ bootstrap( double confidence_level,
+ double* first,
+ double* last,
+ sample const& resample,
+ double ( *estimator )( double const*, double const* ) ) {
+ auto n_samples = last - first;
+
+ double point = estimator( first, last );
+ // Degenerate case with a single sample
+ if ( n_samples == 1 )
+ return { point, point, point, confidence_level };
+
+ sample jack = jackknife( estimator, first, last );
+ double jack_mean =
+ mean( jack.data(), jack.data() + jack.size() );
+ double sum_squares = 0, sum_cubes = 0;
+ for ( double x : jack ) {
+ auto difference = jack_mean - x;
+ auto square = difference * difference;
+ auto cube = square * difference;
+ sum_squares += square;
+ sum_cubes += cube;
+ }
- double outlier_variance(Estimate mean, Estimate stddev, int n) {
- double sb = stddev.point;
- double mn = mean.point / n;
- double mg_min = mn / 2.;
- double sg = (std::min)(mg_min / 4., sb / std::sqrt(n));
- double sg2 = sg * sg;
- double sb2 = sb * sb;
+ double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) );
+ long n = static_cast( resample.size() );
+ double prob_n =
+ std::count_if( resample.begin(),
+ resample.end(),
+ [point]( double x ) { return x < point; } ) /
+ static_cast( n );
+ // degenerate case with uniform samples
+ if ( Catch::Detail::directCompare( prob_n, 0. ) ) {
+ return { point, point, point, confidence_level };
+ }
- auto c_max = [n, mn, sb2, sg2](double x) -> double {
- double k = mn - x;
- double d = k * k;
- double nd = n * d;
- double k0 = -n * nd;
- double k1 = sb2 - n * sg2 + nd;
- double det = k1 * k1 - 4 * sg2 * k0;
- return static_cast(-2. * k0 / (k1 + std::sqrt(det)));
- };
+ double bias = normal_quantile( prob_n );
+ double z1 = normal_quantile( ( 1. - confidence_level ) / 2. );
- auto var_out = [n, sb2, sg2](double c) {
- double nc = n - c;
- return (nc / n) * (sb2 - nc * sg2);
+ auto cumn = [n]( double x ) -> long {
+ return std::lround( normal_cdf( x ) *
+ static_cast( n ) );
};
-
- return (std::min)(var_out(1), var_out((std::min)(c_max(0.), c_max(mg_min)))) / sb2;
- }
-
-
- bootstrap_analysis analyse_samples(double confidence_level, unsigned int n_resamples, std::vector::iterator first, std::vector::iterator last) {
- CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
- CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
- static std::random_device entropy;
- CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
- auto n = static_cast(last - first); // seriously, one can't use integral types without hell in C++
-
- auto mean = &Detail::mean::iterator>;
+ auto a = [bias, accel]( double b ) {
+ return bias + b / ( 1. - accel * b );
+ };
+ double b1 = bias + z1;
+ double b2 = bias - z1;
+ double a1 = a( b1 );
+ double a2 = a( b2 );
+ auto lo = static_cast( (std::max)( cumn( a1 ), 0l ) );
+ auto hi =
+ static_cast( (std::min)( cumn( a2 ), n - 1 ) );
+
+ return { point, resample[lo], resample[hi], confidence_level };
+ }
+
+ bootstrap_analysis analyse_samples(double confidence_level,
+ unsigned int n_resamples,
+ double* first,
+ double* last) {
+ auto mean = &Detail::mean;
auto stddev = &standard_deviation;
#if defined(CATCH_CONFIG_USE_ASYNC)
- auto Estimate = [=](double(*f)(std::vector::iterator, std::vector::iterator)) {
- auto seed = entropy();
+ auto Estimate = [=](double(*f)(double const*, double const*)) {
+ std::random_device rd;
+ auto seed = rd();
return std::async(std::launch::async, [=] {
- std::mt19937 rng(seed);
+ SimplePcg32 rng( seed );
auto resampled = resample(rng, n_resamples, first, last, f);
return bootstrap(confidence_level, first, last, resampled, f);
});
@@ -312,9 +525,10 @@ namespace Catch {
auto mean_estimate = mean_future.get();
auto stddev_estimate = stddev_future.get();
#else
- auto Estimate = [=](double(*f)(std::vector::iterator, std::vector::iterator)) {
- auto seed = entropy();
- std::mt19937 rng(seed);
+ auto Estimate = [=](double(*f)(double const* , double const*)) {
+ std::random_device rd;
+ auto seed = rd();
+ SimplePcg32 rng( seed );
auto resampled = resample(rng, n_resamples, first, last, f);
return bootstrap(confidence_level, first, last, resampled, f);
};
@@ -323,6 +537,7 @@ namespace Catch {
auto stddev_estimate = Estimate(stddev);
#endif // CATCH_USE_ASYNC
+ auto n = static_cast(last - first); // seriously, one can't use integral types without hell in C++
double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
return { mean_estimate, stddev_estimate, outlier_variance };
@@ -349,7 +564,7 @@ bool marginComparison(double lhs, double rhs, double margin) {
namespace Catch {
Approx::Approx ( double value )
- : m_epsilon( std::numeric_limits::epsilon()*100. ),
+ : m_epsilon( static_cast