JSON-Schema-AsType v0.4.4 Perl 5 v5.18.1 i86pc-solaris-thread-multi-64

Status
Pass
From
Chris Williams (BINGOS)
Dist
JSON-Schema-AsType v0.4.4
Platform
Perl 5 v5.18.1 i86pc-solaris-thread-multi-64
Date
2024-04-23 16:15:25
ID
b155a412-018c-11ef-98b0-b3c3213a625c
This distribution has been tested as part of the CPAN Testers
project, supporting the Perl programming language.  See
http://wiki.cpantesters.org/ for more information or email
questions to cpan-testers-discuss@perl.org


--

Dear YANICK,

This is a computer-generated error report created automatically by
CPANPLUS, version 0.9914. Testers personal comments may appear
at the end of this report.


Thank you for uploading your work to CPAN.  Congratulations!
All tests were successful.

TEST RESULTS:

Below is the error stack from stage 'make test':

PERL_DL_NONLAZY=1 "/home/cpan/pit/thr/perl-5.18.1/bin/perl" "-MExtUtils::Command::MM" "-MTest::Harness" "-e" "undef *Test::Harness::Switches; test_harness(0, 'blib/lib', 'blib/arch')" t/*.t
t/00-compile.t ......... ok
# 
# Versions for all modules listed in MYMETA.json (including optional ones):
# 
# === Configure Requires ===
# 
#     Module              Want Have
#     ------------------- ---- ----
#     ExtUtils::MakeMaker  any 7.70
# 
# === Build Requires ===
# 
#     Module              Want Have
#     ------------------- ---- ----
#     ExtUtils::MakeMaker  any 7.70
# 
# === Test Requires ===
# 
#     Module               Want     Have
#     ------------------- ----- --------
#     Exporter              any     5.68
#     ExtUtils::MakeMaker   any     7.70
#     File::Spec            any     3.75
#     IO::Handle            any     1.34
#     IPC::Open3            any     1.13
#     Path::Tiny          0.062    0.144
#     Test::Deep            any    1.204
#     Test::Exception       any     0.43
#     Test::More            any 1.302198
#     lib                   any     0.63
#     parent                any    0.225
# 
# === Test Recommends ===
# 
#     Module         Want     Have
#     ---------- -------- --------
#     CPAN::Meta 2.120900 2.150010
# 
# === Runtime Requires ===
# 
#     Module                     Want     Have
#     ---------------------- -------- --------
#     Clone                       any     0.46
#     JSON                        any     4.10
#     LWP::Simple                 any     6.77
#     List::AllUtils              any     0.19
#     List::MoreUtils             any    0.430
#     List::Util                  any     1.63
#     Moose                       any   2.2207
#     Moose::Role                 any   2.2207
#     Moose::Util                 any   2.2207
#     MooseX::ClassAttribute      any     0.29
#     MooseX::MungeHas            any    0.011
#     Path::Tiny                0.062    0.144
#     Scalar::Util                any     1.63
#     Type::Library               any 2.004000
#     Type::Tiny                  any 2.004000
#     Type::Tiny::Class           any 2.004000
#     Type::Utils                 any 2.004000
#     Types::Standard             any 2.004000
#     URI                         any     5.28
#     perl                   5.014000 5.018001
#     strict                      any     1.07
#     warnings                    any     1.18
# 
t/00-report-prereqs.t .. ok
t/basic.t .............. ok
t/draft3.t ............. ok
t/draft4.t ............. ok
        # {
        #   'exclusiveMinimum' => '1.1'
        # }
        # Value "1.1" did not pass type constraint "ExclusiveMinimum["1.1"]"
        # "ExclusiveMinimum["1.1"]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; $_ > $minimum unless not StrictNum->check($_); }
        # Value "0.6" did not pass type constraint "ExclusiveMinimum["1.1"]"
        # "ExclusiveMinimum["1.1"]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; $_ > $minimum unless not StrictNum->check($_); }
        # {
        #   'enum' => [
        #     1,
        #     2,
        #     3
        #   ]
        # }
        # Value "4" did not pass type constraint "Enum[1,2,3]"
        # "Enum[1,2,3]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $j = $_; any sub { same_structs($_, $j); } , @items; }
        # {
        #   'enum' => [
        #     6,
        #     'foo',
        #     [],
        #     bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
        #     {
        #       'foo' => 12
        #     }
        #   ]
        # }
        # Undef did not pass type constraint "Enum[6,foo,ARRAY(0x31a5a38),1,HASH(0x2cf4148)]"
        # "Enum[6,foo,ARRAY(0x31a5a38),1,HASH(0x2cf4148)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $j = $_; any sub { same_structs($_, $j); } , @items; }
        # Reference {"foo" => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )} did not pass type constraint "Enum[6,foo,ARRAY(0x31a5a38),1,HASH(0x2cf4148)]"
        # "Enum[6,foo,ARRAY(0x31a5a38),1,HASH(0x2cf4148)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $j = $_; any sub { same_structs($_, $j); } , @items; }
        # {
        #   'properties' => {
        #     'bar' => {
        #       'enum' => [
        #         'bar'
        #       ]
        #     },
        #     'foo' => {
        #       'enum' => [
        #         'foo'
        #       ]
        #     }
        #   },
        #   'required' => [
        #     'bar'
        #   ],
        #   'type' => 'object'
        # }
        # "Properties[foo,Enum[foo],bar,Enum[bar]]&Required[bar]&Object" requires that the value pass "Object", "Properties[foo,Enum[foo],bar,Enum[bar]]", and "Required[bar]"
        # Reference {"foo" => "foo"} did not pass type constraint "Required[bar]"
        # "Required[bar]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; all sub { exists $$obj{$_}; } , @keys; }
        # "Properties[foo,Enum[foo],bar,Enum[bar]]&Required[bar]&Object" requires that the value pass "Object", "Properties[foo,Enum[foo],bar,Enum[bar]]", and "Required[bar]"
        # Reference {} did not pass type constraint "Required[bar]"
        # "Required[bar]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; all sub { exists $$obj{$_}; } , @keys; }
        # {
        #   'minLength' => 2
        # }
        # Value "f" did not pass type constraint "MinLength[2]"
        # "MinLength[2]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; $length <= length $_ unless not String->check($_); }
        # Value "\x{1f4a9}" did not pass type constraint "MinLength[2]"
        # "MinLength[2]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; $length <= length $_ unless not String->check($_); }
        # {
        #   'minProperties' => 1
        # }
        # Reference {} did not pass type constraint "MinProperties[1]"
        # "MinProperties[1]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; $nbr <= scalar keys %$_ unless not Object->check($_); }
        # {
        #   'pattern' => '^a*$'
        # }
        # Value "abc" did not pass type constraint "Pattern["^a*\$"]"
        # "Pattern["^a*\$"]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; /$regex/ unless not String->check($_); }
        # {
        #   'pattern' => 'a+'
        # }
        # {
        #   '$ref' => 'http://json-schema.org/draft-04/schema#'
        # }
        # {
        #   '$ref' => 'http://json-schema.org/draft-04/schema#'
        # }
        # ref schema is {"definitions":{"stringArray":{"type":"array","minItems":1,"uniqueItems":true,"items":{"type":"string"}},"positiveInteger":{"minimum":0,"type":"integer"},"positiveIntegerDefault0":{"allOf":[{"$ref":"#/definitions/positiveInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}}},"default":{},"id":"http://json-schema.org/draft-04/schema#","properties":{"pattern":{"format":"regex","type":"string"},"enum":{"uniqueItems":true,"type":"array","minItems":1},"minProperties":{"$ref":"#/definitions/positiveIntegerDefault0"},"oneOf":{"$ref":"#/definitions/schemaArray"},"default":{},"maximum":{"type":"number"},"minLength":{"$ref":"#/definitions/positiveIntegerDefault0"},"minimum":{"type":"number"},"exclusiveMaximum":{"type":"boolean","default":false},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"uniqueItems":true,"minItems":1,"type":"array","items":{"$ref":"#/definitions/simpleTypes"}}]},"additionalItems":{"default":{},"anyOf":[{"type":"boolean"},{"$ref":"#"}]},"not":{"$ref":"#"},"allOf":{"$ref":"#/definitions/schemaArray"},"properties":{"additionalProperties":{"$ref":"#"},"properties":{},"type":"object","patternProperties":{},"default":{}},"minItems":{"$ref":"#/definitions/positiveIntegerDefault0"},"uniqueItems":{"default":false,"type":"boolean"},"definitions":{"additionalProperties":{"$ref":"#"},"properties":{},"type":"object","patternProperties":{},"default":{}},"title":{"type":"string"},"additionalProperties":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"id":{"format":"uri","type":"string"},"patternProperties":{"patternProperties":{},"default":{},"properties":{},"type":"object","additionalProperties":{"$ref":"#"}},"maxProperties":{"$ref":"#/definitions/positiveInteger"},"$schema":{"type":"string","format":"uri"},"items":{"default":{},"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}]},"anyOf":{"$ref":"#/definitions/schemaArray"},"maxItems":{"$ref":"#/definitions/positiveInteger"},"multipleOf":{"type":"number","exclusiveMinimum":true,"minimum":0},"dependencies":{"additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]},"properties":{},"type":"object","patternProperties":{}},"required":{"$ref":"#/definitions/stringArray"},"maxLength":{"$ref":"#/definitions/positiveInteger"},"description":{"type":"string"},"exclusiveMinimum":{"type":"boolean","default":false}},"$schema":"http://json-schema.org/draft-04/schema#","description":"Core schema meta-schema","type":"object","dependencies":{"exclusiveMinimum":["minimum"],"exclusiveMaximum":["maximum"]}}
        # "Dependency[exclusiveMinimum,ARRAY(0x2ee1998)]&Dependency[exclusiveMaximum,ARRAY(0x2e01890)]&Properties[pattern,String,enum,MinItems[1]&Array&UniqueItems,minProperties,Ref(#/definitions/positiveIntegerDefault0),oneOf,Ref(#/definitions/schemaArray),default,Any,maximum,Number,minLength,Ref(#/definitions/positiveIntegerDefault0),minimum,Number,exclusiveMaximum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(#/definitions/simpleTypes)]]]&MinItems[1]&Array&UniqueItems],additionalItems,AnyOf[Boolean,Ref(#)],not,Ref(#),allOf,Ref(#/definitions/schemaArray),properties,AdditionalProperties[ARRAY(0x2ded8e8),Ref(#)]&PatternProperties[]&Properties[]&Object,minItems,Ref(#/definitions/positiveIntegerDefault0),uniqueItems,Boolean,definitions,AdditionalProperties[ARRAY(0x306f300),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,additionalProperties,AnyOf[Boolean,Ref(#)],id,String,patternProperties,AdditionalProperties[ARRAY(0x307ee98),Ref(#)]&PatternProperties[]&Properties[]&Object,maxProperties,Ref(#/definitions/positiveInteger),"\$schema",String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],anyOf,Ref(#/definitions/schemaArray),maxItems,Ref(#/definitions/positiveInteger),multipleOf,ExclusiveMinimum[0]&Number,dependencies,AdditionalProperties[ARRAY(0x30d42d8),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),maxLength,Ref(#/definitions/positiveInteger),description,String,exclusiveMinimum,Boolean]&Object" requires that the value pass "Dependency[exclusiveMaximum,ARRAY(0x2e01890)]", "Dependency[exclusiveMinimum,ARRAY(0x2ee1998)]", "Object", and "Properties[pattern,String,enum,MinItems[1]&Array&UniqueItems,minProperties,Ref(#/definitions/positiveIntegerDefault0),oneOf,Ref(#/definitions/schemaArray),default,Any,maximum,Number,minLength,Ref(#/definitions/positiveIntegerDefault0),minimum,Number,exclusiveMaximum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(#/definitions/simpleTypes)]]]&MinItems[1]&Array&UniqueItems],additionalItems,AnyOf[Boolean,Ref(#)],not,Ref(#),allOf,Ref(#/definitions/schemaArray),properties,AdditionalProperties[ARRAY(0x2ded8e8),Ref(#)]&PatternProperties[]&Properties[]&Object,minItems,Ref(#/definitions/positiveIntegerDefault0),uniqueItems,Boolean,definitions,AdditionalProperties[ARRAY(0x306f300),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,additionalProperties,AnyOf[Boolean,Ref(#)],id,String,patternProperties,AdditionalProperties[ARRAY(0x307ee98),Ref(#)]&PatternProperties[]&Properties[]&Object,maxProperties,Ref(#/definitions/positiveInteger),"\$schema",String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],anyOf,Ref(#/definitions/schemaArray),maxItems,Ref(#/definitions/positiveInteger),multipleOf,ExclusiveMinimum[0]&Number,dependencies,AdditionalProperties[ARRAY(0x30d42d8),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),maxLength,Ref(#/definitions/positiveInteger),description,String,exclusiveMinimum,Boolean]"
        # Reference {"definitions" => {"foo" => 'HASH(0x37df330)'}} did not pass type constraint "Properties[pattern,String,enum,MinItems[1]&Array&UniqueItems,minProperties,Ref(#/definitions/positiveIntegerDefault0),oneOf,Ref(#/definitions/schemaArray),default,Any,maximum,Number,minLength,Ref(#/definitions/positiveIntegerDefault0),minimum,Number,exclusiveMaximum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(#/definitions/simpleTypes)]]]&MinItems[1]&Array&UniqueItems],additionalItems,AnyOf[Boolean,Ref(#)],not,Ref(#),allOf,Ref(#/definitions/schemaArray),properties,AdditionalProperties[ARRAY(0x2ded8e8),Ref(#)]&PatternProperties[]&Properties[]&Object,minItems,Ref(#/definitions/positiveIntegerDefault0),uniqueItems,Boolean,definitions,AdditionalProperties[ARRAY(0x306f300),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,additionalProperties,AnyOf[Boolean,Ref(#)],id,String,patternProperties,AdditionalProperties[ARRAY(0x307ee98),Ref(#)]&PatternProperties[]&Properties[]&Object,maxProperties,Ref(#/definitions/positiveInteger),"\$schema",String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],anyOf,Ref(#/definitions/schemaArray),maxItems,Ref(#/definitions/positiveInteger),multipleOf,ExclusiveMinimum[0]&Number,dependencies,AdditionalProperties[ARRAY(0x30d42d8),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),maxLength,Ref(#/definitions/positiveInteger),description,String,exclusiveMinimum,Boolean]"
        # "Properties[pattern,String,enum,MinItems[1]&Array&UniqueItems,minProperties,Ref(#/definitions/positiveIntegerDefault0),oneOf,Ref(#/definitions/schemaArray),default,Any,maximum,Number,minLength,Ref(#/definitions/positiveIntegerDefault0),minimum,Number,exclusiveMaximum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(#/definitions/simpleTypes)]]]&MinItems[1]&Array&UniqueItems],additionalItems,AnyOf[Boolean,Ref(#)],not,Ref(#),allOf,Ref(#/definitions/schemaArray),properties,AdditionalProperties[ARRAY(0x2ded8e8),Ref(#)]&PatternProperties[]&Properties[]&Object,minItems,Ref(#/definitions/positiveIntegerDefault0),uniqueItems,Boolean,definitions,AdditionalProperties[ARRAY(0x306f300),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,additionalProperties,AnyOf[Boolean,Ref(#)],id,String,patternProperties,AdditionalProperties[ARRAY(0x307ee98),Ref(#)]&PatternProperties[]&Properties[]&Object,maxProperties,Ref(#/definitions/positiveInteger),"\$schema",String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],anyOf,Ref(#/definitions/schemaArray),maxItems,Ref(#/definitions/positiveInteger),multipleOf,ExclusiveMinimum[0]&Number,dependencies,AdditionalProperties[ARRAY(0x30d42d8),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),maxLength,Ref(#/definitions/positiveInteger),description,String,exclusiveMinimum,Boolean]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # "Ref(http://json-schema.org/draft-04/schema#)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # {
        #   'minimum' => '1.1'
        # }
        # Value "0.6" did not pass type constraint "Minimum["1.1"]"
        # "Minimum["1.1"]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; $_ >= $minimum unless not Number->check($_); }
        # {
        #   'properties' => {
        #     'foo' => {
        #       'default' => [],
        #       'type' => 'integer'
        #     }
        #   }
        # }
        # {
        #   'properties' => {
        #     'bar' => {
        #       'default' => 'bad',
        #       'minLength' => 4,
        #       'type' => 'string'
        #     }
        #   }
        # }
        # {
        #   'maxProperties' => 2
        # }
        # Reference {"bar" => 2,"baz" => 3,"foo" => 1} did not pass type constraint "MaxProperties[2]"
        # "MaxProperties[2]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; $nbr >= keys %$_ unless not Object->check($_); }
        # {
        #   '$ref' => 'http://localhost:1234/integer.json'
        # }
        # ref schema is {"type":"integer"}
        # Value "a" did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # "Ref(http://localhost:1234/integer.json)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # {
        #   '$ref' => 'http://localhost:1234/subSchemas.json#/integer'
        # }
        # ref schema is {"type":"integer"}
        # Value "a" did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # "Ref(http://localhost:1234/subSchemas.json#/integer)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # {
        #   '$ref' => 'http://localhost:1234/subSchemas.json#/refToInteger'
        # }
        # ref schema is {"$ref":"#/integer"}
        # ref schema is {"type":"integer"}
        # Value "a" did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # "Ref(#/integer)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # "Ref(http://localhost:1234/subSchemas.json#/refToInteger)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # {
        #   '$id' => 'http://localhost:1234/',
        #   'items' => {
        #     '$id' => 'folder/',
        #     'items' => {
        #       '$ref' => 'folderInteger.json'
        #     }
        #   }
        # }
        # "~ArrayRef|Tuple[Slurpy[ArrayRef[~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]]]]" requires that the value pass "Tuple[Slurpy[ArrayRef[~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]]]]" or "~ArrayRef"
        # Reference [["a"]] did not pass type constraint "~ArrayRef"
        #     Reference [["a"]] did not pass type constraint "~ArrayRef"
        #     "~ArrayRef" is defined as: (not((ref($_) eq 'ARRAY')))
        # Reference [["a"]] did not pass type constraint "Tuple[Slurpy[ArrayRef[~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]]]]"
        #     Reference [["a"]] did not pass type constraint "Tuple[Slurpy[ArrayRef[~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]]]]"
        #     Array elements from index 0 are slurped into a arrayref which is constrained with "ArrayRef[~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]]"
        #     Reference [["a"]] did not pass type constraint "ArrayRef[~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]]" (in $SLURPY)
        #     "ArrayRef[~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]]" constrains each value in the array with "~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]"
        #     "~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]" requires that the value pass "Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]" or "~ArrayRef"
        #     Reference ["a"] did not pass type constraint "~ArrayRef"
        #         Reference ["a"] did not pass type constraint "~ArrayRef"
        #         "~ArrayRef" is defined as: (not((ref($_) eq 'ARRAY')))
        #     Reference ["a"] did not pass type constraint "Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]"
        #         Reference ["a"] did not pass type constraint "Tuple[Slurpy[ArrayRef[Ref(folderInteger.json)]]]"
        #         Array elements from index 0 are slurped into a arrayref which is constrained with "ArrayRef[Ref(folderInteger.json)]"
        #         Reference ["a"] did not pass type constraint "ArrayRef[Ref(folderInteger.json)]" (in $SLURPY)
        #         "ArrayRef[Ref(folderInteger.json)]" constrains each value in the array with "Ref(folderInteger.json)"
        #         ref schema is {"type":"integer"}
        # Value "a" did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); } (in $SLURPY->[0])
        #         "Ref(folderInteger.json)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # {
        #   '$id' => 'http://localhost:1234/scope_change_defs1.json',
        #   'definitions' => {
        #     'baz' => {
        #       '$id' => 'folder/',
        #       'items' => {
        #         '$ref' => 'folderInteger.json'
        #       },
        #       'type' => 'array'
        #     }
        #   },
        #   'properties' => {
        #     'list' => {
        #       '$ref' => '#/definitions/baz'
        #     }
        #   },
        #   'type' => 'object'
        # }
        # "Properties[list,Ref(#/definitions/baz)]&Object" requires that the value pass "Object" and "Properties[list,Ref(#/definitions/baz)]"
        # Reference {"list" => ["a"]} did not pass type constraint "Properties[list,Ref(#/definitions/baz)]"
        # "Properties[list,Ref(#/definitions/baz)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   '$id' => 'http://localhost:1234/scope_change_defs2.json',
        #   'definitions' => {
        #     'baz' => {
        #       '$id' => 'folder/',
        #       'definitions' => {
        #         'bar' => {
        #           'items' => {
        #             '$ref' => 'folderInteger.json'
        #           },
        #           'type' => 'array'
        #         }
        #       }
        #     }
        #   },
        #   'properties' => {
        #     'list' => {
        #       '$ref' => '#/definitions/baz/definitions/bar'
        #     }
        #   },
        #   'type' => 'object'
        # }
        # "Properties[list,Ref(#/definitions/baz/definitions/bar)]&Object" requires that the value pass "Object" and "Properties[list,Ref(#/definitions/baz/definitions/bar)]"
        # Reference {"list" => ["a"]} did not pass type constraint "Properties[list,Ref(#/definitions/baz/definitions/bar)]"
        # "Properties[list,Ref(#/definitions/baz/definitions/bar)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   '$id' => 'http://localhost:1234/object',
        #   'properties' => {
        #     'name' => {
        #       '$ref' => 'name.json#/definitions/orNull'
        #     }
        #   },
        #   'type' => 'object'
        # }
        # "Properties[name,Ref(name.json#/definitions/orNull)]&Object" requires that the value pass "Object" and "Properties[name,Ref(name.json#/definitions/orNull)]"
        # Reference {"name" => {"name" => undef}} did not pass type constraint "Properties[name,Ref(name.json#/definitions/orNull)]"
        # "Properties[name,Ref(name.json#/definitions/orNull)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   'maximum' => '3'
        # }
        # Value "3.5" did not pass type constraint "Maximum[3]"
        # "Maximum[3]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; $_ <= $max unless not StrictNum->check($_); }
        # {
        #   'additionalProperties' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #   'patternProperties' => {},
        #   'properties' => {
        #     'foo' => {
        #       '$ref' => '#'
        #     }
        #   }
        # }
        # "AdditionalProperties[ARRAY(0x32cddb0),0]&PatternProperties[]&Properties[foo,Ref(#)]" requires that the value pass "AdditionalProperties[ARRAY(0x32cddb0),0]", "PatternProperties[]", and "Properties[foo,Ref(#)]"
        # Reference {"bar" => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )} did not pass type constraint "AdditionalProperties[ARRAY(0x32cddb0),0]"
        # "AdditionalProperties[ARRAY(0x32cddb0),0]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my(@add_keys) = grep({my $key = $_; none sub { ref $_ ? $key =~ /$_/ : $key eq $_; } , @$known_properties;} keys %$_); if (eval { do { $type_or_boolean->can('check') } }) { my $obj = $_; return all(sub { $type_or_boolean->check($$obj{$_}); } , @add_keys); } else { return !(@add_keys && !$type_or_boolean); } }
        # "AdditionalProperties[ARRAY(0x32cddb0),0]&PatternProperties[]&Properties[foo,Ref(#)]" requires that the value pass "AdditionalProperties[ARRAY(0x32cddb0),0]", "PatternProperties[]", and "Properties[foo,Ref(#)]"
        # Reference {"foo" => {"bar" => '0'}} did not pass type constraint "Properties[foo,Ref(#)]"
        # "Properties[foo,Ref(#)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   'properties' => {
        #     'bar' => {
        #       '$ref' => '#/properties/foo'
        #     },
        #     'foo' => {
        #       'type' => 'integer'
        #     }
        #   }
        # }
        # Reference {"bar" => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )} did not pass type constraint "Properties[foo,Integer,bar,Ref(#/properties/foo)]"
        # "Properties[foo,Integer,bar,Ref(#/properties/foo)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   'items' => [
        #     {
        #       'type' => 'integer'
        #     },
        #     {
        #       '$ref' => '#/items/0'
        #     }
        #   ]
        # }
        # "~ArrayRef|Tuple[Optional[Integer],Optional[Ref(#/items/0)],Slurpy[Any]]" requires that the value pass "Tuple[Optional[Integer],Optional[Ref(#/items/0)],Slurpy[Any]]" or "~ArrayRef"
        # Reference [1,"foo"] did not pass type constraint "~ArrayRef"
        #     Reference [1,"foo"] did not pass type constraint "~ArrayRef"
        #     "~ArrayRef" is defined as: (not((ref($_) eq 'ARRAY')))
        # Reference [1,"foo"] did not pass type constraint "Tuple[Optional[Integer],Optional[Ref(#/items/0)],Slurpy[Any]]"
        #     Reference [1,"foo"] did not pass type constraint "Tuple[Optional[Integer],Optional[Ref(#/items/0)],Slurpy[Any]]"
        #     "Tuple[Optional[Integer],Optional[Ref(#/items/0)],Slurpy[Any]]" constrains value at index 1 of array with "Optional[Ref(#/items/0)]"
        #     Value "foo" did not pass type constraint "Optional[Ref(#/items/0)]" (in $_->[1])
        #     $_->[1] exists
        #     "Optional[Ref(#/items/0)]" constrains $_->[1] with "Ref(#/items/0)" if it exists
        #     ref schema is {"type":"integer"}
        # Value "foo" did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); } (in $_->[1])
        #     "Ref(#/items/0)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # {
        #   'percent%field' => {
        #     'type' => 'integer'
        #   },
        #   'properties' => {
        #     'percent' => {
        #       '$ref' => '#/percent%25field'
        #     },
        #     'slash' => {
        #       '$ref' => '#/slash~1field'
        #     },
        #     'tilda' => {
        #       '$ref' => '#/tilda~0field'
        #     }
        #   },
        #   'slash/field' => {
        #     'type' => 'integer'
        #   },
        #   'tilda~field' => {
        #     'type' => 'integer'
        #   }
        # }
        # Reference {"slash" => "aoeu"} did not pass type constraint "Properties[percent,Ref(#/percent%25field),tilda,Ref(#/tilda~0field),slash,Ref(#/slash~1field)]"
        # "Properties[percent,Ref(#/percent%25field),tilda,Ref(#/tilda~0field),slash,Ref(#/slash~1field)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # Reference {"tilda" => "aoeu"} did not pass type constraint "Properties[percent,Ref(#/percent%25field),tilda,Ref(#/tilda~0field),slash,Ref(#/slash~1field)]"
        # "Properties[percent,Ref(#/percent%25field),tilda,Ref(#/tilda~0field),slash,Ref(#/slash~1field)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # Reference {"percent" => "aoeu"} did not pass type constraint "Properties[percent,Ref(#/percent%25field),tilda,Ref(#/tilda~0field),slash,Ref(#/slash~1field)]"
        # "Properties[percent,Ref(#/percent%25field),tilda,Ref(#/tilda~0field),slash,Ref(#/slash~1field)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   '$ref' => '#/definitions/c',
        #   'definitions' => {
        #     'a' => {
        #       'type' => 'integer'
        #     },
        #     'b' => {
        #       '$ref' => '#/definitions/a'
        #     },
        #     'c' => {
        #       '$ref' => '#/definitions/b'
        #     }
        #   }
        # }
        # ref schema is {"$ref":"#/definitions/b"}
        # ref schema is {"$ref":"#/definitions/a"}
        # ref schema is {"type":"integer"}
        # Value "a" did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # "Ref(#/definitions/a)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # "Ref(#/definitions/b)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # "Ref(#/definitions/c)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # {
        #   'definitions' => {
        #     'reffed' => {
        #       'type' => 'array'
        #     }
        #   },
        #   'properties' => {
        #     'foo' => {
        #       '$ref' => '#/definitions/reffed',
        #       'maxItems' => 2
        #     }
        #   }
        # }
        # Reference {"foo" => "string"} did not pass type constraint "Properties[foo,Ref(#/definitions/reffed)]"
        # "Properties[foo,Ref(#/definitions/reffed)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   '$ref' => 'http://json-schema.org/draft-04/schema#'
        # }
        # ref schema is {"definitions":{"stringArray":{"type":"array","minItems":1,"uniqueItems":true,"items":{"type":"string"}},"positiveInteger":{"minimum":0,"type":"integer"},"positiveIntegerDefault0":{"allOf":[{"$ref":"#/definitions/positiveInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}}},"default":{},"id":"http://json-schema.org/draft-04/schema#","properties":{"pattern":{"format":"regex","type":"string"},"enum":{"uniqueItems":true,"type":"array","minItems":1},"minProperties":{"$ref":"#/definitions/positiveIntegerDefault0"},"oneOf":{"$ref":"#/definitions/schemaArray"},"default":{},"maximum":{"type":"number"},"minLength":{"$ref":"#/definitions/positiveIntegerDefault0"},"minimum":{"type":"number"},"exclusiveMaximum":{"type":"boolean","default":false},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"uniqueItems":true,"minItems":1,"type":"array","items":{"$ref":"#/definitions/simpleTypes"}}]},"additionalItems":{"default":{},"anyOf":[{"type":"boolean"},{"$ref":"#"}]},"not":{"$ref":"#"},"allOf":{"$ref":"#/definitions/schemaArray"},"properties":{"additionalProperties":{"$ref":"#"},"properties":{},"type":"object","patternProperties":{},"default":{}},"minItems":{"$ref":"#/definitions/positiveIntegerDefault0"},"uniqueItems":{"default":false,"type":"boolean"},"definitions":{"additionalProperties":{"$ref":"#"},"properties":{},"type":"object","patternProperties":{},"default":{}},"title":{"type":"string"},"additionalProperties":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"id":{"format":"uri","type":"string"},"patternProperties":{"patternProperties":{},"default":{},"properties":{},"type":"object","additionalProperties":{"$ref":"#"}},"maxProperties":{"$ref":"#/definitions/positiveInteger"},"$schema":{"type":"string","format":"uri"},"items":{"default":{},"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}]},"anyOf":{"$ref":"#/definitions/schemaArray"},"maxItems":{"$ref":"#/definitions/positiveInteger"},"multipleOf":{"type":"number","exclusiveMinimum":true,"minimum":0},"dependencies":{"additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]},"properties":{},"type":"object","patternProperties":{}},"required":{"$ref":"#/definitions/stringArray"},"maxLength":{"$ref":"#/definitions/positiveInteger"},"description":{"type":"string"},"exclusiveMinimum":{"type":"boolean","default":false}},"$schema":"http://json-schema.org/draft-04/schema#","description":"Core schema meta-schema","type":"object","dependencies":{"exclusiveMinimum":["minimum"],"exclusiveMaximum":["maximum"]}}
        # "Dependency[exclusiveMinimum,ARRAY(0x2ee1998)]&Dependency[exclusiveMaximum,ARRAY(0x2e01890)]&Properties[pattern,String,enum,MinItems[1]&Array&UniqueItems,minProperties,Ref(#/definitions/positiveIntegerDefault0),oneOf,Ref(#/definitions/schemaArray),default,Any,maximum,Number,minLength,Ref(#/definitions/positiveIntegerDefault0),minimum,Number,exclusiveMaximum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(#/definitions/simpleTypes)]]]&MinItems[1]&Array&UniqueItems],additionalItems,AnyOf[Boolean,Ref(#)],not,Ref(#),allOf,Ref(#/definitions/schemaArray),properties,AdditionalProperties[ARRAY(0x2ded8e8),Ref(#)]&PatternProperties[]&Properties[]&Object,minItems,Ref(#/definitions/positiveIntegerDefault0),uniqueItems,Boolean,definitions,AdditionalProperties[ARRAY(0x306f300),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,additionalProperties,AnyOf[Boolean,Ref(#)],id,String,patternProperties,AdditionalProperties[ARRAY(0x307ee98),Ref(#)]&PatternProperties[]&Properties[]&Object,maxProperties,Ref(#/definitions/positiveInteger),"\$schema",String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],anyOf,Ref(#/definitions/schemaArray),maxItems,Ref(#/definitions/positiveInteger),multipleOf,ExclusiveMinimum[0]&Number,dependencies,AdditionalProperties[ARRAY(0x30d42d8),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),maxLength,Ref(#/definitions/positiveInteger),description,String,exclusiveMinimum,Boolean]&Object" requires that the value pass "Dependency[exclusiveMaximum,ARRAY(0x2e01890)]", "Dependency[exclusiveMinimum,ARRAY(0x2ee1998)]", "Object", and "Properties[pattern,String,enum,MinItems[1]&Array&UniqueItems,minProperties,Ref(#/definitions/positiveIntegerDefault0),oneOf,Ref(#/definitions/schemaArray),default,Any,maximum,Number,minLength,Ref(#/definitions/positiveIntegerDefault0),minimum,Number,exclusiveMaximum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(#/definitions/simpleTypes)]]]&MinItems[1]&Array&UniqueItems],additionalItems,AnyOf[Boolean,Ref(#)],not,Ref(#),allOf,Ref(#/definitions/schemaArray),properties,AdditionalProperties[ARRAY(0x2ded8e8),Ref(#)]&PatternProperties[]&Properties[]&Object,minItems,Ref(#/definitions/positiveIntegerDefault0),uniqueItems,Boolean,definitions,AdditionalProperties[ARRAY(0x306f300),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,additionalProperties,AnyOf[Boolean,Ref(#)],id,String,patternProperties,AdditionalProperties[ARRAY(0x307ee98),Ref(#)]&PatternProperties[]&Properties[]&Object,maxProperties,Ref(#/definitions/positiveInteger),"\$schema",String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],anyOf,Ref(#/definitions/schemaArray),maxItems,Ref(#/definitions/positiveInteger),multipleOf,ExclusiveMinimum[0]&Number,dependencies,AdditionalProperties[ARRAY(0x30d42d8),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),maxLength,Ref(#/definitions/positiveInteger),description,String,exclusiveMinimum,Boolean]"
        # Reference {"minLength" => -1} did not pass type constraint "Properties[pattern,String,enum,MinItems[1]&Array&UniqueItems,minProperties,Ref(#/definitions/positiveIntegerDefault0),oneOf,Ref(#/definitions/schemaArray),default,Any,maximum,Number,minLength,Ref(#/definitions/positiveIntegerDefault0),minimum,Number,exclusiveMaximum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(#/definitions/simpleTypes)]]]&MinItems[1]&Array&UniqueItems],additionalItems,AnyOf[Boolean,Ref(#)],not,Ref(#),allOf,Ref(#/definitions/schemaArray),properties,AdditionalProperties[ARRAY(0x2ded8e8),Ref(#)]&PatternProperties[]&Properties[]&Object,minItems,Ref(#/definitions/positiveIntegerDefault0),uniqueItems,Boolean,definitions,AdditionalProperties[ARRAY(0x306f300),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,additionalProperties,AnyOf[Boolean,Ref(#)],id,String,patternProperties,AdditionalProperties[ARRAY(0x307ee98),Ref(#)]&PatternProperties[]&Properties[]&Object,maxProperties,Ref(#/definitions/positiveInteger),"\$schema",String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],anyOf,Ref(#/definitions/schemaArray),maxItems,Ref(#/definitions/positiveInteger),multipleOf,ExclusiveMinimum[0]&Number,dependencies,AdditionalProperties[ARRAY(0x30d42d8),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),maxLength,Ref(#/definitions/positiveInteger),description,String,exclusiveMinimum,Boolean]"
        # "Properties[pattern,String,enum,MinItems[1]&Array&UniqueItems,minProperties,Ref(#/definitions/positiveIntegerDefault0),oneOf,Ref(#/definitions/schemaArray),default,Any,maximum,Number,minLength,Ref(#/definitions/positiveIntegerDefault0),minimum,Number,exclusiveMaximum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(#/definitions/simpleTypes)]]]&MinItems[1]&Array&UniqueItems],additionalItems,AnyOf[Boolean,Ref(#)],not,Ref(#),allOf,Ref(#/definitions/schemaArray),properties,AdditionalProperties[ARRAY(0x2ded8e8),Ref(#)]&PatternProperties[]&Properties[]&Object,minItems,Ref(#/definitions/positiveIntegerDefault0),uniqueItems,Boolean,definitions,AdditionalProperties[ARRAY(0x306f300),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,additionalProperties,AnyOf[Boolean,Ref(#)],id,String,patternProperties,AdditionalProperties[ARRAY(0x307ee98),Ref(#)]&PatternProperties[]&Properties[]&Object,maxProperties,Ref(#/definitions/positiveInteger),"\$schema",String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],anyOf,Ref(#/definitions/schemaArray),maxItems,Ref(#/definitions/positiveInteger),multipleOf,ExclusiveMinimum[0]&Number,dependencies,AdditionalProperties[ARRAY(0x30d42d8),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),maxLength,Ref(#/definitions/positiveInteger),description,String,exclusiveMinimum,Boolean]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # "Ref(http://json-schema.org/draft-04/schema#)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # {
        #   'properties' => {
        #     '$ref' => {
        #       'type' => 'string'
        #     }
        #   }
        # }
        # Reference {"\$ref" => 2} did not pass type constraint "Properties["\$ref",String]"
        # "Properties["\$ref",String]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   '$ref' => '#/definitions/bool',
        #   'definitions' => {
        #     'bool' => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )
        #   }
        # }
        # {
        #   '$ref' => '#/definitions/bool',
        #   'definitions' => {
        #     'bool' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        #   }
        # }
        # ref schema is false
        # Value "foo" did not pass type constraint "None"
        # "None" is defined as: (not((!!1)))
        # "Ref(#/definitions/bool)" is defined as: sub { package JSON::Schema::AsType::Draft4; my $r = $self->resolve_reference($ref); $r->check($_); }
        # {
        #   '$id' => 'http://localhost:1234/tree',
        #   'definitions' => {
        #     'node' => {
        #       '$id' => 'http://localhost:1234/node',
        #       'description' => 'node',
        #       'properties' => {
        #         'subtree' => {
        #           '$ref' => 'tree'
        #         },
        #         'value' => {
        #           'type' => 'number'
        #         }
        #       },
        #       'required' => [
        #         'value'
        #       ],
        #       'type' => 'object'
        #     }
        #   },
        #   'description' => 'tree of nodes',
        #   'properties' => {
        #     'meta' => {
        #       'type' => 'string'
        #     },
        #     'nodes' => {
        #       'items' => {
        #         '$ref' => 'node'
        #       },
        #       'type' => 'array'
        #     }
        #   },
        #   'required' => [
        #     'meta',
        #     'nodes'
        #   ],
        #   'type' => 'object'
        # }
        # "Properties[nodes,~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(node)]]]&Array,meta,String]&Required[meta,nodes]&Object" requires that the value pass "Object", "Properties[nodes,~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(node)]]]&Array,meta,String]", and "Required[meta,nodes]"
        # Reference {"meta" => "root","nodes" => ['HASH(0x38c68a8)','HASH(0x38b98d8)']} did not pass type constraint "Properties[nodes,~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(node)]]]&Array,meta,String]"
        # "Properties[nodes,~ArrayRef|Tuple[Slurpy[ArrayRef[Ref(node)]]]&Array,meta,String]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   'contains' => {
        #     'minimum' => 5
        #   }
        # }
        # Reference [2,3,4] did not pass type constraint "Contains[Minimum[5]]"
        # "Contains[Minimum[5]]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Array->check($_); if (Boolean->check($type)) { (); } return any(sub { $type->check($_); } , @$_); }
        # Reference [] did not pass type constraint "Contains[Minimum[5]]"
        # "Contains[Minimum[5]]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Array->check($_); if (Boolean->check($type)) { (); } return any(sub { $type->check($_); } , @$_); }
        # {
        #   'contains' => {
        #     'const' => 5
        #   }
        # }
        # Reference [1,2,3,4] did not pass type constraint "Contains[Enum[5]]"
        # "Contains[Enum[5]]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Array->check($_); if (Boolean->check($type)) { (); } return any(sub { $type->check($_); } , @$_); }
        # {
        #   'contains' => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )
        # }
        # Reference [] did not pass type constraint "Contains[Any]"
        # "Contains[Any]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Array->check($_); if (Boolean->check($type)) { (); } return any(sub { $type->check($_); } , @$_); }
        # {
        #   'contains' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        # }
        # Reference ["foo"] did not pass type constraint "Contains[None]"
        # "Contains[None]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Array->check($_); if (Boolean->check($type)) { (); } return any(sub { $type->check($_); } , @$_); }
        # Reference [] did not pass type constraint "Contains[None]"
        # "Contains[None]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Array->check($_); if (Boolean->check($type)) { (); } return any(sub { $type->check($_); } , @$_); }
        # {
        #   'patternProperties' => {
        #     'f.*o' => {
        #       'type' => 'integer'
        #     }
        #   }
        # }
        # Reference {"foo" => "bar","fooooo" => 2} did not pass type constraint "PatternProperties["f.*o",Integer]"
        # "PatternProperties["f.*o",Integer]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; foreach my $key (keys %props) { return unless all sub { $props{$key}->check($$obj{$_}); } , grep({/$key/;} keys %$_); } return 1; }
        # Reference {"foo" => "bar","foooooo" => "baz"} did not pass type constraint "PatternProperties["f.*o",Integer]"
        # "PatternProperties["f.*o",Integer]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; foreach my $key (keys %props) { return unless all sub { $props{$key}->check($$obj{$_}); } , grep({/$key/;} keys %$_); } return 1; }
        # {
        #   'patternProperties' => {
        #     'a*' => {
        #       'type' => 'integer'
        #     },
        #     'aaa*' => {
        #       'maximum' => 20
        #     }
        #   }
        # }
        # Reference {"a" => "bar"} did not pass type constraint "PatternProperties["a*",Integer,"aaa*",Maximum[20]]"
        # "PatternProperties["a*",Integer,"aaa*",Maximum[20]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; foreach my $key (keys %props) { return unless all sub { $props{$key}->check($$obj{$_}); } , grep({/$key/;} keys %$_); } return 1; }
        # Reference {"aaaa" => 31} did not pass type constraint "PatternProperties["a*",Integer,"aaa*",Maximum[20]]"
        # "PatternProperties["a*",Integer,"aaa*",Maximum[20]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; foreach my $key (keys %props) { return unless all sub { $props{$key}->check($$obj{$_}); } , grep({/$key/;} keys %$_); } return 1; }
        # Reference {"aaa" => "foo","aaaa" => 31} did not pass type constraint "PatternProperties["a*",Integer,"aaa*",Maximum[20]]"
        # "PatternProperties["a*",Integer,"aaa*",Maximum[20]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; foreach my $key (keys %props) { return unless all sub { $props{$key}->check($$obj{$_}); } , grep({/$key/;} keys %$_); } return 1; }
        # {
        #   'patternProperties' => {
        #     'X_' => {
        #       'type' => 'string'
        #     },
        #     '[0-9]{2,}' => {
        #       'type' => 'boolean'
        #     }
        #   }
        # }
        # Reference {"a31b" => undef} did not pass type constraint "PatternProperties[X_,String,"[0-9]{2,}",Boolean]"
        # "PatternProperties[X_,String,"[0-9]{2,}",Boolean]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; foreach my $key (keys %props) { return unless all sub { $props{$key}->check($$obj{$_}); } , grep({/$key/;} keys %$_); } return 1; }
        # Reference {"a_X_3" => 3} did not pass type constraint "PatternProperties[X_,String,"[0-9]{2,}",Boolean]"
        # "PatternProperties[X_,String,"[0-9]{2,}",Boolean]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; foreach my $key (keys %props) { return unless all sub { $props{$key}->check($$obj{$_}); } , grep({/$key/;} keys %$_); } return 1; }
        # {
        #   'patternProperties' => {
        #     'b.*' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #     'f.*' => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )
        #   }
        # }
        # Reference {"bar" => 2} did not pass type constraint "PatternProperties["f.*",Any,"b.*",None]"
        # "PatternProperties["f.*",Any,"b.*",None]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; foreach my $key (keys %props) { return unless all sub { $props{$key}->check($$obj{$_}); } , grep({/$key/;} keys %$_); } return 1; }
        # Reference {"bar" => 2,"foo" => 1} did not pass type constraint "PatternProperties["f.*",Any,"b.*",None]"
        # "PatternProperties["f.*",Any,"b.*",None]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; foreach my $key (keys %props) { return unless all sub { $props{$key}->check($$obj{$_}); } , grep({/$key/;} keys %$_); } return 1; }
        # {
        #   'additionalProperties' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #   'patternProperties' => {
        #     '^v' => {}
        #   },
        #   'properties' => {
        #     'bar' => {},
        #     'foo' => {}
        #   }
        # }
        # "AdditionalProperties[ARRAY(0x38ca610),0]&PatternProperties["^v",Any]&Properties[bar,Any,foo,Any]" requires that the value pass "AdditionalProperties[ARRAY(0x38ca610),0]", "PatternProperties["^v",Any]", and "Properties[bar,Any,foo,Any]"
        # Reference {"bar" => 2,"foo" => 1,"quux" => "boom"} did not pass type constraint "AdditionalProperties[ARRAY(0x38ca610),0]"
        # "AdditionalProperties[ARRAY(0x38ca610),0]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my(@add_keys) = grep({my $key = $_; none sub { ref $_ ? $key =~ /$_/ : $key eq $_; } , @$known_properties;} keys %$_); if (eval { do { $type_or_boolean->can('check') } }) { my $obj = $_; return all(sub { $type_or_boolean->check($$obj{$_}); } , @add_keys); } else { return !(@add_keys && !$type_or_boolean); } }
        # {
        #   'additionalProperties' => {
        #     'type' => 'boolean'
        #   },
        #   'patternProperties' => {},
        #   'properties' => {
        #     'bar' => {},
        #     'foo' => {}
        #   }
        # }
        # "AdditionalProperties[ARRAY(0x39ac9c0),Boolean]&PatternProperties[]&Properties[bar,Any,foo,Any]" requires that the value pass "AdditionalProperties[ARRAY(0x39ac9c0),Boolean]", "PatternProperties[]", and "Properties[bar,Any,foo,Any]"
        # Reference {"bar" => 2,"foo" => 1,"quux" => 12} did not pass type constraint "AdditionalProperties[ARRAY(0x39ac9c0),Boolean]"
        # "AdditionalProperties[ARRAY(0x39ac9c0),Boolean]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my(@add_keys) = grep({my $key = $_; none sub { ref $_ ? $key =~ /$_/ : $key eq $_; } , @$known_properties;} keys %$_); if (eval { do { $type_or_boolean->can('check') } }) { my $obj = $_; return all(sub { $type_or_boolean->check($$obj{$_}); } , @add_keys); } else { return !(@add_keys && !$type_or_boolean); } }
        # {
        #   'additionalProperties' => {
        #     'type' => 'boolean'
        #   },
        #   'patternProperties' => {},
        #   'properties' => {}
        # }
        # "AdditionalProperties[ARRAY(0x39eac60),Boolean]&PatternProperties[]&Properties[]" requires that the value pass "AdditionalProperties[ARRAY(0x39eac60),Boolean]", "PatternProperties[]", and "Properties[]"
        # Reference {"foo" => 1} did not pass type constraint "AdditionalProperties[ARRAY(0x39eac60),Boolean]"
        # "AdditionalProperties[ARRAY(0x39eac60),Boolean]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my(@add_keys) = grep({my $key = $_; none sub { ref $_ ? $key =~ /$_/ : $key eq $_; } , @$known_properties;} keys %$_); if (eval { do { $type_or_boolean->can('check') } }) { my $obj = $_; return all(sub { $type_or_boolean->check($$obj{$_}); } , @add_keys); } else { return !(@add_keys && !$type_or_boolean); } }
        # {
        #   'properties' => {
        #     'bar' => {},
        #     'foo' => {}
        #   }
        # }
        # {
        #   'allOf' => [
        #     {
        #       'properties' => {
        #         'bar' => {
        #           'type' => 'integer'
        #         }
        #       },
        #       'required' => [
        #         'bar'
        #       ]
        #     },
        #     {
        #       'properties' => {
        #         'foo' => {
        #           'type' => 'string'
        #         }
        #       },
        #       'required' => [
        #         'foo'
        #       ]
        #     }
        #   ]
        # }
        # Reference {"foo" => "baz"} did not pass type constraint "AllOf[Properties[bar,Integer]&Required[bar],Properties[foo,String]&Required[foo]]"
        # "AllOf[Properties[bar,Integer]&Required[bar],Properties[foo,String]&Required[foo]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; all sub { $_->check($v); } , @types; }
        # Reference {"bar" => 2} did not pass type constraint "AllOf[Properties[bar,Integer]&Required[bar],Properties[foo,String]&Required[foo]]"
        # "AllOf[Properties[bar,Integer]&Required[bar],Properties[foo,String]&Required[foo]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; all sub { $_->check($v); } , @types; }
        # Reference {"bar" => "quux","foo" => "baz"} did not pass type constraint "AllOf[Properties[bar,Integer]&Required[bar],Properties[foo,String]&Required[foo]]"
        # "AllOf[Properties[bar,Integer]&Required[bar],Properties[foo,String]&Required[foo]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; all sub { $_->check($v); } , @types; }
        # {
        #   'allOf' => [
        #     {
        #       'properties' => {
        #         'foo' => {
        #           'type' => 'string'
        #         }
        #       },
        #       'required' => [
        #         'foo'
        #       ]
        #     },
        #     {
        #       'properties' => {
        #         'baz' => {
        #           'type' => 'null'
        #         }
        #       },
        #       'required' => [
        #         'baz'
        #       ]
        #     }
        #   ],
        #   'properties' => {
        #     'bar' => {
        #       'type' => 'integer'
        #     }
        #   },
        #   'required' => [
        #     'bar'
        #   ]
        # }
        # "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]&Properties[bar,Integer]&Required[bar]" requires that the value pass "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]", "Properties[bar,Integer]", and "Required[bar]"
        # Reference {"baz" => undef,"foo" => "quux"} did not pass type constraint "Required[bar]"
        # "Required[bar]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; all sub { exists $$obj{$_}; } , @keys; }
        # "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]&Properties[bar,Integer]&Required[bar]" requires that the value pass "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]", "Properties[bar,Integer]", and "Required[bar]"
        # Reference {"bar" => 2,"baz" => undef} did not pass type constraint "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]"
        # "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; all sub { $_->check($v); } , @types; }
        # "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]&Properties[bar,Integer]&Required[bar]" requires that the value pass "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]", "Properties[bar,Integer]", and "Required[bar]"
        # Reference {"bar" => 2,"foo" => "quux"} did not pass type constraint "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]"
        # "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; all sub { $_->check($v); } , @types; }
        # "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]&Properties[bar,Integer]&Required[bar]" requires that the value pass "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]", "Properties[bar,Integer]", and "Required[bar]"
        # Reference {"bar" => 2} did not pass type constraint "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]"
        # "AllOf[Properties[foo,String]&Required[foo],Properties[baz,Null]&Required[baz]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; all sub { $_->check($v); } , @types; }
        # {
        #   'allOf' => [
        #     {
        #       'maximum' => 30
        #     },
        #     {
        #       'minimum' => 20
        #     }
        #   ]
        # }
        # Value "35" did not pass type constraint "AllOf[Maximum[30],Minimum[20]]"
        # "AllOf[Maximum[30],Minimum[20]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; all sub { $_->check($v); } , @types; }
        # {
        #   'allOf' => [
        #     bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
        #     $VAR1->{'allOf'}[0]
        #   ]
        # }
        # {
        #   'allOf' => [
        #     bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
        #     bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        #   ]
        # }
        # Value "foo" did not pass type constraint "AllOf[Any,None]"
        # "AllOf[Any,None]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; all sub { $_->check($v); } , @types; }
        # {
        #   'allOf' => [
        #     bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #     $VAR1->{'allOf'}[0]
        #   ]
        # }
        # Value "foo" did not pass type constraint "AllOf[None,None]"
        # "AllOf[None,None]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; all sub { $_->check($v); } , @types; }
        # {
        #   'uniqueItems' => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )
        # }
        # Reference [1,1] did not pass type constraint "UniqueItems"
        # "UniqueItems" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Array->check($_); @$_ == uniq(map({to_json $_, {'allow_nonref', 1};} @$_)); }
        # Reference [1,1,1] did not pass type constraint "UniqueItems"
        # "UniqueItems" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Array->check($_); @$_ == uniq(map({to_json $_, {'allow_nonref', 1};} @$_)); }
        # Reference [{"foo" => "bar"},{"foo" => "bar"}] did not pass type constraint "UniqueItems"
        # "UniqueItems" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Array->check($_); @$_ == uniq(map({to_json $_, {'allow_nonref', 1};} @$_)); }
        # Reference [{"foo" => 'HASH(0x417b050)'},{"foo" => 'HASH(0x3978e20)'}] did not pass type constraint "UniqueItems"
        # "UniqueItems" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Array->check($_); @$_ == uniq(map({to_json $_, {'allow_nonref', 1};} @$_)); }
        # Reference [["foo"],["foo"]] did not pass type constraint "UniqueItems"
        # "UniqueItems" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Array->check($_); @$_ == uniq(map({to_json $_, {'allow_nonref', 1};} @$_)); }
        # Reference [{},[1],bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),undef,{},1] did not pass type constraint "UniqueItems"
        # "UniqueItems" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Array->check($_); @$_ == uniq(map({to_json $_, {'allow_nonref', 1};} @$_)); }
        # {
        #   'not' => {
        #     'type' => 'integer'
        #   }
        # }
        # Value "1" did not pass type constraint "Not[__ANON__]"
        # "Not[__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not $type->check($_); }
        # {
        #   'not' => {
        #     'type' => [
        #       'integer',
        #       'boolean'
        #     ]
        #   }
        # }
        # Value "1" did not pass type constraint "Not[__ANON__]"
        # "Not[__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not $type->check($_); }
        # Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) did not pass type constraint "Not[__ANON__]"
        # "Not[__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not $type->check($_); }
        # {
        #   'not' => {
        #     'properties' => {
        #       'foo' => {
        #         'type' => 'string'
        #       }
        #     },
        #     'type' => 'object'
        #   }
        # }
        # Reference {"foo" => "bar"} did not pass type constraint "Not[__ANON__]"
        # "Not[__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not $type->check($_); }
        # {
        #   'properties' => {
        #     'foo' => {
        #       'not' => {}
        #     }
        #   }
        # }
        # Reference {"bar" => 2,"foo" => 1} did not pass type constraint "Properties[foo,Not[__ANON__]]"
        # "Properties[foo,Not[__ANON__]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   'not' => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )
        # }
        # Value "foo" did not pass type constraint "Not[__ANON__]"
        # "Not[__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not $type->check($_); }
        # {
        #   'not' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        # }
        # {
        #   'properties' => {
        #     'bar' => {
        #       'type' => 'string'
        #     },
        #     'foo' => {
        #       'type' => 'integer'
        #     }
        #   }
        # }
        # Reference {"bar" => {},"foo" => 1} did not pass type constraint "Properties[foo,Integer,bar,String]"
        # "Properties[foo,Integer,bar,String]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # Reference {"bar" => {},"foo" => []} did not pass type constraint "Properties[foo,Integer,bar,String]"
        # "Properties[foo,Integer,bar,String]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   'additionalProperties' => {
        #     'type' => 'integer'
        #   },
        #   'patternProperties' => {
        #     'f.o' => {
        #       'minItems' => 2
        #     }
        #   },
        #   'properties' => {
        #     'bar' => {
        #       'type' => 'array'
        #     },
        #     'foo' => {
        #       'maxItems' => 3,
        #       'type' => 'array'
        #     }
        #   }
        # }
        # "AdditionalProperties[ARRAY(0x395c138),Integer]&PatternProperties["f.o",MinItems[2]]&Properties[foo,MaxItems[3]&Array,bar,Array]" requires that the value pass "AdditionalProperties[ARRAY(0x395c138),Integer]", "PatternProperties["f.o",MinItems[2]]", and "Properties[foo,MaxItems[3]&Array,bar,Array]"
        # Reference {"foo" => [1,2,3,4]} did not pass type constraint "Properties[foo,MaxItems[3]&Array,bar,Array]"
        # "Properties[foo,MaxItems[3]&Array,bar,Array]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # "AdditionalProperties[ARRAY(0x395c138),Integer]&PatternProperties["f.o",MinItems[2]]&Properties[foo,MaxItems[3]&Array,bar,Array]" requires that the value pass "AdditionalProperties[ARRAY(0x395c138),Integer]", "PatternProperties["f.o",MinItems[2]]", and "Properties[foo,MaxItems[3]&Array,bar,Array]"
        # Reference {"foo" => []} did not pass type constraint "PatternProperties["f.o",MinItems[2]]"
        # "PatternProperties["f.o",MinItems[2]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; foreach my $key (keys %props) { return unless all sub { $props{$key}->check($$obj{$_}); } , grep({/$key/;} keys %$_); } return 1; }
        # "AdditionalProperties[ARRAY(0x395c138),Integer]&PatternProperties["f.o",MinItems[2]]&Properties[foo,MaxItems[3]&Array,bar,Array]" requires that the value pass "AdditionalProperties[ARRAY(0x395c138),Integer]", "PatternProperties["f.o",MinItems[2]]", and "Properties[foo,MaxItems[3]&Array,bar,Array]"
        # Reference {"fxo" => []} did not pass type constraint "PatternProperties["f.o",MinItems[2]]"
        # "PatternProperties["f.o",MinItems[2]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; foreach my $key (keys %props) { return unless all sub { $props{$key}->check($$obj{$_}); } , grep({/$key/;} keys %$_); } return 1; }
        # "AdditionalProperties[ARRAY(0x395c138),Integer]&PatternProperties["f.o",MinItems[2]]&Properties[foo,MaxItems[3]&Array,bar,Array]" requires that the value pass "AdditionalProperties[ARRAY(0x395c138),Integer]", "PatternProperties["f.o",MinItems[2]]", and "Properties[foo,MaxItems[3]&Array,bar,Array]"
        # Reference {"quux" => "foo"} did not pass type constraint "AdditionalProperties[ARRAY(0x395c138),Integer]"
        # "AdditionalProperties[ARRAY(0x395c138),Integer]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my(@add_keys) = grep({my $key = $_; none sub { ref $_ ? $key =~ /$_/ : $key eq $_; } , @$known_properties;} keys %$_); if (eval { do { $type_or_boolean->can('check') } }) { my $obj = $_; return all(sub { $type_or_boolean->check($$obj{$_}); } , @add_keys); } else { return !(@add_keys && !$type_or_boolean); } }
        # {
        #   'properties' => {
        #     'bar' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #     'foo' => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )
        #   }
        # }
        # Reference {"bar" => 2} did not pass type constraint "Properties[bar,None,foo,Any]"
        # "Properties[bar,None,foo,Any]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # Reference {"bar" => 2,"foo" => 1} did not pass type constraint "Properties[bar,None,foo,Any]"
        # "Properties[bar,None,foo,Any]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); return $type->check($_); }
        # {
        #   'exclusiveMaximum' => '3'
        # }
        # Value "3" did not pass type constraint "ExclusiveMaximum[3]"
        # "ExclusiveMaximum[3]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; $_ < $max unless not StrictNum->check($_); }
        # Value "3.5" did not pass type constraint "ExclusiveMaximum[3]"
        # "ExclusiveMaximum[3]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; $_ < $max unless not StrictNum->check($_); }
        # {
        #   'propertyNames' => {
        #     'maxLength' => 3
        #   }
        # }
        # Reference {"foo" => {},"foobar" => {}} did not pass type constraint "PropertyNames[MaxLength[3]]"
        # "PropertyNames[MaxLength[3]]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Object->check($_); return 1 if $type eq Any; return !keys(%$_) if $type eq ~Any; return all(sub { $type->check($_); } , keys %$_); }
        # {
        #   'propertyNames' => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )
        # }
        # {
        #   'propertyNames' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        # }
        # Reference {"foo" => 1} did not pass type constraint "PropertyNames[None]"
        # "PropertyNames[None]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Object->check($_); return 1 if $type eq Any; return !keys(%$_) if $type eq ~Any; return all(sub { $type->check($_); } , keys %$_); }
        # {
        #   'maxLength' => 2
        # }
        # Value "foo" did not pass type constraint "MaxLength[2]"
        # "MaxLength[2]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; $length >= length $_ unless not String->check($_); }
        # {
        #   'anyOf' => [
        #     {
        #       'type' => 'integer'
        #     },
        #     {
        #       'minimum' => 2
        #     }
        #   ]
        # }
        # Value "1.5" did not pass type constraint "AnyOf[Integer,Minimum[2]]"
        # "AnyOf[Integer,Minimum[2]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; any sub { $_->check($v); } , @types; }
        # {
        #   'anyOf' => [
        #     {
        #       'maxLength' => 2
        #     },
        #     {
        #       'minLength' => 4
        #     }
        #   ],
        #   'type' => 'string'
        # }
        # "AnyOf[MaxLength[2],MinLength[4]]&String" requires that the value pass "AnyOf[MaxLength[2],MinLength[4]]" and "String"
        # Value "3" did not pass type constraint "String"
        # "String" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 16384; }
        # "AnyOf[MaxLength[2],MinLength[4]]&String" requires that the value pass "AnyOf[MaxLength[2],MinLength[4]]" and "String"
        # Value "foo" did not pass type constraint "AnyOf[MaxLength[2],MinLength[4]]"
        # "AnyOf[MaxLength[2],MinLength[4]]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; any sub { $_->check($v); } , @types; }
        # {
        #   'anyOf' => [
        #     bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
        #     $VAR1->{'anyOf'}[0]
        #   ]
        # }
        # {
        #   'anyOf' => [
        #     bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
        #     bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        #   ]
        # }
        # {
        #   'anyOf' => [
        #     bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #     $VAR1->{'anyOf'}[0]
        #   ]
        # }
        # Value "foo" did not pass type constraint "AnyOf[None,None]"
        # "AnyOf[None,None]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; any sub { $_->check($v); } , @types; }
        # {
        #   'multipleOf' => 2
        # }
        # Value "7" did not pass type constraint "MultipleOf[2]"
        # "MultipleOf[2]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not Number->check($_) && ($_ / $num) =~ /\./; }
        # {
        #   'multipleOf' => '1.5'
        # }
        # Value "35" did not pass type constraint "MultipleOf["1.5"]"
        # "MultipleOf["1.5"]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not Number->check($_) && ($_ / $num) =~ /\./; }
        # {
        #   'multipleOf' => '0.0001'
        # }
        # Value "0.00751" did not pass type constraint "MultipleOf["0.0001"]"
        # "MultipleOf["0.0001"]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not Number->check($_) && ($_ / $num) =~ /\./; }
        # {
        #   'oneOf' => [
        #     {
        #       'type' => 'integer'
        #     },
        #     {
        #       'minimum' => 2
        #     }
        #   ]
        # }
        # Value "3" did not pass type constraint "OneOf[__ANON__,__ANON__]"
        # "OneOf[__ANON__,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; 1 == grep({$_->check($v);} @types); }
        # Value "1.5" did not pass type constraint "OneOf[__ANON__,__ANON__]"
        # "OneOf[__ANON__,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; 1 == grep({$_->check($v);} @types); }
        # {
        #   'oneOf' => [
        #     {
        #       'minLength' => 2
        #     },
        #     {
        #       'maxLength' => 4
        #     }
        #   ],
        #   'type' => 'string'
        # }
        # "OneOf[__ANON__,__ANON__]&String" requires that the value pass "OneOf[__ANON__,__ANON__]" and "String"
        # Value "3" did not pass type constraint "OneOf[__ANON__,__ANON__]"
        # "OneOf[__ANON__,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; 1 == grep({$_->check($v);} @types); }
        # "OneOf[__ANON__,__ANON__]&String" requires that the value pass "OneOf[__ANON__,__ANON__]" and "String"
        # Value "foo" did not pass type constraint "OneOf[__ANON__,__ANON__]"
        # "OneOf[__ANON__,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; 1 == grep({$_->check($v);} @types); }
        # {
        #   'oneOf' => [
        #     bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
        #     $VAR1->{'oneOf'}[0],
        #     $VAR1->{'oneOf'}[0]
        #   ]
        # }
        # Value "foo" did not pass type constraint "OneOf[__ANON__,__ANON__,__ANON__]"
        # "OneOf[__ANON__,__ANON__,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; 1 == grep({$_->check($v);} @types); }
        # {
        #   'oneOf' => [
        #     bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
        #     bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #     $VAR1->{'oneOf'}[1]
        #   ]
        # }
        # {
        #   'oneOf' => [
        #     bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
        #     $VAR1->{'oneOf'}[0],
        #     bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        #   ]
        # }
        # Value "foo" did not pass type constraint "OneOf[__ANON__,__ANON__,__ANON__]"
        # "OneOf[__ANON__,__ANON__,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; 1 == grep({$_->check($v);} @types); }
        # {
        #   'oneOf' => [
        #     bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #     $VAR1->{'oneOf'}[0],
        #     $VAR1->{'oneOf'}[0]
        #   ]
        # }
        # Value "foo" did not pass type constraint "OneOf[__ANON__,__ANON__,__ANON__]"
        # "OneOf[__ANON__,__ANON__,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; 1 == grep({$_->check($v);} @types); }
        # {
        #   'maxItems' => 2
        # }
        # Reference [1,2,3] did not pass type constraint "MaxItems[2]"
        # "MaxItems[2]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; @$_ <= $max unless ref $_ ne 'ARRAY'; }
        # {
        #   'dependencies' => {
        #     'bar' => [
        #       'foo'
        #     ]
        #   }
        # }
        # Reference {"bar" => 2} did not pass type constraint "Dependency[bar,ARRAY(0x38c5de8)]"
        # "Dependency[bar,ARRAY(0x38c5de8)]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Object->check($_); return 1 unless exists $$_{$property}; my $obj = $_; return all(sub { exists $$obj{$_}; } , @$dep) if ref $dep eq 'ARRAY'; return exists $$obj{$dep} unless ref $dep; return $dep->check($_); }
        # {
        #   'dependencies' => {
        #     'bar' => []
        #   }
        # }
        # {
        #   'dependencies' => {
        #     'quux' => [
        #       'foo',
        #       'bar'
        #     ]
        #   }
        # }
        # Reference {"foo" => 1,"quux" => 2} did not pass type constraint "Dependency[quux,ARRAY(0x42147d8)]"
        # "Dependency[quux,ARRAY(0x42147d8)]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Object->check($_); return 1 unless exists $$_{$property}; my $obj = $_; return all(sub { exists $$obj{$_}; } , @$dep) if ref $dep eq 'ARRAY'; return exists $$obj{$dep} unless ref $dep; return $dep->check($_); }
        # Reference {"bar" => 1,"quux" => 2} did not pass type constraint "Dependency[quux,ARRAY(0x42147d8)]"
        # "Dependency[quux,ARRAY(0x42147d8)]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Object->check($_); return 1 unless exists $$_{$property}; my $obj = $_; return all(sub { exists $$obj{$_}; } , @$dep) if ref $dep eq 'ARRAY'; return exists $$obj{$dep} unless ref $dep; return $dep->check($_); }
        # Reference {"quux" => 1} did not pass type constraint "Dependency[quux,ARRAY(0x42147d8)]"
        # "Dependency[quux,ARRAY(0x42147d8)]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Object->check($_); return 1 unless exists $$_{$property}; my $obj = $_; return all(sub { exists $$obj{$_}; } , @$dep) if ref $dep eq 'ARRAY'; return exists $$obj{$dep} unless ref $dep; return $dep->check($_); }
        # {
        #   'dependencies' => {
        #     'bar' => {
        #       'properties' => {
        #         'bar' => {
        #           'type' => 'integer'
        #         },
        #         'foo' => {
        #           'type' => 'integer'
        #         }
        #       }
        #     }
        #   }
        # }
        # Reference {"bar" => 2,"foo" => "quux"} did not pass type constraint "Dependency[bar,__ANON__]"
        # "Dependency[bar,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Object->check($_); return 1 unless exists $$_{$property}; my $obj = $_; return all(sub { exists $$obj{$_}; } , @$dep) if ref $dep eq 'ARRAY'; return exists $$obj{$dep} unless ref $dep; return $dep->check($_); }
        # Reference {"bar" => "quux","foo" => 2} did not pass type constraint "Dependency[bar,__ANON__]"
        # "Dependency[bar,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Object->check($_); return 1 unless exists $$_{$property}; my $obj = $_; return all(sub { exists $$obj{$_}; } , @$dep) if ref $dep eq 'ARRAY'; return exists $$obj{$dep} unless ref $dep; return $dep->check($_); }
        # Reference {"bar" => "quux","foo" => "quux"} did not pass type constraint "Dependency[bar,__ANON__]"
        # "Dependency[bar,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Object->check($_); return 1 unless exists $$_{$property}; my $obj = $_; return all(sub { exists $$obj{$_}; } , @$dep) if ref $dep eq 'ARRAY'; return exists $$obj{$dep} unless ref $dep; return $dep->check($_); }
        # {
        #   'dependencies' => {
        #     'bar' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #     'foo' => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )
        #   }
        # }
        # "Dependency[foo,__ANON__]&Dependency[bar,__ANON__]" requires that the value pass "Dependency[bar,__ANON__]" and "Dependency[foo,__ANON__]"
        # Reference {"bar" => 2} did not pass type constraint "Dependency[bar,__ANON__]"
        # "Dependency[bar,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Object->check($_); return 1 unless exists $$_{$property}; my $obj = $_; return all(sub { exists $$obj{$_}; } , @$dep) if ref $dep eq 'ARRAY'; return exists $$obj{$dep} unless ref $dep; return $dep->check($_); }
        # "Dependency[foo,__ANON__]&Dependency[bar,__ANON__]" requires that the value pass "Dependency[bar,__ANON__]" and "Dependency[foo,__ANON__]"
        # Reference {"bar" => 2,"foo" => 1} did not pass type constraint "Dependency[bar,__ANON__]"
        # "Dependency[bar,__ANON__]" is defined as: sub { package JSON::Schema::AsType::Draft6::Types; return 1 unless Object->check($_); return 1 unless exists $$_{$property}; my $obj = $_; return all(sub { exists $$obj{$_}; } , @$dep) if ref $dep eq 'ARRAY'; return exists $$obj{$dep} unless ref $dep; return $dep->check($_); }
        # {
        #   'items' => {
        #     'type' => 'integer'
        #   }
        # }
        # "~ArrayRef|Tuple[Slurpy[ArrayRef[Integer]]]" requires that the value pass "Tuple[Slurpy[ArrayRef[Integer]]]" or "~ArrayRef"
        # Reference [1,"x"] did not pass type constraint "~ArrayRef"
        #     Reference [1,"x"] did not pass type constraint "~ArrayRef"
        #     "~ArrayRef" is defined as: (not((ref($_) eq 'ARRAY')))
        # Reference [1,"x"] did not pass type constraint "Tuple[Slurpy[ArrayRef[Integer]]]"
        #     Reference [1,"x"] did not pass type constraint "Tuple[Slurpy[ArrayRef[Integer]]]"
        #     Array elements from index 0 are slurped into a arrayref which is constrained with "ArrayRef[Integer]"
        #     Reference [1,"x"] did not pass type constraint "ArrayRef[Integer]" (in $SLURPY)
        #     "ArrayRef[Integer]" constrains each value in the array with "Integer"
        #     Value "x" did not pass type constraint "Integer" (in $SLURPY->[1])
        #     "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # {
        #   'items' => [
        #     {
        #       'type' => 'integer'
        #     },
        #     {
        #       'type' => 'string'
        #     }
        #   ]
        # }
        # "~ArrayRef|Tuple[Optional[Integer],Optional[String],Slurpy[Any]]" requires that the value pass "Tuple[Optional[Integer],Optional[String],Slurpy[Any]]" or "~ArrayRef"
        # Reference ["foo",1] did not pass type constraint "~ArrayRef"
        #     Reference ["foo",1] did not pass type constraint "~ArrayRef"
        #     "~ArrayRef" is defined as: (not((ref($_) eq 'ARRAY')))
        # Reference ["foo",1] did not pass type constraint "Tuple[Optional[Integer],Optional[String],Slurpy[Any]]"
        #     Reference ["foo",1] did not pass type constraint "Tuple[Optional[Integer],Optional[String],Slurpy[Any]]"
        #     "Tuple[Optional[Integer],Optional[String],Slurpy[Any]]" constrains value at index 0 of array with "Optional[Integer]"
        #     Value "foo" did not pass type constraint "Optional[Integer]" (in $_->[0])
        #     $_->[0] exists
        #     "Optional[Integer]" constrains $_->[0] with "Integer" if it exists
        #     Value "foo" did not pass type constraint "Integer" (in $_->[0])
        #     "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # {
        #   'items' => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )
        # }
        # {
        #   'items' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        # }
        # Reference [1,"foo",bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )] did not pass type constraint "Items[0]"
        # "Items[0]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not @$_; }
        # {
        #   'items' => [
        #     bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
        #     bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        #   ]
        # }
        # "~ArrayRef|Tuple[Optional[Any],Optional[None],Slurpy[Any]]" requires that the value pass "Tuple[Optional[Any],Optional[None],Slurpy[Any]]" or "~ArrayRef"
        # Reference [1,"foo"] did not pass type constraint "~ArrayRef"
        #     Reference [1,"foo"] did not pass type constraint "~ArrayRef"
        #     "~ArrayRef" is defined as: (not((ref($_) eq 'ARRAY')))
        # Reference [1,"foo"] did not pass type constraint "Tuple[Optional[Any],Optional[None],Slurpy[Any]]"
        #     Reference [1,"foo"] did not pass type constraint "Tuple[Optional[Any],Optional[None],Slurpy[Any]]"
        #     "Tuple[Optional[Any],Optional[None],Slurpy[Any]]" constrains value at index 1 of array with "Optional[None]"
        #     Value "foo" did not pass type constraint "Optional[None]" (in $_->[1])
        #     $_->[1] exists
        #     "Optional[None]" constrains $_->[1] with "None" if it exists
        #     Value "foo" did not pass type constraint "None" (in $_->[1])
        #     "None" is defined as: (not((!!1)))
        # {
        #   'minItems' => 1
        # }
        # Reference [] did not pass type constraint "MinItems[1]"
        # "MinItems[1]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; @$_ >= $min unless ref $_ ne 'ARRAY'; }
        # {
        #   'properties' => {
        #     'bar' => {},
        #     'foo' => {}
        #   },
        #   'required' => [
        #     'foo'
        #   ]
        # }
        # "Properties[bar,Any,foo,Any]&Required[foo]" requires that the value pass "Properties[bar,Any,foo,Any]" and "Required[foo]"
        # Reference {"bar" => 1} did not pass type constraint "Required[foo]"
        # "Required[foo]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 1 unless Object->check($_); my $obj = $_; all sub { exists $$obj{$_}; } , @keys; }
        # {
        #   'properties' => {
        #     'foo' => {}
        #   }
        # }
        # {
        #   'properties' => {
        #     'foo' => {}
        #   },
        #   'required' => []
        # }
        # {
        #   'const' => 2
        # }
        # Value "5" did not pass type constraint "Enum[2]"
        # "Enum[2]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $j = $_; any sub { same_structs($_, $j); } , @items; }
        # Value "a" did not pass type constraint "Enum[2]"
        # "Enum[2]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $j = $_; any sub { same_structs($_, $j); } , @items; }
        # {
        #   'const' => {
        #     'baz' => 'bax',
        #     'foo' => 'bar'
        #   }
        # }
        # Reference {"foo" => "bar"} did not pass type constraint "Enum[HASH(0x426b588)]"
        # "Enum[HASH(0x426b588)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $j = $_; any sub { same_structs($_, $j); } , @items; }
        # Reference [1,2] did not pass type constraint "Enum[HASH(0x426b588)]"
        # "Enum[HASH(0x426b588)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $j = $_; any sub { same_structs($_, $j); } , @items; }
        # {
        #   'const' => undef
        # }
        # Value "0" did not pass type constraint "Enum[undef]"
        # "Enum[undef]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $j = $_; any sub { same_structs($_, $j); } , @items; }
        # bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )
        # bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        # Value "1" did not pass type constraint "None"
        # "None" is defined as: (not((!!1)))
        # Value "foo" did not pass type constraint "None"
        # "None" is defined as: (not((!!1)))
        # Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) did not pass type constraint "None"
        # "None" is defined as: (not((!!1)))
        # Reference bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ) did not pass type constraint "None"
        # "None" is defined as: (not((!!1)))
        # Undef did not pass type constraint "None"
        # "None" is defined as: (not((!!1)))
        # Reference {"foo" => "bar"} did not pass type constraint "None"
        # "None" is defined as: (not((!!1)))
        # Reference {} did not pass type constraint "None"
        # "None" is defined as: (not((!!1)))
        # Reference ["foo"] did not pass type constraint "None"
        # "None" is defined as: (not((!!1)))
        # Reference [] did not pass type constraint "None"
        # "None" is defined as: (not((!!1)))
        # {
        #   'type' => 'integer'
        # }
        # Value "1.1" did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # Value "foo" did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # Reference {} did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # Reference [] did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # Undef did not pass type constraint "Integer"
        # "Integer" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 4096 && !($flags & 16384); }
        # {
        #   'type' => 'number'
        # }
        # Value "foo" did not pass type constraint "Number"
        # "Number" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 12288 && !($flags & 16384); }
        # Reference {} did not pass type constraint "Number"
        # "Number" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 12288 && !($flags & 16384); }
        # Reference [] did not pass type constraint "Number"
        # "Number" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 12288 && !($flags & 16384); }
        # Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) did not pass type constraint "Number"
        # "Number" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 12288 && !($flags & 16384); }
        # Undef did not pass type constraint "Number"
        # "Number" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 12288 && !($flags & 16384); }
        # {
        #   'type' => 'string'
        # }
        # Value "1" did not pass type constraint "String"
        # "String" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 16384; }
        # Value "1.1" did not pass type constraint "String"
        # "String" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; return 0 if not defined $_ or ref $_; my $b_obj = B::svref_2object(\$_); my $flags = $b_obj->FLAGS; return $flags & 16384; }
        # "String" is a subtype of "Str"
        # "Str" is a subtype of "Value"
        # Reference {} did not pass type constraint "Value"
        # "Value" is defined as: (defined($_) and not ref($_))
        # "String" is a subtype of "Str"
        # "Str" is a subtype of "Value"
        # Reference [] did not pass type constraint "Value"
        # "Value" is defined as: (defined($_) and not ref($_))
        # "String" is a subtype of "Str"
        # "Str" is a subtype of "Value"
        # Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) did not pass type constraint "Value"
        # "Value" is defined as: (defined($_) and not ref($_))
        # "String" is a subtype of "Str"
        # "Str" is a subtype of "Value"
        # "Value" is a subtype of "Defined"
        # Undef did not pass type constraint "Defined"
        # "Defined" is defined as: (defined($_))
        # {
        #   'type' => 'object'
        # }
        # "Object" is a subtype of "HashRef"
        # "HashRef" is a subtype of "Ref"
        # Value "1" did not pass type constraint "Ref"
        # "Ref" is defined as: (!!ref($_))
        # "Object" is a subtype of "HashRef"
        # "HashRef" is a subtype of "Ref"
        # Value "1.1" did not pass type constraint "Ref"
        # "Ref" is defined as: (!!ref($_))
        # "Object" is a subtype of "HashRef"
        # "HashRef" is a subtype of "Ref"
        # Value "foo" did not pass type constraint "Ref"
        # "Ref" is defined as: (!!ref($_))
        # "Object" is a subtype of "HashRef"
        # Reference [] did not pass type constraint "HashRef"
        # "HashRef" is defined as: (ref($_) eq 'HASH')
        # "Object" is a subtype of "HashRef"
        # Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) did not pass type constraint "HashRef"
        # "HashRef" is defined as: (ref($_) eq 'HASH')
        # "Object" is a subtype of "HashRef"
        # "HashRef" is a subtype of "Ref"
        # "Ref" is a subtype of "Defined"
        # Undef did not pass type constraint "Defined"
        # "Defined" is defined as: (defined($_))
        # {
        #   'type' => 'array'
        # }
        # "Array" is a subtype of "ArrayRef"
        # "ArrayRef" is a subtype of "Ref"
        # Value "1" did not pass type constraint "Ref"
        # "Ref" is defined as: (!!ref($_))
        # "Array" is a subtype of "ArrayRef"
        # "ArrayRef" is a subtype of "Ref"
        # Value "1.1" did not pass type constraint "Ref"
        # "Ref" is defined as: (!!ref($_))
        # "Array" is a subtype of "ArrayRef"
        # "ArrayRef" is a subtype of "Ref"
        # Value "foo" did not pass type constraint "Ref"
        # "Ref" is defined as: (!!ref($_))
        # "Array" is a subtype of "ArrayRef"
        # Reference {} did not pass type constraint "ArrayRef"
        # "ArrayRef" is defined as: (ref($_) eq 'ARRAY')
        # "Array" is a subtype of "ArrayRef"
        # Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) did not pass type constraint "ArrayRef"
        # "ArrayRef" is defined as: (ref($_) eq 'ARRAY')
        # "Array" is a subtype of "ArrayRef"
        # "ArrayRef" is a subtype of "Ref"
        # "Ref" is a subtype of "Defined"
        # Undef did not pass type constraint "Defined"
        # "Defined" is defined as: (defined($_))
        # {
        #   'type' => 'boolean'
        # }
        # Value "1" did not pass type constraint "Boolean"
        # "Boolean" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; ref($_) =~ /JSON/; }
        # Value "1.1" did not pass type constraint "Boolean"
        # "Boolean" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; ref($_) =~ /JSON/; }
        # Value "foo" did not pass type constraint "Boolean"
        # "Boolean" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; ref($_) =~ /JSON/; }
        # Reference {} did not pass type constraint "Boolean"
        # "Boolean" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; ref($_) =~ /JSON/; }
        # Reference [] did not pass type constraint "Boolean"
        # "Boolean" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; ref($_) =~ /JSON/; }
        # Undef did not pass type constraint "Boolean"
        # "Boolean" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; ref($_) =~ /JSON/; }
        # {
        #   'type' => 'null'
        # }
        # Value "1" did not pass type constraint "Null"
        # "Null" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not defined $_; }
        # Value "1.1" did not pass type constraint "Null"
        # "Null" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not defined $_; }
        # Value "foo" did not pass type constraint "Null"
        # "Null" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not defined $_; }
        # Reference {} did not pass type constraint "Null"
        # "Null" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not defined $_; }
        # Reference [] did not pass type constraint "Null"
        # "Null" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not defined $_; }
        # Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) did not pass type constraint "Null"
        # "Null" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not defined $_; }
        # {
        #   'type' => [
        #     'integer',
        #     'string'
        #   ]
        # }
        # Value "1.1" did not pass type constraint "AnyOf[Integer,String]"
        # "AnyOf[Integer,String]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; any sub { $_->check($v); } , @types; }
        # Reference {} did not pass type constraint "AnyOf[Integer,String]"
        # "AnyOf[Integer,String]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; any sub { $_->check($v); } , @types; }
        # Reference [] did not pass type constraint "AnyOf[Integer,String]"
        # "AnyOf[Integer,String]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; any sub { $_->check($v); } , @types; }
        # Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) did not pass type constraint "AnyOf[Integer,String]"
        # "AnyOf[Integer,String]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; any sub { $_->check($v); } , @types; }
        # Undef did not pass type constraint "AnyOf[Integer,String]"
        # "AnyOf[Integer,String]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; any sub { $_->check($v); } , @types; }
        # {
        #   'additionalItems' => {
        #     'type' => 'integer'
        #   },
        #   'items' => [
        #     {}
        #   ]
        # }
        # 
        # {
        #   'additionalItems' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #   'items' => {}
        # }
        # {
        #   'additionalItems' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #   'items' => [
        #     {},
        #     {},
        #     {}
        #   ]
        # }
        # "AdditionalItems[3]&~ArrayRef|Tuple[Optional[Any],Optional[Any],Optional[Any],Slurpy[Any]]" requires that the value pass "AdditionalItems[3]" and "~ArrayRef|Tuple[Optional[Any],Optional[Any],Optional[Any],Slurpy[Any]]"
        # Reference [1,2,3,4] did not pass type constraint "AdditionalItems[3]"
        # "AdditionalItems[3]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; @$_ <= $size; }
        # {
        #   'additionalItems' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        # }
        # {
        #   'items' => [
        #     {
        #       'type' => 'integer'
        #     }
        #   ]
        # }
t/draft6.t ............. ok
t/recurse.t ............ ok
t/register_uris.t ...... ok
t/schema-coerce.t ...... ok
t/spec-schema.t ........ ok
t/string_number.t ...... ok
        # Value "1" did not pass type constraint "Not[Integer]"
t/types_draft3.t ....... ok
        # Value "4" did not pass type constraint "Minimum[5]"
        # Value "5" did not pass type constraint "ExclusiveMinimum[5]"
        # Value "6" did not pass type constraint "Maximum[5]"
        # Value "5" did not pass type constraint "ExclusiveMaximum[5]"
        # Value "foo" did not pass type constraint "MinLength[5]"
        # Value "banana" did not pass type constraint "MaxLength[5]"
        # Value "3" did not pass type constraint "MultipleOf[5]"
        # Reference [1,2,3] did not pass type constraint "MaxItems[2]"
        # Reference [1] did not pass type constraint "MinItems[2]"
Use of uninitialized value in join or string at t/types_draft4.t line 144.
            # Value "banana" did not pass type constraint "Null"
            # Value "1" did not pass type constraint "Boolean"
            # Value "1" did not pass type constraint "Array"
            # Reference [] did not pass type constraint "Object"
            # Reference [] did not pass type constraint "String"
            # Value "1.3" did not pass type constraint "Integer"
            # Reference [] did not pass type constraint "Number"
            # Value "potato" did not pass type constraint "Pattern[(?^:foo)]"
        # Reference {"bar" => 1} did not pass type constraint "Required[foo]"
        # Reference {"bar" => 1} did not pass type constraint "Required[foo,bar]"
        # Value "1" did not pass type constraint "Not[Integer]"
        # Reference {1 => 2,3 => 4,5 => 6} did not pass type constraint "MaxProperties[2]"
        # Reference {1 => 2} did not pass type constraint "MinProperties[2]"
        # Value "banana" did not pass type constraint "OneOf[Integer,Boolean]"
        # Value "banana" did not pass type constraint "OneOf[MaxLength[7],MaxLength[6]]"
        # Value "banana" did not pass type constraint "AnyOf[Integer,Boolean]"
        # Value "banana" did not pass type constraint "AllOf[MaxLength[5],MinLength[2]]"
        # Reference ["banana"] did not pass type constraint "~ArrayRef|Tuple[Slurpy[ArrayRef[Number]]]"
        # Reference [1] did not pass type constraint "AdditionalItems[1,Number]"
        # Reference {"foo" => "x"} did not pass type constraint "PatternProperties[f,Number,b,Array]"
        # Reference {"foo" => "x"} did not pass type constraint "Dependency[baz,MaxProperties[2]]&Dependency[foo,ARRAY(0x1708580)]"
        # Reference {"foo" => "x"} did not pass type constraint "Enum[foo,HASH(0x39553a0)]"
        # Reference [1,1,2,3] did not pass type constraint "UniqueItems"
        # Reference {"foo" => "x"} did not pass type constraint "Properties[foo,Number,bar,Array]"
        # Reference {"quux" => "x"} did not pass type constraint "AdditionalProperties[ARRAY(0x3869c70),0]"
t/types_draft4.t ....... ok
All tests successful.
Files=13, Tests=139, 36 wallclock secs ( 0.45 usr  0.09 sys + 33.03 cusr  2.52 csys = 36.09 CPU)
Result: PASS


PREREQUISITES:

Here is a list of prerequisites you specified and versions we
managed to load:

	  Module Name                        Have     Want
	  Clone                              0.46        0
	  Exporter                           5.68        0
	  ExtUtils::MakeMaker                7.70        0
	  File::Spec                         3.75        0
	  IO::Handle                         1.34        0
	  IPC::Open3                         1.13        0
	  JSON                               4.10        0
	  LWP::Simple                        6.77        0
	  List::AllUtils                     0.19        0
	  List::MoreUtils                   0.430        0
	  List::Util                         1.63        0
	  Moose                            2.2207        0
	  Moose::Role                      2.2207        0
	  Moose::Util                      2.2207        0
	  MooseX::ClassAttribute             0.29        0
	  MooseX::MungeHas                  0.011        0
	  Path::Tiny                        0.144    0.062
	  Scalar::Util                       1.63        0
	  Test::Deep                        1.204        0
	  Test::Exception                    0.43        0
	  Test::More                     1.302198        0
	  Type::Library                  2.004000        0
	  Type::Tiny                     2.004000        0
	  Type::Tiny::Class              2.004000        0
	  Type::Utils                    2.004000        0
	  Types::Standard                2.004000        0
	  URI                                5.28        0
	  lib                                0.63        0
	  parent                            0.225        0
	  strict                             1.07        0
	  warnings                           1.18        0

Perl module toolchain versions installed:
	Module Name                        Have
	CPANPLUS                         0.9914
	CPANPLUS::Dist::Build              0.90
	Cwd                                3.75
	ExtUtils::CBuilder             0.280236
	ExtUtils::Command                  7.70
	ExtUtils::Install                  2.22
	ExtUtils::MakeMaker                7.70
	ExtUtils::Manifest                 1.75
	ExtUtils::ParseXS                  3.51
	File::Spec                         3.75
	Module::Build                    0.4234
	Pod::Parser                        1.60
	Pod::Simple                        3.28
	Test2                          1.302198
	Test::Harness                      3.48
	Test::More                     1.302198
	version                          0.9930

******************************** NOTE ********************************
The comments above are created mechanically, possibly without manual
checking by the sender.  As there are many people performing automatic
tests on each upload to CPAN, it is likely that you will receive
identical messages about the same problem.

If you believe that the message is mistaken, please reply to the first
one with correction and/or additional informations, and do not take
it personally.  We appreciate your patience. :)
**********************************************************************

Additional comments:


This report was machine-generated by CPANPLUS::Dist::YACSmoke 1.08.
Powered by minismokebox version 0.68

CPANPLUS is prefering Build.PL

------------------------------
ENVIRONMENT AND OTHER CONTEXT
------------------------------

Environment variables:

    AUTOMATED_TESTING = 1
    LANG = en_GB.UTF-8
    NONINTERACTIVE_TESTING = 1
    PATH = /usr/bin:/usr/sbin:/sbin:/opt/ooce/bin:/usr/gnu/bin
    PERL5LIB = /home/cpan/pit/jail/70ikJFdzxR/lib/perl5:/home/cpan/pit/thr/conf/perl-5.18.1/.cpanplus/5.18.1/build/_cGN5qlCiI/JSON-Schema-AsType-0.4.4/blib/lib:/home/cpan/pit/thr/conf/perl-5.18.1/.cpanplus/5.18.1/build/_cGN5qlCiI/JSON-Schema-AsType-0.4.4/blib/arch
    PERL5_CPANPLUS_IS_RUNNING = 549
    PERL5_CPANPLUS_IS_VERSION = 0.9914
    PERL5_MINISMOKEBOX = 0.68
    PERL5_YACSMOKE_BASE = /home/cpan/pit/thr/conf/perl-5.18.1
    PERL_EXTUTILS_AUTOINSTALL = --defaultdeps
    PERL_LOCAL_LIB_ROOT = /home/cpan/pit/jail/70ikJFdzxR
    PERL_MB_OPT = --install_base "/home/cpan/pit/jail/70ikJFdzxR"
    PERL_MM_OPT = INSTALL_BASE=/home/cpan/pit/jail/70ikJFdzxR
    PERL_MM_USE_DEFAULT = 1
    SHELL = /bin/bash
    TERM = screen.xterm-256color

Perl special variables (and OS-specific diagnostics, for MSWin32):

    Perl: $^X = /home/cpan/pit/thr/perl-5.18.1/bin/perl
    UID:  $<  = 101
    EUID: $>  = 101
    GID:  $(  = 101 101
    EGID: $)  = 101 101


-------------------------------


--

Summary of my perl5 (revision 5 version 18 subversion 1) configuration:
   
  Platform:
    osname=solaris, osvers=2.11, archname=i86pc-solaris-thread-multi-64
    uname='sunos ouzel 5.11 omnios-r151034-0d278a0cc5 i86pc i386 i86pc '
    config_args='-des -Dprefix=/home/cpan/pit/thr/perl-5.18.1 -Dusethreads -Duse64bitall -Dcc=gcc'
    hint=recommended, useposix=true, d_sigaction=define
    useithreads=define, usemultiplicity=define
    useperlio=define, d_sfio=undef, uselargefiles=define, usesocks=undef
    use64bitint=define, use64bitall=define, uselongdouble=undef
    usemymalloc=n, bincompat5005=undef
  Compiler:
    cc='gcc', ccflags ='-D_REENTRANT -m64 -fwrapv -fno-strict-aliasing -pipe -fstack-protector -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -DPERL_USE_SAFE_PUTENV',
    optimize='-O',
    cppflags='-D_REENTRANT -m64 -fwrapv -fno-strict-aliasing -pipe -fstack-protector'
    ccversion='', gccversion='9.3.0', gccosandvers=''
    intsize=4, longsize=8, ptrsize=8, doublesize=8, byteorder=12345678
    d_longlong=define, longlongsize=8, d_longdbl=define, longdblsize=16
    ivtype='long', ivsize=8, nvtype='double', nvsize=8, Off_t='off_t', lseeksize=8
    alignbytes=8, prototype=define
  Linker and Libraries:
    ld='gcc', ldflags =' -m64 -fstack-protector -L/usr/gnu/lib '
    libpth=/usr/gnu/lib /usr/lib /usr/ccs/lib
    libs=-lsocket -lnsl -ldl -lm -lpthread -lc
    perllibs=-lsocket -lnsl -ldl -lm -lpthread -lc
    libc=/lib/libc.so, so=so, useshrplib=true, libperl=libperl.so
    gnulibc_version=''
  Dynamic Linking:
    dlsrc=dl_dlopen.xs, dlext=so, d_dlsymun=undef, ccdlflags='  -R /home/cpan/pit/thr/perl-5.18.1/lib/5.18.1/i86pc-solaris-thread-multi-64/CORE'
    cccdlflags='-fPIC', lddlflags=' -shared -m64 -L/usr/gnu/lib -fstack-protector'


Characteristics of this binary (from libperl): 
  Compile-time options: HAS_TIMES MULTIPLICITY PERLIO_LAYERS
                        PERL_DONT_CREATE_GVSV
                        PERL_HASH_FUNC_ONE_AT_A_TIME_HARD
                        PERL_IMPLICIT_CONTEXT PERL_MALLOC_WRAP
                        PERL_PRESERVE_IVUV PERL_SAWAMPERSAND
                        PERL_USE_SAFE_PUTENV USE_64_BIT_ALL USE_64_BIT_INT
                        USE_ITHREADS USE_LARGE_FILES USE_LOCALE
                        USE_LOCALE_COLLATE USE_LOCALE_CTYPE
                        USE_LOCALE_NUMERIC USE_PERLIO USE_PERL_ATOF
                        USE_REENTRANT_API
  Locally applied patches:
	Devel::PatchPerl 2.00
  Built under solaris
  Compiled at Aug 20 2020 03:30:50
  %ENV:
    PERL5LIB="/home/cpan/pit/jail/70ikJFdzxR/lib/perl5:/home/cpan/pit/thr/conf/perl-5.18.1/.cpanplus/5.18.1/build/_cGN5qlCiI/JSON-Schema-AsType-0.4.4/blib/lib:/home/cpan/pit/thr/conf/perl-5.18.1/.cpanplus/5.18.1/build/_cGN5qlCiI/JSON-Schema-AsType-0.4.4/blib/arch"
    PERL5_CPANPLUS_IS_RUNNING="549"
    PERL5_CPANPLUS_IS_VERSION="0.9914"
    PERL5_MINISMOKEBOX="0.68"
    PERL5_YACSMOKE_BASE="/home/cpan/pit/thr/conf/perl-5.18.1"
    PERL_EXTUTILS_AUTOINSTALL="--defaultdeps"
    PERL_LOCAL_LIB_ROOT="/home/cpan/pit/jail/70ikJFdzxR"
    PERL_MB_OPT="--install_base "/home/cpan/pit/jail/70ikJFdzxR""
    PERL_MM_OPT="INSTALL_BASE=/home/cpan/pit/jail/70ikJFdzxR"
    PERL_MM_USE_DEFAULT="1"
  @INC:
    /home/cpan/pit/jail/70ikJFdzxR/lib/perl5/5.18.1/i86pc-solaris-thread-multi-64
    /home/cpan/pit/jail/70ikJFdzxR/lib/perl5/5.18.1
    /home/cpan/pit/jail/70ikJFdzxR/lib/perl5/i86pc-solaris-thread-multi-64
    /home/cpan/pit/jail/70ikJFdzxR/lib/perl5
    /home/cpan/pit/thr/conf/perl-5.18.1/.cpanplus/5.18.1/build/_cGN5qlCiI/JSON-Schema-AsType-0.4.4/blib/lib
    /home/cpan/pit/thr/conf/perl-5.18.1/.cpanplus/5.18.1/build/_cGN5qlCiI/JSON-Schema-AsType-0.4.4/blib/arch
    /home/cpan/pit/thr/perl-5.18.1/lib/site_perl/5.18.1/i86pc-solaris-thread-multi-64
    /home/cpan/pit/thr/perl-5.18.1/lib/site_perl/5.18.1
    /home/cpan/pit/thr/perl-5.18.1/lib/5.18.1/i86pc-solaris-thread-multi-64
    /home/cpan/pit/thr/perl-5.18.1/lib/5.18.1
    .