JSON-Schema-AsType v0.4.4 Perl 5 v5.26.1 amd64-freebsd

Status
Pass
From
Slaven Rezić
Dist
JSON-Schema-AsType v0.4.4
Platform
Perl 5 v5.26.1 amd64-freebsd
Date
2024-04-16 21:44:12
ID
76c2764c-fc3a-11ee-874a-a00c6e8775ea
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 Champoux,

This is a computer-generated report for JSON-Schema-AsType-0.4.4
on perl 5.26.1, created by CPAN-Reporter-1.2018.

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

Sections of this report:

    * Tester comments
    * Program output
    * Prerequisites
    * Environment and other context

------------------------------
TESTER COMMENTS
------------------------------

Additional comments from tester:

none provided

------------------------------
PROGRAM OUTPUT
------------------------------

Output from '/usr/bin/make test':

PERL_DL_NONLAZY=1 "/usr/perl5.26.1p/bin/perl5.26.1" "-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.58
# 
# === Build Requires ===
# 
#     Module              Want Have
#     ------------------- ---- ----
#     ExtUtils::MakeMaker  any 7.58
# 
# === Test Requires ===
# 
#     Module               Want     Have
#     ------------------- ----- --------
#     Exporter              any     5.72
#     ExtUtils::MakeMaker   any     7.58
#     File::Spec            any     3.67
#     IO::Handle            any     1.36
#     IPC::Open3            any     1.20
#     Path::Tiny          0.062    0.104
#     Test::Deep            any    1.127
#     Test::Exception       any     0.43
#     Test::More            any 1.302106
#     lib                   any     0.64
#     parent                any    0.236
# 
# === Test Recommends ===
# 
#     Module         Want     Have
#     ---------- -------- --------
#     CPAN::Meta 2.120900 2.150010
# 
# === Runtime Requires ===
# 
#     Module                     Want     Have
#     ---------------------- -------- --------
#     Clone                       any     0.39
#     JSON                        any     2.94
#     LWP::Simple                 any     6.29
#     List::AllUtils              any     0.14
#     List::MoreUtils             any    0.426
#     List::Util                  any     1.49
#     Moose                       any   2.2006
#     Moose::Role                 any   2.2006
#     Moose::Util                 any   2.2006
#     MooseX::ClassAttribute      any     0.29
#     MooseX::MungeHas            any    0.008
#     Path::Tiny                0.062    0.104
#     Scalar::Util                any     1.49
#     Type::Library               any 1.002001
#     Type::Tiny                  any 1.002001
#     Type::Tiny::Class           any 1.002001
#     Type::Utils                 any 1.002001
#     Types::Standard             any 1.002001
#     URI                         any     1.72
#     perl                   5.014000 5.026001
#     strict                      any     1.11
#     warnings                    any     1.37
# 
t/00-report-prereqs.t .. ok
t/basic.t .............. ok
t/draft3.t ............. ok
t/draft4.t ............. ok
        # {
        #   'not' => {
        #     'type' => 'integer'
        #   }
        # }
        # Value "1" did not pass type constraint "Not[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x808024a08)]"
        # "Not[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x808024a08)]" 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[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8089ae3d8)]"
        # "Not[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8089ae3d8)]" 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[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8089ae3d8)]"
        # "Not[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8089ae3d8)]" 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[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80827eee8)]"
        # "Not[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80827eee8)]" 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[Moose::Meta::Class::__ANON__::SERIAL::16=HASH(0x8088ea558)]]"
        # "Properties[foo,Not[Moose::Meta::Class::__ANON__::SERIAL::16=HASH(0x8088ea558)]]" 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[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x808a48ed0)]"
        # "Not[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x808a48ed0)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; not $type->check($_); }
        # {
        #   'not' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        # }
        # {
        #   'additionalProperties' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        #   'patternProperties' => {},
        #   'properties' => {
        #     'foo' => {
        #       '$ref' => '#'
        #     }
        #   }
        # }
        # "AdditionalProperties[ARRAY(0x8080ce168),0]&PatternProperties[]&Properties[foo,Ref(#)]" requires that the value pass "AdditionalProperties[ARRAY(0x8080ce168),0]", "PatternProperties[]", and "Properties[foo,Ref(#)]"
        # Reference {"bar" => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )} did not pass type constraint "AdditionalProperties[ARRAY(0x8080ce168),0]"
        # "AdditionalProperties[ARRAY(0x8080ce168),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(0x8080ce168),0]&PatternProperties[]&Properties[foo,Ref(#)]" requires that the value pass "AdditionalProperties[ARRAY(0x8080ce168),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::Util::XS::is_plain_arrayref($_))))
        # 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[tilda,Ref(#/tilda~0field),percent,Ref(#/percent%25field),slash,Ref(#/slash~1field)]"
        # "Properties[tilda,Ref(#/tilda~0field),percent,Ref(#/percent%25field),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[tilda,Ref(#/tilda~0field),percent,Ref(#/percent%25field),slash,Ref(#/slash~1field)]"
        # "Properties[tilda,Ref(#/tilda~0field),percent,Ref(#/percent%25field),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[tilda,Ref(#/tilda~0field),percent,Ref(#/percent%25field),slash,Ref(#/slash~1field)]"
        # "Properties[tilda,Ref(#/tilda~0field),percent,Ref(#/percent%25field),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 {"default":{},"dependencies":{"exclusiveMinimum":["minimum"],"exclusiveMaximum":["maximum"]},"definitions":{"positiveInteger":{"minimum":0,"type":"integer"},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"positiveIntegerDefault0":{"allOf":[{"$ref":"#/definitions/positiveInteger"},{"default":0}]},"stringArray":{"type":"array","uniqueItems":true,"minItems":1,"items":{"type":"string"}},"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}}},"id":"http://json-schema.org/draft-04/schema#","properties":{"additionalProperties":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"dependencies":{"properties":{},"type":"object","patternProperties":{},"additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"maxLength":{"$ref":"#/definitions/positiveInteger"},"not":{"$ref":"#"},"oneOf":{"$ref":"#/definitions/schemaArray"},"enum":{"minItems":1,"uniqueItems":true,"type":"array"},"maximum":{"type":"number"},"uniqueItems":{"default":false,"type":"boolean"},"minProperties":{"$ref":"#/definitions/positiveIntegerDefault0"},"description":{"type":"string"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":{}},"maxProperties":{"$ref":"#/definitions/positiveInteger"},"properties":{"properties":{},"patternProperties":{},"type":"object","default":{},"additionalProperties":{"$ref":"#"}},"definitions":{"additionalProperties":{"$ref":"#"},"default":{},"type":"object","patternProperties":{},"properties":{}},"required":{"$ref":"#/definitions/stringArray"},"allOf":{"$ref":"#/definitions/schemaArray"},"exclusiveMaximum":{"default":false,"type":"boolean"},"minimum":{"type":"number"},"additionalItems":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"maxItems":{"$ref":"#/definitions/positiveInteger"},"default":{},"id":{"format":"uri","type":"string"},"multipleOf":{"type":"number","exclusiveMinimum":true,"minimum":0},"minItems":{"$ref":"#/definitions/positiveIntegerDefault0"},"anyOf":{"$ref":"#/definitions/schemaArray"},"patternProperties":{"additionalProperties":{"$ref":"#"},"default":{},"type":"object","patternProperties":{},"properties":{}},"title":{"type":"string"},"pattern":{"format":"regex","type":"string"},"$schema":{"format":"uri","type":"string"},"minLength":{"$ref":"#/definitions/positiveIntegerDefault0"},"exclusiveMinimum":{"default":false,"type":"boolean"},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"minItems":1,"uniqueItems":true,"type":"array","items":{"$ref":"#/definitions/simpleTypes"}}]}},"description":"Core schema meta-schema","$schema":"http://json-schema.org/draft-04/schema#","type":"object"}
        # "Dependency[exclusiveMaximum,ARRAY(0x807a98ba0)]&Dependency[exclusiveMinimum,ARRAY(0x807a98b88)]&Properties[additionalProperties,AnyOf[Boolean,Ref(#)],dependencies,AdditionalProperties[ARRAY(0x807a4c870),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,maxLength,Ref(#/definitions/positiveInteger),not,Ref(#),oneOf,Ref(#/definitions/schemaArray),enum,MinItems[1]&Array&UniqueItems,maximum,Number,uniqueItems,Boolean,minProperties,Ref(#/definitions/positiveIntegerDefault0),description,String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],maxProperties,Ref(#/definitions/positiveInteger),properties,AdditionalProperties[ARRAY(0x807ad9f00),Ref(#)]&PatternProperties[]&Properties[]&Object,definitions,AdditionalProperties[ARRAY(0x807b62c60),Ref(#)]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),allOf,Ref(#/definitions/schemaArray),exclusiveMaximum,Boolean,minimum,Number,additionalItems,AnyOf[Boolean,Ref(#)],maxItems,Ref(#/definitions/positiveInteger),default,Any,id,String,multipleOf,ExclusiveMinimum[0]&Number,minItems,Ref(#/definitions/positiveIntegerDefault0),anyOf,Ref(#/definitions/schemaArray),patternProperties,AdditionalProperties[ARRAY(0x807b63798),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,pattern,String,$schema,String,minLength,Ref(#/definitions/positiveIntegerDefault0),exclusiveMinimum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[slurpy ArrayRef[Ref(#/definitions/simpleTypes)]]&MinItems[1]&Array&UniqueItems]]&Object" requires that the value pass "Dependency[exclusiveMaximum,ARRAY(0x807a98ba0)]", "Dependency[exclusiveMinimum,ARRAY(0x807a98b88)]", "Object", and "Properties[additionalProperties,AnyOf[Boolean,Ref(#)],dependencies,AdditionalProperties[ARRAY(0x807a4c870),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,maxLength,Ref(#/definitions/positiveInteger),not,Ref(#),oneOf,Ref(#/definitions/schemaArray),enum,MinItems[1]&Array&UniqueItems,maximum,Number,uniqueItems,Boolean,minProperties,Ref(#/definitions/positiveIntegerDefault0),description,String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],maxProperties,Ref(#/definitions/positiveInteger),properties,AdditionalProperties[ARRAY(0x807ad9f00),Ref(#)]&PatternProperties[]&Properties[]&Object,definitions,AdditionalProperties[ARRAY(0x807b62c60),Ref(#)]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),allOf,Ref(#/definitions/schemaArray),exclusiveMaximum,Boolean,minimum,Number,additionalItems,AnyOf[Boolean,Ref(#)],maxItems,Ref(#/definitions/positiveInteger),default,Any,id,String,multipleOf,ExclusiveMinimum[0]&Number,minItems,Ref(#/definitions/positiveIntegerDefault0),anyOf,Ref(#/definitions/schemaArray),patternProperties,AdditionalProperties[ARRAY(0x807b63798),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,pattern,String,$schema,String,minLength,Ref(#/definitions/positiveIntegerDefault0),exclusiveMinimum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[slurpy ArrayRef[Ref(#/definitions/simpleTypes)]]&MinItems[1]&Array&UniqueItems]]"
        # Reference {"minLength" => -1} did not pass type constraint "Properties[additionalProperties,AnyOf[Boolean,Ref(#)],dependencies,AdditionalProperties[ARRAY(0x807a4c870),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,maxLength,Ref(#/definitions/positiveInteger),not,Ref(#),oneOf,Ref(#/definitions/schemaArray),enum,MinItems[1]&Array&UniqueItems,maximum,Number,uniqueItems,Boolean,minProperties,Ref(#/definitions/positiveIntegerDefault0),description,String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],maxProperties,Ref(#/definitions/positiveInteger),properties,AdditionalProperties[ARRAY(0x807ad9f00),Ref(#)]&PatternProperties[]&Properties[]&Object,definitions,AdditionalProperties[ARRAY(0x807b62c60),Ref(#)]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),allOf,Ref(#/definitions/schemaArray),exclusiveMaximum,Boolean,minimum,Number,additionalItems,AnyOf[Boolean,Ref(#)],maxItems,Ref(#/definitions/positiveInteger),default,Any,id,String,multipleOf,ExclusiveMinimum[0]&Number,minItems,Ref(#/definitions/positiveIntegerDefault0),anyOf,Ref(#/definitions/schemaArray),patternProperties,AdditionalProperties[ARRAY(0x807b63798),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,pattern,String,$schema,String,minLength,Ref(#/definitions/positiveIntegerDefault0),exclusiveMinimum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[slurpy ArrayRef[Ref(#/definitions/simpleTypes)]]&MinItems[1]&Array&UniqueItems]]"
        # "Properties[additionalProperties,AnyOf[Boolean,Ref(#)],dependencies,AdditionalProperties[ARRAY(0x807a4c870),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,maxLength,Ref(#/definitions/positiveInteger),not,Ref(#),oneOf,Ref(#/definitions/schemaArray),enum,MinItems[1]&Array&UniqueItems,maximum,Number,uniqueItems,Boolean,minProperties,Ref(#/definitions/positiveIntegerDefault0),description,String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],maxProperties,Ref(#/definitions/positiveInteger),properties,AdditionalProperties[ARRAY(0x807ad9f00),Ref(#)]&PatternProperties[]&Properties[]&Object,definitions,AdditionalProperties[ARRAY(0x807b62c60),Ref(#)]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),allOf,Ref(#/definitions/schemaArray),exclusiveMaximum,Boolean,minimum,Number,additionalItems,AnyOf[Boolean,Ref(#)],maxItems,Ref(#/definitions/positiveInteger),default,Any,id,String,multipleOf,ExclusiveMinimum[0]&Number,minItems,Ref(#/definitions/positiveIntegerDefault0),anyOf,Ref(#/definitions/schemaArray),patternProperties,AdditionalProperties[ARRAY(0x807b63798),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,pattern,String,$schema,String,minLength,Ref(#/definitions/positiveIntegerDefault0),exclusiveMinimum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[slurpy ArrayRef[Ref(#/definitions/simpleTypes)]]&MinItems[1]&Array&UniqueItems]]" 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 "~Any"
        # "~Any" 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(0x808a544e0)','HASH(0x808a54780)']} 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($_); }
        # {
        #   '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(0x808aac780),1,HASH(0x808aac330)]"
        # "Enum[6,foo,ARRAY(0x808aac780),1,HASH(0x808aac330)]" 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(0x808aac780),1,HASH(0x808aac330)]"
        # "Enum[6,foo,ARRAY(0x808aac780),1,HASH(0x808aac330)]" 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[bar,Enum[bar],foo,Enum[foo]]&Required[bar]&Object" requires that the value pass "Object", "Properties[bar,Enum[bar],foo,Enum[foo]]", 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[bar,Enum[bar],foo,Enum[foo]]&Required[bar]&Object" requires that the value pass "Object", "Properties[bar,Enum[bar],foo,Enum[foo]]", 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; }
        # {
        #   '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::Util::XS::is_plain_hashref($_))
        # "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::Util::XS::is_plain_hashref($_))
        # "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::Util::XS::is_plain_arrayref($_))
        # "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::Util::XS::is_plain_arrayref($_))
        # "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; }
        # {
        #   '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,~Any]"
        # "AllOf[Any,~Any]" 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[~Any,~Any]"
        # "AllOf[~Any,~Any]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; all sub { $_->check($v); } , @types; }
        # {
        #   '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[~Any,~Any]"
        # "AnyOf[~Any,~Any]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; any sub { $_->check($v); } , @types; }
        # {
        #   '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(0x80904a3d8)]"
        # "Enum[HASH(0x80904a3d8)]" 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(0x80904a3d8)]"
        # "Enum[HASH(0x80904a3d8)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $j = $_; any sub { same_structs($_, $j); } , @items; }
