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

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

@@ -1,97 +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_THROWS( patch( a, value::array( { { { "op", "move" }, { "from", "" }, { "path", "" } } } ) ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "move" }, { "from", "/a" }, { "path", "" } } } ) ) == value( { { "foo", 1 } } ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "move" }, { "from", "/a" }, { "path", "/a" } } } ) ) == a );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "move" }, { "from", "/a/foo" }, { "path", "/a/foo" } } } ) ) == a );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "move" }, { "from", "/a" }, { "path", "/b" } } } ) ) == value( { { "b", { { "foo", 1 } } } } ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "move" }, { "from", "/a/foo" }, { "path", "/b" } } } ) ) == value( { { "a", empty_object }, { "b", 1 } } ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "move" }, { "from", "/a/foo" }, { "path", "/a" } } } ) ) == value( { { "a", 1 } } ) );
-      TEST_THROWS( patch( a, value::array( { { { "op", "move" }, { "from", "/a" }, { "path", "/a/foo" } } } ) ) );
-      TEST_THROWS( patch( a, value::array( { { { "op", "move" }, { "from", "/b" }, { "path", "/a" } } } ) ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "move" }, { "from", "/b/0" }, { "path", "/b/0" } } } ) ) == b );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "move" }, { "from", "/b/0" }, { "path", "/b/1" } } } ) ) == value( { { "b", value::array( { 2, 1, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "move" }, { "from", "/b/1" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { 2, 1, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "move" }, { "from", "/b/0" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 2, 3, 1, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "move" }, { "from", "/b/2" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { 3, 1, 2, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "move" }, { "from", "/b/0" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 2, 3, 4, 1 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "move" }, { "from", "/b/2" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 1, 2, 4, 3 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "move" }, { "from", "/b/3" }, { "path", "/b/-" } } } ) ) == b );
-      TEST_THROWS( patch( b, value::array( { { { "op", "move" }, { "from", "/b/4" }, { "path", "/b/-" } } } ) ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "move" }, { "from", "/b/-" }, { "path", "/b/-" } } } ) ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "move" }, { "from", "/b/0" }, { "path", "/a" } } } ) ) == value( { { "a", 1 }, { "b", value::array( { 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "move" }, { "from", "/b/2" }, { "path", "/a" } } } ) ) == value( { { "a", 3 }, { "b", value::array( { 1, 2, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "move" }, { "from", "/b/3" }, { "path", "/a" } } } ) ) == value( { { "a", 4 }, { "b", value::array( { 1, 2, 3 } ) } } ) );
-
-      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_THROWS( cpatch( a, value::array( { { { "op", "move" }, { "from", "" }, { "path", "" } } } ) ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "move" }, { "from", "/a" }, { "path", "" } } } ) ) == value( { { "foo", 1 } } ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "move" }, { "from", "/a" }, { "path", "/a" } } } ) ) == a );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "move" }, { "from", "/a/foo" }, { "path", "/a/foo" } } } ) ) == a );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "move" }, { "from", "/a" }, { "path", "/b" } } } ) ) == value( { { "b", { { "foo", 1 } } } } ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "move" }, { "from", "/a/foo" }, { "path", "/b" } } } ) ) == value( { { "a", empty_object }, { "b", 1 } } ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "move" }, { "from", "/a/foo" }, { "path", "/a" } } } ) ) == value( { { "a", 1 } } ) );
-      TEST_THROWS( cpatch( a, value::array( { { { "op", "move" }, { "from", "/a" }, { "path", "/a/foo" } } } ) ) );
-      TEST_THROWS( cpatch( a, value::array( { { { "op", "move" }, { "from", "/b" }, { "path", "/a" } } } ) ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/0" }, { "path", "/b/0" } } } ) ) == b );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/0" }, { "path", "/b/1" } } } ) ) == value( { { "b", value::array( { 2, 1, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/1" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { 2, 1, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/0" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 2, 3, 1, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/2" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { 3, 1, 2, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/0" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 2, 3, 4, 1 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/2" }, { "path", "/b/-" } } } ) ) == value( { { "b", value::array( { 1, 2, 4, 3 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/3" }, { "path", "/b/-" } } } ) ) == b );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/4" }, { "path", "/b/-" } } } ) ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/-" }, { "path", "/b/-" } } } ) ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/0" }, { "path", "/a" } } } ) ) == value( { { "a", 1 }, { "b", value::array( { 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/2" }, { "path", "/a" } } } ) ) == value( { { "a", 3 }, { "b", value::array( { 1, 2, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "move" }, { "from", "/b/3" }, { "path", "/a" } } } ) ) == value( { { "a", 4 }, { "b", value::array( { 1, 2, 3 } ) } } ) );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

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

