couchbase 3.0.0.alpha.2-universal-darwin-19 → 3.0.0-universal-darwin-19

data/ext/third_party/json/src/test/json/binding_versions.cpp

@@ -1,95 +0,0 @@
-// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#include "test.hpp"
-
-#include <tao/json.hpp>
-
-namespace tao::json
-{
-   using type_1 = std::pair< int, std::string >;
-
-   struct version_a
-      : binding::array< TAO_JSON_BIND_ELEMENT( &type_1::first ),
-                        TAO_JSON_BIND_ELEMENT( &type_1::second ) >
-   {};
-
-   struct version_b
-      : binding::array< TAO_JSON_BIND_ELEMENT( &type_1::first ),
-                        TAO_JSON_BIND_ELEMENT( &type_1::second ),
-                        binding::element_b< true > >
-   {};
-
-   template<>
-   struct traits< type_1 >
-      : binding::versions< version_b, version_a >
-   {
-      TAO_JSON_DEFAULT_KEY( "t" );
-   };
-
-   void unit_test_1()
-   {
-      const value v = value::array( { 42, "florida arklab" } );
-      const auto a = v.as< type_1 >();
-      TEST_ASSERT( a.first == 42 );
-      TEST_ASSERT( a.second == "florida arklab" );
-   }
-
-   void unit_test_2()
-   {
-      const value v = value::array( { 42, "florida arklab", true } );
-      const auto a = v.as< type_1 >();
-      TEST_ASSERT( a.first == 42 );
-      TEST_ASSERT( a.second == "florida arklab" );
-      const value w = a;
-      TEST_ASSERT( w == v );
-      const value x = produce::to_value( a );
-      TEST_ASSERT( x == w );
-      TEST_ASSERT( v == x );
-   }
-
-   void unit_test_3()
-   {
-      const value v = value::array( { 42, "florida arklab", false } );
-      TEST_THROWS( v.as< type_1 >() );
-      const value w = value::array( { true, "florida arklab", true } );
-      TEST_THROWS( w.as< type_1 >() );
-      const value x = value::array( { 42, "florida arklab", true, null } );
-      TEST_THROWS( x.as< type_1 >() );
-   }
-
-   void unit_test_4()
-   {
-      parts_parser p( "[ 17, \"valley forge\" ]", __FUNCTION__ );
-      const auto a = consume< type_1 >( p );
-      TEST_ASSERT( a.first == 17 );
-      TEST_ASSERT( a.second == "valley forge" );
-   }
-
-   void unit_test_5()
-   {
-      parts_parser p( "[ 17, \"valley forge\", true ]", __FUNCTION__ );
-      const auto a = consume< type_1 >( p );
-      TEST_ASSERT( a.first == 17 );
-      TEST_ASSERT( a.second == "valley forge" );
-   }
-
-   void unit_test_6()
-   {
-      parts_parser p( "[ 17, \"valley forge\", true, false ]", __FUNCTION__ );
-      TEST_THROWS( consume< type_1 >( p ) );
-   }
-
-   void unit_test()
-   {
-      unit_test_1();
-      unit_test_2();
-      unit_test_3();
-      unit_test_4();
-      unit_test_5();
-      unit_test_6();
-   }
-
-}  // namespace tao::json
-
-#include "../../test/json/main.hpp"

data/ext/third_party/json/src/test/json/cbor.cpp

@@ -1,149 +0,0 @@
-// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#include "test.hpp"
-#include "test_unhex.hpp"
-
-#include "make_events.hpp"
-
-#include <tao/json/from_string.hpp>
-#include <tao/json/to_string.hpp>
-
-#include <tao/json/cbor.hpp>
-
-namespace tao::json
-{
-   void events_test()
-   {
-      cbor::events::to_string t;
-      test::make_events( t );
-      const auto r = pegtl::internal::file_reader( "tests/taocpp/make_events.cbor" ).read();
-      TEST_ASSERT( r == t.value() );
-   }
-
-   void cbor_encode( const std::string& text, const std::string& data )
-   {
-      TEST_ASSERT( cbor::to_string( from_string( text ) ) == test_unhex( data ) );
-   }
-
-   void cbor_decode( const std::string& data, const std::string& text )
-   {
-      TEST_ASSERT( to_string( cbor::from_string( test_unhex( data ) ) ) == to_string( from_string( text ) ) );
-   }
-
-   void cbor_roundtrip( const std::string& text )
-   {
-      const auto a = from_string( text );
-      TEST_ASSERT( to_string( a ) == to_string( cbor::from_string( cbor::to_string( a ) ) ) );
-   }
-
-   void encode_tests()
-   {
-      cbor_encode( "null", "f6" );
-      cbor_encode( "true", "f5" );
-      cbor_encode( "false", "f4" );
-
-      cbor_encode( "0", "00" );
-      cbor_encode( "1", "01" );
-      cbor_encode( "23", "17" );
-      cbor_encode( "24", "1818" );
-      cbor_encode( "255", "18ff" );
-      cbor_encode( "256", "190100" );
-      cbor_encode( "65535", "19ffff" );
-      cbor_encode( "65536", "1a00010000" );
-      cbor_encode( "4294967295", "1affffffff" );
-      cbor_encode( "4294967296", "1b0000000100000000" );
-      cbor_encode( "18446744073709551615", "1bffffffffffffffff" );
-
-      cbor_encode( "3.14159", "fb400921f9f01b866e" );
-      cbor_encode( "-4.2777e-12", "fbbd92d043147f15ff" );
-
-      cbor_encode( "\"0\"", "6130" );
-
-      cbor_encode( '"' + std::string( std::size_t( 23 ), 'D' ) + '"', "77" + std::string( std::size_t( 46 ), '4' ) );
-      cbor_encode( '"' + std::string( std::size_t( 24 ), 'D' ) + '"', "7818" + std::string( std::size_t( 48 ), '4' ) );
-      cbor_encode( '"' + std::string( std::size_t( 255 ), 'D' ) + '"', "78ff" + std::string( std::size_t( 510 ), '4' ) );
-      cbor_encode( '"' + std::string( std::size_t( 256 ), 'D' ) + '"', "790100" + std::string( std::size_t( 512 ), '4' ) );
-      cbor_encode( '"' + std::string( std::size_t( 65535 ), 'D' ) + '"', "79ffff" + std::string( std::size_t( 131070 ), '4' ) );
-      cbor_encode( '"' + std::string( std::size_t( 65536 ), 'D' ) + '"', "7a00010000" + std::string( std::size_t( 131072 ), '4' ) );
-
-      //         cbor_encode( '"' + std::string( std::size_t( 4294967295 ), 'D' ) + '"', "7affffffff" + std::string( std::size_t( 8589934590 ), '4' ) );  // Uses 24GB of RAM.
-      //         cbor_encode( '"' + std::string( std::size_t( 4294967296 ), 'D' ) + '"', "7b0000000100000000" + std::string( std::size_t( 8589934592 ), '4' ) );  // Uses 24GB of RAM.
-
-      cbor_encode( "[]", "80" );
-      cbor_encode( "{}", "a0" );
-
-      cbor_encode( "[1,2,3,4]", "8401020304" );
-      cbor_encode( "{\"a\":0,\"b\":1}", "a2616100616201" );
-
-      cbor_encode( "[{}]", "81a0" );
-      cbor_encode( "{\"a\":[]}", "a1616180" );
-   }
-
-   void decode_tests()
-   {
-      cbor_decode( "00", "0" );
-      cbor_decode( "80", "[]" );
-      cbor_decode( "9fff", "[]" );
-      cbor_decode( "8100", "[0]" );
-      cbor_decode( "9f00ff", "[0]" );
-      cbor_decode( "8180", "[[]]" );
-      cbor_decode( "9f80ff", "[[]]" );
-      cbor_decode( "9f9fffff", "[[]]" );
-      cbor_decode( "819fff", "[[]]" );
-
-      cbor_decode( "f90400", "0.00006103515625" );
-      cbor_decode( "f9c400", "-4.0" );
-
-      cbor_decode( "fa402df84d", to_string( value( 2.71828F ) ) );
-      cbor_decode( "fa9607d3a8", to_string( value( -1.0972e-25F ) ) );
-
-      cbor_decode( "fb400921f9f01b866e", "3.14159" );
-      cbor_decode( "fbbd92d043147f15ff", "-4.2777e-12" );
-
-      cbor_decode( "8a00010203040506070809", "[0,1,2,3,4,5,6,7,8,9]" );
-      cbor_decode( "9f00010203040506070809ff", "[0,1,2,3,4,5,6,7,8,9]" );
-      cbor_decode( "a0", "{}" );
-      cbor_decode( "bfff", "{}" );
-      cbor_decode( "a1616100", "{\"a\":0}" );
-      cbor_decode( "bf616100ff", "{\"a\":0}" );
-      cbor_decode( "7f6161626262ff", "\"abb\"" );
-
-      // TODO: Decode tests for broken inputs.
-   }
-
-   void roundtrip_tests()
-   {
-      cbor_roundtrip( "0" );
-      cbor_roundtrip( "1" );
-      cbor_roundtrip( "-1" );
-      cbor_roundtrip( "24" );
-      cbor_roundtrip( "257" );
-      cbor_roundtrip( "-129" );
-      cbor_roundtrip( "65536" );
-      cbor_roundtrip( "-32769" );
-      cbor_roundtrip( "4294967296" );
-      cbor_roundtrip( "-2147483649" );
-      cbor_roundtrip( "null" );
-      cbor_roundtrip( "true" );
-      cbor_roundtrip( "false" );
-      cbor_roundtrip( "[]" );
-      cbor_roundtrip( "{}" );
-      cbor_roundtrip( "[{}]" );
-      cbor_roundtrip( "[1,2,3,4]" );
-      cbor_roundtrip( "{\"a\":[],\"b\":{},\"\":0}" );
-      cbor_roundtrip( "1.23" );
-      cbor_roundtrip( "345e-123" );
-   }
-
-   void unit_test()
-   {
-      events_test();
-      encode_tests();
-      decode_tests();
-      roundtrip_tests();
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

data/ext/third_party/json/src/test/json/cbor_parts_parser.cpp

@@ -1,36 +0,0 @@
-// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#include "test.hpp"
-#include "test_unhex.hpp"
-
-#include <tao/json.hpp>
-
-namespace tao::json
-{
-   void unit_test()
-   {
-      {
-         cbor::parts_parser p( "", __FUNCTION__ );
-         TEST_ASSERT( p.empty() );
-      }
-      {
-         cbor::parts_parser p( test_unhex( "f6" ), __FUNCTION__ );
-         TEST_ASSERT( p.null() == true );
-         TEST_ASSERT( p.empty() );
-      }
-      {
-         cbor::parts_parser p( test_unhex( "f4" ), __FUNCTION__ );
-         TEST_ASSERT( p.boolean() == false );
-         TEST_ASSERT( p.empty() );
-      }
-      {
-         cbor::parts_parser p( test_unhex( "f5" ), __FUNCTION__ );
-         TEST_ASSERT( p.boolean() == true );
-         TEST_ASSERT( p.empty() );
-      }
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

data/ext/third_party/json/src/test/json/contrib_diff.cpp

@@ -1,43 +0,0 @@
-// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#include "test.hpp"
-
-#include <tao/json/stream.hpp>
-#include <tao/json/value.hpp>
-
-#include <tao/json/contrib/diff.hpp>
-
-namespace tao::json
-{
-   void unit_test()
-   {
-      const value source = {
-         { "foo", 42 },
-         { "blue", 3.14 },
-         { "bar", value::array( { 1, 2, 3, 4, 5 } ) },
-         { "baz", 2 }
-      };
-
-      const value destination = {
-         { "bar", value::array( { 1, 2, 7 } ) },
-         { "foo", 42 },
-         { "yellow", empty_object },
-         { "baz", "hello" }
-      };
-
-      const auto d = diff( source, destination );
-
-      // clang-format off
-      TEST_ASSERT( d == value::array( { { { "op", "replace" }, { "path", "/bar/2" }, { "value", 7 } },
-                                        { { "op", "remove" }, { "path", "/bar/4" } },
-                                        { { "op", "remove" }, { "path", "/bar/3" } },
-                                        { { "op", "replace" }, { "path", "/baz" }, { "value", "hello" } },
-                                        { { "op", "remove" }, { "path", "/blue" } },
-                                        { { "op", "add" }, { "path", "/yellow" }, { "value", empty_object } } } ) );
-      // clang-format on
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

data/ext/third_party/json/src/test/json/contrib_get.cpp

@@ -1,42 +0,0 @@
-// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#include "test.hpp"
-
-#include <tao/json.hpp>
-#include <tao/json/contrib/get.hpp>
-
-namespace tao::json
-{
-   void unit_test()
-   {
-      const value v = from_string( "{ \"a\": 1, \"b\": { \"ba\": 2, \"bb\": [ 3, 4, [], {}, { \"bb4a\": true } ] } }" );
-      TEST_ASSERT( get::value( v, "a" ).is_value_ptr() );
-      TEST_ASSERT( get::value( v, "a" ).skip_value_ptr().is_integer() );
-      TEST_ASSERT( get::value( v, "a" ).skip_value_ptr().as< int >() == 1 );
-
-      TEST_ASSERT( get::as< int >( get::value( v, "a" ) ) == 1 );
-      TEST_ASSERT( !get::value( v, "zz" ) );
-      TEST_THROWS( get::as< int >( get::value( v, "zz" ) ) );
-
-      TEST_ASSERT( get::as< int >( v, "a" ) == 1 );
-      TEST_THROWS( get::as< int >( v, "zz" ) );
-
-      TEST_ASSERT( *get::optional< int >( v, "a" ) == 1 );
-      TEST_ASSERT( !get::optional< int >( v, "zz" ) );
-      TEST_ASSERT( !get::optional< int >( get::value( v, "zz" ) ) );
-
-      TEST_ASSERT( get::defaulted( 2, v, "a" ) == 1 );
-      TEST_ASSERT( get::defaulted( 2, v, "zz" ) == 2 );
-      TEST_ASSERT( get::defaulted( 2, get::value( v, "zz" ) ) == 2 );
-
-      TEST_ASSERT( get::as< bool >( v, "b", "bb", 4, "bb4a" ) == true );
-      TEST_ASSERT( *get::optional< bool >( v, "b", "bb", 4, "bb4a" ) == true );
-      TEST_ASSERT( get::defaulted( false, v, "b", "bb", 4, "bb4a" ) == true );
-
-      TEST_ASSERT( !get::value( get::value( v, "zz" ), "zz" ) );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

data/ext/third_party/json/src/test/json/contrib_patch_add.cpp

@@ -1,75 +0,0 @@
-// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#include "test.hpp"
-
-#include <tao/json/value.hpp>
-
-#include <tao/json/contrib/patch.hpp>
-
-namespace tao::json
-{
-   [[nodiscard]] value cpatch( const value& v, const value& patch )
-   {
-      return json::patch( v, patch );
-   }
-
-   void unit_test()
-   {
-      const value n = null;
-      const value one = 1U;
-      const value two = 2;
-      const value ea = empty_array;
-      const value eo = empty_object;
-
-      const value a = { { "a", { { "foo", one } } } };
-      const value b = { { "b", value::array( { one, two, 3, 4 } ) } };
-
-      const value q = { { "q", { { "bar", two } } } };
-
-      TEST_ASSERT( patch( n, ea ) == n );
-      TEST_ASSERT( patch( ea, ea ) == ea );
-      TEST_ASSERT( patch( eo, ea ) == eo );
-      TEST_ASSERT( patch( a, ea ) == a );
-      TEST_ASSERT( patch( b, ea ) == b );
-      TEST_ASSERT( patch( q, ea ) == q );
-
-      TEST_THROWS( patch( n, value::array( { { { "op", "foo" }, { "path", "" } } } ) ) );
-
-      TEST_ASSERT( patch( a, value::array( { { { "op", "add" }, { "path", "/b" }, { "value", 42 } } } ) ) == value( { { "a", { { "foo", 1 } } }, { "b", 42 } } ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "add" }, { "path", "/a/b" }, { "value", 42 } } } ) ) == value( { { "a", { { "foo", 1 }, { "b", 42 } } } } ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "add" }, { "path", "" }, { "value", 42 } } } ) ) == 42 );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "add" }, { "path", "/b/0" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 42, 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "add" }, { "path", "/b/1" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 42, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "add" }, { "path", "/b/2" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 2, 42, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "add" }, { "path", "/b/3" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 42, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "add" }, { "path", "/b/-" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 4, 42 } ) } } ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "add" }, { "path", "/b/4" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "add" }, { "path", "/b/a" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( patch( q, value::array( { { { "op", "add" }, { "path", "/a/b" }, { "value", 42 } } } ) ) );
-
-      TEST_ASSERT( cpatch( n, ea ) == n );
-      TEST_ASSERT( cpatch( ea, ea ) == ea );
-      TEST_ASSERT( cpatch( eo, ea ) == eo );
-      TEST_ASSERT( cpatch( a, ea ) == a );
-      TEST_ASSERT( cpatch( b, ea ) == b );
-      TEST_ASSERT( cpatch( q, ea ) == q );
-
-      TEST_THROWS( cpatch( n, value::array( { { { "op", "foo" }, { "path", "" } } } ) ) );
-
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "add" }, { "path", "/b" }, { "value", 42 } } } ) ) == value( { { "a", { { "foo", 1 } } }, { "b", 42 } } ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "add" }, { "path", "/a/b" }, { "value", 42 } } } ) ) == value( { { "a", { { "foo", 1 }, { "b", 42 } } } } ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "add" }, { "path", "" }, { "value", 42 } } } ) ) == 42 );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "add" }, { "path", "/b/0" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 42, 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "add" }, { "path", "/b/1" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 42, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "add" }, { "path", "/b/2" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 2, 42, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "add" }, { "path", "/b/3" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 42, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "add" }, { "path", "/b/-" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 4, 42 } ) } } ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "add" }, { "path", "/b/4" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "add" }, { "path", "/b/a" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( cpatch( q, value::array( { { { "op", "add" }, { "path", "/a/b" }, { "value", 42 } } } ) ) );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

data/ext/third_party/json/src/test/json/contrib_patch_copy.cpp

@@ -1,113 +0,0 @@
-// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#include "test.hpp"
-
-#include <tao/json/value.hpp>
-
-#include <tao/json/contrib/patch.hpp>
-
-namespace tao::json
-{
-   [[nodiscard]] value cpatch( const value& v, const value& patch )
-   {
-      return json::patch( v, patch );
-   }
-
-   void unit_test()
-   {
-      const value n = null;
-      const value one = 1U;
-      const value two = 2;
-      const value ea = empty_array;
-      const value eo = empty_object;
-
-      const value a = { { "a", { { "foo", one } } } };
-      const value b = { { "b", value::array( { one, two, 3, 4 } ) } };
-
-      const value q = { { "q", { { "bar", two } } } };
-
-      TEST_ASSERT( patch( n, ea ) == n );
-      TEST_ASSERT( patch( ea, ea ) == ea );
-      TEST_ASSERT( patch( eo, ea ) == eo );
-      TEST_ASSERT( patch( a, ea ) == a );
-      TEST_ASSERT( patch( b, ea ) == b );
-      TEST_ASSERT( patch( q, ea ) == q );
-
-      TEST_THROWS( patch( n, value::array( { { { "op", "foo" }, { "path", "" } } } ) ) );
-
-      TEST_ASSERT( patch( a, value::array( { { { "op", "copy" }, { "from", "" }, { "path", "" } } } ) ) == a );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "copy" }, { "from", "/a" }, { "path", "" } } } ) ) == value( { { "foo", 1 } } ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "copy" }, { "from", "/a" }, { "path", "/a" } } } ) ) == a );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "copy" }, { "from", "/a/foo" }, { "path", "/a/foo" } } } ) ) == a );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "copy" }, { "from", "/a" }, { "path", "/b" } } } ) ) == value( { { "a", { { "foo", 1 } } }, { "b", { { "foo", 1 } } } } ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "copy" }, { "from", "/a/foo" }, { "path", "/b" } } } ) ) == value( { { "a", { { "foo", 1 } } }, { "b", 1 } } ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "copy" }, { "from", "/a/foo" }, { "path", "/a" } } } ) ) == value( { { "a", 1 } } ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "copy" }, { "from", "/a" }, { "path", "/a/foo" } } } ) ) == value( { { "a", { { "foo", { { "foo", 1 } } } } } } ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "copy" }, { "from", "/a" }, { "path", "/a/bar" } } } ) ) == value( { { "a", { { "foo", 1 }, { "bar", { { "foo", 1 } } } } } } ) );
-      TEST_THROWS( patch( a, value::array( { { { "op", "copy" }, { "from", "/b" }, { "path", "/a" } } } ) ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { 1, 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/1" } } } ) ) == value( { { "b", value::array( { 1, 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 1, 2, 1, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/3" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 1, 4 } ) } } ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/4" } } } ) ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 4, 1 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { 3, 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/1" } } } ) ) == value( { { "b", value::array( { 1, 3, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/3" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 3, 4 } ) } } ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/4" } } } ) ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 4, 3 } ) } } ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/4" }, { "path", "/b/-" } } } ) ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "copy" }, { "from", "/b/-" }, { "path", "/b/-" } } } ) ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { value::array( { 1, 2, 3, 4 } ), 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 1, 2, value::array( { 1, 2, 3, 4 } ), 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "/b" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 4, value::array( { 1, 2, 3, 4 } ) } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { { { "b", value::array( { 1, 2, 3, 4 } ) } }, 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 1, 2, { { "b", value::array( { 1, 2, 3, 4 } ) } }, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "copy" }, { "from", "" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 4, { { "b", value::array( { 1, 2, 3, 4 } ) } } } ) } } ) );
-
-      TEST_ASSERT( cpatch( n, ea ) == n );
-      TEST_ASSERT( cpatch( ea, ea ) == ea );
-      TEST_ASSERT( cpatch( eo, ea ) == eo );
-      TEST_ASSERT( cpatch( a, ea ) == a );
-      TEST_ASSERT( cpatch( b, ea ) == b );
-      TEST_ASSERT( cpatch( q, ea ) == q );
-
-      TEST_THROWS( cpatch( n, value::array( { { { "op", "foo" }, { "path", "" } } } ) ) );
-
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "copy" }, { "from", "" }, { "path", "" } } } ) ) == a );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "copy" }, { "from", "/a" }, { "path", "" } } } ) ) == value( { { "foo", 1 } } ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "copy" }, { "from", "/a" }, { "path", "/a" } } } ) ) == a );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "copy" }, { "from", "/a/foo" }, { "path", "/a/foo" } } } ) ) == a );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "copy" }, { "from", "/a" }, { "path", "/b" } } } ) ) == value( { { "a", { { "foo", 1 } } }, { "b", { { "foo", 1 } } } } ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "copy" }, { "from", "/a/foo" }, { "path", "/b" } } } ) ) == value( { { "a", { { "foo", 1 } } }, { "b", 1 } } ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "copy" }, { "from", "/a/foo" }, { "path", "/a" } } } ) ) == value( { { "a", 1 } } ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "copy" }, { "from", "/a" }, { "path", "/a/foo" } } } ) ) == value( { { "a", { { "foo", { { "foo", 1 } } } } } } ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "copy" }, { "from", "/a" }, { "path", "/a/bar" } } } ) ) == value( { { "a", { { "foo", 1 }, { "bar", { { "foo", 1 } } } } } } ) );
-      TEST_THROWS( cpatch( a, value::array( { { { "op", "copy" }, { "from", "/b" }, { "path", "/a" } } } ) ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { 1, 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/1" } } } ) ) == value( { { "b", value::array( { 1, 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 1, 2, 1, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/3" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 1, 4 } ) } } ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/4" } } } ) ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/0" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 4, 1 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { 3, 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/1" } } } ) ) == value( { { "b", value::array( { 1, 3, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/3" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 3, 4 } ) } } ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/4" } } } ) ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/2" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 4, 3 } ) } } ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/4" }, { "path", "/b/-" } } } ) ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b/-" }, { "path", "/b/-" } } } ) ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { value::array( { 1, 2, 3, 4 } ), 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 1, 2, value::array( { 1, 2, 3, 4 } ), 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "/b" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 4, value::array( { 1, 2, 3, 4 } ) } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { { { "b", value::array( { 1, 2, 3, 4 } ) } }, 1, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 1, 2, { { "b", value::array( { 1, 2, 3, 4 } ) } }, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "copy" }, { "from", "" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 4, { { "b", value::array( { 1, 2, 3, 4 } ) } } } ) } } ) );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"