Use of uninitialized value $a[0] in join or string at /usr/perl5.26.1p/lib/site_perl/5.26.1/Type/Tiny.pm line 420.
        # {
        #   'const' => undef
        # }
        # Value "0" did not pass type constraint "Enum[]"
        # "Enum[]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $j = $_; any sub { same_structs($_, $j); } , @items; }
        # {
        #   '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::Util::XS::is_plain_arrayref($_))))
        # 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::Util::XS::is_plain_arrayref($_))))
        # 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[~Any],slurpy Any]" requires that the value pass "Tuple[Optional[Any],Optional[~Any],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::Util::XS::is_plain_arrayref($_))))
        # Reference [1,"foo"] did not pass type constraint "Tuple[Optional[Any],Optional[~Any],slurpy Any]"
        #     Reference [1,"foo"] did not pass type constraint "Tuple[Optional[Any],Optional[~Any],slurpy Any]"
        #     "Tuple[Optional[Any],Optional[~Any],slurpy Any]" constrains value at index 1 of array with "Optional[~Any]"
        #     Value "foo" did not pass type constraint "Optional[~Any]" (in $_->[1])
        #     $_->[1] exists
        #     "Optional[~Any]" constrains $_->[1] with "~Any" if it exists
        #     Value "foo" did not pass type constraint "~Any" (in $_->[1])
        #     "~Any" is defined as: (not((!!1)))
        # {
        #   'oneOf' => [
        #     {
        #       'type' => 'integer'
        #     },
        #     {
        #       'minimum' => 2
        #     }
        #   ]
        # }
        # Value "3" did not pass type constraint "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80907ef90),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80907eb70)]"
        # "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80907ef90),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80907eb70)]" 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[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80907ef90),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80907eb70)]"
        # "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80907ef90),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80907eb70)]" 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[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8090889a8),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809088ba0)]&String" requires that the value pass "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8090889a8),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809088ba0)]" and "String"
        # Value "3" did not pass type constraint "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8090889a8),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809088ba0)]"
        # "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8090889a8),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809088ba0)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; 1 == grep({$_->check($v);} @types); }
        # "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8090889a8),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809088ba0)]&String" requires that the value pass "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8090889a8),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809088ba0)]" and "String"
        # Value "foo" did not pass type constraint "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8090889a8),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809088ba0)]"
        # "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8090889a8),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809088ba0)]" 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[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809090198),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809090150),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809090540)]"
        # "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809090198),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809090150),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809090540)]" 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[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809093e10),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809093ed0),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809097108)]"
        # "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809093e10),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809093ed0),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809097108)]" 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[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809097e58),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80909a990),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80909aa08)]"
        # "OneOf[Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x809097e58),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80909a990),Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x80909aa08)]" is defined as: sub { package JSON::Schema::AsType::Draft4::Types; my $v = $_; 1 == grep({$_->check($v);} @types); }
        # {
        #   'properties' => {
        #     'foo' => {
        #       'default' => [],
        #       'type' => 'integer'
        #     }
        #   }
        # }
        # {
        #   'properties' => {
        #     'bar' => {
        #       'default' => 'bad',
        #       'minLength' => 4,
        #       'type' => 'string'
        #     }
        #   }
        # }
        # {
        #   '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($_); }
        # {
        #   '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($_); }
        # {
        #   '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+'
        # }
        # {
        #   '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[~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($_); } , @$_); }
        # 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($_); } , @$_); }
        # {
        #   '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'; }
        # {
        #   '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[foo,Any,bar,Any]&Required[foo]" requires that the value pass "Properties[foo,Any,bar,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' => []
        # }
        # {
        #   '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($_); }
        # {
        #   '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($_); }
        # {
        #   '$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::Util::XS::is_plain_arrayref($_))))
        # 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::Util::XS::is_plain_arrayref($_))))
        #     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($_); }
        # {
        #   '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) =~ /\./; }
        # {
        #   'properties' => {
        #     'bar' => {
        #       'type' => 'string'
        #     },
        #     'foo' => {
        #       'type' => 'integer'
        #     }
        #   }
        # }
        # Reference {"bar" => {},"foo" => 1} did not pass type constraint "Properties[bar,String,foo,Integer]"
        # "Properties[bar,String,foo,Integer]" 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[bar,String,foo,Integer]"
        # "Properties[bar,String,foo,Integer]" 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(0x808a58af8),Integer]&PatternProperties[f.o,MinItems[2]]&Properties[foo,MaxItems[3]&Array,bar,Array]" requires that the value pass "AdditionalProperties[ARRAY(0x808a58af8),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(0x808a58af8),Integer]&PatternProperties[f.o,MinItems[2]]&Properties[foo,MaxItems[3]&Array,bar,Array]" requires that the value pass "AdditionalProperties[ARRAY(0x808a58af8),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(0x808a58af8),Integer]&PatternProperties[f.o,MinItems[2]]&Properties[foo,MaxItems[3]&Array,bar,Array]" requires that the value pass "AdditionalProperties[ARRAY(0x808a58af8),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(0x808a58af8),Integer]&PatternProperties[f.o,MinItems[2]]&Properties[foo,MaxItems[3]&Array,bar,Array]" requires that the value pass "AdditionalProperties[ARRAY(0x808a58af8),Integer]", "PatternProperties[f.o,MinItems[2]]", and "Properties[foo,MaxItems[3]&Array,bar,Array]"
        # Reference {"quux" => "foo"} did not pass type constraint "AdditionalProperties[ARRAY(0x808a58af8),Integer]"
        # "AdditionalProperties[ARRAY(0x808a58af8),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[foo,Any,bar,~Any]"
        # "Properties[foo,Any,bar,~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[foo,Any,bar,~Any]"
        # "Properties[foo,Any,bar,~Any]" 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' => 'http://json-schema.org/draft-04/schema#'
        # }
        # ref schema is {"default":{},"dependencies":{"exclusiveMinimum":["minimum"],"exclusiveMaximum":["maximum"]},"definitions":{"positiveInteger":{"minimum":0,"type":"integer"},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"positiveIntegerDefault0":{"allOf":[{"$ref":"#/definitions/positiveInteger"},{"default":0}]},"stringArray":{"type":"array","uniqueItems":true,"minItems":1,"items":{"type":"string"}},"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}}},"id":"http://json-schema.org/draft-04/schema#","properties":{"additionalProperties":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"dependencies":{"properties":{},"type":"object","patternProperties":{},"additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"maxLength":{"$ref":"#/definitions/positiveInteger"},"not":{"$ref":"#"},"oneOf":{"$ref":"#/definitions/schemaArray"},"enum":{"minItems":1,"uniqueItems":true,"type":"array"},"maximum":{"type":"number"},"uniqueItems":{"default":false,"type":"boolean"},"minProperties":{"$ref":"#/definitions/positiveIntegerDefault0"},"description":{"type":"string"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":{}},"maxProperties":{"$ref":"#/definitions/positiveInteger"},"properties":{"properties":{},"patternProperties":{},"type":"object","default":{},"additionalProperties":{"$ref":"#"}},"definitions":{"additionalProperties":{"$ref":"#"},"default":{},"type":"object","patternProperties":{},"properties":{}},"required":{"$ref":"#/definitions/stringArray"},"allOf":{"$ref":"#/definitions/schemaArray"},"exclusiveMaximum":{"default":false,"type":"boolean"},"minimum":{"type":"number"},"additionalItems":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"maxItems":{"$ref":"#/definitions/positiveInteger"},"default":{},"id":{"format":"uri","type":"string"},"multipleOf":{"type":"number","exclusiveMinimum":true,"minimum":0},"minItems":{"$ref":"#/definitions/positiveIntegerDefault0"},"anyOf":{"$ref":"#/definitions/schemaArray"},"patternProperties":{"additionalProperties":{"$ref":"#"},"default":{},"type":"object","patternProperties":{},"properties":{}},"title":{"type":"string"},"pattern":{"format":"regex","type":"string"},"$schema":{"format":"uri","type":"string"},"minLength":{"$ref":"#/definitions/positiveIntegerDefault0"},"exclusiveMinimum":{"default":false,"type":"boolean"},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"minItems":1,"uniqueItems":true,"type":"array","items":{"$ref":"#/definitions/simpleTypes"}}]}},"description":"Core schema meta-schema","$schema":"http://json-schema.org/draft-04/schema#","type":"object"}
        # "Dependency[exclusiveMaximum,ARRAY(0x807a98ba0)]&Dependency[exclusiveMinimum,ARRAY(0x807a98b88)]&Properties[additionalProperties,AnyOf[Boolean,Ref(#)],dependencies,AdditionalProperties[ARRAY(0x807a4c870),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,maxLength,Ref(#/definitions/positiveInteger),not,Ref(#),oneOf,Ref(#/definitions/schemaArray),enum,MinItems[1]&Array&UniqueItems,maximum,Number,uniqueItems,Boolean,minProperties,Ref(#/definitions/positiveIntegerDefault0),description,String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],maxProperties,Ref(#/definitions/positiveInteger),properties,AdditionalProperties[ARRAY(0x807ad9f00),Ref(#)]&PatternProperties[]&Properties[]&Object,definitions,AdditionalProperties[ARRAY(0x807b62c60),Ref(#)]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),allOf,Ref(#/definitions/schemaArray),exclusiveMaximum,Boolean,minimum,Number,additionalItems,AnyOf[Boolean,Ref(#)],maxItems,Ref(#/definitions/positiveInteger),default,Any,id,String,multipleOf,ExclusiveMinimum[0]&Number,minItems,Ref(#/definitions/positiveIntegerDefault0),anyOf,Ref(#/definitions/schemaArray),patternProperties,AdditionalProperties[ARRAY(0x807b63798),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,pattern,String,$schema,String,minLength,Ref(#/definitions/positiveIntegerDefault0),exclusiveMinimum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[slurpy ArrayRef[Ref(#/definitions/simpleTypes)]]&MinItems[1]&Array&UniqueItems]]&Object" requires that the value pass "Dependency[exclusiveMaximum,ARRAY(0x807a98ba0)]", "Dependency[exclusiveMinimum,ARRAY(0x807a98b88)]", "Object", and "Properties[additionalProperties,AnyOf[Boolean,Ref(#)],dependencies,AdditionalProperties[ARRAY(0x807a4c870),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,maxLength,Ref(#/definitions/positiveInteger),not,Ref(#),oneOf,Ref(#/definitions/schemaArray),enum,MinItems[1]&Array&UniqueItems,maximum,Number,uniqueItems,Boolean,minProperties,Ref(#/definitions/positiveIntegerDefault0),description,String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],maxProperties,Ref(#/definitions/positiveInteger),properties,AdditionalProperties[ARRAY(0x807ad9f00),Ref(#)]&PatternProperties[]&Properties[]&Object,definitions,AdditionalProperties[ARRAY(0x807b62c60),Ref(#)]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),allOf,Ref(#/definitions/schemaArray),exclusiveMaximum,Boolean,minimum,Number,additionalItems,AnyOf[Boolean,Ref(#)],maxItems,Ref(#/definitions/positiveInteger),default,Any,id,String,multipleOf,ExclusiveMinimum[0]&Number,minItems,Ref(#/definitions/positiveIntegerDefault0),anyOf,Ref(#/definitions/schemaArray),patternProperties,AdditionalProperties[ARRAY(0x807b63798),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,pattern,String,$schema,String,minLength,Ref(#/definitions/positiveIntegerDefault0),exclusiveMinimum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[slurpy ArrayRef[Ref(#/definitions/simpleTypes)]]&MinItems[1]&Array&UniqueItems]]"
        # Reference {"definitions" => {"foo" => 'HASH(0x8091840a8)'}} did not pass type constraint "Properties[additionalProperties,AnyOf[Boolean,Ref(#)],dependencies,AdditionalProperties[ARRAY(0x807a4c870),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,maxLength,Ref(#/definitions/positiveInteger),not,Ref(#),oneOf,Ref(#/definitions/schemaArray),enum,MinItems[1]&Array&UniqueItems,maximum,Number,uniqueItems,Boolean,minProperties,Ref(#/definitions/positiveIntegerDefault0),description,String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],maxProperties,Ref(#/definitions/positiveInteger),properties,AdditionalProperties[ARRAY(0x807ad9f00),Ref(#)]&PatternProperties[]&Properties[]&Object,definitions,AdditionalProperties[ARRAY(0x807b62c60),Ref(#)]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),allOf,Ref(#/definitions/schemaArray),exclusiveMaximum,Boolean,minimum,Number,additionalItems,AnyOf[Boolean,Ref(#)],maxItems,Ref(#/definitions/positiveInteger),default,Any,id,String,multipleOf,ExclusiveMinimum[0]&Number,minItems,Ref(#/definitions/positiveIntegerDefault0),anyOf,Ref(#/definitions/schemaArray),patternProperties,AdditionalProperties[ARRAY(0x807b63798),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,pattern,String,$schema,String,minLength,Ref(#/definitions/positiveIntegerDefault0),exclusiveMinimum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[slurpy ArrayRef[Ref(#/definitions/simpleTypes)]]&MinItems[1]&Array&UniqueItems]]"
        # "Properties[additionalProperties,AnyOf[Boolean,Ref(#)],dependencies,AdditionalProperties[ARRAY(0x807a4c870),AnyOf[Ref(#),Ref(#/definitions/stringArray)]]&PatternProperties[]&Properties[]&Object,maxLength,Ref(#/definitions/positiveInteger),not,Ref(#),oneOf,Ref(#/definitions/schemaArray),enum,MinItems[1]&Array&UniqueItems,maximum,Number,uniqueItems,Boolean,minProperties,Ref(#/definitions/positiveIntegerDefault0),description,String,items,AnyOf[Ref(#),Ref(#/definitions/schemaArray)],maxProperties,Ref(#/definitions/positiveInteger),properties,AdditionalProperties[ARRAY(0x807ad9f00),Ref(#)]&PatternProperties[]&Properties[]&Object,definitions,AdditionalProperties[ARRAY(0x807b62c60),Ref(#)]&PatternProperties[]&Properties[]&Object,required,Ref(#/definitions/stringArray),allOf,Ref(#/definitions/schemaArray),exclusiveMaximum,Boolean,minimum,Number,additionalItems,AnyOf[Boolean,Ref(#)],maxItems,Ref(#/definitions/positiveInteger),default,Any,id,String,multipleOf,ExclusiveMinimum[0]&Number,minItems,Ref(#/definitions/positiveIntegerDefault0),anyOf,Ref(#/definitions/schemaArray),patternProperties,AdditionalProperties[ARRAY(0x807b63798),Ref(#)]&PatternProperties[]&Properties[]&Object,title,String,pattern,String,$schema,String,minLength,Ref(#/definitions/positiveIntegerDefault0),exclusiveMinimum,Boolean,type,AnyOf[Ref(#/definitions/simpleTypes),~ArrayRef|Tuple[slurpy ArrayRef[Ref(#/definitions/simpleTypes)]]&MinItems[1]&Array&UniqueItems]]" 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($_); }
        # {
        #   '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(0x8091946d8)'},{"foo" => 'HASH(0x809197f30)'}] 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};} @$_)); }
        # {
        #   'dependencies' => {
        #     'bar' => [
        #       'foo'
        #     ]
        #   }
        # }
        # Reference {"bar" => 2} did not pass type constraint "Dependency[bar,ARRAY(0x8091bf6c0)]"
        # "Dependency[bar,ARRAY(0x8091bf6c0)]" 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(0x8091b9540)]"
        # "Dependency[quux,ARRAY(0x8091b9540)]" 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(0x8091b9540)]"
        # "Dependency[quux,ARRAY(0x8091b9540)]" 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(0x8091b9540)]"
        # "Dependency[quux,ARRAY(0x8091b9540)]" 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,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091c3138)]"
        # "Dependency[bar,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091c3138)]" 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,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091c3138)]"
        # "Dependency[bar,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091c3138)]" 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,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091c3138)]"
        # "Dependency[bar,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091c3138)]" 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,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091caee8)]&Dependency[bar,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091ca828)]" requires that the value pass "Dependency[bar,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091ca828)]" and "Dependency[foo,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091caee8)]"
        # Reference {"bar" => 2} did not pass type constraint "Dependency[bar,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091ca828)]"
        # "Dependency[bar,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091ca828)]" 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,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091caee8)]&Dependency[bar,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091ca828)]" requires that the value pass "Dependency[bar,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091ca828)]" and "Dependency[foo,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091caee8)]"
        # Reference {"bar" => 2,"foo" => 1} did not pass type constraint "Dependency[bar,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091ca828)]"
        # "Dependency[bar,Moose::Meta::Class::__ANON__::SERIAL::15=HASH(0x8091ca828)]" 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($_); }
        # {
        #   '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($_); }
        # {
        #   '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($_); }
        # {
        #   '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[~Any]"
        # "PropertyNames[~Any]" 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 %$_); }
        # bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' )
        # bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
        # Value "1" did not pass type constraint "~Any"
        # "~Any" is defined as: (not((!!1)))
        # Value "foo" did not pass type constraint "~Any"
        # "~Any" is defined as: (not((!!1)))
        # Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) did not pass type constraint "~Any"
        # "~Any" is defined as: (not((!!1)))
        # Reference bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ) did not pass type constraint "~Any"
        # "~Any" is defined as: (not((!!1)))
        # Undef did not pass type constraint "~Any"
        # "~Any" is defined as: (not((!!1)))
        # Reference {"foo" => "bar"} did not pass type constraint "~Any"
        # "~Any" is defined as: (not((!!1)))
        # Reference {} did not pass type constraint "~Any"
        # "~Any" is defined as: (not((!!1)))
        # Reference ["foo"] did not pass type constraint "~Any"
        # "~Any" is defined as: (not((!!1)))
        # Reference [] did not pass type constraint "~Any"
        # "~Any" is defined as: (not((!!1)))
        # {
        #   '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'
        #     }
        #   ]
        # }
        # {
        #   '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($_); }
        # {
        #   '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($_); }
        # {
        #   '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.*,~Any]"
        # "PatternProperties[f.*,Any,b.*,~Any]" 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.*,~Any]"
        # "PatternProperties[f.*,Any,b.*,~Any]" 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(0x8091132e8),0]&PatternProperties[^v,Any]&Properties[bar,Any,foo,Any]" requires that the value pass "AdditionalProperties[ARRAY(0x8091132e8),0]", "PatternProperties[^v,Any]", and "Properties[bar,Any,foo,Any]"
        # Reference {"bar" => 2,"foo" => 1,"quux" => "boom"} did not pass type constraint "AdditionalProperties[ARRAY(0x8091132e8),0]"
        # "AdditionalProperties[ARRAY(0x8091132e8),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(0x809239930),Boolean]&PatternProperties[]&Properties[bar,Any,foo,Any]" requires that the value pass "AdditionalProperties[ARRAY(0x809239930),Boolean]", "PatternProperties[]", and "Properties[bar,Any,foo,Any]"
        # Reference {"bar" => 2,"foo" => 1,"quux" => 12} did not pass type constraint "AdditionalProperties[ARRAY(0x809239930),Boolean]"
        # "AdditionalProperties[ARRAY(0x809239930),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(0x80923b4e0),Boolean]&PatternProperties[]&Properties[]" requires that the value pass "AdditionalProperties[ARRAY(0x80923b4e0),Boolean]", "PatternProperties[]", and "Properties[]"
        # Reference {"foo" => 1} did not pass type constraint "AdditionalProperties[ARRAY(0x80923b4e0),Boolean]"
        # "AdditionalProperties[ARRAY(0x80923b4e0),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' => {}
        #   }
        # }
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(0x807a23ee8)]"
        # Reference {"foo" => "x"} did not pass type constraint "Enum[foo,HASH(0x8079aa330)]"
        # 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(0x807a64648),0]"
t/types_draft4.t ....... ok
All tests successful.
Files=13, Tests=139, 12 wallclock secs ( 0.07 usr  0.25 sys +  7.64 cusr  3.69 csys = 11.65 CPU)
Result: PASS

------------------------------
PREREQUISITES
------------------------------

Prerequisite modules loaded:

requires:

    Module                 Need     Have    
    ---------------------- -------- --------
    Clone                  0        0.39    
    JSON                   0        2.94    
    List::AllUtils         0        0.14    
    List::MoreUtils        0        0.426   
    List::Util             0        1.49    
    LWP::Simple            0        6.29    
    Moose                  0        2.2006  
    Moose::Role            0        2.2006  
    Moose::Util            0        2.2006  
    MooseX::ClassAttribute 0        0.29    
    MooseX::MungeHas       0        0.008   
    Path::Tiny             0.062    0.104   
    perl                   5.014000 5.026001
    Scalar::Util           0        1.49    
    strict                 0        1.11    
    Type::Library          0        1.002001
    Type::Tiny             0        1.002001
    Type::Tiny::Class      0        1.002001
    Type::Utils            0        1.002001
    Types::Standard        0        1.002001
    URI                    0        1.72    
    warnings               0        1.37    

build_requires:

    Module                 Need     Have    
    ---------------------- -------- --------
    Exporter               0        5.72    
    ExtUtils::MakeMaker    0        7.58    
    File::Spec             0        3.67    
    IO::Handle             0        1.36    
    IPC::Open3             0        1.20    
    lib                    0        0.64    
    parent                 0        0.236   
    Path::Tiny             0.062    0.104   
    Test::Deep             0        1.127   
    Test::Exception        0        0.43    
    Test::More             0        1.302106

configure_requires:

    Module                 Need     Have    
    ---------------------- -------- --------
    ExtUtils::MakeMaker    0        7.58    


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

Environment variables:

    LC_ALL = de_DE.ISO8859-1
    PATH = /usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin:/home/cpansand/bin/freebsd10.3:/home/cpansand/bin/sh:/home/cpansand/bin:/usr/games:/home/cpansand/devel:/home/eserte/src/srezic-misc/scripts
    PERL5LIB = /home/cpansand/.cpan/build/2024041622/MooseX-ClassAttribute-0.29-0/blib/arch:/home/cpansand/.cpan/build/2024041622/MooseX-ClassAttribute-0.29-0/blib/lib
    PERL5OPT = 
    PERL5_CPANPLUS_IS_RUNNING = 88248
    PERL5_CPAN_IS_RUNNING = 88248
    PERL5_CPAN_IS_RUNNING_IN_RECURSION = 88211,88248
    PERLDOC = -MPod::Perldoc::ToTextOverstrike
    PERL_BATCH = yes
    PERL_CANARY_STABILITY_NOPROMPT = 1
    PERL_CPAN_REPORTER_CONFIG = /var/tmp/cpansmoker-1023/2024041622/cpanreporter_000_config.ini
    PERL_EXTUTILS_AUTOINSTALL = --defaultdeps
    PERL_USE_UNSAFE_INC = 1
    SHELL = /usr/local/bin/zsh
    TERM = screen
    TMPDIR = /var/tmp/cpansmoker-1023/2024041622

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

    $^X = /usr/perl5.26.1p/bin/perl5.26.1
    $UID/$EUID = 1023 / 1023
    $GID = 1023 1023
    $EGID = 1023 1023

Perl module toolchain versions installed:

    Module              Have    
    ------------------- --------
    CPAN                2.18    
    CPAN::Meta          2.150010
    Cwd                 3.67    
    ExtUtils::CBuilder  0.280226
    ExtUtils::Command   7.58    
    ExtUtils::Install   2.06    
    ExtUtils::MakeMaker 7.58    
    ExtUtils::Manifest  1.70    
    ExtUtils::ParseXS   3.34    
    File::Spec          3.67    
    JSON                2.94    
    JSON::PP            2.94    
    Module::Build       0.4224  
    Module::Signature   0.81    
    Parse::CPAN::Meta   2.150010
    Test::Harness       3.39    
    Test::More          1.302106
    YAML                1.24    
    YAML::Syck          1.30    
    version             0.9917  


--

Summary of my perl5 (revision 5 version 26 subversion 1) configuration:
   
  Platform:
    osname=freebsd
    osvers=10.3-release-p11
    archname=amd64-freebsd
    uname='freebsd cvrsnica-freebsd-101.herceg.de 10.3-release-p11 freebsd 10.3-release-p11 #0: mon oct 24 18:49:24 utc 2016 root@amd64-builder.daemonology.net:usrobjusrsrcsysgeneric amd64 '
    config_args='-ds -e -Dprefix=/usr/perl5.26.1p -Dcf_email=srezic@cpan.org -Doptimize=-O2 -pipe'
    hint=recommended
    useposix=true
    d_sigaction=define
    useithreads=undef
    usemultiplicity=undef
    use64bitint=define
    use64bitall=define
    uselongdouble=undef
    usemymalloc=n
    default_inc_excludes_dot=define
    bincompat5005=undef
  Compiler:
    cc='cc'
    ccflags ='-DHAS_FPSETMASK -DHAS_FLOATINGPOINT_H -fno-strict-aliasing -pipe -fstack-protector -I/usr/local/include -D_FORTIFY_SOURCE=2'
    optimize='-O2 -pipe'
    cppflags='-DHAS_FPSETMASK -DHAS_FLOATINGPOINT_H -fno-strict-aliasing -pipe -fstack-protector -I/usr/local/include'
    ccversion=''
    gccversion='4.2.1 Compatible FreeBSD Clang 3.4.1 (tags/RELEASE_34/dot1-final 208032)'
    gccosandvers=''
    intsize=4
    longsize=8
    ptrsize=8
    doublesize=8
    byteorder=12345678
    doublekind=3
    d_longlong=define
    longlongsize=8
    d_longdbl=define
    longdblsize=16
    longdblkind=3
    ivtype='long'
    ivsize=8
    nvtype='double'
    nvsize=8
    Off_t='off_t'
    lseeksize=8
    alignbytes=8
    prototype=define
  Linker and Libraries:
    ld='cc'
    ldflags ='-pthread -Wl,-E  -fstack-protector -L/usr/local/lib'
    libpth=/usr/lib /usr/local/lib /usr/include/clang/3.4.1 /usr/lib
    libs=-lpthread -lgdbm -lm -lcrypt -lutil -lc -lelf
    perllibs=-lpthread -lm -lcrypt -lutil -lc -lelf
    libc=
    so=so
    useshrplib=false
    libperl=libperl.a
    gnulibc_version=''
  Dynamic Linking:
    dlsrc=dl_dlopen.xs
    dlext=so
    d_dlsymun=undef
    ccdlflags=' '
    cccdlflags='-DPIC -fPIC'
    lddlflags='-shared  -L/usr/local/lib -fstack-protector'


