couchbase 4.2.1 → 4.2.3

package/deps/couchbase-cxx-client/third_party/catch2/tests/SelfTest/IntrospectiveTests/CmdLineHelpers.tests.cpp

@@ -0,0 +1,111 @@
+
+//              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
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/internal/catch_reporter_spec_parser.hpp>
+#include <catch2/matchers/catch_matchers_vector.hpp>
+#include <catch2/interfaces/catch_interfaces_config.hpp>
+
+TEST_CASE("Reporter spec splitting", "[reporter-spec][cli][approvals]") {
+	using Catch::Detail::splitReporterSpec;
+	using Catch::Matchers::Equals;
+	using namespace std::string_literals;
+
+    SECTION("Various edge cases") {
+        REQUIRE_THAT( splitReporterSpec( "" ),
+                      Equals( std::vector<std::string>{ ""s } ) );
+        REQUIRE_THAT( splitReporterSpec( "::" ),
+                      Equals( std::vector<std::string>{ "", "" } ) );
+        REQUIRE_THAT( splitReporterSpec( "::rep" ),
+                      Equals( std::vector<std::string>{ "", "rep" } ) );
+        REQUIRE_THAT( splitReporterSpec( "rep::" ),
+                      Equals( std::vector<std::string>{ "rep", "" } ) );
+
+    }
+
+    SECTION("Validish specs") {
+        REQUIRE_THAT( splitReporterSpec( "newReporter" ),
+                      Equals( std::vector<std::string>{ "newReporter"s } ) );
+        REQUIRE_THAT(
+            splitReporterSpec( "foo-reporter::key1=value1::key2=value with "
+                               "space::key with space=some-value" ),
+            Equals(
+                std::vector<std::string>{ "foo-reporter"s,
+                                          "key1=value1"s,
+                                          "key2=value with space"s,
+                                          "key with space=some-value"s } ) );
+        REQUIRE_THAT(
+            splitReporterSpec( "spaced reporter name::key:key=value:value" ),
+            Equals( std::vector<std::string>{ "spaced reporter name"s,
+                                              "key:key=value:value"s } ) );
+    }
+}
+
+TEST_CASE( "Parsing colour mode", "[cli][colour][approvals]" ) {
+    using Catch::Detail::stringToColourMode;
+    using Catch::ColourMode;
+    SECTION("Valid strings") {
+        REQUIRE( stringToColourMode( "none" ) == ColourMode::None );
+        REQUIRE( stringToColourMode( "ansi" ) == ColourMode::ANSI );
+        REQUIRE( stringToColourMode( "win32" ) == ColourMode::Win32 );
+        REQUIRE( stringToColourMode( "default" ) ==
+                 ColourMode::PlatformDefault );
+    }
+    SECTION("Wrong strings") {
+        REQUIRE_FALSE( stringToColourMode( "NONE" ) );
+        REQUIRE_FALSE( stringToColourMode( "-" ) );
+        REQUIRE_FALSE( stringToColourMode( "asdbjsdb kasbd" ) );
+    }
+}
+
+
+TEST_CASE("Parsing reporter specs", "[cli][reporter-spec][approvals]") {
+    using Catch::parseReporterSpec;
+    using Catch::ReporterSpec;
+    using namespace std::string_literals;
+
+    SECTION( "Correct specs" ) {
+        REQUIRE( parseReporterSpec( "someReporter" ) ==
+                 ReporterSpec( "someReporter"s, {}, {}, {} ) );
+        REQUIRE( parseReporterSpec( "otherReporter::Xk=v::out=c:\\blah" ) ==
+                 ReporterSpec(
+                     "otherReporter"s, "c:\\blah"s, {}, { { "Xk"s, "v"s } } ) );
+        REQUIRE( parseReporterSpec( "diffReporter::Xk1=v1::Xk2==v2" ) ==
+                 ReporterSpec( "diffReporter",
+                               {},
+                               {},
+                               { { "Xk1"s, "v1"s }, { "Xk2"s, "=v2"s } } ) );
+        REQUIRE( parseReporterSpec(
+                     "Foo:bar:reporter::colour-mode=ansi::Xk 1=v 1::Xk2=v:3" ) ==
+                 ReporterSpec( "Foo:bar:reporter",
+                               {},
+                               Catch::ColourMode::ANSI,
+                               { { "Xk 1"s, "v 1"s }, { "Xk2"s, "v:3"s } } ) );
+    }
+
+    SECTION( "Bad specs" ) {
+        REQUIRE_FALSE( parseReporterSpec( "::" ) );
+        // Unknown Catch2 arg (should be "out")
+        REQUIRE_FALSE( parseReporterSpec( "reporter::output=filename" ) );
+        // Wrong colour spec
+        REQUIRE_FALSE( parseReporterSpec( "reporter::colour-mode=custom" ) );
+        // Duplicated colour spec
+        REQUIRE_FALSE( parseReporterSpec( "reporter::colour-mode=ansi::colour-mode=ansi" ) );
+        // Duplicated out arg
+        REQUIRE_FALSE( parseReporterSpec( "reporter::out=f.txt::out=z.txt" ) );
+        // Duplicated custom arg
+        REQUIRE_FALSE( parseReporterSpec( "reporter::Xa=foo::Xa=bar" ) );
+        // Empty key
+        REQUIRE_FALSE( parseReporterSpec( "reporter::X=foo" ) );
+        REQUIRE_FALSE( parseReporterSpec( "reporter::=foo" ) );
+        // Empty value
+        REQUIRE_FALSE( parseReporterSpec( "reporter::Xa=" ) );
+        // non-key value later field
+        REQUIRE_FALSE( parseReporterSpec( "reporter::Xab" ) );
+    }
+}

package/deps/couchbase-cxx-client/third_party/catch2/tests/SelfTest/IntrospectiveTests/ColourImpl.tests.cpp

@@ -0,0 +1,64 @@
+
+//              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
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/internal/catch_console_colour.hpp>
+#include <catch2/internal/catch_istream.hpp>
+
+#include <sstream>
+
+namespace {
+    class TestColourImpl : public Catch::ColourImpl {
+        using Catch::ColourImpl::ColourImpl;
+        // Inherited via ColourImpl
+        void use( Catch::Colour::Code colourCode ) const override {
+            m_stream->stream() << "Using code: " << colourCode << '\n';
+        }
+    };
+
+    class TestStringStream : public Catch::IStream {
+        std::stringstream m_stream;
+    public:
+        std::ostream& stream() override {
+            return m_stream;
+        }
+
+        std::string str() const { return m_stream.str(); }
+    };
+}
+
+TEST_CASE("ColourGuard behaviour", "[console-colours]") {
+    TestStringStream streamWrapper;
+    TestColourImpl colourImpl( &streamWrapper );
+    auto& stream = streamWrapper.stream();
+
+    SECTION("ColourGuard is disengaged by default") {
+        { auto guard = colourImpl.guardColour( Catch::Colour::Red ); }
+
+        REQUIRE( streamWrapper.str().empty() );
+    }
+
+    SECTION("ColourGuard is engaged by op<<") {
+        stream << "1\n" << colourImpl.guardColour( Catch::Colour::Red ) << "2\n";
+        stream << "3\n";
+
+        REQUIRE( streamWrapper.str() == "1\nUsing code: 2\n2\nUsing code: 0\n3\n" );
+    }
+
+    SECTION("ColourGuard can be engaged explicitly") {
+        {
+            auto guard =
+                colourImpl.guardColour( Catch::Colour::Red ).engage( stream );
+            stream << "A\n"
+                   << "B\n";
+        }
+        stream << "C\n";
+        REQUIRE( streamWrapper.str() ==
+                 "Using code: 2\nA\nB\nUsing code: 0\nC\n" );
+    }
+}

package/deps/couchbase-cxx-client/third_party/catch2/tests/SelfTest/IntrospectiveTests/Details.tests.cpp

@@ -0,0 +1,131 @@
+
+//              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
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/internal/catch_enforce.hpp>
+#include <catch2/internal/catch_case_insensitive_comparisons.hpp>
+#include <catch2/internal/catch_optional.hpp>
+
+#include <helpers/type_with_lit_0_comparisons.hpp>
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4702) // unreachable code in the macro expansions
+#endif
+
+TEST_CASE("Check that our error handling macros throw the right exceptions", "[!throws][internals][approvals]") {
+    REQUIRE_THROWS_AS(CATCH_INTERNAL_ERROR(""), std::logic_error);
+    REQUIRE_THROWS_AS(CATCH_ERROR(""), std::domain_error);
+    REQUIRE_THROWS_AS(CATCH_RUNTIME_ERROR(""), std::runtime_error);
+    REQUIRE_THROWS_AS([](){CATCH_ENFORCE(false, "");}(), std::domain_error);
+    REQUIRE_NOTHROW([](){CATCH_ENFORCE(true, "");}());
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop) // unreachable code in the macro expansions
+#endif
+
+TEST_CASE("CaseInsensitiveLess is case insensitive", "[comparisons][string-case]") {
+    Catch::Detail::CaseInsensitiveLess lt;
+    SECTION( "Degenerate cases" ) {
+        REQUIRE( lt( "", "a" ) );
+        REQUIRE_FALSE( lt( "a", "a" ) );
+        REQUIRE_FALSE( lt( "", "" ) );
+    }
+    SECTION("Plain comparisons") {
+        REQUIRE( lt( "a", "b" ) );
+        REQUIRE( lt( "a", "B" ) );
+        REQUIRE( lt( "A", "b" ) );
+        REQUIRE( lt( "A", "B" ) );
+    }
+}
+
+TEST_CASE( "CaseInsensitiveEqualsTo is case insensitive",
+           "[comparisons][string-case]" ) {
+    Catch::Detail::CaseInsensitiveEqualTo eq;
+    SECTION( "Degenerate cases" ) {
+        REQUIRE( eq( "", "" ) );
+        REQUIRE_FALSE( eq( "", "a" ) );
+    }
+    SECTION( "Plain comparisons" ) {
+        REQUIRE( eq( "a", "a" ) );
+        REQUIRE( eq( "a", "A" ) );
+        REQUIRE( eq( "A", "a" ) );
+        REQUIRE( eq( "A", "A" ) );
+        REQUIRE_FALSE( eq( "a", "b" ) );
+        REQUIRE_FALSE( eq( "a", "B" ) );
+    }
+}
+
+TEST_CASE("Optional comparison ops", "[optional][approvals]") {
+    using Catch::Optional;
+
+    Optional<int> a, b;
+
+    SECTION( "Empty optionals are equal" ) {
+        REQUIRE( a == b );
+        REQUIRE_FALSE( a != b );
+    }
+    SECTION( "Empty and non-empty optionals are never equal" ) {
+        a = 1;
+        REQUIRE_FALSE( a == b );
+        REQUIRE( a != b );
+    }
+    SECTION(
+        "non-empty optionals are equal if the contained elements are equal") {
+        a = 1;
+        b = 2;
+        REQUIRE( a != b );
+        REQUIRE_FALSE( a == b );
+
+        a = 2;
+        REQUIRE( a == b );
+        REQUIRE_FALSE( a != b );
+    }
+}
+
+TEST_CASE( "Decomposer checks that the argument is 0 when handling "
+           "only-0-comparable types",
+           "[decomposition][approvals]" ) {
+    TypeWithLit0Comparisons t{};
+
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+    CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+
+    REQUIRE_THROWS( Catch::Decomposer{} <= t == 42 );
+    REQUIRE_THROWS( Catch::Decomposer{} <= 42 == t );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= t == 0 );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 == t );
+
+    REQUIRE_THROWS( Catch::Decomposer{} <= t != 42 );
+    REQUIRE_THROWS( Catch::Decomposer{} <= 42 != t );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= t != 0 );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 != t );
+
+    REQUIRE_THROWS( Catch::Decomposer{} <= t < 42 );
+    REQUIRE_THROWS( Catch::Decomposer{} <= 42 < t );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= t < 0 );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 < t );
+
+    REQUIRE_THROWS( Catch::Decomposer{} <= t <= 42 );
+    REQUIRE_THROWS( Catch::Decomposer{} <= 42 <= t );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= t <= 0 );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 <= t );
+
+    REQUIRE_THROWS( Catch::Decomposer{} <= t > 42 );
+    REQUIRE_THROWS( Catch::Decomposer{} <= 42 > t );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= t > 0 );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 > t );
+
+    REQUIRE_THROWS( Catch::Decomposer{} <= t >= 42 );
+    REQUIRE_THROWS( Catch::Decomposer{} <= 42 >= t );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= t >= 0 );
+    REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 >= t );
+
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+}

