couchbase 3.0.0.alpha.4-universal-darwin-19 → 3.0.0.alpha.5-universal-darwin-19

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

@@ -1,79 +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 <limits>
-
-#include "test.hpp"
-
-#include <tao/json.hpp>
-
-namespace tao::json
-{
-   struct type_1
-   {};
-
-   template<>
-   struct traits< type_1 >
-   {
-      TAO_JSON_DEFAULT_KEY( "type_1" );
-
-      static void assign( value& v, const type_1 /*unused*/ )
-      {
-         v = 42;
-      }
-   };
-
-   void unit_test()
-   {
-      {
-         const std::optional< std::string > f;
-         value v = f;
-         TEST_ASSERT( v == f );
-         TEST_ASSERT( v.is_null() );
-         const auto g = v.as< std::optional< std::string > >();
-         TEST_ASSERT( g == f );
-      }
-      {
-         const std::optional< std::string > f( "hallo" );
-         value v = f;
-         TEST_ASSERT( v == f );
-         TEST_ASSERT( v.is_string() );
-         TEST_ASSERT( v == "hallo" );
-         TEST_ASSERT( v.get_string() == "hallo" );
-         const auto g = v.as< std::optional< std::string > >();
-         TEST_ASSERT( *g == *f );
-      }
-      {
-         const std::optional< int > i;
-         const value v = null;
-         TEST_ASSERT( i == v );
-      }
-      {
-         const type_1 a;
-         const value v = { a };
-         TEST_ASSERT( v.is_object() );
-         TEST_ASSERT( v.get_object().size() == 1 );
-         TEST_ASSERT( v.get_object().begin()->first == "type_1" );
-         TEST_ASSERT( v.get_object().begin()->second.as< int >() == 42 );
-      }
-      {
-         const std::optional< type_1 > a = type_1();
-         const value v = { a };
-         TEST_ASSERT( v.is_object() );
-         TEST_ASSERT( v.get_object().size() == 1 );
-         TEST_ASSERT( v.get_object().begin()->first == "type_1" );
-         TEST_ASSERT( v.get_object().begin()->second.as< int >() == 42 );
-      }
-      {
-         const std::optional< std::optional< type_1 > > a = std::optional< type_1 >( type_1() );
-         const value v = { a };
-         TEST_ASSERT( v.is_object() );
-         TEST_ASSERT( v.get_object().size() == 1 );
-         TEST_ASSERT( v.get_object().begin()->first == "type_1" );
-         TEST_ASSERT( v.get_object().begin()->second.as< int >() == 42 );
-      }
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

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

@@ -1,142 +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/value.hpp>
-
-#include <tao/json/contrib/traits.hpp>
-
-namespace tao::json
-{
-   template< typename T >
-   struct my_traits
-      : traits< T >
-   {};
-
-   template<>
-   struct my_traits< void >
-      : traits< void >
-   {
-      template< typename T >
-      struct public_base
-      {
-         [[nodiscard]] const T& self() const noexcept
-         {
-            return static_cast< const T& >( *this );
-         }
-
-         [[nodiscard]] bool empty() const noexcept
-         {
-            switch( self().type() ) {
-               case json::type::UNINITIALIZED:
-               case json::type::VALUELESS_BY_EXCEPTION:
-                  return true;
-
-               case json::type::NULL_:
-               case json::type::BOOLEAN:
-               case json::type::SIGNED:
-               case json::type::UNSIGNED:
-               case json::type::DOUBLE:
-               case json::type::VALUE_PTR:
-               case json::type::OPAQUE_PTR:
-                  return false;
-
-               case json::type::STRING:
-                  return self().get_string().empty();
-
-               case json::type::STRING_VIEW:
-                  return self().get_string_view().empty();
-
-               case json::type::BINARY:
-                  return self().get_binary().empty();
-
-               case json::type::BINARY_VIEW:
-                  return self().get_binary_view().empty();
-
-               case json::type::ARRAY:
-                  return self().get_array().empty();
-
-               case json::type::OBJECT:
-                  return self().get_object().empty();
-            }
-            // LCOV_EXCL_START
-            assert( false );
-            return false;
-            // LCOV_EXCL_STOP
-         }
-
-         [[nodiscard]] std::size_t size() const noexcept
-         {
-            switch( self().type() ) {
-               case json::type::UNINITIALIZED:
-               case json::type::VALUELESS_BY_EXCEPTION:
-                  return 0;
-
-               case json::type::NULL_:
-               case json::type::BOOLEAN:
-               case json::type::SIGNED:
-               case json::type::UNSIGNED:
-               case json::type::DOUBLE:
-               case json::type::VALUE_PTR:
-               case json::type::OPAQUE_PTR:
-                  return 1;
-
-               case json::type::STRING:
-                  return self().get_string().size();
-
-               case json::type::STRING_VIEW:
-                  return self().get_string_view().size();
-
-               case json::type::BINARY:
-                  return self().get_binary().size();
-
-               case json::type::BINARY_VIEW:
-                  return self().get_binary_view().size();
-
-               case json::type::ARRAY:
-                  return self().get_array().size();
-
-               case json::type::OBJECT:
-                  return self().get_object().size();
-            }
-            // LCOV_EXCL_START
-            assert( false );
-            return 0;
-            // LCOV_EXCL_STOP
-         }
-      };
-   };
-
-   using my_value = basic_value< my_traits >;
-
-   void unit_test()
-   {
-      my_value v1;
-      assert( v1.empty() );
-      assert( v1.size() == 0 );
-
-      my_value v2 = "";
-      assert( v2.empty() );
-      assert( v2.size() == 0 );
-
-      my_value v3 = empty_array;
-      assert( v3.empty() );
-      assert( v3.size() == 0 );
-
-      my_value v4 = empty_object;
-      assert( v4.empty() );
-      assert( v4.size() == 0 );
-
-      my_value f1 = 0;
-      assert( !f1.empty() );
-      assert( f1.size() == 1 );
-
-      my_value f2 = my_value::array( { 42, "Hallo" } );
-      assert( !f2.empty() );
-      assert( f2.size() == 2 );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

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

@@ -1,106 +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/self_contained.hpp>
-#include <tao/json/value.hpp>
-
-namespace tao::json
-{
-   template< typename T >
-   struct view_traits
-      : traits< T >
-   {
-   };
-
-   template<>
-   struct view_traits< std::string_view >
-      : traits< std::string_view >
-   {
-      template< template< typename... > class Traits >
-      static void assign( basic_value< Traits >& v, const std::string_view sv ) noexcept
-      {
-         v.set_string_view( sv );
-      }
-   };
-
-   template<>
-   struct view_traits< tao::binary_view >
-      : traits< tao::binary_view >
-   {
-      template< template< typename... > class Traits >
-      static void assign( basic_value< Traits >& v, const tao::binary_view xv ) noexcept
-      {
-         v.set_binary_view( xv );
-      }
-   };
-
-   void unit_test()
-   {
-      value v = { { "foo", 1 } };
-
-      value v1 = { { "bar", v }, { "baz", value::array( { 2, v, 3 } ) } };
-      value v2 = { { "bar", &v }, { "baz", value::array( { 2, &v, 3 } ) } };
-      value v4 = { { "bar", { { "foo", 1 } } }, { "baz", value::array( { 2, { { "foo", 1 } }, 3 } ) } };
-
-      TEST_ASSERT( v1 == v2 );
-      TEST_ASSERT( v1 == v4 );
-      TEST_ASSERT( v2 == v4 );
-
-      TEST_ASSERT( v1.at( "bar" ).type() == type::OBJECT );
-      TEST_ASSERT( v1.at( "baz" ).at( 1 ).type() == type::OBJECT );
-
-      TEST_ASSERT( v2.at( "bar" ).type() == type::VALUE_PTR );
-      TEST_ASSERT( v2.at( "baz" ).at( 1 ).type() == type::VALUE_PTR );
-
-      TEST_ASSERT( is_self_contained( v1 ) );
-      TEST_ASSERT( !is_self_contained( v2 ) );
-      TEST_ASSERT( is_self_contained( v4 ) );
-
-      make_self_contained( v1 );
-      make_self_contained( v2 );
-
-      TEST_ASSERT( is_self_contained( v1 ) );
-      TEST_ASSERT( is_self_contained( v2 ) );
-      TEST_ASSERT( v1 == v2 );
-      TEST_ASSERT( v1 == v4 );
-      TEST_ASSERT( v2 == v4 );
-
-      TEST_ASSERT( v1.at( "bar" ).type() == type::OBJECT );
-      TEST_ASSERT( v1.at( "baz" ).at( 1 ).type() == type::OBJECT );
-
-      TEST_ASSERT( v2.at( "bar" ).type() == type::OBJECT );
-      TEST_ASSERT( v2.at( "baz" ).at( 1 ).type() == type::OBJECT );
-
-      std::byte data[ 4 ];
-
-      TEST_ASSERT( is_self_contained( value() ) );
-      TEST_ASSERT( is_self_contained( value( true ) ) );
-      TEST_ASSERT( is_self_contained( value( std::string( "hallo" ) ) ) );
-      TEST_ASSERT( is_self_contained( value( std::int64_t( -1 ) ) ) );
-      TEST_ASSERT( is_self_contained( value( std::uint64_t( 1 ) ) ) );
-      TEST_ASSERT( is_self_contained( value( double( 3.0 ) ) ) );
-      TEST_ASSERT( is_self_contained( value( tao::binary( 2, std::byte( 42 ) ) ) ) );
-      TEST_ASSERT( is_self_contained( value( null ) ) );
-      TEST_ASSERT( is_self_contained( value( empty_array ) ) );
-      TEST_ASSERT( is_self_contained( value( empty_object ) ) );
-      TEST_ASSERT( is_self_contained( value( std::string_view( "hallo" ) ) ) );               // Default traits put a string in the value for safety.
-      TEST_ASSERT( is_self_contained( value( tao::binary_view( data, sizeof( data ) ) ) ) );  // Default traits put a binary in the value for safety.
-
-      basic_value< view_traits > sv( std::string_view( "hallo" ) );
-      TEST_ASSERT( !is_self_contained( sv ) );
-      make_self_contained( sv );
-      TEST_ASSERT( is_self_contained( sv ) );
-      TEST_ASSERT( basic_value< view_traits >( std::string_view( "hallo" ) ) == sv );
-
-      basic_value< view_traits > bv( tao::binary_view( data, sizeof( data ) ) );
-      TEST_ASSERT( !is_self_contained( bv ) );
-      make_self_contained( bv );
-      TEST_ASSERT( is_self_contained( bv ) );
-      TEST_ASSERT( basic_value< view_traits >( tao::binary_view( data, sizeof( data ) ) ) == bv );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

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

@@ -1,38 +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/internal/sha256.hpp>
-
-namespace tao::json
-{
-   static char hex[] = "0123456789ABCDEF";
-
-   [[nodiscard]] std::string to_hex( const std::string& s )
-   {
-      std::string result;
-      result.reserve( s.size() * 2 );
-      for( unsigned char c : s ) {
-         result += hex[ c >> 4 ];
-         result += hex[ c & 15 ];
-      }
-      return result;
-   }
-
-   void unit_test()
-   {
-      // two test vectors from RFC 6234 should be enough
-
-      internal::sha256 d;
-      d.feed( "abc" );
-      TEST_ASSERT( to_hex( d.get() ) == "BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD" );
-
-      d.reset();
-      d.feed( "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" );
-      TEST_ASSERT( to_hex( d.get() ) == "248D6A61D20638B8E5C026930C3E6039A33CE45964FF2167F6ECEDD419DB06C1" );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

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

@@ -1,70 +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 <tao/json/value.hpp>
-
-#include <sstream>
-
-namespace tao::json
-{
-   void unit_test()
-   {
-      const char* p = "Hello, world!";
-      const std::string s = p;
-      const std::string_view sv = p;
-
-      TEST_ASSERT( s == p );
-      TEST_ASSERT( p == s );
-      TEST_ASSERT( s == s );
-      TEST_ASSERT( sv == p );
-      TEST_ASSERT( sv == s );
-      TEST_ASSERT( p == sv );
-      TEST_ASSERT( s == sv );
-      TEST_ASSERT( sv == sv );
-
-      TEST_ASSERT( sv.find( '!' ) == 12 );
-      TEST_ASSERT( sv.find_first_not_of( "elo, wrd", 1 ) == 12 );
-
-      // the default is copying all string_views
-      const value vp = p;
-      const value vs = s;
-      const value vsv = sv;
-
-      TEST_ASSERT( vp.type() == type::STRING );
-      TEST_ASSERT( vs.type() == type::STRING );
-      TEST_ASSERT( vsv.type() == type::STRING );
-
-      TEST_ASSERT( vp.as< const char* >() == s );
-      TEST_ASSERT( vp.as< std::string_view >() == s );
-      TEST_ASSERT( vp.as< std::string >() == s );
-      TEST_ASSERT( vp.as< const std::string& >() == s );
-
-      TEST_ASSERT( vs.as< const char* >() == s );
-      TEST_ASSERT( vs.as< std::string_view >() == s );
-      TEST_ASSERT( vs.as< std::string >() == s );
-      TEST_ASSERT( vs.as< const std::string& >() == s );
-
-      TEST_ASSERT( vsv.as< const char* >() == s );
-      TEST_ASSERT( vsv.as< std::string_view >() == s );
-      TEST_ASSERT( vsv.as< std::string >() == s );
-      TEST_ASSERT( vsv.as< const std::string& >() == s );
-
-      // storing a string_view is possible
-      value v;
-      v.set_string_view( sv );
-
-      TEST_ASSERT( v.type() == type::STRING_VIEW );
-
-      TEST_ASSERT( v.as< std::string_view >() == s );
-      TEST_ASSERT( v.as< std::string >() == s );
-
-      std::ostringstream oss;
-      oss << sv;
-      TEST_ASSERT( oss.str() == sv );
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"

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

@@ -1,339 +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 <bitset>
-#include <limits>
-#include <list>
-#include <map>
-#include <type_traits>
-#include <vector>
-
-#include "test.hpp"
-#include "test_unhex.hpp"
-
-#include <tao/json.hpp>
-#include <tao/json/binding.hpp>
-#include <tao/json/consume.hpp>
-
-#include <tao/json/cbor/parts_parser.hpp>
-#include <tao/json/parts_parser.hpp>
-
-#include <tao/json/contrib/traits.hpp>
-
-namespace tao::json
-{
-   template< typename T, typename = void >
-   struct my_traits
-      : public traits< T >
-   {};
-
-   class base_class
-   {
-   public:
-      virtual ~base_class() = default;
-
-      base_class( const base_class& ) = delete;
-      base_class( base_class&& ) = delete;
-      void operator=( const base_class& ) = delete;
-      void operator=( base_class&& ) = delete;
-
-   protected:
-      base_class() = default;
-   };
-
-   class derived_one
-      : public base_class
-   {
-   public:
-      std::string s;
-   };
-
-   class derived_two
-      : public base_class
-   {
-   public:
-      int i = 0;
-   };
-
-   template<>
-   struct my_traits< derived_one >
-      : binding::object< TAO_JSON_BIND_REQUIRED( "s", &derived_one::s ) >
-   {};
-
-   template<>
-   struct my_traits< derived_two >
-      : binding::object< TAO_JSON_BIND_REQUIRED( "i", &derived_two::i ) >
-   {};
-
-   template<>
-   struct my_traits< std::shared_ptr< base_class > >
-      : binding::factory< TAO_JSON_FACTORY_BIND( "one", derived_one ),
-                          TAO_JSON_FACTORY_BIND( "two", derived_two ) >
-   {};
-
-   template<>
-   struct my_traits< std::unique_ptr< base_class > >
-      : my_traits< std::shared_ptr< base_class > >
-   {};
-
-   struct foo
-   {
-      std::string a = "hello";
-      std::string b = "world";
-   };
-
-   struct foo_version_two
-      : public binding::array< TAO_JSON_BIND_ELEMENT( &foo::a ),
-                               TAO_JSON_BIND_ELEMENT( &foo::b ),
-                               binding::element_u< 2 > >
-   {};
-
-   struct foo_version_one
-      : public binding::array< TAO_JSON_BIND_ELEMENT( &foo::a ),
-                               TAO_JSON_BIND_ELEMENT( &foo::b ) >
-   {};
-
-   template<>
-   struct my_traits< foo >
-      : binding::versions< foo_version_two,
-                           foo_version_one >
-   {};
-
-   struct foo2
-      : public foo
-   {
-      int plus = 0;
-   };
-
-   template<>
-   struct my_traits< foo2 >
-      : binding::array< binding::inherit< foo_version_one >,
-                        TAO_JSON_BIND_ELEMENT( &foo2::plus ) >
-   {};
-
-   struct bar
-   {
-      int i = -1;
-      std::string c = "c";
-   };
-
-   template<>
-   struct my_traits< bar >
-      : binding::object< TAO_JSON_BIND_REQUIRED( "i", &bar::i ),
-                         TAO_JSON_BIND_OPTIONAL( "c", &bar::c ) >
-   {};
-
-   struct baz
-   {
-      [[nodiscard]] int get_i() const
-      {
-         return i;
-      }
-
-      int i = -1;
-      int j = -2;
-   };
-
-   [[nodiscard]] int get_j( const baz& b )
-   {
-      return b.j;
-   }
-
-   template<>
-   struct my_traits< baz >
-      : binding::array< TAO_JSON_BIND_ELEMENT( &baz::get_i ),
-                        TAO_JSON_BIND_ELEMENT( &get_j ) >
-   {};
-
-   struct test_empty
-   {
-      std::list< int > list;
-   };
-
-   template<>
-   struct my_traits< test_empty >
-      : binding::object< TAO_JSON_BIND_OPTIONAL( "list", &test_empty::list ) >
-   {};
-
-   struct test_suppress
-   {
-      std::list< int > list;
-   };
-
-   template<>
-   struct my_traits< test_suppress >
-      : binding::basic_object< binding::for_unknown_key::skip,
-                               binding::for_nothing_value::suppress,
-                               TAO_JSON_BIND_OPTIONAL( "list", &test_suppress::list ) >
-   {};
-
-   using my_value = basic_value< my_traits >;
-
-   void unit_test()
-   {
-      {
-         test_suppress w;
-         basic_value< my_traits > v = w;
-         TEST_ASSERT( v.is_object() );
-         TEST_ASSERT( v.get_object().empty() );
-      }
-      {
-         test_empty w;
-         basic_value< my_traits > v = w;
-         TEST_ASSERT( v.is_object() );
-         TEST_ASSERT( v.get_object().size() == 1 );
-         TEST_ASSERT( v.get_object().at( "list" ).is_array() );
-         TEST_ASSERT( v.get_object().at( "list" ).get_array().empty() );
-         w.list.push_back( 3 );
-         basic_value< my_traits > x = w;
-         TEST_ASSERT( x.is_object() );
-         TEST_ASSERT( x.get_object().size() == 1 );
-         TEST_ASSERT( x.get_object().at( "list" ).is_array() );
-         TEST_ASSERT( x.get_object().at( "list" ).get_array().size() == 1 );
-         TEST_ASSERT( x.get_object().at( "list" ).get_array()[ 0 ] == 3 );
-      }
-      {
-         const basic_value< my_traits > v = basic_value< my_traits >::array( { "a", "b", 3 } );
-         const auto f = v.as< foo2 >();
-         TEST_ASSERT( f.a == "a" );
-         TEST_ASSERT( f.b == "b" );
-         TEST_ASSERT( f.plus == 3 );
-      }
-      {
-         const std::tuple< int, std::string, double > b{ 42, "hallo", 3.0 };
-         basic_value< my_traits > v = b;
-         TEST_ASSERT( v.is_array() );
-         TEST_ASSERT( v.get_array().size() == 3 );
-         TEST_ASSERT( v[ 0 ] == 42 );
-         TEST_ASSERT( v[ 1 ] == std::string( "hallo" ) );
-         TEST_ASSERT( v[ 2 ] == 3.0 );
-         const auto c = v.as< std::tuple< int, std::string, double > >();
-         TEST_ASSERT( b == c );
-      }
-      {
-         baz b;
-         basic_value< my_traits > v = b;
-         TEST_ASSERT( v.is_array() );
-         TEST_ASSERT( v.get_array().size() == 2 );
-         TEST_ASSERT( v[ 0 ] == -1 );
-         TEST_ASSERT( v[ 1 ] == -2 );
-      }
-      {
-         parts_parser pp( "  [  \"kasimir\"  ,  \"fridolin\", 2  ]  ", __FUNCTION__ );
-         const auto f = consume< foo, my_traits >( pp );
-         TEST_ASSERT( f.a == "kasimir" );
-         TEST_ASSERT( f.b == "fridolin" );
-      }
-      {
-         const auto f = consume_string< foo, my_traits >( "  [  \"kasimir\"  ,  \"fridolin\", 2  ]  " );
-         TEST_ASSERT( f.a == "kasimir" );
-         TEST_ASSERT( f.b == "fridolin" );
-      }
-      {
-         parts_parser pp( "  [  ]  ", __FUNCTION__ );
-         const auto v = consume< std::shared_ptr< std::vector< int > >, my_traits >( pp );
-         TEST_ASSERT( v->empty() );
-      }
-      {
-         parts_parser pp( "  [  1  , 2, 3  ]  ", __FUNCTION__ );
-         const auto v = consume< std::vector< int >, my_traits >( pp );
-         TEST_ASSERT( v.size() == 3 );
-         TEST_ASSERT( v[ 0 ] == 1 );
-         TEST_ASSERT( v[ 1 ] == 2 );
-         TEST_ASSERT( v[ 2 ] == 3 );
-      }
-      {
-         cbor::parts_parser pp( test_unhex( "80" ), __FUNCTION__ );
-         const auto v = consume< std::vector< unsigned >, my_traits >( pp );
-         TEST_ASSERT( v.empty() );
-      }
-      {
-         cbor::parts_parser pp( test_unhex( "8a00010203040506070809" ), __FUNCTION__ );
-         const auto v = consume< std::vector< unsigned >, my_traits >( pp );
-         TEST_ASSERT( v.size() == 10 );
-         for( std::size_t i = 0; i < 10; ++i ) {
-            TEST_ASSERT( v[ i ] == i );
-         }
-      }
-      {
-         const auto v = cbor::consume_string< std::vector< unsigned >, my_traits >( test_unhex( "8a00010203040506070809" ) );
-         TEST_ASSERT( v.size() == 10 );
-         for( std::size_t i = 0; i < 10; ++i ) {
-            TEST_ASSERT( v[ i ] == i );
-         }
-      }
-      {
-         cbor::parts_parser pp( test_unhex( "9f00010203040506070809ff" ), __FUNCTION__ );
-         const auto v = consume< std::vector< unsigned >, my_traits >( pp );
-         TEST_ASSERT( v.size() == 10 );
-         for( std::size_t i = 0; i < 10; ++i ) {
-            TEST_ASSERT( v[ i ] == i );
-         }
-      }
-      {
-         cbor::parts_parser pp( test_unhex( "8261616162" ), __FUNCTION__ );
-         const auto v = consume< foo, my_traits >( pp );
-         TEST_ASSERT( v.a == "a" );
-         TEST_ASSERT( v.b == "b" );
-      }
-      {
-         parts_parser pp( " { \"a\" : 4, \"b\" : 5 } ", __FUNCTION__ );
-         const auto v = consume< std::map< std::string, int, std::less<> >, my_traits >( pp );
-         TEST_ASSERT( v.size() == 2 );
-         TEST_ASSERT( v.at( "a" ) == 4 );
-         TEST_ASSERT( v.at( "b" ) == 5 );
-      }
-      {
-         parts_parser pp( " { \"c\" : \"yeah\" , \"i\" : 42 } ", __FUNCTION__ );
-         const auto v = consume< bar, my_traits >( pp );
-         TEST_ASSERT( v.c == "yeah" );
-         TEST_ASSERT( v.i == 42 );
-      }
-      {
-         parts_parser pp( " { \"i\" : 42 } ", __FUNCTION__ );
-         const auto v = consume< bar, my_traits >( pp );
-         TEST_ASSERT( v.c == "c" );
-         TEST_ASSERT( v.i == 42 );
-      }
-      {
-         cbor::parts_parser pp( test_unhex( "bf616364796561686169182aff" ), __FUNCTION__ );
-         const auto v = consume< bar, my_traits >( pp );
-         TEST_ASSERT( v.c == "yeah" );
-         TEST_ASSERT( v.i == 42 );
-      }
-      {
-         const basic_value< my_traits > v = {
-            { "c", "x" },
-            { "i", 2 }
-         };
-         const auto x = v.as< bar >();
-         TEST_ASSERT( x.c == "x" );
-         TEST_ASSERT( x.i == 2 );
-      }
-      {
-         parts_parser pp( "{ \"two\":{ \"i\" : 17 }}", __FUNCTION__ );
-         const auto v = consume< std::shared_ptr< base_class >, my_traits >( pp );
-         const auto c = std::dynamic_pointer_cast< derived_two >( v );
-         TEST_ASSERT( c );
-         TEST_ASSERT( c->i == 17 );
-      }
-      {
-         parts_parser pp( "{ \"two\":{ \"i\" : 17 }}", __FUNCTION__ );
-         const auto v = consume< std::unique_ptr< base_class >, my_traits >( pp );
-         const auto* c = dynamic_cast< derived_two* >( v.get() );
-         TEST_ASSERT( c );
-         TEST_ASSERT( c->i == 17 );
-      }
-      {
-         basic_value< my_traits > v;
-         v[ "two" ][ "i" ] = 17;
-         const auto x = v.as< std::shared_ptr< base_class > >();
-         const auto c = std::dynamic_pointer_cast< derived_two >( x );
-         TEST_ASSERT( c );
-         TEST_ASSERT( c->i == 17 );
-      }
-   }
-
-}  // namespace tao::json
-
-#include "main.hpp"