@@ -1,85 +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", "remove" }, { "path", "/a" } } } ) ) == empty_object );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "remove" }, { "path", "/a" } } } ) ) == eo );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "remove" }, { "path", "/a/foo" } } } ) ) == value( { { "a", empty_object } } ) );
-      TEST_THROWS( patch( a, value::array( { { { "op", "remove" }, { "path", "/q" } } } ) ) );
-      TEST_THROWS( patch( a, value::array( { { { "op", "remove" }, { "path", "" } } } ) ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "remove" }, { "path", "/b" } } } ) ) == empty_object );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "remove" }, { "path", "/b" } } } ) ) == eo );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "remove" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "remove" }, { "path", "/b/1" } } } ) ) == value( { { "b", value::array( { 1, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "remove" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 1, 2, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "remove" }, { "path", "/b/3" } } } ) ) == value( { { "b", value::array( { 1, 2, 3 } ) } } ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "remove" }, { "path", "/b/4" } } } ) ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "remove" }, { "path", "/b/-" } } } ) ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "remove" }, { "path", "/b/a" } } } ) ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "remove" }, { "path", "/a" } } } ) ) );
-      TEST_THROWS( patch( q, value::array( { { { "op", "remove" }, { "path", "/a" } } } ) ) );
-
-      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", "remove" }, { "path", "/a" } } } ) ) == empty_object );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "remove" }, { "path", "/a" } } } ) ) == eo );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "remove" }, { "path", "/a/foo" } } } ) ) == value( { { "a", empty_object } } ) );
-      TEST_THROWS( cpatch( a, value::array( { { { "op", "remove" }, { "path", "/q" } } } ) ) );
-      TEST_THROWS( cpatch( a, value::array( { { { "op", "remove" }, { "path", "" } } } ) ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "remove" }, { "path", "/b" } } } ) ) == empty_object );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "remove" }, { "path", "/b" } } } ) ) == eo );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "remove" }, { "path", "/b/0" } } } ) ) == value( { { "b", value::array( { 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "remove" }, { "path", "/b/1" } } } ) ) == value( { { "b", value::array( { 1, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "remove" }, { "path", "/b/2" } } } ) ) == value( { { "b", value::array( { 1, 2, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "remove" }, { "path", "/b/3" } } } ) ) == value( { { "b", value::array( { 1, 2, 3 } ) } } ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "remove" }, { "path", "/b/4" } } } ) ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "remove" }, { "path", "/b/-" } } } ) ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "remove" }, { "path", "/b/a" } } } ) ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "remove" }, { "path", "/a" } } } ) ) );
-      TEST_THROWS( cpatch( q, value::array( { { { "op", "remove" }, { "path", "/a" } } } ) ) );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

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