Characteristics of this binary (from libperl): 
  Compile-time options:
    HAS_TIMES
    PERLIO_LAYERS
    PERL_COPY_ON_WRITE
    PERL_DONT_CREATE_GVSV
    PERL_MALLOC_WRAP
    PERL_OP_PARENT
    PERL_PRESERVE_IVUV
    USE_64_BIT_ALL
    USE_64_BIT_INT
    USE_LARGE_FILES
    USE_LOCALE
    USE_LOCALE_COLLATE
    USE_LOCALE_CTYPE
    USE_LOCALE_NUMERIC
    USE_LOCALE_TIME
    USE_PERLIO
    USE_PERL_ATOF
  Built under freebsd
  Compiled at Oct 31 2017 09:43:34
  %ENV:
    PERL5LIB="/home/cpansand/.cpan/build/2024041622/MooseX-ClassAttribute-0.29-0/blib/arch:/home/cpansand/.cpan/build/2024041622/MooseX-ClassAttribute-0.29-0/blib/lib"
    PERL5OPT=""
    PERL5_CPANPLUS_IS_RUNNING="88248"
    PERL5_CPAN_IS_RUNNING="88248"
    PERL5_CPAN_IS_RUNNING_IN_RECURSION="88211,88248"
    PERLDOC="-MPod::Perldoc::ToTextOverstrike"
    PERL_BATCH="yes"
    PERL_CANARY_STABILITY_NOPROMPT="1"
    PERL_CPAN_REPORTER_CONFIG="/var/tmp/cpansmoker-1023/2024041622/cpanreporter_000_config.ini"
    PERL_EXTUTILS_AUTOINSTALL="--defaultdeps"
    PERL_USE_UNSAFE_INC="1"
  @INC:
    /home/cpansand/.cpan/build/2024041622/MooseX-ClassAttribute-0.29-0/blib/arch
    /home/cpansand/.cpan/build/2024041622/MooseX-ClassAttribute-0.29-0/blib/lib
    /usr/perl5.26.1p/lib/site_perl/5.26.1/amd64-freebsd
    /usr/perl5.26.1p/lib/site_perl/5.26.1
    /usr/perl5.26.1p/lib/5.26.1/amd64-freebsd
    /usr/perl5.26.1p/lib/5.26.1
    .