package/deps/couchbase-cxx-client/third_party/catch2/tests/SelfTest/IntrospectiveTests/FloatingPoint.tests.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
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_template_test_macros.hpp>
+#include <catch2/internal/catch_floating_point_helpers.hpp>
+
+
+TEST_CASE("convertToBits", "[floating-point][conversion]") {
+    using Catch::Detail::convertToBits;
+
+    CHECK( convertToBits( 0.f ) == 0 );
+    CHECK( convertToBits( -0.f ) == ( 1ULL << 31 ) );
+    CHECK( convertToBits( 0. ) == 0 );
+    CHECK( convertToBits( -0. ) == ( 1ULL << 63 ) );
+    CHECK( convertToBits( std::numeric_limits<float>::denorm_min() ) == 1 );
+    CHECK( convertToBits( std::numeric_limits<double>::denorm_min() ) == 1 );
+}
+
+TEMPLATE_TEST_CASE("type-shared ulpDistance tests", "[floating-point][ulp][approvals]", float, double) {
+    using FP = TestType;
+    using Catch::ulpDistance;
+
+    // Distance between zeros is zero
+    CHECK( ulpDistance( FP{}, FP{} ) == 0 );
+    CHECK( ulpDistance( FP{}, -FP{} ) == 0 );
+    CHECK( ulpDistance( -FP{}, -FP{} ) == 0 );
+
+    // Distance between same-sign infinities is zero
+    static constexpr FP infinity = std::numeric_limits<FP>::infinity();
+    CHECK( ulpDistance( infinity, infinity ) == 0 );
+    CHECK( ulpDistance( -infinity, -infinity ) == 0 );
+
+    // Distance between max-finite-val and same sign infinity is 1
+    static constexpr FP max_finite = std::numeric_limits<FP>::max();
+    CHECK( ulpDistance( max_finite, infinity ) == 1 );
+    CHECK( ulpDistance( -max_finite, -infinity ) == 1 );
+
+    // Distance between X and 0 is half of distance between X and -X
+    CHECK( ulpDistance( -infinity, infinity ) ==
+           2 * ulpDistance( infinity, FP{} ) );
+    CHECK( 2 * ulpDistance( FP{ -2. }, FP{} ) ==
+           ulpDistance( FP{ -2. }, FP{ 2. } ) );
+    CHECK( 2 * ulpDistance( FP{ 2. }, FP{} ) ==
+           ulpDistance( FP{ -2. }, FP{ 2. } ) );
+
+    // Denorms are supported
+    CHECK( ulpDistance( std::numeric_limits<FP>::denorm_min(), FP{} ) == 1 );
+    CHECK( ulpDistance( std::numeric_limits<FP>::denorm_min(), -FP{} ) == 1 );
+    CHECK( ulpDistance( -std::numeric_limits<FP>::denorm_min(), FP{} ) == 1 );
+    CHECK( ulpDistance( -std::numeric_limits<FP>::denorm_min(), -FP{} ) == 1 );
+    CHECK( ulpDistance( std::numeric_limits<FP>::denorm_min(),
+                        -std::numeric_limits<FP>::denorm_min() ) == 2 );
+
+    // Machine epsilon
+    CHECK( ulpDistance( FP{ 1. },
+                        FP{ 1. } + std::numeric_limits<FP>::epsilon() ) == 1 );
+    CHECK( ulpDistance( -FP{ 1. },
+                        -FP{ 1. } - std::numeric_limits<FP>::epsilon() ) == 1 );
+}
+
+TEST_CASE("UlpDistance", "[floating-point][ulp][approvals]") {
+    using Catch::ulpDistance;
+
+    CHECK( ulpDistance( 1., 2. ) == 0x10'00'00'00'00'00'00 );
+    CHECK( ulpDistance( -2., 2. ) == 0x80'00'00'00'00'00'00'00 );
+    CHECK( ulpDistance( 1.f, 2.f ) == 0x80'00'00 );
+    CHECK( ulpDistance( -2.f, 2.f ) == 0x80'00'00'00 );
+}