couchbase 4.2.2 → 4.2.3

package/deps/couchbase-cxx-client/third_party/catch2/docs/matchers.md

@@ -1,77 +1,123 @@
 <a id="top"></a>
 # Matchers
 
-Matchers are an alternative way to do assertions which are easily extensible and composable.
-This makes them well suited to use with more complex types (such as collections) or your own custom types.
-Matchers were first popularised by the [Hamcrest](https://en.wikipedia.org/wiki/Hamcrest) family of frameworks.
+**Contents**<br>
+[Using Matchers](#using-matchers)<br>
+[Built-in matchers](#built-in-matchers)<br>
+[Writing custom matchers (old style)](#writing-custom-matchers-old-style)<br>
+[Writing custom matchers (new style)](#writing-custom-matchers-new-style)<br>
 
-## In use
+Matchers, as popularized by the [Hamcrest](https://en.wikipedia.org/wiki/Hamcrest)
+framework are an alternative way to write assertions, useful for tests
+where you work with complex types or need to assert more complex
+properties. Matchers are easily composable and users can write their
+own and combine them with the Catch2-provided matchers seamlessly.
 
-Matchers are introduced with the `REQUIRE_THAT` or `CHECK_THAT` macros, which take two arguments.
-The first argument is the thing (object or value) under test. The second part is a match _expression_,
-which consists of either a single matcher or one or more matchers combined using `&&`, `||` or `!` operators.
 
-For example, to assert that a string ends with a certain substring:
+## Using Matchers
 
- ```c++
-using Catch::Matchers::EndsWith; // or Catch::EndsWith
-std::string str = getStringFromSomewhere();
-REQUIRE_THAT( str, EndsWith( "as a service" ) );
-```
+Matchers are most commonly used in tandem with the `REQUIRE_THAT` or
+`CHECK_THAT` macros. The `REQUIRE_THAT` macro takes two arguments,
+the first one is the input (object/value) to test, the second argument
+is the matcher itself.
 
-The matcher objects can take multiple arguments, allowing more fine tuning.
-The built-in string matchers, for example, take a second argument specifying whether the comparison is
-case sensitive or not:
+For example, to assert that a string ends with the "as a service"
+substring, you can write the following assertion
 
-```c++
-REQUIRE_THAT( str, EndsWith( "as a service", Catch::CaseSensitive::No ) );
- ```
+```cpp
+using Catch::Matchers::EndsWith;
 
-And matchers can be combined:
+REQUIRE_THAT( getSomeString(), EndsWith("as a service") );
+```
 
-```c++
-REQUIRE_THAT( str,
-    EndsWith( "as a service" ) ||
-    (StartsWith( "Big data" ) && !Contains( "web scale" ) ) );
+Individual matchers can also be combined using the C++ logical
+operators, that is `&&`, `||`, and `!`, like so:
+
+```cpp
+using Catch::Matchers::EndsWith;
+using Catch::Matchers::ContainsSubstring;
+
+REQUIRE_THAT( getSomeString(),
+              EndsWith("as a service") && ContainsSubstring("web scale"));
 ```
 
-_The combining operators do not take ownership of the matcher objects.
-This means that if you store the combined object, you have to ensure that
-the matcher objects outlive its last use. What this means is that code
-like this leads to a use-after-free and (hopefully) a crash:_
+The example above asserts that the string returned from `getSomeString`
+_both_ ends with the suffix "as a service" _and_ contains the string
+"web scale" somewhere.
+
+
+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 <catch2/matchers/catch_matchers_string.hpp>`.
+
+**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):
 
 ```cpp
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_string.hpp>
+
 TEST_CASE("Bugs, bugs, bugs", "[Bug]"){
     std::string str = "Bugs as a service";
 
-    auto match_expression = Catch::EndsWith( "as a service" ) ||
-        (Catch::StartsWith( "Big data" ) && !Catch::Contains( "web scale" ) );
+    auto match_expression = Catch::Matchers::EndsWith( "as a service" ) ||
+        (Catch::Matchers::StartsWith( "Big data" ) && !Catch::Matchers::ContainsSubstring( "web scale" ) );
     REQUIRE_THAT(str, match_expression);
 }
 ```
 
 
-## Built in matchers
-Catch2 provides some matchers by default. They can be found in the
-`Catch::Matchers::foo` namespace and are imported into the `Catch`
-namespace as well.
+## Built-in matchers
+
+Every matcher provided by Catch2 is split into 2 parts, a factory
+function that lives in the `Catch::Matchers` namespace, and the actual
+matcher type that is in some deeper namespace and should not be used by
+the user. In the examples above, we used `Catch::Matchers::Contains`.
+This is the factory function for the
+`Catch::Matchers::StdString::ContainsMatcher` type that does the actual
+matching.
 
-There are two parts to each of the built-in matchers, the matcher
-type itself and a helper function that provides template argument
-deduction when creating templated matchers. As an example, the matcher
-for checking that two instances of `std::vector` are identical is
-`EqualsMatcher<T>`, but the user is expected to use the `Equals`
-helper function instead.
+Out of the box, Catch2 provides the following matchers:
 
 
-### String matchers
-The string matchers are `StartsWith`, `EndsWith`, `Contains`, `Equals` and `Matches`. The first four match a literal (sub)string against a result, while `Matches` takes and matches an ECMAScript regex. Do note that `Matches` matches the string as a whole, meaning that "abc" will not match against "abcd", but "abc.*" will.
+### `std::string` matchers
 
-Each of the provided `std::string` matchers also takes an optional second argument, that decides case sensitivity (by-default, they are case sensitive).
+Catch2 provides 5 different matchers that work with `std::string`,
+* `StartsWith(std::string str, CaseSensitive)`,
+* `EndsWith(std::string str, CaseSensitive)`,
+* `ContainsSubstring(std::string str, CaseSensitive)`,
+* `Equals(std::string str, CaseSensitive)`, and
+* `Matches(std::string str, CaseSensitive)`.
+
+The first three should be fairly self-explanatory, they succeed if
+the argument starts with `str`, ends with `str`, or contains `str`
+somewhere inside it.
+
+The `Equals` matcher matches a string if (and only if) the argument
+string is equal to `str`.
+
+Finally, the `Matches` matcher performs an ECMAScript regex match using
+`str` against the argument string. It is important to know that
+the match is performed against the string as a whole, meaning that
+the regex `"abc"` will not match input string `"abcd"`. To match
+`"abcd"`, you need to use e.g. `"abc.*"` as your regex.
+
+The second argument sets whether the matching should be case-sensitive
+or not. By default, it is case-sensitive.
+
+> `std::string` matchers live in `catch2/matchers/catch_matchers_string.hpp`
 
 
 ### Vector matchers
-Catch2 currently provides 5 built-in matchers that work on `std::vector`.
+
+_Vector matchers have been deprecated in favour of the generic
+range matchers with the same functionality._
+
+Catch2 provides 5 built-in matchers that work on `std::vector`.
+
 These are
 
  * `Contains` which checks whether a specified vector is present in the result
@@ -79,42 +125,57 @@ These are
  * `Equals` which checks whether the result is exactly equal (order matters) to a specific vector
  * `UnorderedEquals` which checks whether the result is equal to a specific vector under a permutation
  * `Approx` which checks whether the result is "approx-equal" (order matters, but comparison is done via `Approx`) to a specific vector
-> Approx matcher was [introduced](https://github.com/catchorg/Catch2/issues/1499) in Catch 2.7.2.
+> Approx matcher was [introduced](https://github.com/catchorg/Catch2/issues/1499) in Catch2 2.7.2.
+
+An example usage:
+```cpp
+    std::vector<int> some_vec{ 1, 2, 3 };
+    REQUIRE_THAT(some_vec, Catch::Matchers::UnorderedEquals(std::vector<int>{ 3, 2, 1 }));
+```
+
+This assertions will pass, because the elements given to the matchers
+are a permutation of the ones in `some_vec`.
+
+> vector matchers live in `catch2/matchers/catch_matchers_vector.hpp`
 
 
 ### Floating point matchers
-Catch2 provides 3 matchers for working with floating point numbers. These
-are `WithinAbsMatcher`, `WithinUlpsMatcher` and `WithinRelMatcher`.
-
-The `WithinAbsMatcher` matcher accepts floating point numbers that are
-within a certain distance of target. It should be constructed with the
-`WithinAbs(double target, double margin)` helper.
-
-The `WithinUlpsMatcher` matcher accepts floating point numbers that are
-within a certain number of [ULPs](https://en.wikipedia.org/wiki/Unit_in_the_last_place)
-of the target. Because ULP comparisons need to be done differently for
-`float`s and for `double`s, there are two overloads of the helpers for
-this matcher, `WithinULP(float target, int64_t ULPs)`, and
-`WithinULP(double target, int64_t ULPs)`.
-
-The `WithinRelMatcher` matcher accepts floating point numbers that are
-_approximately equal_ with the target number with some specific tolerance.
-In other words, it checks that `|lhs - rhs| <= epsilon * max(|lhs|, |rhs|)`,
-with special casing for `INFINITY` and `NaN`. There are _4_ overloads of
-the helpers for this matcher, `WithinRel(double target, double margin)`,
-`WithinRel(float target, float margin)`, `WithinRel(double target)`, and
-`WithinRel(float target)`. The latter two provide a default epsilon of
-machine epsilon * 100.
-
-> `WithinRel` matcher was introduced in Catch 2.10.0
-
-### Generic matchers
-Catch also aims to provide a set of generic matchers. Currently this set
-contains only a matcher that takes arbitrary callable predicate and applies
-it onto the provided object.
-
-Because of type inference limitations, the argument type of the predicate
-has to be provided explicitly. Example:
+
+Catch2 provides 4 matchers that target floating point numbers. These
+are:
+
+* `WithinAbs(double target, double margin)`,
+* `WithinULP(FloatingPoint target, uint64_t maxUlpDiff)`, and
+* `WithinRel(FloatingPoint target, FloatingPoint eps)`.
+* `IsNaN()`
+
+> `WithinRel` matcher was introduced in Catch2 2.10.0
+
+> `IsNaN` matcher was introduced in Catch2 3.3.2.
+
+The first three serve to compare two floating pointe numbers. For more
+details about how they work, read [the docs on comparing floating point
+numbers](comparing-floating-point-numbers.md#floating-point-matchers).
+
+`IsNaN` then does exactly what it says on the tin. It matches the input
+if it is a NaN (Not a Number). The advantage of using it over just plain
+`REQUIRE(std::isnan(x))`, is that if the check fails, with `REQUIRE` you
+won't see the value of `x`, but with `REQUIRE_THAT(x, IsNaN())`, you will.
+
+
+### Miscellaneous matchers
+
+Catch2 also provides some matchers and matcher utilities that do not
+quite fit into other categories.
+
+The first one of them is the `Predicate(Callable pred, std::string description)`
+matcher. It creates a matcher object that calls `pred` for the provided
+argument. The `description` argument allows users to set what the
+resulting matcher should self-describe as if required.
+
+Do note that you will need to explicitly specify the type of the
+argument, like in this example:
+
 ```cpp
 REQUIRE_THAT("Hello olleH",
              Predicate<std::string>(
@@ -123,84 +184,256 @@ REQUIRE_THAT("Hello olleH",
 );
 ```
 
-The second argument is an optional description of the predicate, and is
-used only during reporting of the result.
+> the predicate matcher lives in `catch2/matchers/catch_matchers_predicate.hpp`
 
 
-### Exception matchers
-Catch2 also provides an exception matcher that can be used to verify
-that an exception's message exactly matches desired string. The matcher
-is `ExceptionMessageMatcher`, and we also provide a helper function
-`Message`.
+The other miscellaneous matcher utility is exception matching.
 
-The matched exception must publicly derive from `std::exception` and
-the message matching is done _exactly_, including case.
 
-> `ExceptionMessageMatcher` was introduced in Catch 2.10.0
+#### 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)`.
+
+> `REQUIRE_THROWS_MATCHES` macro lives in `catch2/matchers/catch_matchers.hpp`
+
+
+Catch2 currently provides two matchers for exceptions.
+These are:
+* `Message(std::string message)`.
+* `MessageMatches(Matcher matcher)`.
+
+> `MessageMatches` was [introduced](https://github.com/catchorg/Catch2/pull/2570) in Catch2 3.3.0
+
+`Message` checks that the exception's
+message, as returned from `what` is exactly equal to `message`.
+
+`MessageMatches` applies the provided matcher on the exception's
+message, as returned from `what`. This is useful in conjunctions with the `std::string` matchers (e.g. `StartsWith`)
 
 Example use:
 ```cpp
 REQUIRE_THROWS_MATCHES(throwsDerivedException(),  DerivedException,  Message("DerivedException::what"));
+REQUIRE_THROWS_MATCHES(throwsDerivedException(),  DerivedException,  MessageMatches(StartsWith("DerivedException")));
 ```
 
-## Custom matchers
-It's easy to provide your own matchers to extend Catch or just to work with your own types.
+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`
+
+
+### Generic range Matchers
+
+> Generic range matchers were introduced in Catch2 3.0.1
+
+Catch2 also provides some matchers that use the new style matchers
+definitions to handle generic range-like types. These are:
 
-You need to provide two things:
-1. A matcher class, derived from `Catch::MatcherBase<T>` - where `T` is the type being tested.
-The constructor takes and stores any arguments needed (e.g. something to compare against) and you must
-override two methods: `match()` and `describe()`.
-2. A simple builder function. This is what is actually called from the test code and allows overloading.
+* `IsEmpty()`
+* `SizeIs(size_t target_size)`
+* `SizeIs(Matcher size_matcher)`
+* `Contains(T&& target_element, Comparator = std::equal_to<>{})`
+* `Contains(Matcher element_matcher)`
+* `AllMatch(Matcher element_matcher)`
+* `AnyMatch(Matcher element_matcher)`
+* `NoneMatch(Matcher element_matcher)`
+* `AllTrue()`, `AnyTrue()`, `NoneTrue()`
+* `RangeEquals(TargetRangeLike&&, Comparator = std::equal_to<>{})`
+* `UnorderedRangeEquals(TargetRangeLike&&, Comparator = std::equal_to<>{})`
 
-Here's an example for asserting that an integer falls within a given range
-(note that it is all inline for the sake of keeping the example short):
+> `IsEmpty`, `SizeIs`, `Contains` were introduced in Catch2 3.0.1
+
+> `All/Any/NoneMatch` were introduced in Catch2 3.0.1
+
+> `All/Any/NoneTrue` were introduced in Catch2 3.1.0
+
+> `RangeEquals` and `UnorderedRangeEquals` matchers were [introduced](https://github.com/catchorg/Catch2/pull/2377) in Catch2 3.3.0
+
+`IsEmpty` should be self-explanatory. It successfully matches objects
+that are empty according to either `std::empty`, or ADL-found `empty`
+free function.
+
+`SizeIs` checks range's size. If constructed with `size_t` arg, the
+matchers accepts ranges whose size is exactly equal to the arg. If
+constructed from another matcher, then the resulting matcher accepts
+ranges whose size is accepted by the provided matcher.
+
+`Contains` accepts ranges that contain specific element. There are
+again two variants, one that accepts the desired element directly,
+in which case a range is accepted if any of its elements is equal to
+the target element. The other variant is constructed from a matcher,
+in which case a range is accepted if any of its elements is accepted
+by the provided matcher.
+
+`AllMatch`, `NoneMatch`, and `AnyMatch` match ranges for which either
+all, none, or any of the contained elements matches the given matcher,
+respectively.
+
+`AllTrue`, `NoneTrue`, and `AnyTrue` match ranges for which either
+all, none, or any of the contained elements are `true`, respectively.
+It works for ranges of `bool`s and ranges of elements (explicitly)
+convertible to `bool`.
+
+`RangeEquals` compares the range that the matcher is constructed with
+(the "target range") against the range to be tested, element-wise. The
+match succeeds if all elements from the two ranges compare equal (using
+`operator==` by default). The ranges do not need to be the same type,
+and the element types do not need to be the same, as long as they are
+comparable. (e.g. you may compare `std::vector<int>` to `std::array<char>`).
+
+`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.
+
+Both `RangeEquals` and `UnorderedRangeEquals` optionally accept a
+predicate which can be used to compare the containers element-wise.
+
+To check a container elementwise against a given matcher, use
+`AllMatch`.
+
+
+## Writing custom matchers (old style)
+
+The old style of writing matchers has been introduced back in Catch
+Classic. To create an old-style matcher, you have to create your own
+type that derives from `Catch::Matchers::MatcherBase<ArgT>`, where
+`ArgT` is the type your matcher works for. Your type has to override
+two methods, `bool match(ArgT const&) const`,
+and `std::string describe() const`.
+
+As the name suggests, `match` decides whether the provided argument
+is matched (accepted) by the matcher. `describe` then provides a
+human-oriented description of what the matcher does.
+
+We also recommend that you create factory function, just like Catch2
+does, but that is mostly useful for template argument deduction for
+templated matchers (assuming you do not have CTAD available).
+
+To combine these into an example, let's say that you want to write
+a matcher that decides whether the provided argument is a number
+within certain range. We will call it `IsBetweenMatcher<T>`:
 
 ```c++
-// The matcher class
-class IntRange : public Catch::MatcherBase<int> {
-    int m_begin, m_end;
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers.hpp>
+// ...
+
+
+template <typename T>
+class IsBetweenMatcher : public Catch::Matchers::MatcherBase<T> {
+    T m_begin, m_end;
 public:
-    IntRange( int begin, int end ) : m_begin( begin ), m_end( end ) {}
+    IsBetweenMatcher(T begin, T end) : m_begin(begin), m_end(end) {}
 
-    // Performs the test for this matcher
-    bool match( int const& i ) const override {
-        return i >= m_begin && i <= m_end;
+    bool match(T const& in) const override {
+        return in >= m_begin && in <= m_end;
     }
 
-    // Produces a string describing what this matcher does. It should
-    // include any provided data (the begin/ end in this case) and
-    // be written as if it were stating a fact (in the output it will be
-    // preceded by the value under test).
-    virtual std::string describe() const override {
+    std::string describe() const override {
         std::ostringstream ss;
         ss << "is between " << m_begin << " and " << m_end;
         return ss.str();
     }
 };
 
-// The builder function
-inline IntRange IsBetween( int begin, int end ) {
-    return IntRange( begin, end );
+template <typename T>
+IsBetweenMatcher<T> IsBetween(T begin, T end) {
+    return { begin, end };
 }
 
 // ...
 
-// Usage
-TEST_CASE("Integers are within a range")
-{
-    CHECK_THAT( 3, IsBetween( 1, 10 ) );
-    CHECK_THAT( 100, IsBetween( 1, 10 ) );
+TEST_CASE("Numbers are within range") {
+    // infers `double` for the argument type of the matcher
+    CHECK_THAT(3., IsBetween(1., 10.));
+    // infers `int` for the argument type of the matcher
+    CHECK_THAT(100, IsBetween(1, 10));
 }
 ```
 
-Running this test gives the following in the console:
+Obviously, the code above can be improved somewhat, for example you
+might want to `static_assert` over the fact that `T` is an arithmetic
+type... or generalize the matcher to cover any type for which the user
+can provide a comparison function object.
 
+Note that while any matcher written using the old style can also be
+written using the new style, combining old style matchers should
+generally compile faster. Also note that you can combine old and new
+style matchers arbitrarily.
+
+> `MatcherBase` lives in `catch2/matchers/catch_matchers.hpp`
+
+
+## Writing custom matchers (new style)
+
+> New style matchers were introduced in Catch2 3.0.1
+
+To create a new-style matcher, you have to create your own type that
+derives from `Catch::Matchers::MatcherGenericBase`. Your type has to
+also provide two methods, `bool match( ... ) const` and overridden
+`std::string describe() const`.
+
+Unlike with old-style matchers, there are no requirements on how
+the `match` member function takes its argument. This means that the
+argument can be taken by value or by mutating reference, but also that
+the matcher's `match` member function can be templated.
+
+This allows you to write more complex matcher, such as a matcher that
+can compare one range-like (something that responds to `begin` and
+`end`) object to another, like in the following example:
+
+```cpp
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_templated.hpp>
+// ...
+
+template<typename Range>
+struct EqualsRangeMatcher : Catch::Matchers::MatcherGenericBase {
+    EqualsRangeMatcher(Range const& range):
+        range{ range }
+    {}
+
+    template<typename OtherRange>
+    bool match(OtherRange const& other) const {
+        using std::begin; using std::end;
+
+        return std::equal(begin(range), end(range), begin(other), end(other));
+    }
+
+    std::string describe() const override {
+        return "Equals: " + Catch::rangeToString(range);
+    }
+
+private:
+    Range const& range;
+};
+
+template<typename Range>
+auto EqualsRange(const Range& range) -> EqualsRangeMatcher<Range> {
+    return EqualsRangeMatcher<Range>{range};
+}
+
+TEST_CASE("Combining templated matchers", "[matchers][templated]") {
+    std::array<int, 3> container{{ 1,2,3 }};
+
+    std::array<int, 3> a{{ 1,2,3 }};
+    std::vector<int> b{ 0,1,2 };
+    std::list<int> c{ 4,5,6 };
+
+    REQUIRE_THAT(container, EqualsRange(a) || EqualsRange(b) || EqualsRange(c));
+}
 ```
-/**/TestFile.cpp:123: FAILED:
-  CHECK_THAT( 100, IsBetween( 1, 10 ) )
-with expansion:
-  100 is between 1 and 10
-```
+
+Do note that while you can rewrite any matcher from the old style to
+a new style matcher, combining new style matchers is more expensive
+in terms of compilation time. Also note that you can combine old style
+and new style matchers arbitrarily.
+
+> `MatcherGenericBase` lives in `catch2/matchers/catch_matchers_templated.hpp`
+
 
 ---
 

package/deps/couchbase-cxx-client/third_party/catch2/docs/migrate-v2-to-v3.md

@@ -0,0 +1,98 @@
+<a id="top"></a>
+# Migrating from v2 to v3
+
+v3 is the next major version of Catch2 and brings three significant changes:
+ * Catch2 is now split into multiple headers
+ * Catch2 is now compiled as a static library
+ * C++14 is the minimum required C++ version
+
+There are many reasons why we decided to go from the old single-header
+distribution model to a more standard library distribution model. The
+big one is compile-time performance, but moving over to a split header
+distribution model also improves the future maintainability and
+extendability of the codebase. For example v3 adds a new kind of matchers
+without impacting the compilation times of users that do not use matchers
+in their tests. The new model is also more friendly towards package
+managers, such as vcpkg and Conan.
+
+The result of this move is a significant improvement in compilation
+times, e.g. the inclusion overhead of Catch2 in the common case has been
+reduced by roughly 80%. The improved ease of maintenance also led to
+various runtime performance improvements and the introduction of new features.
+For details, look at [the release notes of 3.0.1](release-notes.md#301).
+
+_Note that we still provide one header + one translation unit (TU)
+distribution but do not consider it the primarily supported option. You
+should also expect that the compilation times will be worse if you use
+this option._
+
+
+## How to migrate projects from v2 to v3
+
+To migrate to v3, there are two basic approaches to do so.
+
+1. Use `catch_amalgamated.hpp` and `catch_amalgamated.cpp`.
+2. Build Catch2 as a proper (static) library, and move to piecewise headers
+
+Doing 1 means downloading the [amalgamated header](/extras/catch_amalgamated.hpp)
+and the [amalgamated sources](/extras/catch_amalgamated.cpp) from `extras`,
+dropping them into your test project, and rewriting your includes from
+`<catch2/catch.hpp>` to `"catch_amalgamated.hpp"` (or something similar,
+based on how you set up your paths).
+
+The disadvantage of using this approach are increased compilation times,
+at least compared to the second approach, but it does let you avoid
+dealing with consuming libraries in your build system of choice.
+
+
+However, we recommend doing 2, and taking extra time to migrate to v3
+properly. This lets you reap the benefits of significantly improved
+compilation times in the v3 version. The basic steps to do so are:
+
+1. Change your CMakeLists.txt to link against `Catch2WithMain` target if
+you use Catch2's default main. (If you do not, keep linking against
+the `Catch2` target.). If you use pkg-config, change `pkg-config catch2` to
+`pkg-config catch2-with-main`.
+2. Delete TU with `CATCH_CONFIG_RUNNER` or `CATCH_CONFIG_MAIN` defined,
+as it is no longer needed.
+3. Change `#include <catch2/catch.hpp>` to `#include <catch2/catch_all.hpp>`
+4. Check that everything compiles. You might have to modify namespaces,
+or perform some other changes (see the
+[Things that can break during porting](#things-that-can-break-during-porting)
+section for the most common things).
+5. Start migrating your test TUs from including `<catch2/catch_all.hpp>`
+to piecemeal includes. You will likely want to start by including
+`<catch2/catch_test_macros.hpp>`, and then go from there. (see
+[other notes](#other-notes) for further ideas)
+
+## Other notes
+
+* The main test include is now `<catch2/catch_test_macros.hpp>`
+
+* Big "subparts" like Matchers, or Generators, have their own folder, and
+also their own "big header", so if you just want to include all matchers,
+you can include `<catch2/matchers/catch_matchers_all.hpp>`,
+or `<catch2/generators/catch_generators_all.hpp>`
+
+
+## Things that can break during porting
+
+* The namespaces of Matchers were flattened and cleaned up.
+
+Matchers are no longer declared deep within an internal namespace and
+then brought up into `Catch` namespace. All Matchers now live in the
+`Catch::Matchers` namespace.
+
+* The `Contains` string matcher was renamed to `ContainsSubstring`.
+
+* The reporter interfaces changed in a breaking manner.
+
+If you are using a custom reporter or listener, you will likely need to
+modify them to conform to the new interfaces. Unlike before in v2,
+the [interfaces](reporters.md#top) and the [events](reporter-events.md#top)
+are now documented.
+
+
+---
+
+[Home](Readme.md#top)