couchbase 4.2.2 → 4.2.4

package/deps/couchbase-cxx-client/third_party/catch2/projects/SelfTest/UsageTests/EnumToString.tests.cpp

@@ -1,99 +0,0 @@
-#include "catch.hpp"
-
-
-namespace {
-// Enum without user-provided stream operator
-enum Enum1 { Enum1Value0, Enum1Value1 };
-
-// Enum with user-provided stream operator
-enum Enum2 { Enum2Value0, Enum2Value1 };
-
-std::ostream& operator<<( std::ostream& os, Enum2 v ) {
-    return os << "E2{" << static_cast<int>(v) << "}";
-}
-} // end anonymous namespace
-
-TEST_CASE( "toString(enum)", "[toString][enum]" ) {
-    Enum1 e0 = Enum1Value0;
-    CHECK( ::Catch::Detail::stringify(e0) == "0" );
-    Enum1 e1 = Enum1Value1;
-    CHECK( ::Catch::Detail::stringify(e1) == "1" );
-}
-
-TEST_CASE( "toString(enum w/operator<<)", "[toString][enum]" ) {
-    Enum2 e0 = Enum2Value0;
-    CHECK( ::Catch::Detail::stringify(e0) == "E2{0}" );
-    Enum2 e1 = Enum2Value1;
-    CHECK( ::Catch::Detail::stringify(e1) == "E2{1}" );
-}
-
-// Enum class without user-provided stream operator
-namespace {
-enum class EnumClass1 { EnumClass1Value0, EnumClass1Value1 };
-
-// Enum class with user-provided stream operator
-enum class EnumClass2 { EnumClass2Value0, EnumClass2Value1 };
-
-std::ostream& operator<<( std::ostream& os, EnumClass2 e2 ) {
-    switch( static_cast<int>( e2 ) ) {
-        case static_cast<int>( EnumClass2::EnumClass2Value0 ):
-            return os << "E2/V0";
-        case static_cast<int>( EnumClass2::EnumClass2Value1 ):
-            return os << "E2/V1";
-        default:
-            return os << "Unknown enum value " << static_cast<int>( e2 );
-    }
-}
-
-} // end anonymous namespace
-
-TEST_CASE( "toString(enum class)", "[toString][enum][enumClass]" ) {
-    EnumClass1 e0 = EnumClass1::EnumClass1Value0;
-    CHECK( ::Catch::Detail::stringify(e0) == "0" );
-    EnumClass1 e1 = EnumClass1::EnumClass1Value1;
-    CHECK( ::Catch::Detail::stringify(e1) == "1" );
-}
-
-
-TEST_CASE( "toString(enum class w/operator<<)", "[toString][enum][enumClass]" ) {
-    EnumClass2 e0 = EnumClass2::EnumClass2Value0;
-    CHECK( ::Catch::Detail::stringify(e0) == "E2/V0" );
-    EnumClass2 e1 = EnumClass2::EnumClass2Value1;
-    CHECK( ::Catch::Detail::stringify(e1) == "E2/V1" );
-
-    auto e3 = static_cast<EnumClass2>(10);
-    CHECK( ::Catch::Detail::stringify(e3) == "Unknown enum value 10" );
-}
-
-enum class EnumClass3 { Value1, Value2, Value3, Value4 };
-
-CATCH_REGISTER_ENUM( EnumClass3, EnumClass3::Value1, EnumClass3::Value2, EnumClass3::Value3 )
-
-
-TEST_CASE( "Enums can quickly have stringification enabled using REGISTER_ENUM" ) {
-    using Catch::Detail::stringify;
-    REQUIRE( stringify( EnumClass3::Value1 ) == "Value1" );
-    REQUIRE( stringify( EnumClass3::Value2 ) == "Value2" );
-    REQUIRE( stringify( EnumClass3::Value3 ) == "Value3" );
-    REQUIRE( stringify( EnumClass3::Value4 ) == "{** unexpected enum value **}" );
-
-    EnumClass3 ec3 = EnumClass3 ::Value2;
-    REQUIRE( stringify( ec3 ) == "Value2" );
-}
-
-namespace Bikeshed {
-    enum class Colours { Red, Green, Blue };
-}
-
-// Important!: This macro must appear at top level scope - not inside a namespace
-// You can fully qualify the names, or use a using if you prefer
-CATCH_REGISTER_ENUM( Bikeshed::Colours,
-                     Bikeshed::Colours::Red,
-                     Bikeshed::Colours::Green,
-                     Bikeshed::Colours::Blue )
-
-TEST_CASE( "Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" ) {
-    using Catch::Detail::stringify;
-    REQUIRE( stringify( Bikeshed::Colours::Red ) == "Red" );
-    REQUIRE( stringify( Bikeshed::Colours::Blue ) == "Blue" );
-}

