npm - couchbase - Versions diffs - 4.2.2 → 4.2.3 - Mend

couchbase 4.2.2 → 4.2.3

Files changed (1523) hide show

package/deps/couchbase-cxx-client/third_party/catch2/projects/SelfTest/UsageTests/Tricky.tests.cpp DELETED Viewed

@@ -1,429 +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)
- */
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-#ifdef _MSC_VER
-#pragma warning (disable : 4702) // Disable unreachable code warning for the last test
-                                 // that is triggered when compiling as Win32|Release
-#endif
-#include "catch.hpp"
-#include <cstdio>
-#include <sstream>
-#include <iostream>
-///////////////////////////////////////////////////////////////////////////////
-TEST_CASE
-(
-    "Where there is more to the expression after the RHS",
-    "[Tricky][failing][.]"
-)
-{
-//    int a = 1, b = 2;
-//    REQUIRE( a == 2 || b == 2 );
-    WARN( "Uncomment the code in this test to check that it gives a sensible compiler error" );
-}
-///////////////////////////////////////////////////////////////////////////////
-TEST_CASE
-(
-    "Where the LHS is not a simple value",
-    "[Tricky][failing][.]"
-)
-{
-    /*
-    int a = 1;
-    int b = 2;
-    // This only captures part of the expression, but issues a warning about the rest
-    REQUIRE( a+1 == b-1 );
-    */
-    WARN( "Uncomment the code in this test to check that it gives a sensible compiler error" );
-}
-struct Opaque
-{
-    int val;
-    bool operator ==( const Opaque& o ) const
-    {
-        return val == o.val;
-    }
-};
-///////////////////////////////////////////////////////////////////////////////
-TEST_CASE
-(
-    "A failing expression with a non streamable type is still captured",
-    "[Tricky][failing][.]"
-)
-{
-    Opaque o1, o2;
-    o1.val = 7;
-    o2.val = 8;
-    CHECK( &o1 == &o2 );
-    CHECK( o1 == o2 );
-}
-///////////////////////////////////////////////////////////////////////////////
-TEST_CASE
-(
-    "string literals of different sizes can be compared",
-    "[Tricky][failing][.]"
-)
-{
-    REQUIRE( std::string( "first" ) == "second" );
-}
-///////////////////////////////////////////////////////////////////////////////
-TEST_CASE
-(
-    "An expression with side-effects should only be evaluated once",
-    "[Tricky]"
-)
-{
-    int i = 7;
-    REQUIRE( i++ == 7 );
-    REQUIRE( i++ == 8 );
-}
-namespace A {
-    struct X
-    {
-        X() : a(4), b(2), c(7) {}
-        X(int v) : a(v), b(2), c(7) {}
-        int a;
-        int b;
-        int c;
-    };
-}
-namespace B {
-    struct Y
-    {
-        Y() : a(4), b(2), c(7) {}
-        Y(int v) : a(v), b(2), c(7) {}
-        int a;
-        int b;
-        int c;
-    };
-}
-inline bool operator==(const A::X& lhs, const B::Y& rhs)
-{
-    return (lhs.a == rhs.a);
-}
-inline bool operator==(const B::Y& lhs, const A::X& rhs)
-{
-    return (lhs.a == rhs.a);
-}
-///////////////////////////////////////////////////////////////////////////////
-/* This, currently, does not compile with LLVM
-TEST_CASE
-(
-    "Operators at different namespace levels not hijacked by Koenig lookup"
-    "[Tricky]"
-)
-{
-    A::X x;
-    B::Y y;
-    REQUIRE( x == y );
-}
-*/
-namespace ObjectWithConversions
-{
-    struct Object
-    {
-        operator unsigned int() const {return 0xc0000000;}
-    };
-    ///////////////////////////////////////////////////////////////////////////////
-    TEST_CASE
-    (
-        "Implicit conversions are supported inside assertion macros",
-        "[Tricky][approvals]"
-    )
-    {
-        Object o;
-        REQUIRE(0xc0000000 == o );
-    }
-}
-namespace EnumBitFieldTests
-{
-    enum Bits : uint32_t {
-        bit0 = 0x0001,
-        bit1 = 0x0002,
-        bit2 = 0x0004,
-        bit3 = 0x0008,
-        bit1and2 = bit1 | bit2,
-        bit30 = 0x40000000,
-        bit31 = 0x80000000,
-        bit30and31 = bit30 | bit31
-    };
-    TEST_CASE( "Test enum bit values", "[Tricky]" )
-    {
-        REQUIRE( 0xc0000000 == bit30and31 );
-    }
-}
-struct Obj
-{
-    Obj():prop(&p){}
-    int p;
-    int* prop;
-};
-TEST_CASE("boolean member", "[Tricky]")
-{
-    Obj obj;
-    REQUIRE( obj.prop != nullptr );
-}
-// Tests for a problem submitted by Ralph McArdell
-//
-// The static bool value should not need to be defined outside the
-// struct it is declared in - but when evaluating it in a deduced
-// context it appears to require the extra definition.
-// The issue was fixed by adding bool overloads to bypass the
-// templates that were there to deduce it.
-template <bool B>
-struct is_true
-{
-    static const bool value = B;
-};
-TEST_CASE( "(unimplemented) static bools can be evaluated", "[Tricky]" )
-{
-    SECTION("compare to true")
-    {
-        REQUIRE( is_true<true>::value == true );
-        REQUIRE( true == is_true<true>::value );
-    }
-    SECTION("compare to false")
-    {
-        REQUIRE( is_true<false>::value == false );
-        REQUIRE( false == is_true<false>::value );
-    }
-    SECTION("negation")
-    {
-        REQUIRE( !is_true<false>::value );
-    }
-    SECTION("double negation")
-    {
-        REQUIRE( !!is_true<true>::value );
-    }
-    SECTION("direct")
-    {
-        REQUIRE( is_true<true>::value );
-        REQUIRE_FALSE( is_true<false>::value );
-    }
-}
-// Uncomment these tests to produce an error at test registration time
-/*
-TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" )
-{
-}
-TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" )
-{
-}
-*/
-struct Boolable
-{
-    explicit Boolable( bool value ) : m_value( value ) {}
-    explicit operator bool() const {
-        return m_value;
-    }
-    bool m_value;
-};
-TEST_CASE( "Objects that evaluated in boolean contexts can be checked", "[Tricky][SafeBool]" )
-{
-    Boolable True( true );
-    Boolable False( false );
-    CHECK( True );
-    CHECK( !False );
-    CHECK_FALSE( False );
-}
-TEST_CASE( "Assertions then sections", "[Tricky]" )
-{
-    // This was causing a failure due to the way the console reporter was handling
-    // the current section
-    REQUIRE( true );
-    SECTION( "A section" )
-    {
-        REQUIRE( true );
-        SECTION( "Another section" )
-        {
-            REQUIRE( true );
-        }
-        SECTION( "Another other section" )
-        {
-            REQUIRE( true );
-        }
-    }
-}
-struct Awkward
-{
-    operator int() const { return 7; }
-};
-TEST_CASE( "non streamable - with conv. op", "[Tricky]" )
-{
-    Awkward awkward;
-    std::string s = ::Catch::Detail::stringify( awkward );
-    REQUIRE( s == "7" );
-}
-inline void foo() {}
-typedef void (*fooptr_t)();
-TEST_CASE( "Comparing function pointers", "[Tricky][function pointer]" )
-{
-    // This was giving a warning in VS2010
-    // #179
-    fooptr_t a = foo;
-    REQUIRE( a );
-    REQUIRE( a == &foo );
-}
-struct S
-{
-    void f() {}
-};
-TEST_CASE( "Comparing member function pointers", "[Tricky][member function pointer][approvals]" )
-{
-    typedef void (S::*MF)();
-    MF m = &S::f;
-    CHECK( m == &S::f );
-}
-class ClassName {};
-TEST_CASE( "pointer to class", "[Tricky]" )
-{
-   ClassName *p = 0;
-   REQUIRE( p == 0 );
-}
-#include <memory>
-TEST_CASE( "null_ptr", "[Tricky]" )
-{
-    std::unique_ptr<int> ptr;
-    REQUIRE(ptr.get() == nullptr);
-}
-TEST_CASE( "X/level/0/a", "[Tricky]" )      { SUCCEED(""); }
-TEST_CASE( "X/level/0/b", "[Tricky][fizz]" ){ SUCCEED(""); }
-TEST_CASE( "X/level/1/a", "[Tricky]" )      { SUCCEED(""); }
-TEST_CASE( "X/level/1/b", "[Tricky]" )      { SUCCEED(""); }
-TEST_CASE( "has printf" ) {
-    // This can cause problems as, currently, stdout itself is not redirected - only the cout (and cerr) buffer
-    printf( "loose text artifact\n" );
-}
-namespace {
-    struct constructor_throws {
-        [[noreturn]] constructor_throws() {
-            throw 1;
-        }
-    };
-}
-TEST_CASE("Commas in various macros are allowed") {
-    REQUIRE_THROWS( std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}} );
-    CHECK_THROWS( std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}} );
-    REQUIRE_NOTHROW( std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3} );
-    CHECK_NOTHROW( std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3} );
-    REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});
-    CHECK( std::vector<int>{1, 2} == std::vector<int>{1, 2} );
-    REQUIRE_FALSE(std::vector<int>{1, 2} == std::vector<int>{1, 2, 3});
-    CHECK_FALSE( std::vector<int>{1, 2} == std::vector<int>{1, 2, 3} );
-    CHECK_NOFAIL( std::vector<int>{1, 2} == std::vector<int>{1, 2} );
-    CHECKED_IF( std::vector<int>{1, 2} == std::vector<int>{1, 2} ) {
-        REQUIRE(true);
-    } CHECKED_ELSE( std::vector<int>{1, 2} == std::vector<int>{1, 2} ) {
-        CHECK(true);
-    }
-}
-TEST_CASE( "non-copyable objects", "[.][failing]" ) {
-    // Thanks to Agustin Bergé (@k-ballo on the cpplang Slack) for raising this
-    std::type_info const& ti = typeid(int);
-    CHECK( ti == typeid(int) );
-}
-TEST_CASE("#1514: stderr/stdout is not captured in tests aborted by an exception", "[output-capture][regression][.]") {
-    std::cout << "This would not be caught previously\n" << std::flush;
-    std::clog << "Nor would this\n" << std::flush;
-    // FAIL aborts the test by throwing a Catch exception
-    FAIL("1514");
-}
-TEST_CASE( "#2025: -c shouldn't cause infinite loop", "[sections][generators][regression][.approvals]" ) {
-    SECTION( "Check cursor from buffer offset" ) {
-        auto bufPos = GENERATE_REF( range( 0, 44 ) );
-        WHEN( "Buffer position is " << bufPos ) { REQUIRE( 1 == 1 ); }
-    }
-}
-TEST_CASE("#2025: original repro", "[sections][generators][regression][.approvals]") {
-    auto fov = GENERATE(true, false);
-    DYNAMIC_SECTION("fov_" << fov) {
-        std::cout << "inside with fov: " << fov << '\n';
-    }
-}
-TEST_CASE("#2025: same-level sections", "[sections][generators][regression][.approvals]") {
-    SECTION("A") {
-        SUCCEED();
-    }
-    auto i = GENERATE(1, 2, 3);
-    SECTION("B") {
-        REQUIRE(i < 4);
-    }
-}

package/deps/couchbase-cxx-client/third_party/catch2/projects/SelfTest/UsageTests/VariadicMacros.tests.cpp DELETED Viewed

@@ -1,29 +0,0 @@
-/*
- *  Created by Phil on 15/03/2013.
- *  Copyright 2013 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"
-TEST_CASE()
-{
-    SUCCEED( "anonymous test case" );
-}
-TEST_CASE( "Test case with one argument" )
-{
-    SUCCEED( "no assertions" );
-}
-TEST_CASE( "Variadic macros", "[variadic][sections]" )
-{
-    SECTION( "Section with one argument" )
-    {
-        SUCCEED( "no assertions" );
-    }
-}

package/deps/couchbase-cxx-client/third_party/catch2/projects/SelfTest/WarnAboutNoTests.cmake DELETED Viewed

@@ -1,19 +0,0 @@
-# Workaround for a peculiarity where CTest disregards the return code from a
-# test command if a PASS_REGULAR_EXPRESSION is also set
-execute_process(
-    COMMAND ${CMAKE_ARGV3} -w NoTests "___nonexistent_test___"
-    RESULT_VARIABLE ret
-    OUTPUT_VARIABLE out
-)
-message("${out}")
-if(NOT ${ret} MATCHES "^[0-9]+$")
-    message(FATAL_ERROR "${ret}")
-endif()
-if(${ret} EQUAL 0)
-    message(FATAL_ERROR "Expected nonzero return code")
-elseif(${out} MATCHES "Helper failed with")
-    message(FATAL_ERROR "Helper failed")
-endif()

package/deps/couchbase-cxx-client/third_party/catch2/projects/TestScripts/testRandomOrder.py DELETED Viewed

@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-"""
-This test script verifies that the random ordering of tests inside
-Catch2 is invariant in regards to subsetting. This is done by running
-the binary 3 times, once with all tests selected, and twice with smaller
-subsets of tests selected, and verifying that the selected tests are in
-the same relative order.
-"""
-import subprocess
-import sys
-import random
-def list_tests(self_test_exe, tags, rng_seed):
-    cmd = [self_test_exe, '--list-test-names-only', '--order', 'rand',
-            '--rng-seed', str(rng_seed)]
-    tags_arg = ','.join('[{}]~[.]'.format(t) for t in tags)
-    if tags_arg:
-        cmd.append(tags_arg)
-    process = subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    stdout, stderr = process.communicate()
-    if stderr:
-        raise RuntimeError("Unexpected error output:\n" + process.stderr)
-    result = stdout.split(b'\n')
-    result = [s for s in result if s]
-    if len(result) < 2:
-        raise RuntimeError("Unexpectedly few tests listed (got {})".format(
-            len(result)))
-    return result
-def check_is_sublist_of(shorter, longer):
-    assert len(shorter) < len(longer)
-    assert len(set(longer)) == len(longer)
-    indexes_in_longer = {s: i for i, s in enumerate(longer)}
-    for s1, s2 in zip(shorter, shorter[1:]):
-        assert indexes_in_longer[s1] < indexes_in_longer[s2], (
-                '{} comes before {} in longer list.\n'
-                'Longer: {}\nShorter: {}'.format(s2, s1, longer, shorter))
-def main():
-    self_test_exe, = sys.argv[1:]
-    # We want a random seed for the test, but want to avoid 0,
-    # because it has special meaning
-    seed = random.randint(1, 2 ** 32 - 1)
-    list_one_tag = list_tests(self_test_exe, ['generators'], seed)
-    list_two_tags = list_tests(self_test_exe, ['generators', 'matchers'], seed)
-    list_all = list_tests(self_test_exe, [], seed)
-    # First, verify that restricting to a subset yields the same order
-    check_is_sublist_of(list_two_tags, list_all)
-    check_is_sublist_of(list_one_tag, list_two_tags)
-if __name__ == '__main__':
-    sys.exit(main())

package/deps/couchbase-cxx-client/third_party/catch2/projects/XCode/OCTest/OCTest/CatchOCTestCase.h DELETED Viewed

@@ -1,25 +0,0 @@
-//
-//  CatchOCTestCase.h
-//  OCTest
-//
-//  Created by Phil on 13/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)
-#ifndef TWOBLUECUBES_CATCHOCTESTCASE_H_INCLUDED
-#define TWOBLUECUBES_CATCHOCTESTCASE_H_INCLUDED
-#include "catch.hpp"
-#import <Cocoa/Cocoa.h>
-#import "TestObj.h"
-@interface TestFixture : NSObject <OcFixture>
-{
-    TestObj* obj;
-}
-@end
-#endif // TWOBLUECUBES_CATCHOCTESTCASE_H_INCLUDED

package/deps/couchbase-cxx-client/third_party/catch2/projects/XCode/OCTest/OCTest/CatchOCTestCase.mm DELETED Viewed

@@ -1,87 +0,0 @@
-//
-//  CatchOCTestCase.mm
-//  OCTest
-//
-//  Created by Phil Nash on 13/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)
-#import "CatchOCTestCase.h"
-@implementation TestFixture
--(void) setUp
-{
-    obj = [[TestObj alloc] init];
-}
--(void) tearDown
-{
-    arcSafeRelease( obj );
-}
-OC_TEST_CASE( "This is a test case", "" )
-{
-    REQUIRE( obj.int_val == 0 );
-    obj.int_val = 1;
-    REQUIRE( obj.int_val == 1 );
-}
-OC_TEST_CASE( "This is another test case", "" )
-{
-    REQUIRE( obj.int_val == 0 );
-    obj.int_val = 2;
-    REQUIRE( obj.int_val == 2 );
-}
-OC_TEST_CASE( "tests a boolean value", "[!shouldfail]" )
-{
-    CHECK( [obj isTrue] == NO );
-    CHECK( [obj isFalse] == YES );
-}
-OC_TEST_CASE( "throws an Objective-C exception", "[!throws][!shouldfail]" )
-{
-    @throw [[NSException alloc] initWithName: NSGenericException
-                                      reason: @"Objective-C exception"
-                                    userInfo: nil];
-}
-OC_TEST_CASE( "throws a std c++ exception", "[!throws][!shouldfail]" )
-{
-    throw std::domain_error( "std C++ exception" );
-}
-///////////////////////////////////////////////////////////////////////////
-template<typename T>
-void useObject( const T& object ){}
-template<typename T>
-void useObject( const T* object ){}
-OC_TEST_CASE( "Matches work with OC types (NSString so far)", "[!shouldfail]" )
-{
-    using namespace Catch::Matchers;
-    REQUIRE_THAT( @"This is a string", Equals( @"This isn't a string" ) );
-    REQUIRE_THAT( @"This is a string", Contains( @"is a" ) );
-    REQUIRE_THAT( @"This is a string", StartsWith( @"This" ) );
-    REQUIRE_THAT( @"This is a string", EndsWith( @"string" ) );
-}
-OC_TEST_CASE( "nil NSString should not crash the test", "[!shouldfail]" )
-{
-    using namespace Catch::Matchers;
-    CHECK_THAT( (NSString*)nil, Equals( @"This should fail, but not crash" ) );
-    CHECK_THAT( (NSString*)nil, StartsWith( @"anything" ) );
-}
-@end

package/deps/couchbase-cxx-client/third_party/catch2/projects/XCode/OCTest/OCTest/Main.mm DELETED Viewed

	@@ -1,2 +0,0 @@
1	- #define CATCH_CONFIG_MAIN
2	- #import "catch.hpp"