@@ -1,79 +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", "replace" }, { "path", "" }, { "value", 42 } } } ) ) == 42 );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "replace" }, { "path", "/a" }, { "value", 42 } } } ) ) == value( { { "a", 42 } } ) );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "replace" }, { "path", "/a/foo" }, { "value", 42 } } } ) ) == value( { { "a", { { "foo", 42 } } } } ) );
-      TEST_THROWS( patch( a, value::array( { { { "op", "replace" }, { "path", "/b" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( patch( a, value::array( { { { "op", "replace" }, { "path", "/a/b" }, { "value", 42 } } } ) ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "replace" }, { "path", "/b/0" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 42, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "replace" }, { "path", "/b/1" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 42, 3, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "replace" }, { "path", "/b/2" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 2, 42, 4 } ) } } ) );
-      TEST_ASSERT( patch( b, value::array( { { { "op", "replace" }, { "path", "/b/3" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 42 } ) } } ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "replace" }, { "path", "/b/4" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "replace" }, { "path", "/b/-" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( patch( b, value::array( { { { "op", "replace" }, { "path", "/b/a" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( patch( q, value::array( { { { "op", "replace" }, { "path", "/a/foo" }, { "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", "replace" }, { "path", "" }, { "value", 42 } } } ) ) == 42 );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "replace" }, { "path", "/a" }, { "value", 42 } } } ) ) == value( { { "a", 42 } } ) );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "replace" }, { "path", "/a/foo" }, { "value", 42 } } } ) ) == value( { { "a", { { "foo", 42 } } } } ) );
-      TEST_THROWS( cpatch( a, value::array( { { { "op", "replace" }, { "path", "/b" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( cpatch( a, value::array( { { { "op", "replace" }, { "path", "/a/b" }, { "value", 42 } } } ) ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "replace" }, { "path", "/b/0" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 42, 2, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "replace" }, { "path", "/b/1" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 42, 3, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "replace" }, { "path", "/b/2" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 2, 42, 4 } ) } } ) );
-      TEST_ASSERT( cpatch( b, value::array( { { { "op", "replace" }, { "path", "/b/3" }, { "value", 42 } } } ) ) == value( { { "b", value::array( { 1, 2, 3, 42 } ) } } ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "replace" }, { "path", "/b/4" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "replace" }, { "path", "/b/-" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( cpatch( b, value::array( { { { "op", "replace" }, { "path", "/b/a" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( cpatch( q, value::array( { { { "op", "replace" }, { "path", "/a/foo" }, { "value", 42 } } } ) ) );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

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

@@ -1,69 +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( n, value::array( { { { "op", "test" }, { "path", "" }, { "value", null } } } ) ) == null );
-      TEST_THROWS( patch( n, value::array( { { { "op", "test" }, { "path", "" }, { "value", 42 } } } ) ) );
-
-      TEST_ASSERT( patch( a, value::array( { { { "op", "test" }, { "path", "/a" }, { "value", { { "foo", 1 } } } } } ) ) == a );
-      TEST_ASSERT( patch( a, value::array( { { { "op", "test" }, { "path", "/a/foo" }, { "value", 1 } } } ) ) == a );
-
-      TEST_THROWS( patch( a, value::array( { { { "op", "test" }, { "path", "" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( patch( a, value::array( { { { "op", "test" }, { "path", "/a" }, { "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( n, value::array( { { { "op", "test" }, { "path", "" }, { "value", null } } } ) ) == null );
-      TEST_THROWS( cpatch( n, value::array( { { { "op", "test" }, { "path", "" }, { "value", 42 } } } ) ) );
-
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "test" }, { "path", "/a" }, { "value", { { "foo", 1 } } } } } ) ) == a );
-      TEST_ASSERT( cpatch( a, value::array( { { { "op", "test" }, { "path", "/a/foo" }, { "value", 1 } } } ) ) == a );
-
-      TEST_THROWS( cpatch( a, value::array( { { { "op", "test" }, { "path", "" }, { "value", 42 } } } ) ) );
-      TEST_THROWS( cpatch( a, value::array( { { { "op", "test" }, { "path", "/a" }, { "value", 42 } } } ) ) );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

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

@@ -1,48 +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/contrib/position.hpp>
-
-namespace tao::json
-{
-   void test_json()
-   {
-      const std::string f = "tests/taocpp/position.json";
-
-      auto v = from_file_with_position( f );
-
-      TEST_ASSERT( v.source() == f );
-      TEST_ASSERT( v.line() == 1 );
-      TEST_ASSERT( v.byte_in_line() == 0 );
-
-      TEST_ASSERT( v.at( 0 ).source() == f );
-      TEST_ASSERT( v.at( 0 ).line() == 2 );
-      TEST_ASSERT( v.at( 0 ).byte_in_line() == 8 );
-
-      TEST_ASSERT( v.at( 1 ).source() == f );
-      TEST_ASSERT( v.at( 1 ).line() == 3 );
-      TEST_ASSERT( v.at( 1 ).byte_in_line() == 8 );
-
-      TEST_ASSERT( v.at( 2 ).source() == f );
-      TEST_ASSERT( v.at( 2 ).line() == 4 );
-      TEST_ASSERT( v.at( 2 ).byte_in_line() == 8 );
-
-      TEST_ASSERT( v.at( 3 ).source() == f );
-      TEST_ASSERT( v.at( 3 ).line() == 5 );
-      TEST_ASSERT( v.at( 3 ).byte_in_line() == 8 );
-
-      TEST_ASSERT( v.at( 3 ).at( "hello" ).source() == f );
-      TEST_ASSERT( v.at( 3 ).at( "hello" ).line() == 6 );
-      TEST_ASSERT( v.at( 3 ).at( "hello" ).byte_in_line() == 26 );
-   }
-
-   void unit_test()
-   {
-      test_json();
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

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

@@ -1,44 +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/contrib/reference.hpp>
-#include <tao/json/from_string.hpp>
-#include <tao/json/value.hpp>
-
-namespace tao::json
-{
-   void test( const std::string& s1, const std::string& s2 )
-   {
-      auto v1 = from_string( s1 );
-      const auto v2 = from_string( s2 );
-      resolve_references( v1 );
-      TEST_ASSERT( v1 == v2 );
-   }
-
-   void test_throws( const value& v )
-   {
-      value v2( v );
-      TEST_THROWS( resolve_references( v2 ) );
-   }
-
-   void unit_test()
-   {
-      {
-         value e;
-         resolve_references( e );
-      }
-
-      test( "{\"foo\":1,\"bar\":2}", "{\"foo\":1,\"bar\":2}" );
-      test( "{\"foo\":1,\"bar\":{\"$ref\":\"#/foo\"}}", "{\"foo\":1,\"bar\":1}" );
-      test( "{\"foo\":\"#/foo\",\"bar\":{\"$ref\":{\"$ref\":\"#/foo\"}}}", "{\"foo\":\"#/foo\",\"bar\":\"#/foo\"}" );
-
-      test_throws( { { "$ref", "#" } } );
-      test_throws( { { "$ref", "#/foo" } } );
-      test_throws( { { "foo", 0 }, { "bar", { { "$ref", "#/foo/bar" } } } } );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

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

@@ -1,132 +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 <fstream>
-#include <iomanip>
-#include <iostream>
-
-#include <tao/json/contrib/schema.hpp>
-#include <tao/json/from_file.hpp>
-#include <tao/json/from_stream.hpp>
-#include <tao/json/pointer.hpp>
-#include <tao/json/value.hpp>
-
-namespace tao::json
-{
-   unsigned tests = 0;
-
-   [[nodiscard]] value parse_stream( const std::string& name )
-   {
-      std::ifstream ifs( name.c_str() );
-      return from_stream( ifs, name, 192 );
-   }
-
-   void test( const std::string& name )
-   {
-      std::cout << "File: " << name << std::endl;
-      try {
-         const value v = parse_stream( name );
-         for( const auto& e : v.get_array() ) {
-            std::cout << "  Schema: " << e.at( "description" ).get_string() << std::endl;
-            bool expected_schema = true;
-            if( const auto* schema_valid = e.find( "valid" ) ) {
-               expected_schema = schema_valid->get_boolean();
-            }
-            try {
-               schema s( e.at( "schema" ) );
-               if( !expected_schema ) {
-                  ++failed;
-                  std::cout << "  Failed: Schema is valid, but it should not be" << std::endl;
-               }
-               else {
-                  for( const auto& c : e.at( "tests" ).get_array() ) {
-                     std::cout << "    Testcase: " << c.at( "description" ).get_string() << std::endl;
-                     ++tests;
-                     try {
-                        const bool result = s.validate( c.at( "data" ) );
-                        const bool expected = c.at( "valid" ).get_boolean();
-                        if( result != expected ) {
-                           ++failed;
-                           if( result ) {
-                              std::cout << "    Failed: Schema matches, but it should not" << std::endl;
-                           }
-                           else {
-                              std::cout << "    Failed: Schema does not match, but it should" << std::endl;
-                           }
-                        }
-                     }
-                     catch( const std::exception& ex ) {
-                        ++failed;
-                        std::cout << "    Failed with exception: " << ex.what() << std::endl;
-                     }
-                  }
-               }
-            }
-            catch( const std::exception& ex ) {
-               if( expected_schema ) {
-                  ++failed;
-                  std::cout << "  Failed with exception: " << ex.what() << std::endl;
-               }
-               else {
-                  ++tests;
-               }
-            }
-         }
-      }
-      catch( const std::exception& ex ) {
-         ++failed;
-         std::cout << "Failed with exception: " << ex.what() << std::endl;
-      }
-   }
-
-   void unit_test()
-   {
-      test( "tests/draft4/additionalItems.json" );
-      test( "tests/draft4/additionalProperties.json" );
-      test( "tests/draft4/allOf.json" );
-      test( "tests/draft4/anyOf.json" );
-      test( "tests/draft4/default.json" );
-      test( "tests/draft4/definitions.json" );
-      test( "tests/draft4/dependencies.json" );
-      test( "tests/draft4/enum.json" );
-      test( "tests/draft4/items.json" );
-      test( "tests/draft4/maximum.json" );
-      test( "tests/draft4/maxItems.json" );
-      test( "tests/draft4/maxLength.json" );
-      test( "tests/draft4/maxProperties.json" );
-      test( "tests/draft4/minimum.json" );
-      test( "tests/draft4/minItems.json" );
-      test( "tests/draft4/minLength.json" );
-      test( "tests/draft4/minProperties.json" );
-      test( "tests/draft4/multipleOf.json" );
-      test( "tests/draft4/not.json" );
-      test( "tests/draft4/oneOf.json" );
-      test( "tests/draft4/pattern.json" );
-      test( "tests/draft4/patternProperties.json" );
-      test( "tests/draft4/properties.json" );
-      test( "tests/draft4/ref.json" );
-      test( "tests/draft4/refRemote.json" );
-      test( "tests/draft4/required.json" );
-      test( "tests/draft4/type.json" );
-      test( "tests/draft4/uniqueItems.json" );
-
-      test( "tests/draft4/optional/bignum.json" );
-      test( "tests/draft4/optional/format.json" );
-      test( "tests/draft4/optional/zeroTerminatedFloats.json" );
-
-      test( "tests/taocpp/schema.json" );
-      test( "tests/taocpp/number.json" );
-      test( "tests/taocpp/dateTime.json" );
-
-      // TODO: Remove this temporary work-around once all tests succeed
-      if( failed != 0 ) {
-         std::cerr << "JSON Schema failures: " << failed << '/' << tests << std::endl;
-      }
-      failed = 0;
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"