package/deps/couchbase-cxx-client/third_party/catch2/projects/SelfTest/UsageTests/Exception.tests.cpp

@@ -1,210 +0,0 @@
-/*
- *  Created by Phil on 09/11/2010.
- *  Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-
-#include "catch.hpp"
-
-#include <string>
-#include <stdexcept>
-
-#ifdef _MSC_VER
-#pragma warning(disable:4702) // Unreachable code -- unconditional throws and so on
-#endif
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#pragma clang diagnostic ignored "-Wmissing-noreturn"
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
-
-namespace { namespace ExceptionTests {
-
-#ifndef EXCEPTION_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
-#define EXCEPTION_TEST_HELPERS_INCLUDED
-
-int thisThrows() {
-    throw std::domain_error( "expected exception" );
-    return 1;
-}
-
-int thisDoesntThrow() {
-    return 0;
-}
-
-class CustomException {
-public:
-    explicit CustomException( const std::string& msg )
-    : m_msg( msg )
-    {}
-
-    std::string getMessage() const {
-        return m_msg;
-    }
-
-private:
-    std::string m_msg;
-};
-
-class CustomStdException : public std::exception {
-public:
-    explicit CustomStdException( const std::string& msg )
-    : m_msg( msg )
-    {}
-    ~CustomStdException() noexcept override {}
-
-    std::string getMessage() const {
-        return m_msg;
-    }
-
-private:
-    std::string m_msg;
-};
-
-[[noreturn]] void throwCustom() {
-    throw CustomException( "custom exception - not std" );
-}
-
-#endif
-
-TEST_CASE( "When checked exceptions are thrown they can be expected or unexpected", "[!throws]" ) {
-    REQUIRE_THROWS_AS( thisThrows(), std::domain_error );
-    REQUIRE_NOTHROW( thisDoesntThrow() );
-    REQUIRE_THROWS( thisThrows() );
-}
-
-TEST_CASE( "Expected exceptions that don't throw or unexpected exceptions fail the test", "[.][failing][!throws]" ) {
-    CHECK_THROWS_AS( thisThrows(), std::string );
-    CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error );
-    CHECK_NOTHROW( thisThrows() );
-}
-
-TEST_CASE( "When unchecked exceptions are thrown directly they are always failures", "[.][failing][!throws]" ) {
-    throw std::domain_error( "unexpected exception" );
-}
-
-TEST_CASE( "An unchecked exception reports the line of the last assertion", "[.][failing][!throws]" ) {
-    CHECK( 1 == 1 );
-    throw std::domain_error( "unexpected exception" );
-}
-
-TEST_CASE( "When unchecked exceptions are thrown from sections they are always failures", "[.][failing][!throws]" ) {
-    SECTION( "section name" ) {
-        throw std::domain_error("unexpected exception");
-    }
-}
-
-TEST_CASE( "When unchecked exceptions are thrown from functions they are always failures", "[.][failing][!throws]" ) {
-    CHECK( thisThrows() == 0 );
-}
-
-TEST_CASE( "When unchecked exceptions are thrown during a REQUIRE the test should abort fail", "[.][failing][!throws]" ) {
-    REQUIRE( thisThrows() == 0 );
-    FAIL( "This should never happen" );
-}
-
-TEST_CASE( "When unchecked exceptions are thrown during a CHECK the test should continue", "[.][failing][!throws]" ) {
-    try {
-        CHECK(thisThrows() == 0);
-    }
-    catch(...) {
-        FAIL( "This should never happen" );
-    }
-}
-
-TEST_CASE( "When unchecked exceptions are thrown, but caught, they do not affect the test", "[!throws]" ) {
-    try {
-        throw std::domain_error( "unexpected exception" );
-    }
-    catch(...) {}
-}
-
-
-CATCH_TRANSLATE_EXCEPTION( CustomException& ex ) {
-    return ex.getMessage();
-}
-
-CATCH_TRANSLATE_EXCEPTION( CustomStdException& ex ) {
-    return ex.getMessage();
-}
-
-CATCH_TRANSLATE_EXCEPTION( double& ex ) {
-    return Catch::Detail::stringify( ex );
-}
-
-TEST_CASE("Non-std exceptions can be translated", "[.][failing][!throws]" ) {
-    throw CustomException( "custom exception" );
-}
-
-TEST_CASE("Custom std-exceptions can be custom translated", "[.][failing][!throws]" ) {
-    throw CustomException( "custom std exception" );
-}
-
-TEST_CASE( "Custom exceptions can be translated when testing for nothrow", "[.][failing][!throws]" ) {
-    REQUIRE_NOTHROW( throwCustom() );
-}
-
-TEST_CASE( "Custom exceptions can be translated when testing for throwing as something else", "[.][failing][!throws]" ) {
-    REQUIRE_THROWS_AS( throwCustom(), std::exception );
-}
-
-TEST_CASE( "Unexpected exceptions can be translated", "[.][failing][!throws]"  ) {
-    throw double( 3.14 );
-}
-
-TEST_CASE("Thrown string literals are translated", "[.][failing][!throws]") {
-    throw "For some reason someone is throwing a string literal!";
-}
-
-TEST_CASE("thrown std::strings are translated", "[.][failing][!throws]") {
-    throw std::string{ "Why would you throw a std::string?" };
-}
-
-
-#ifndef CATCH_CONFIG_DISABLE_MATCHERS
-
-TEST_CASE( "Exception messages can be tested for", "[!throws]" ) {
-    using namespace Catch::Matchers;
-    SECTION( "exact match" )
-        REQUIRE_THROWS_WITH( thisThrows(), "expected exception" );
-    SECTION( "different case" )
-    REQUIRE_THROWS_WITH( thisThrows(), Equals( "expecteD Exception", Catch::CaseSensitive::No ) );
-    SECTION( "wildcarded" ) {
-        REQUIRE_THROWS_WITH( thisThrows(), StartsWith( "expected" ) );
-        REQUIRE_THROWS_WITH( thisThrows(), EndsWith( "exception" ) );
-        REQUIRE_THROWS_WITH( thisThrows(), Contains( "except" ) );
-        REQUIRE_THROWS_WITH( thisThrows(), Contains( "exCept", Catch::CaseSensitive::No ) );
-    }
-}
-
-#endif
-
-TEST_CASE( "Mismatching exception messages failing the test", "[.][failing][!throws]" ) {
-    REQUIRE_THROWS_WITH( thisThrows(), "expected exception" );
-    REQUIRE_THROWS_WITH( thisThrows(), "should fail" );
-    REQUIRE_THROWS_WITH( thisThrows(), "expected exception" );
-}
-
-TEST_CASE( "#748 - captures with unexpected exceptions", "[.][failing][!throws][!shouldfail]" ) {
-    int answer = 42;
-    CAPTURE( answer );
-    // the message should be printed on the first two sections but not on the third
-    SECTION( "outside assertions" ) {
-        thisThrows();
-    }
-    SECTION( "inside REQUIRE_NOTHROW" ) {
-        REQUIRE_NOTHROW( thisThrows() );
-    }
-    SECTION( "inside REQUIRE_THROWS" ) {
-        REQUIRE_THROWS( thisThrows() );
-    }
-}
-
-}} // namespace ExceptionTests
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif

package/deps/couchbase-cxx-client/third_party/catch2/projects/SelfTest/UsageTests/Generators.tests.cpp

@@ -1,271 +0,0 @@
-#include "catch.hpp"
-
-#include <cstring>
-
-
-// Generators and sections can be nested freely
-TEST_CASE("Generators -- simple", "[generators]") {
-    auto i = GENERATE(1, 2, 3);
-    SECTION("one") {
-        auto j = GENERATE(values({ -3, -2, -1 }));
-        REQUIRE(j < i);
-    }
-
-    SECTION("two") {
-        // You can also explicitly set type for generators via Catch::Generators::as
-        auto str = GENERATE(as<std::string>{}, "a", "bb", "ccc");
-        REQUIRE(4u * i > str.size());
-    }
-}
-
-// You can create a cartesian-product of generators by creating multiple ones
-TEST_CASE("3x3x3 ints", "[generators]") {
-    auto x = GENERATE(1, 2, 3);
-    auto y = GENERATE(4, 5, 6);
-    auto z = GENERATE(7, 8, 9);
-    // These assertions will be run 27 times (3x3x3)
-    CHECK(x < y);
-    CHECK(y < z);
-    REQUIRE(x < z);
-}
-
-// You can also create data tuples
-TEST_CASE("tables", "[generators]") {
-    // Note that this will not compile with libstdc++ older than libstdc++6
-    // See https://stackoverflow.com/questions/12436586/tuple-vector-and-initializer-list
-    // for possible workarounds
-    //    auto data = GENERATE(table<char const*, int>({
-    //        {"first", 5},
-    //        {"second", 6},
-    //        {"third", 5},
-    //        {"etc...", 6}
-    //    }));
-
-    // Workaround for the libstdc++ bug mentioned above
-    using tuple_type = std::tuple<char const*, int>;
-    auto data = GENERATE(table<char const*, int>({
-        tuple_type{"first", 5},
-        tuple_type{"second", 6},
-        tuple_type{"third", 5},
-        tuple_type{"etc...", 6}
-    }));
-
-    REQUIRE(strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)));
-}
-
-
-#ifdef __cpp_structured_bindings
-
-// Structured bindings make the table utility much nicer to use
-TEST_CASE( "strlen2", "[approvals][generators]" ) {
-    using tuple_type = std::tuple<std::string, int>; // see above workaround
-    auto [test_input, expected] =
-        GENERATE( table<std::string, size_t>( { tuple_type{ "one", 3 },
-                                                tuple_type{ "two", 3 },
-                                                tuple_type{ "three", 5 },
-                                                tuple_type{ "four", 4 } } ) );
-
-    REQUIRE( test_input.size() == expected );
-}
-#endif
-
-
-// An alternate way of doing data tables without structured bindings
-struct Data { std::string str; size_t len; };
-
-TEST_CASE( "strlen3", "[generators]" ) {
-    auto data = GENERATE( values<Data>({
-            {"one", 3},
-            {"two", 3},
-            {"three", 5},
-            {"four", 4}
-        }));
-
-    REQUIRE( data.str.size() == data.len );
-}
-
-
-
-#ifdef __cpp_structured_bindings
-
-// Based on example from https://docs.cucumber.io/gherkin/reference/#scenario-outline
-// (thanks to https://github.com/catchorg/Catch2/issues/850#issuecomment-399504851)
-
-// Note that GIVEN, WHEN, and THEN now forward onto DYNAMIC_SECTION instead of SECTION.
-// DYNAMIC_SECTION takes its name as a stringstream-style expression, so can be formatted using
-// variables in scope - such as the generated variables here. This reads quite nicely in the
-// test name output (the full scenario description).
-
-static auto eatCucumbers( int start, int eat ) -> int { return start-eat; }
-
-SCENARIO("Eating cucumbers", "[generators][approvals]") {
-    using tuple_type = std::tuple<int, int, int>;
-    auto [start, eat, left] = GENERATE( table<int, int, int>(
-        { tuple_type{ 12, 5, 7 }, tuple_type{ 20, 5, 15 } } ) );
-
-    GIVEN( "there are " << start << " cucumbers" )
-    WHEN( "I eat " << eat << " cucumbers" )
-    THEN( "I should have " << left << " cucumbers" ) {
-        REQUIRE( eatCucumbers( start, eat ) == left );
-    }
-}
-#endif
-
-// There are also some generic generator manipulators
-TEST_CASE("Generators -- adapters", "[generators][generic]") {
-    // TODO: This won't work yet, introduce GENERATE_VAR?
-    //auto numbers = Catch::Generators::values({ 1, 2, 3, 4, 5, 6 });
-    SECTION("Filtering by predicate") {
-        SECTION("Basic usage") {
-            // This filters out all odd (false) numbers, giving [2, 4, 6]
-            auto i = GENERATE(filter([] (int val) { return val % 2 == 0; }, values({ 1, 2, 3, 4, 5, 6 })));
-            REQUIRE(i % 2 == 0);
-        }
-        SECTION("Throws if there are no matching values") {
-            using namespace Catch::Generators;
-            REQUIRE_THROWS_AS(filter([] (int) {return false; }, value(1)), Catch::GeneratorException);
-        }
-    }
-    SECTION("Shortening a range") {
-        // This takes the first 3 elements from the values, giving back [1, 2, 3]
-        auto i = GENERATE(take(3, values({ 1, 2, 3, 4, 5, 6 })));
-        REQUIRE(i < 4);
-    }
-    SECTION("Transforming elements") {
-        SECTION("Same type") {
-            // This doubles values [1, 2, 3] into [2, 4, 6]
-            auto i = GENERATE(map([] (int val) { return val * 2; }, values({ 1, 2, 3 })));
-            REQUIRE(i % 2 == 0);
-        }
-        SECTION("Different type") {
-            // This takes a generator that returns ints and maps them into strings
-            auto i = GENERATE(map<std::string>([] (int val) { return std::to_string(val); }, values({ 1, 2, 3 })));
-            REQUIRE(i.size() == 1);
-        }
-        SECTION("Different deduced type") {
-            // This takes a generator that returns ints and maps them into strings
-            auto i = GENERATE(map([] (int val) { return std::to_string(val); }, values({ 1, 2, 3 })));
-            REQUIRE(i.size() == 1);
-        }
-    }
-    SECTION("Repeating a generator") {
-        // This will return values [1, 2, 3, 1, 2, 3]
-        auto j = GENERATE(repeat(2, values({ 1, 2, 3 })));
-        REQUIRE(j > 0);
-    }
-    SECTION("Chunking a generator into sized pieces") {
-        SECTION("Number of elements in source is divisible by chunk size") {
-            auto chunk2 = GENERATE(chunk(2, values({ 1, 1, 2, 2, 3, 3 })));
-            REQUIRE(chunk2.size() == 2);
-            REQUIRE(chunk2.front() == chunk2.back());
-        }
-        SECTION("Number of elements in source is not divisible by chunk size") {
-            auto chunk2 = GENERATE(chunk(2, values({ 1, 1, 2, 2, 3 })));
-            REQUIRE(chunk2.size() == 2);
-            REQUIRE(chunk2.front() == chunk2.back());
-            REQUIRE(chunk2.front() < 3);
-        }
-        SECTION("Chunk size of zero") {
-            auto chunk2 = GENERATE(take(3, chunk(0, value(1))));
-            REQUIRE(chunk2.size() == 0);
-        }
-        SECTION("Throws on too small generators") {
-            using namespace Catch::Generators;
-            REQUIRE_THROWS_AS(chunk(2, value(1)), Catch::GeneratorException);
-        }
-    }
-}
-
-// Note that because of the non-reproducibility of distributions,
-// anything involving the random generators cannot be part of approvals
-TEST_CASE("Random generator", "[generators][approvals]") {
-    SECTION("Infer int from integral arguments") {
-        auto val = GENERATE(take(4, random(0, 1)));
-        STATIC_REQUIRE(std::is_same<decltype(val), int>::value);
-        REQUIRE(0 <= val);
-        REQUIRE(val <= 1);
-    }
-    SECTION("Infer double from double arguments") {
-        auto val = GENERATE(take(4, random(0., 1.)));
-        STATIC_REQUIRE(std::is_same<decltype(val), double>::value);
-        REQUIRE(0. <= val);
-        REQUIRE(val < 1);
-    }
-}
-
-
-TEST_CASE("Nested generators and captured variables", "[generators]") {
-    // Workaround for old libstdc++
-    using record = std::tuple<int, int>;
-    // Set up 3 ranges to generate numbers from
-    auto extent = GENERATE(table<int, int>({
-        record{3, 7},
-        record{-5, -3},
-        record{90, 100}
-    }));
-
-    auto from = std::get<0>(extent);
-    auto to = std::get<1>(extent);
-
-    auto values = GENERATE_COPY(range(from, to));
-    REQUIRE(values > -6);
-}
-
-namespace {
-    size_t call_count = 0;
-    size_t test_count = 0;
-    std::vector<int> make_data() {
-        return { 1, 3, 5, 7, 9, 11 };
-    }
-    std::vector<int> make_data_counted() {
-        ++call_count;
-        return make_data();
-    }
-}
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-TEST_CASE("Copy and then generate a range", "[generators]") {
-    SECTION("from var and iterators") {
-        static auto data = make_data();
-
-        // It is important to notice that a generator is only initialized
-        // **once** per run. What this means is that modifying data will not
-        // modify the underlying generator.
-        auto elem = GENERATE_REF(from_range(data.begin(), data.end()));
-        REQUIRE(elem % 2 == 1);
-    }
-    SECTION("From a temporary container") {
-        auto elem = GENERATE(from_range(make_data_counted()));
-        ++test_count;
-        REQUIRE(elem % 2 == 1);
-    }
-    SECTION("Final validation") {
-        REQUIRE(call_count == 1);
-        REQUIRE(make_data().size() == test_count);
-    }
-}
-
-TEST_CASE("#1913 - GENERATE inside a for loop should not keep recreating the generator", "[regression][generators]") {
-    static int counter = 0;
-    for (int i = 0; i < 3; ++i) {
-        int _ = GENERATE(1, 2);
-        (void)_;
-        ++counter;
-    }
-    // There should be at most 6 (3 * 2) counter increments
-    REQUIRE(counter < 7);
-}
-
-TEST_CASE("#1913 - GENERATEs can share a line", "[regression][generators]") {
-    int i = GENERATE(1, 2); int j = GENERATE(3, 4);
-    REQUIRE(i != j);
-}
-
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif