Bug#1104375: libtype-tiny-perl: FTBFS: dh_auto_test: error: make -j8 test TEST_VERBOSE=1 returned exit code 2
Lucas Nussbaum
lucas at debian.org
Tue Apr 29 13:56:41 BST 2025
Source: libtype-tiny-perl
Version: 2.004000-1
Severity: serious
Justification: FTBFS
Tags: trixie sid ftbfs
User: lucas at debian.org
Usertags: ftbfs-20250429 ftbfs-trixie
Hi,
During a rebuild of all packages in sid, your package failed to build
on amd64.
Relevant part (hopefully):
> make[1]: Entering directory '/build/reproducible-path/libtype-tiny-perl-2.004000'
> PERL_DL_NONLAZY=1 "/usr/bin/perl" "-MExtUtils::Command::MM" "-MTest::Harness" "-e" "undef *Test::Harness::Switches; test_harness(1, 'inc', 'blib/lib', 'blib/arch')" t/*.t t/20-modules/Devel-TypeTiny-Perl58Compat/*.t t/20-modules/Error-TypeTiny-Assertion/*.t t/20-modules/Error-TypeTiny-Compilation/*.t t/20-modules/Error-TypeTiny-WrongNumberOfParameters/*.t t/20-modules/Error-TypeTiny/*.t t/20-modules/Eval-TypeTiny-CodeAccumulator/*.t t/20-modules/Eval-TypeTiny/*.t t/20-modules/Test-TypeTiny/*.t t/20-modules/Type-Coercion-FromMoose/*.t t/20-modules/Type-Coercion-Union/*.t t/20-modules/Type-Coercion/*.t t/20-modules/Type-Library/*.t t/20-modules/Type-Params-Signature/*.t t/20-modules/Type-Params/*.t t/20-modules/Type-Parser/*.t t/20-modules/Type-Registry/*.t t/20-modules/Type-Tie/*.t t/20-modules/Type-Tiny-Bitfield/*.t t/20-modules/Type-Tiny-Class/*.t t/20-modules/Type-Tiny-ConstrainedObject/*.t t/20-modules/Type-Tiny-Duck/*.t t/20-modules/Type-Tiny-Enum/*.t t/20-modules/Type-Tiny-Intersection/*.t t/20-modules/Type-Tiny-Role/*.t t/20-modules/Type-Tiny-Union/*.t t/20-modules/Type-Tiny-_HalfOp/*.t t/20-modules/Type-Tiny/*.t t/20-modules/Type-Utils/*.t t/20-modules/Types-Common-Numeric/*.t t/20-modules/Types-Common-String/*.t t/20-modules/Types-Common/*.t t/20-modules/Types-Standard/*.t t/20-modules/Types-TypeTiny/*.t t/21-types/*.t t/30-external/Class-InsideOut/*.t t/30-external/Class-Plain/*.t t/30-external/Data-Constraint/*.t t/30-external/Exporter-Tiny/*.t t/30-external/Function-Parameters/*.t t/30-external/JSON-PP/*.t t/30-external/Kavorka/*.t t/30-external/Moo/*.t t/30-external/Moops/*.t t/30-external/Moose/*.t t/30-external/MooseX-Getopt/*.t t/30-external/MooseX-Types/*.t t/30-external/Mouse/*.t t/30-external/MouseX-Types/*.t t/30-external/Object-Accessor/*.t t/30-external/Return-Type/*.t t/30-external/Specio/*.t t/30-external/Sub-Quote/*.t t/30-external/Switcheroo/*.t t/30-external/Type-Library-Compiler/*.t t/30-external/Types-ReadOnly/*.t t/30-external/Validation-Class-Simple/*.t t/30-external/match-simple/*.t t/40-bugs/*.t
> #
> # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
> #
> # PERL: 5.040001
> # XS: maybe XS
> # NUMBERS: loose
> # TESTING: normal
> #
> # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
> #
> # Exporter::Tiny 1.006002
> # Return::Type 0.007
> # Type::Tiny::XS 0.025
> #
> # Scalar::Util/Sub::Util 1.63/1.63
> # Ref::Util/Ref::Util::XS undef/undef
> # Regexp::Util undef
> # Class::XSAccessor 1.19
> # Devel::LexAlias/PadWalker 0.05/2.5
> # Devel::StackTrace 2.05
> #
> # Class::Tiny undef
> # Moo/MooX::TypeTiny 2.005005/undef
> # Moose/MooseX::Types 2.2207/0.51
> # Mouse/MouseX::Types 2.5/0.06
> #
> # $AUTOMATED_TESTING undef
> # $NONINTERACTIVE_TESTING undef
> # $EXTENDED_TESTING undef
> # $AUTHOR_TESTING undef
> # $RELEASE_TESTING undef
> #
> # $PERL_TYPE_TINY_XS undef
> # $PERL_TYPES_STANDARD_STRICTNUM undef
> # $PERL_ONLY undef
> #
> # >>>> Type::Tiny is using Type::Tiny::XS
> #
> # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
> #
> t/00-begin.t .................................................
> ok 1
> 1..1
> ok
> t/01-compile.t ...............................................
> ok 1 - use Eval::TypeTiny;
> ok 2 - use Test::TypeTiny;
> ok 3 - use Type::Coercion;
> ok 4 - use Type::Coercion::Union;
> ok 5 - use Error::TypeTiny;
> ok 6 - use Error::TypeTiny::Assertion;
> ok 7 - use Error::TypeTiny::Compilation;
> ok 8 - use Error::TypeTiny::WrongNumberOfParameters;
> ok 9 - use Type::Library;
> ok 10 - use Types::Standard;
> ok 11 - use Types::TypeTiny;
> ok 12 - use Type::Tiny;
> ok 13 - use Type::Tiny::Class;
> ok 14 - use Type::Tiny::Duck;
> ok 15 - use Type::Tiny::Enum;
> ok 16 - use Type::Tiny::Intersection;
> ok 17 - use Type::Tiny::Role;
> ok 18 - use Type::Tiny::Union;
> ok 19 - use Type::Utils;
> ok 20 - use Type::Params;
> 1..20
> ok
> t/02-api.t ...................................................
> ok 1 - Moose::Meta::TypeConstraint API: TestType->can('_actually_compile_type_constraint')
> ok 2 - Moose::Meta::TypeConstraint API: TestType->can('_collect_all_parents')
> ok 3 - Moose::Meta::TypeConstraint API: TestType->can('_compile_subtype')
> ok 4 - Moose::Meta::TypeConstraint API: TestType->can('_compile_type')
> ok 5 - Moose::Meta::TypeConstraint API: TestType->can('_compiled_type_constraint')
> ok 6 - Moose::Meta::TypeConstraint API: TestType->can('_default_message')
> ok 7 - Moose::Meta::TypeConstraint API: TestType->can('_has_compiled_type_constraint')
> ok 8 - Moose::Meta::TypeConstraint API: TestType->can('_inline_check')
> ok 9 - Moose::Meta::TypeConstraint API: TestType->can('_new')
> ok 10 - Moose::Meta::TypeConstraint API: TestType->can('_package_defined_in')
> ok 11 - Moose::Meta::TypeConstraint API: TestType->can('_set_constraint')
> ok 12 - Moose::Meta::TypeConstraint API: TestType->can('assert_coerce')
> ok 13 - Moose::Meta::TypeConstraint API: TestType->can('assert_valid')
> ok 14 - Moose::Meta::TypeConstraint API: TestType->can('can_be_inlined')
> ok 15 - Moose::Meta::TypeConstraint API: TestType->can('check')
> ok 16 - Moose::Meta::TypeConstraint API: TestType->can('coerce')
> ok 17 - Moose::Meta::TypeConstraint API: TestType->can('coercion')
> ok 18 - Moose::Meta::TypeConstraint API: TestType->can('compile_type_constraint')
> ok 19 - Moose::Meta::TypeConstraint API: TestType->can('constraint')
> ok 20 - Moose::Meta::TypeConstraint API: TestType->can('create_child_type')
> ok 21 - Moose::Meta::TypeConstraint API: TestType->can('equals')
> ok 22 - Moose::Meta::TypeConstraint API: TestType->can('get_message')
> ok 23 - Moose::Meta::TypeConstraint API: TestType->can('has_coercion')
> ok 24 - Moose::Meta::TypeConstraint API: TestType->can('has_message')
> ok 25 - Moose::Meta::TypeConstraint API: TestType->can('has_parent')
> ok 26 - Moose::Meta::TypeConstraint API: TestType->can('inline_environment')
> ok 27 - Moose::Meta::TypeConstraint API: TestType->can('inlined')
> ok 28 - Moose::Meta::TypeConstraint API: TestType->can('is_a_type_of')
> ok 29 - Moose::Meta::TypeConstraint API: TestType->can('is_subtype_of')
> ok 30 - Moose::Meta::TypeConstraint API: TestType->can('message')
> ok 31 - Moose::Meta::TypeConstraint API: TestType->can('meta')
> ok 32 - Moose::Meta::TypeConstraint API: TestType->can('name')
> ok 33 - Moose::Meta::TypeConstraint API: TestType->can('new')
> ok 34 - Moose::Meta::TypeConstraint API: TestType->can('parent')
> ok 35 - Moose::Meta::TypeConstraint API: TestType->can('parents')
> ok 36 - Moose::Meta::TypeConstraint API: TestType->can('validate')
> ok 37 - Moose::Meta::TypeConstraint API: TestType->can('bleh_this_does_not_exist')
> ok 38
> ok 39
> ok 40 - Mouse::Meta::TypeConstraint API: TestType->can('__is_parameterized')
> ok 41 - Mouse::Meta::TypeConstraint API: TestType->can('_add_type_coercions')
> ok 42 - Mouse::Meta::TypeConstraint API: TestType->can('_as_string')
> ok 43 - Mouse::Meta::TypeConstraint API: TestType->can('_compiled_type_coercion')
> ok 44 - Mouse::Meta::TypeConstraint API: TestType->can('_compiled_type_constraint')
> ok 45 - Mouse::Meta::TypeConstraint API: TestType->can('_identity')
> ok 46 - Mouse::Meta::TypeConstraint API: TestType->can('_unite')
> ok 47 - Mouse::Meta::TypeConstraint API: TestType->can('assert_valid')
> ok 48 - Mouse::Meta::TypeConstraint API: TestType->can('check')
> ok 49 - Mouse::Meta::TypeConstraint API: TestType->can('coerce')
> ok 50 - Mouse::Meta::TypeConstraint API: TestType->can('compile_type_constraint')
> ok 51 - Mouse::Meta::TypeConstraint API: TestType->can('create_child_type')
> ok 52 - Mouse::Meta::TypeConstraint API: TestType->can('get_message')
> ok 53 - Mouse::Meta::TypeConstraint API: TestType->can('has_coercion')
> ok 54 - Mouse::Meta::TypeConstraint API: TestType->can('is_a_type_of')
> ok 55 - Mouse::Meta::TypeConstraint API: TestType->can('message')
> ok 56 - Mouse::Meta::TypeConstraint API: TestType->can('name')
> ok 57 - Mouse::Meta::TypeConstraint API: TestType->can('new')
> ok 58 - Mouse::Meta::TypeConstraint API: TestType->can('parameterize')
> ok 59 - Mouse::Meta::TypeConstraint API: TestType->can('parent')
> ok 60 - Mouse::Meta::TypeConstraint API: TestType->can('type_parameter')
> ok 61 - Moose::Meta::TypeCoercion API: TestCoercion->can('_compiled_type_coercion')
> ok 62 - Moose::Meta::TypeCoercion API: TestCoercion->can('_new')
> ok 63 - Moose::Meta::TypeCoercion API: TestCoercion->can('add_type_coercions')
> ok 64 - Moose::Meta::TypeCoercion API: TestCoercion->can('coerce')
> ok 65 - Moose::Meta::TypeCoercion API: TestCoercion->can('compile_type_coercion')
> ok 66 - Moose::Meta::TypeCoercion API: TestCoercion->can('has_coercion_for_type')
> ok 67 - Moose::Meta::TypeCoercion API: TestCoercion->can('meta')
> ok 68 - Moose::Meta::TypeCoercion API: TestCoercion->can('new')
> ok 69 - Moose::Meta::TypeCoercion API: TestCoercion->can('type_coercion_map')
> ok 70 - Moose::Meta::TypeCoercion API: TestCoercion->can('type_constraint')
> 1..70
> ok
> t/03-leak.t .................................................. skipped: useithreads
> t/20-modules/Devel-TypeTiny-Perl58Compat/basic.t .............
> ok 1 - re::is_regexp(qr{foo})
> ok 2 - re::is_regexp(bless qr{foo}, "Foo")
> 1..2
> ok
> t/20-modules/Error-TypeTiny-Assertion/basic.t ................
> ok 1 - autogeneration of $e->message
> ok 2 - '$e' isa 'Error::TypeTiny'
> ok 3 - $Error::TypeTiny::LastError
> ok 4 - $e->message is as expected
> ok 5 - '$e' isa 'Error::TypeTiny::Assertion'
> ok 6 - $e->type is as expected
> ok 7 - $e->value is as expected
> ok 8 - $e->explain is as expected
> ok 9 - ArrayRef[Int] deep explanation, given [1, 2, [3]]
> ok 10 - ArrayRef[Int] deep explanation, given {}
> ok 11 - Ref["ARRAY"] deep explanation, given {}
> ok 12 - HashRef[Maybe[Int]] deep explanation, given {a => undef, b => 42, c => []}
> ok 13 - $dict deep explanation, given {a => 1, c => 1}
> ok 14 - $dict deep explanation, given {b => 1}
> ok 15 - $dict deep explanation, given {a => 1, b => 2}
> not ok 16 - Map[Int,Num] deep explanation, given {1=>1.1,2.2=>2.3,3.3=>3.4} # TODO Data::Dumper output changed after 2.145
> # Failed (TODO) test 'Map[Int,Num] deep explanation, given {1=>1.1,2.2=>2.3,3.3=>3.4}'
> # at t/20-modules/Error-TypeTiny-Assertion/basic.t line 178.
> # Structures begin differing at:
> # $got->[0] = 'Reference {"1" => "1.1","2.2" => "2.3","3.3" => "3.4"} did not pass type constraint "Map[Int,Num]"'
> # $expected->[0] = 'Reference {1 => "1.1","2.2" => "2.3","3.3" => "3.4"} did not pass type constraint "Map[Int,Num]"'
> ok 17 - Dict[foo=>ArrayRef,Slurpy[Map[Ext,Int]]] works ok it seems
> ok 18 - $AlwaysFail explanation, given 1
> ok 19 - $TupleOf1 explanation, given [1,2]
> ok 20 - $CTuple explanation, given [1,"Foo"]
> ok 21 - $SlurpyThing explanation, given 1
> ok 22 - $SlurpyThing explanation, given [[]]
> ok 23 - $SlurpyThing explanation, given [1.1, yeah => "Hello"]
> ok 24 - $UndefRef explanantion, given \"bar"
> ok 25 - $UndefRef explanantion, given []
> ok 26 - $e_where->context
> ok 27 - "$e_where"
> ok 28 - correct exception from type with null constraint
> ok 29 - local $Type::Tiny::DD
> 1..29
> ok
> t/20-modules/Error-TypeTiny-Compilation/basic.t ..............
> ok 1 - '$e' isa 'Error::TypeTiny::Compilation'
> ok 2 - throw exception when code does not compile
> ok 3 - $e->message
> # Subtest: $e->context
> ok 1 - $ctx->{package}
> ok 2 - $ctx->{file}
> ok 3 - $ctx->{line} >= 37
> ok 4 - $ctx->{line} <= 42
> 1..4
> ok 4 - $e->context
> ok 5 - $e->errstr
> ok 6 - $e->code
> ok 7 - $e->environment
> 1..7
> ok
> t/20-modules/Error-TypeTiny-WrongNumberOfParameters/basic.t ..
> # Subtest: nth_root()
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> 1..6
> ok 1 - nth_root()
> # Subtest: nth_root(1)
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> 1..6
> ok 2 - nth_root(1)
> # Subtest: nth_root(1, 2, 3)
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> 1..6
> ok 3 - nth_root(1, 2, 3)
> # Subtest: nth_root_opt()
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> 1..6
> ok 4 - nth_root_opt()
> # Subtest: nth_root_slurp()
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> 1..6
> ok 5 - nth_root_slurp()
> ok 6 - silly exception which should never happen anyway
> ok 7 - unspecific exception
> 1..7
> ok
> t/20-modules/Error-TypeTiny/basic.t ..........................
> ok 1 - $e1->message (default)
> ok 2 - $e1->context->{main}
> ok 3 - $e1->contex1t->{line}
> ok 4 - $e1->context->{file}
> ok 5 - $e2->message
> ok 6 - $e3->message (set by croak)
> 1..6
> ok
> t/20-modules/Error-TypeTiny/stacktrace.t .....................
> ok 1
> 1..1
> ok
> t/20-modules/Eval-TypeTiny-CodeAccumulator/basic.t ...........
> ok 1
> ok 2
> ok 3
> # sub {
> # my $other_addend = shift;
> #
> # return $addend + $other_addend;
> # }
> ok 4
> 1..4
> ok
> t/20-modules/Eval-TypeTiny-CodeAccumulator/callback.t ........
> ok 1
> ok 2
> ok 3
> # sub {
> # my $other_addend = shift;
> #
> # return $addend + $other_addend;
> # }
> ok 4
> 1..4
> ok
> t/20-modules/Eval-TypeTiny/aliases-devel-lexalias.t ..........
> ok 1 - tied implementation was not used
> ok 2 - closure over scalar
> ok 3 - closure over array
> ok 4 - closure over hash
> ok 5 - closure over scalar - worked
> ok 6 - closure over array - worked
> ok 7 - closure over hash - worked
> ok 8 - closing over variables really really really works!
> ok 9
> ok 10
> ok 11 - closed over variables disappear on cue
> 1..11
> ok
> t/20-modules/Eval-TypeTiny/aliases-native.t ..................
> ok 1 - tied implementation was not used
> ok 2 - closure over scalar
> ok 3 - closure over array
> ok 4 - closure over hash
> ok 5 - closure over scalar - worked
> ok 6 - closure over array - worked
> ok 7 - closure over hash - worked
> ok 8 - closing over variables really really really works!
> ok 9
> ok 10
> ok 11 - closed over variables disappear on cue
> 1..11
> ok
> t/20-modules/Eval-TypeTiny/aliases-padwalker.t ...............
> ok 1 - tied implementation was not used
> ok 2 - closure over scalar
> ok 3 - closure over array
> ok 4 - closure over hash
> ok 5 - closure over scalar - worked
> ok 6 - closure over array - worked
> ok 7 - closure over hash - worked
> ok 8 - closing over variables really really really works!
> ok 9
> ok 10
> ok 11 - closed over variables disappear on cue
> 1..11
> ok
> t/20-modules/Eval-TypeTiny/aliases-tie.t .....................
> ok 1 - tied implementation was loaded
> ok 2 - closure over scalar
> ok 3 - closure over array
> ok 4 - closure over hash
> ok 5 - closure over scalar - worked
> ok 6 - closure over array - worked
> ok 7 - closure over hash - worked
> ok 8 - closing over variables really really really works!
> ok 9
> ok 10
> ok 11 - closed over variables disappear on cue
> 1..11
> ok
> t/20-modules/Eval-TypeTiny/basic.t ...........................
> # Subtest: constants exist
> # Subtest: constant HAS_LEXICAL_SUBS
> ok 1 - constant HAS_LEXICAL_SUBS exists
> ok 2 - ... and doesn't throw an error
> ok 3 - ... and seems to be constant
> 1..3
> ok 1 - constant HAS_LEXICAL_SUBS
> # Subtest: constant ALIAS_IMPLEMENTATION
> ok 1 - constant ALIAS_IMPLEMENTATION exists
> ok 2 - ... and doesn't throw an error
> ok 3 - ... and seems to be constant
> 1..3
> ok 2 - constant ALIAS_IMPLEMENTATION
> # Subtest: constant IMPLEMENTATION_DEVEL_LEXALIAS
> ok 1 - constant IMPLEMENTATION_DEVEL_LEXALIAS exists
> ok 2 - ... and doesn't throw an error
> ok 3 - ... and seems to be constant
> 1..3
> ok 3 - constant IMPLEMENTATION_DEVEL_LEXALIAS
> # Subtest: constant IMPLEMENTATION_PADWALKER
> ok 1 - constant IMPLEMENTATION_PADWALKER exists
> ok 2 - ... and doesn't throw an error
> ok 3 - ... and seems to be constant
> 1..3
> ok 4 - constant IMPLEMENTATION_PADWALKER
> # Subtest: constant IMPLEMENTATION_NATIVE
> ok 1 - constant IMPLEMENTATION_NATIVE exists
> ok 2 - ... and doesn't throw an error
> ok 3 - ... and seems to be constant
> 1..3
> ok 5 - constant IMPLEMENTATION_NATIVE
> # Subtest: constant IMPLEMENTATION_TIE
> ok 1 - constant IMPLEMENTATION_TIE exists
> ok 2 - ... and doesn't throw an error
> ok 3 - ... and seems to be constant
> 1..3
> ok 6 - constant IMPLEMENTATION_TIE
> 1..6
> ok 1 - constants exist
> # Subtest: compiling string source
> ok 1 - closure over scalar
> ok 2 - closure over array
> ok 3 - closure over hash
> 1..3
> ok 2 - compiling string source
> # Subtest: compiling arrayref source
> ok 1 - closure over scalar
> ok 2 - closure over array
> ok 3 - closure over hash
> 1..3
> ok 3 - compiling arrayref source
> ok 4 - closing over variables really really really works!
> # Subtest: closed over variables disappear on cue
> ok 1 - closure works
> ok 2 - closed over variable still exists
> ok 3 - closed over variable destroyed once closure has been destroyed
> 1..3
> ok 5 - closed over variables disappear on cue
> # Subtest: tied variables can be closed over (even with tied alias implementation)
> ok 1 - can close over tied variables ... AUTOLOAD stuff
> ok 2 - ... can
> ok 3 - ... !can
> ok 4 - ... tie still works
> ok 5 - ... can be retied
> ok 6 - ... can be untied
> 1..6
> ok 6 - tied variables can be closed over (even with tied alias implementation)
> ok 7 - "description" option works
> ok 8 - "line" option works
> # Subtest: exception for syntax error
> ok 1 - proper exceptions thrown for compilation errors
> ok 2 - $exception->code
> ok 3 - $exception->errstr
> ok 4 - $exception->context
> 1..4
> ok 9 - exception for syntax error
> # Subtest: exception for syntax error (given arrayref)
> ok 1 - proper exceptions thrown for compilation errors
> ok 2 - $exception->code
> ok 3 - $exception->errstr
> ok 4 - $exception->context
> 1..4
> ok 10 - exception for syntax error (given arrayref)
> # Subtest: exception for wrong reference type
> ok 1 - exception was thrown
> 1..1
> ok 11 - exception for wrong reference type
> # Subtest: _pick_alternative
> ok 1
> ok 2
> 1..2
> ok 12 - _pick_alternative
> 1..12
> ok
> t/20-modules/Eval-TypeTiny/lexical-subs.t ....................
> ok 1 - closure over scalar
> ok 2 - closure over array
> ok 3 - closure over hash
> ok 4 - closure over lexical sub - undef
> ok 5 - closure over lexical sub - 2
> ok 6 - closure over lexical sub - 42
> ok 7 - '$e' isa 'Error::TypeTiny::Compilation'
> ok 8 - throw exception when code does not compile
> ok 9 - $e->errstr
> ok 10 - $e->code
> ok 11 - "description" option works
> ok 12 - "line" option works
> 1..12
> ok
> t/20-modules/Test-TypeTiny/basic.t ...........................
> 1..48
> ok 1 - Test 'successful should_pass' completed
> ok 2 - Test 'successful should_pass' no premature diagnostication
> ok 3 - Test 'successful should_pass' result count
> ok 4 - subtest 'Value "1" passes type constraint Int' of 'successful should_pass' compare ok
> ok 5 - subtest 'Value "1" passes type constraint Int' of 'successful should_pass' compare type
> ok 6 - subtest 'Value "1" passes type constraint Int' of 'successful should_pass' compare name
> ok 7 - checking depth
> ok 8 - subtest 'Value "1" passes type constraint Int' of 'successful should_pass' compare diag
> ok 9 - Test 'unsuccessful should_pass' completed
> ok 10 - Test 'unsuccessful should_pass' no premature diagnostication
> ok 11 - Test 'unsuccessful should_pass' result count
> ok 12 - subtest 'Reference [] passes type constraint Int' of 'unsuccessful should_pass' compare ok
> ok 13 - subtest 'Reference [] passes type constraint Int' of 'unsuccessful should_pass' compare type
> ok 14 - subtest 'Reference [] passes type constraint Int' of 'unsuccessful should_pass' compare name
> ok 15 - checking depth
> ok 16 - subtest 'Reference [] passes type constraint Int' of 'unsuccessful should_pass' compare diag
> ok 17 - Test 'successful (i.e. failing) should_fail' completed
> ok 18 - Test 'successful (i.e. failing) should_fail' no premature diagnostication
> ok 19 - Test 'successful (i.e. failing) should_fail' result count
> ok 20 - subtest 'Reference [] fails type constraint Int' of 'successful (i.e. failing) should_fail' compare ok
> ok 21 - subtest 'Reference [] fails type constraint Int' of 'successful (i.e. failing) should_fail' compare type
> ok 22 - subtest 'Reference [] fails type constraint Int' of 'successful (i.e. failing) should_fail' compare name
> ok 23 - checking depth
> ok 24 - subtest 'Reference [] fails type constraint Int' of 'successful (i.e. failing) should_fail' compare diag
> ok 25 - Test 'unsuccessful (i.e. passing) should_fail' completed
> ok 26 - Test 'unsuccessful (i.e. passing) should_fail' no premature diagnostication
> ok 27 - Test 'unsuccessful (i.e. passing) should_fail' result count
> ok 28 - subtest 'Value "1" fails type constraint Int' of 'unsuccessful (i.e. passing) should_fail' compare ok
> ok 29 - subtest 'Value "1" fails type constraint Int' of 'unsuccessful (i.e. passing) should_fail' compare type
> ok 30 - subtest 'Value "1" fails type constraint Int' of 'unsuccessful (i.e. passing) should_fail' compare name
> ok 31 - checking depth
> ok 32 - subtest 'Value "1" fails type constraint Int' of 'unsuccessful (i.e. passing) should_fail' compare diag
> ok 33 - Test 'successful ok_subtype' completed
> ok 34 - Test 'successful ok_subtype' no premature diagnostication
> ok 35 - Test 'successful ok_subtype' result count
> ok 36 - subtest 'Num subtype: Int' of 'successful ok_subtype' compare ok
> ok 37 - subtest 'Num subtype: Int' of 'successful ok_subtype' compare type
> ok 38 - subtest 'Num subtype: Int' of 'successful ok_subtype' compare name
> ok 39 - checking depth
> ok 40 - subtest 'Num subtype: Int' of 'successful ok_subtype' compare diag
> ok 41 - Test 'unsuccessful ok_subtype' completed
> ok 42 - Test 'unsuccessful ok_subtype' no premature diagnostication
> ok 43 - Test 'unsuccessful ok_subtype' result count
> ok 44 - subtest 'Int subtype: Num' of 'unsuccessful ok_subtype' compare ok
> ok 45 - subtest 'Int subtype: Num' of 'unsuccessful ok_subtype' compare type
> ok 46 - subtest 'Int subtype: Num' of 'unsuccessful ok_subtype' compare name
> ok 47 - checking depth
> ok 48 - subtest 'Int subtype: Num' of 'unsuccessful ok_subtype' compare diag
> ok
> t/20-modules/Test-TypeTiny/extended.t ........................
> 1..16
> ok 1 - Test 'successful ok_subtype' completed
> ok 2 - Test 'successful ok_subtype' no premature diagnostication
> ok 3 - Test 'successful ok_subtype' result count
> ok 4 - subtest 'Num subtype: Int' of 'successful ok_subtype' compare ok
> ok 5 - subtest 'Num subtype: Int' of 'successful ok_subtype' compare type
> ok 6 - subtest 'Num subtype: Int' of 'successful ok_subtype' compare name
> ok 7 - checking depth
> ok 8 - subtest 'Num subtype: Int' of 'successful ok_subtype' compare diag
> ok 9 - Test 'unsuccessful ok_subtype' completed
> ok 10 - Test 'unsuccessful ok_subtype' no premature diagnostication
> ok 11 - Test 'unsuccessful ok_subtype' result count
> ok 12 - subtest 'Int subtype: Num' of 'unsuccessful ok_subtype' compare ok
> ok 13 - subtest 'Int subtype: Num' of 'unsuccessful ok_subtype' compare type
> ok 14 - subtest 'Int subtype: Num' of 'unsuccessful ok_subtype' compare name
> ok 15 - checking depth
> ok 16 - subtest 'Int subtype: Num' of 'unsuccessful ok_subtype' compare diag
> ok
> t/20-modules/Test-TypeTiny/matchfor.t ........................
> 1..6
> ok 1 - stringification
> # Subtest: successful matchfor(qr//)
> ok 1 - Test 'successful matchfor(qr//)' completed
> ok 2 - Test 'successful matchfor(qr//)' no premature diagnostication
> ok 3 - Test 'successful matchfor(qr//)' result count
> ok 4 - subtest 'ONE' of 'successful matchfor(qr//)' compare ok
> ok 5 - subtest 'ONE' of 'successful matchfor(qr//)' compare type
> ok 6 - subtest 'ONE' of 'successful matchfor(qr//)' compare name
> ok 7 - checking depth
> ok 8 - subtest 'ONE' of 'successful matchfor(qr//)' compare diag
> 1..8
> ok 2 - successful matchfor(qr//)
> # Subtest: successful matchfor(qr//) 2
> ok 1 - Test 'successful matchfor(qr//)' completed
> ok 2 - Test 'successful matchfor(qr//)' no premature diagnostication
> ok 3 - Test 'successful matchfor(qr//)' result count
> ok 4 - subtest 'TWO' of 'successful matchfor(qr//)' compare ok
> ok 5 - subtest 'TWO' of 'successful matchfor(qr//)' compare type
> ok 6 - subtest 'TWO' of 'successful matchfor(qr//)' compare name
> ok 7 - checking depth
> ok 8 - subtest 'TWO' of 'successful matchfor(qr//)' compare diag
> 1..8
> ok 3 - successful matchfor(qr//) 2
> # Subtest: unsuccessful matchfor(qr//)
> ok 1 - Test 'unsuccessful matchfor(qr//)' completed
> ok 2 - Test 'unsuccessful matchfor(qr//)' no premature diagnostication
> ok 3 - Test 'unsuccessful matchfor(qr//)' result count
> ok 4 - subtest 'THREE' of 'unsuccessful matchfor(qr//)' compare ok
> ok 5 - subtest 'THREE' of 'unsuccessful matchfor(qr//)' compare name
> ok 6 - checking depth
> 1..6
> ok 4 - unsuccessful matchfor(qr//)
> # Subtest: successful matchfor(CLASS)
> ok 1 - Test 'successful matchfor(CLASS)' completed
> ok 2 - Test 'successful matchfor(CLASS)' no premature diagnostication
> ok 3 - Test 'successful matchfor(CLASS)' result count
> ok 4 - subtest 'FOUR' of 'successful matchfor(CLASS)' compare ok
> ok 5 - subtest 'FOUR' of 'successful matchfor(CLASS)' compare type
> ok 6 - subtest 'FOUR' of 'successful matchfor(CLASS)' compare name
> ok 7 - checking depth
> ok 8 - subtest 'FOUR' of 'successful matchfor(CLASS)' compare diag
> 1..8
> ok 5 - successful matchfor(CLASS)
> # Subtest: unsuccessful successful matchfor(CLASS)
> ok 1 - Test 'unsuccessful successful matchfor(CLASS)' completed
> ok 2 - Test 'unsuccessful successful matchfor(CLASS)' no premature diagnostication
> ok 3 - Test 'unsuccessful successful matchfor(CLASS)' result count
> ok 4 - subtest 'FIVE' of 'unsuccessful successful matchfor(CLASS)' compare ok
> ok 5 - subtest 'FIVE' of 'unsuccessful successful matchfor(CLASS)' compare name
> ok 6 - checking depth
> 1..6
> ok 6 - unsuccessful successful matchfor(CLASS)
> ok
> t/20-modules/Type-Coercion-FromMoose/basic.t .................
> ok 1 - '$Array_of_Rounded->type_parameter' isa 'Type::Tiny'
> ok 2 - '$Array_of_Rounded->type_parameter->coercion' isa 'Type::Coercion'
> ok 3 - '$Array_of_Rounded->type_parameter->coercion' isa 'Type::Coercion::FromMoose'
> ok 4 - coercion works
> not ok 5 - coercion can be altered later # TODO $Array_of_Rounded's coercion has already been compiled
> # Failed (TODO) test 'coercion can be altered later'
> # at t/20-modules/Type-Coercion-FromMoose/basic.t line 79.
> # Structures begin differing at:
> # $got->[0] = '9.1'
> # $expected->[0] = '9'
> ok 6
> ok 7
> 1..7
> ok
> t/20-modules/Type-Coercion-FromMoose/errors.t ................
> ok 1
> ok 2
> not ok 3 - no exception adding coercions to a Moose-imported type constraint # TODO Adding coercions to Type::Coercion::FromMoose not currently supported
> # Failed (TODO) test 'no exception adding coercions to a Moose-imported type constraint'
> # at t/20-modules/Type-Coercion-FromMoose/errors.t line 63.
> # got: 'Adding coercions to Type::Coercion::FromMoose not currently supported at t/20-modules/Type-Coercion-FromMoose/errors.t line 61.
> # '
> # expected: undef
> not ok 4 - ... and the coercion works # TODO Adding coercions to Type::Coercion::FromMoose not currently supported
> # Failed (TODO) test '... and the coercion works'
> # at t/20-modules/Type-Coercion-FromMoose/errors.t line 66.
> # got: 'ARRAY(0x5587f4de6518)'
> # expected: '666'
> ok 5
> 1..5
> ok
> t/20-modules/Type-Coercion-Union/basic.t .....................
> ok 1 - Value "4" passes type constraint RoundedInteger
> ok 2 - Value "1.1" fails type constraint RoundedInteger
> ok 3 - Value "xyz" fails type constraint RoundedInteger
> ok 4 - Value "xyz" passes type constraint String3
> ok 5 - Value "x" fails type constraint String3
> ok 6 - Value "wxyz" fails type constraint String3
> ok 7 - Value "3.4" passes type constraint RoundedInteger|String3
> ok 8 - Value "30" passes type constraint RoundedInteger|String3
> ok 9 - Value "3.12" fails type constraint RoundedInteger|String3
> ok 10 - Value "wxyz" fails type constraint RoundedInteger|String3
> ok 11 - RoundedInteger coerces from Num
> ok 12 - RoundedInteger does not coerce from Str
> ok 13 - String3 coerces from Str
> ok 14 - String3 does not coerce from ArrayRef
> ok 15 - unions automatically have a coercion if their child constraints do
> # (((do { my $tmp = $X; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ }) or do { package Type::Tiny; !ref($X) and !!( $X =~ $Types::Standard::StrMatch::expressions{"Regexp|(?^:^.{3}\$)"} ) })) ? $X : ((defined($X) && !ref($X) && Scalar::Util::looks_like_number($X))) ? scalar(do { local $_ = $X; int($_) }) : ((Type::Tiny::XS::Str($X))) ? scalar(do { local $_ = $X; substr("$_ ", 0, 3) }) : $X
> ok 16 - unions do not automatically have a coercion if their child constraints do not
> ok 17 - Union1 does not need to coerce an Int
> ok 18 - Union1 does not need to coerce a String3
> ok 19 - Union1 does not need to coerce a String3, even if it looks like a Num
> ok 20 - Union1 coerces Str -> String3
> ok 21 - given the choice of two valid coercions, Union1 prefers RoundedInteger because it occurs sooner
> ok 22 - Union1 cannot coerce an arrayref
> ok 23 - Cannot add to Type::Tiny::Union's coercion
> 1..23
> ok
> t/20-modules/Type-Coercion/basic.t ...........................
> ok 1 - coercion works
> ok 2 - coercion overloads &{}
> ok 3 - BigInteger has_coercion_for_type ArrayRef
> ok 4 - BigInteger has_coercion_for_type SmallInteger
> ok 5 - not BigInteger has_coercion_for_type SmallInteger
> ok 6 - BigInteger has_coercion_for_type BigInteger eq "0 but true"
> ok 7 - BigInteger has_coercion_for_type $BiggerInteger eq "0 but true"
> ok 8 - BigInteger has_coercion_for_value []
> ok 9 - BigInteger has_coercion_for_value 2
> ok 10 - not BigInteger has_coercion_for_value {}
> ok 11 - BigInteger has_coercion_for_value 200 eq "0 but true"
> ok 12 - coerce doesn't throw an exception if it can coerce
> ok 13 - coerce doesn't throw an exception if it can't coerce
> ok 14 - assert_coerce doesn't throw an exception if it can coerce
> ok 15 - assert_coerce DOES throw an exception if it can't coerce
> ok 16 - 'ArrayRefFromAny' isa 'Type::Coercion'
> ok 17 - ArrayRefFromAny coercion works
> ok 18 - Coercion ArrayRefFromAny+ArrayRefFromPiped prioritizes ArrayRefFromAny
> ok 19 - Coercion ArrayRefFromPiped+ArrayRefFromAny prioritizes ArrayRefFromPiped
> ok 20 - Type $arr coercion works
> ok 21 - Type $sum3 coercion works
> ok 22 - Type $sum4 coercion works
> ok 23 - Reference [] passes type constraint ArrayRef|Str
> ok 24 - Value "1|2|3" passes type constraint ArrayRef|Str
> ok 25 - Reference {} fails type constraint ArrayRef|Str
> ok 26 - Reference [] passes type constraint ArrayRef
> ok 27 - Value "1|2|3" fails type constraint ArrayRef
> ok 28 - Reference {} fails type constraint ArrayRef
> ok 29 - $arrayref_from_piped->coercibles == $arrayref_from_piped->coercibles
> # Subtest: add a Type::Coercion to a Type::Coercion
> ok 1 - empty coercion can't coerce a Str
> ok 2 - add a coercion from Str
> ok 3 - check that coercion was added
> ok 4 - can coerce from a Str
> 1..4
> ok 30 - add a Type::Coercion to a Type::Coercion
> 1..30
> ok
> t/20-modules/Type-Coercion/esoteric.t ........................
> ok 1 - $type->coercion->meta
> ok 2 - $type->coercion->add_type_coercions(TYPE, STR)
> ok 3 - $type->coercion->_compiled_type_coercion(OBJECT)
> ok 4 - $type->coercion->_compiled_type_coercion(CODE)
> ok 5
> ok 6
> 1..6
> ok
> t/20-modules/Type-Coercion/frozen.t ..........................
> ok 1 - coercions are not initially frozen
> ok 2 - coercions do not freeze because of adding code
> ok 3 - ... and they work
> ok 4 - coercions do freeze when forced inflation to Moose
> ok 5 - cannot add code to a frozen coercion
> ok 6 - i_really_want_to_unfreeze
> ok 7 - ... can now add coercions
> ok 8 - ... ... which work
> 1..8
> ok
> t/20-modules/Type-Coercion/inlining.t ........................
> ok 1 - inlined coercion works
> ok 2 - no coercion necessary
> ok 3 - no coercion possible
> 1..3
> ok
> t/20-modules/Type-Coercion/parameterized.t ...................
> ok 1 - length $chars == 17
> ok 2 - length $bytes_utf8 == 19
> ok 3 - length $bytes_western == 17
> ok 4 - $SplitSpace can be inlined
> ok 5 - $SplitPipe can be inlined
> ok 6 - $SplitSpace->coerce($chars)
> ok 7 - $SplitSpace->coerce($bytes_utf8)
> ok 8 - $SplitSpace->coerce($bytes_western)
> ok 9 - Reference ["Caf\x{e9}","Paris|Gar\x{e7}on"] passes type constraint ArrayRef[Str]
> ok 10 - Reference ["Caf\303\251","Paris|Gar\303\247on"] passes type constraint ArrayRef[Str]
> ok 11 - Reference ["Caf\351","Paris|Gar\347on"] passes type constraint ArrayRef[Str]
> ok 12 - $SplitPipe->coerce($chars)
> ok 13 - $SplitPipe->coerce($bytes_utf8)
> ok 14 - $SplitPipe->coerce($bytes_western)
> ok 15 - $JoinPipe->coerce($arr_chars)
> ok 16 - Value "Caf\x{e9} Paris|Gar\x{e7}on" passes type constraint Str
> ok 17 - $JoinPipe->coerce($arr_bytes_utf8)
> ok 18 - Value "Caf\303\251 Paris|Gar\303\247on" passes type constraint Str
> ok 19 - $JoinPipe->coerce($arr_bytes_western)
> ok 20 - Value "Caf\351 Paris|Gar\347on" passes type constraint Str
> ok 21 - $Stringy->is_parameterizable
> ok 22 - 'parameterizable coercion' isa 'Type::Coercion'
> ok 23 - ... coercion included in base definition works
> ok 24 - ... coercion generated by parameterization does not exist yet
> ok 25 - 'parameterized coercion which has not yet been combined with type constraint' isa 'Type::Coercion'
> ok 26 - ... coercion included in base definition works
> ok 27 - ... coercion generated by parameterization works
> ok 28 - 'type constraint consuming parameterized coercion' isa 'Type::Tiny'
> ok 29 - ... coercion included in base definition works
> ok 30 - ... coercion generated by parameterization works; must have been regenerated
> 1..30
> ok
> t/20-modules/Type-Coercion/smartmatch.t ......................
> ok 1
> ok 2
> 1..2
> ok
> t/20-modules/Type-Coercion/typetiny-constructor.t ............
> # Subtest: coercion => ARRAY
> ok 1
> ok 2
> ok 3
> 1..3
> ok 1 - coercion => ARRAY
> # Subtest: coercion => CODE
> ok 1
> ok 2
> ok 3
> 1..3
> ok 2 - coercion => CODE
> 1..2
> ok
> t/20-modules/Type-Library/assert.t ...........................
> ok 1 - assert_String works (value that should pass)
> ok 2 - assert_String works (value that should fail)
> ok 3 - BiggerLib::assert_String works (value that should pass)
> ok 4 - BiggerLib::assert_String works (value that should fail)
> ok 5 - assert_SmallInteger works (value that should pass)
> ok 6 - assert_SmallInteger works (value that should fail)
> 1..6
> ok
> t/20-modules/Type-Library/declared-types.t ...................
> ok 1 - Reference {"bar" => {"quux" => 2},"foo" => 1} passes type constraint MyHashRef
> ok 2 - Reference {"bar" => {"quux" => "2.1"},"foo" => 1} fails type constraint MyHashRef
> ok 3 - Reference {"bar" => {"quux" => 2},"foo" => 1} passes type constraint MyHashRef
> ok 4 - Reference {"bar" => {"quux" => "2.1"},"foo" => 1} fails type constraint MyHashRef
> ok 5 - coderef got redefined
> # (MyTypes::is_MyHashRef($xyz))
> # do { package Type::Tiny; (ref($xyz) eq 'HASH') and do { my $ok = 1; for my $i (values %{$xyz}) { ($ok = 0, last) unless ((do { my $tmp = $i; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ }) or (MyTypes::is_MyHashRef($i))) }; $ok } }
> 1..5
> ok
> t/20-modules/Type-Library/deprecation.t ......................
> ok 1
> ok 2
> ok 3
> 1..3
> ok
> t/20-modules/Type-Library/errors.t ...........................
> ok 1 - cannot add same type constraint twice
> ok 2 - cannot add an anonymous type constraint to a library
> ok 3 - cannot add a coercion with same name as a constraint
> 1..3
> ok
> t/20-modules/Type-Library/exportables-duplicated.t ...........
> ok 1
> 1..1
> ok
> t/20-modules/Type-Library/exportables.t ...................... skipped: requires Test::Deep
> t/20-modules/Type-Library/import-params.t ....................
> ok 1 - Reference [] passes type constraint Ref
> ok 2 - Reference {} passes type constraint Ref
> ok 3 - Reference sub { "DUMMY" } passes type constraint Ref
> ok 4 - Value "1" fails type constraint Ref
> ok 5 - Reference [] passes type constraint Ref[ARRAY]
> ok 6 - Reference {} fails type constraint Ref[ARRAY]
> ok 7 - Reference sub { "DUMMY" } fails type constraint Ref[ARRAY]
> ok 8 - Value "1" fails type constraint Ref[ARRAY]
> ok 9 - Reference {} passes type constraint Ref[HASH]
> ok 10 - Reference [] fails type constraint Ref[HASH]
> ok 11 - Reference sub { "DUMMY" } fails type constraint Ref[HASH]
> ok 12 - Value "1" fails type constraint Ref[HASH]
> ok 13 - Reference {} passes type constraint Ref[HASH]
> ok 14 - Reference [] fails type constraint Ref[HASH]
> ok 15 - Reference sub { "DUMMY" } fails type constraint Ref[HASH]
> ok 16 - Value "1" fails type constraint Ref[HASH]
> ok 17 - Reference {} passes type constraint __ANON__
> ok 18 - Reference [] passes type constraint __ANON__
> ok 19 - Reference sub { "DUMMY" } fails type constraint __ANON__
> ok 20 - Value "1" fails type constraint __ANON__
> ok 21
> ok 22
> ok 23
> ok 24
> ok 25
> 1..25
> ok
> t/20-modules/Type-Library/inheritance.t ......................
> ok 1 - length $chars == 17
> ok 2 - length $bytes_utf8 == 19
> ok 3 - length $bytes_western == 17
> ok 4 - $SplitSpace can be inlined
> ok 5 - $SplitPipe can be inlined
> ok 6 - $SplitSpace->coerce($chars)
> ok 7 - $SplitSpace->coerce($bytes_utf8)
> ok 8 - $SplitSpace->coerce($bytes_western)
> ok 9 - Reference ["Caf\x{e9}","Paris|Gar\x{e7}on"] passes type constraint ArrayRef[Str]
> ok 10 - Reference ["Caf\303\251","Paris|Gar\303\247on"] passes type constraint ArrayRef[Str]
> ok 11 - Reference ["Caf\351","Paris|Gar\347on"] passes type constraint ArrayRef[Str]
> ok 12 - $SplitPipe->coerce($chars)
> ok 13 - $SplitPipe->coerce($bytes_utf8)
> ok 14 - $SplitPipe->coerce($bytes_western)
> ok 15 - $JoinPipe->coerce($arr_chars)
> ok 16 - Value "Caf\x{e9} Paris|Gar\x{e7}on" passes type constraint Str
> ok 17 - $JoinPipe->coerce($arr_bytes_utf8)
> ok 18 - Value "Caf\303\251 Paris|Gar\303\247on" passes type constraint Str
> ok 19 - $JoinPipe->coerce($arr_bytes_western)
> ok 20 - Value "Caf\351 Paris|Gar\347on" passes type constraint Str
> ok 21 - use Types::Standard -base will set up a type library
> ok 22 - use Types::Standard -base will inherit from Types::Standard
> ok 23 - new type works
> ok 24 - inherited type works
> 1..24
> ok
> t/20-modules/Type-Library/is.t ...............................
> ok 1 - is_String works (value that should pass)
> ok 2 - is_String works (value that should fail)
> ok 3 - is_Number works (value that should pass)
> ok 4 - is_Number works (value that should fail)
> ok 5 - is_Integer works (value that should pass)
> ok 6 - is_Integer works (value that should fail)
> ok 7 - is_SmallInteger works (value that should pass)
> ok 8 - is_SmallInteger works (value that should fail)
> 1..8
> ok
> t/20-modules/Type-Library/own-registry.t .....................
> ok 1 - Type libraries automatically put types into their own registry
> 1..1
> ok
> t/20-modules/Type-Library/recursive-type-definitions.t .......
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> 1..12
> ok
> t/20-modules/Type-Library/remove-type.t ......................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> 1..9
> ok
> t/20-modules/Type-Library/to.t ...............................
> ok 1 - to_BigInteger converts a small integer OK
> ok 2 - to_BigInteger leaves an existing BigInteger OK
> ok 3 - to_BigInteger ignores something it cannot coerce
> ok 4 - no coercion for Str - should die
> 1..4
> ok
> t/20-modules/Type-Library/types.t ............................
> ok 1 - 'String' isa 'Type::Tiny'
> ok 2 - 'Number' isa 'Type::Tiny'
> ok 3 - 'Integer' isa 'Type::Tiny'
> ok 4 - 'DemoLib::String' isa 'Type::Tiny'
> ok 5 - 'DemoLib::Number' isa 'Type::Tiny'
> ok 6 - 'DemoLib::Integer' isa 'Type::Tiny'
> ok 7 - String has correct stringification
> ok 8 - Number has correct stringification
> ok 9 - Integer has correct stringification
> ok 10 - DemoLib::String has correct stringification
> ok 11 - DemoLib::Number has correct stringification
> ok 12 - DemoLib::Integer has correct stringification
> ok 13 - coderef overload (with value that should pass type constraint) does not die
> ok 14 - coderef overload returns correct value
> ok 15 - coderef overload (value that should fail type constraint) dies
> ok 16 - Sub::Exporter-style export renaming
> ok 17 - eq works
> ok 18 - type constant in list context
> ok 19 - parameterizable type constant in list context
> ok 20 - parameterized type constant in list context
> 1..20
> ok
> t/20-modules/Type-Params-Signature/basic.t ...................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> ok 13
> ok 14
> ok 15
> ok 16
> 1..16
> ok
> t/20-modules/Type-Params/alias.t .............................
> ok 1 - real args
> ok 2 - aliases for args
> ok 3 - mixed 1
> ok 4 - mixed 2
> ok 5 - hashref
> ok 6 - error
> ok 7 - correct hash keys in $arg
> ok 8 - Type::Params::OO::Klass1->can(...)
> ok 9 - no method "x"
> ok 10 - no method "y"
> 1..10
> ok
> t/20-modules/Type-Params/badsigs.t ...........................
> ok 1 - Cannot follow an optional parameter with a required parameter
> ok 2 - Cannot follow a slurpy parameter with anything
> ok 3 - This makes no sense, but no longer throws an exception
> 1..3
> ok
> t/20-modules/Type-Params/carping.t ...........................
> ok 1 - An object of class 'Error::TypeTiny::Assertion' isa 'Error::TypeTiny'
> ok 2
> 1..2
> ok
> t/20-modules/Type-Params/clone.t .............................
> ok 1 - compile with clone => 0
> ok 2 - compile with clone => 1
> ok 3 - compile_named with clone => 0
> ok 4 - compile_named with clone => 1
> 1..4
> ok
> t/20-modules/Type-Params/coerce.t ............................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7 - if value passes type constraint; no need to clone arrayref
> ok 8 - if value fails type constraint; need to clone arrayref
> ok 9
> 1..9
> ok
> t/20-modules/Type-Params/compile-named-avoidcallbacks.t ......
> ok 1
> # Subtest: simple test with everything inlineable
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 2 - simple test with everything inlineable
> # Subtest: simple test with inlineable types, but non-inlineable coercion
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 3 - simple test with inlineable types, but non-inlineable coercion
> # Subtest: simple test with everything non-inlineable
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 4 - simple test with everything non-inlineable
> # Subtest: slurpy test with everything inlineable
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 2 - compile_named
> 1..2
> ok 5 - slurpy test with everything inlineable
> # Subtest: slurpy test with inlineable types, but non-inlineable coercion
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 2 - compile_named
> 1..2
> ok 6 - slurpy test with inlineable types, but non-inlineable coercion
> # Subtest: slurpy test with everything non-inlineable
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 2 - compile_named
> 1..2
> ok 7 - slurpy test with everything non-inlineable
> # Subtest: Shortcuts for Any and Optional[Any]
> ok 1
> ok 2
> ok 3
> ok 4
> 1..4
> ok 8 - Shortcuts for Any and Optional[Any]
> 1..8
> ok
> t/20-modules/Type-Params/compile-named-bless.t ...............
> # Subtest: simple test with everything inlineable
> # Subtest: bless => CLASS
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 1 - bless => CLASS
> # Subtest: class => CLASS
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 2 - class => CLASS
> # Subtest: class => [CLASS, METHOD]
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 3 - class => [CLASS, METHOD]
> # Subtest: class => CLASS, constructor METHOD
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 4 - class => CLASS, constructor METHOD
> 1..4
> ok 1 - simple test with everything inlineable
> # Subtest: simple test with inlineable types, but non-inlineable coercion
> # Subtest: bless => CLASS
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 1 - bless => CLASS
> # Subtest: class => CLASS
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 2 - class => CLASS
> # Subtest: class => [CLASS, METHOD]
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 3 - class => [CLASS, METHOD]
> # Subtest: class => CLASS, constructor METHOD
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 4 - class => CLASS, constructor METHOD
> 1..4
> ok 2 - simple test with inlineable types, but non-inlineable coercion
> # Subtest: simple test with everything non-inlineable
> # Subtest: bless => CLASS
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 1 - bless => CLASS
> # Subtest: class => CLASS
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 2 - class => CLASS
> # Subtest: class => [CLASS, METHOD]
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 3 - class => [CLASS, METHOD]
> # Subtest: class => CLASS, constructor METHOD
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 4 - class => CLASS, constructor METHOD
> 1..4
> ok 3 - simple test with everything non-inlineable
> # Subtest: slurpy test with everything inlineable
> # Subtest: bless => CLASS
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 2 - compile_named
> 1..2
> ok 1 - bless => CLASS
> # Subtest: class => CLASS
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 2 - compile_named
> 1..2
> ok 2 - class => CLASS
> # Subtest: class => [CLASS, METHOD]
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 2 - compile_named
> 1..2
> ok 3 - class => [CLASS, METHOD]
> # Subtest: class => CLASS, constructor METHOD
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 2 - compile_named
> 1..2
> ok 4 - class => CLASS, constructor METHOD
> 1..4
> ok 4 - slurpy test with everything inlineable
> 1..4
> ok
> t/20-modules/Type-Params/compile-named-oo-pp.t ...............
> ok 1 - compile_named_oo returns a coderef
> ok 2 - $object[0] is an object
> ok 3 - Type::Params::OO::Klass1->can(...)
> ok 4 - $object[0]->foo == 42
> ok 5 - $object[0]->bar == 69
> ok 6 - $object[0]->bazz->{quux} == 666
> ok 7 - $object[0]->has_bar
> ok 8 - $object[0]->haz
> ok 9 - no has_foo method
> ok 10 - no has_baz method
> ok 11 - $object[1] is an object
> ok 12 - Type::Params::OO::Klass1->can(...)
> ok 13 - $object[1]->foo == 42
> ok 14 - $object[1]->bar == 69
> ok 15 - $object[1]->bazz->{quux} == 666
> ok 16 - $object[1]->has_bar
> ok 17 - $object[1]->haz
> ok 18 - no has_foo method
> ok 19 - no has_baz method
> ok 20 - $object[2] is an object
> ok 21 - Type::Params::OO::Klass1->can(...)
> ok 22 - $object[2]->foo == 42
> ok 23 - not defined $object[2]->bar
> ok 24 - not defined $object[2]->bazz
> ok 25 - !$object[2]->has_bar
> ok 26 - !$object[2]->haz
> ok 27 - no has_foo method
> ok 28 - no has_baz method
> ok 29 - $object[3] is an object
> ok 30 - Type::Params::OO::Klass1->can(...)
> ok 31 - $object[3]->foo == 42
> ok 32 - not defined $object[3]->bar
> ok 33 - not defined $object[3]->bazz
> ok 34 - !$object[3]->has_bar
> ok 35 - !$object[3]->haz
> ok 36 - no has_foo method
> ok 37 - no has_baz method
> ok 38 - exception thrown for bad accessor name
> ok 39 - correct message
> ok 40 - packages reused when possible
> ok 41 - want_details
> # {
> # 'class_definition' => '{
> # package Type::Params::OO::Klass1;
> # use strict;
> # no warnings;
> # sub bar { $_[0]{"bar"} }
> # sub bazz { $_[0]{"baz"} }
> # sub foo { $_[0]{"foo"} }
> # sub has_bar { exists $_[0]{"bar"} }
> # sub haz { exists $_[0]{"baz"} }
> # 1;
> # }',
> # 'closure' => sub { "DUMMY" },
> # 'environment' => {
> # '$coercion_for_head_0' => \sub { "DUMMY" }
> # },
> # 'max_args' => undef,
> # 'min_args' => 4,
> # 'named' => !!1,
> # 'source' => 'sub {
> # my ( %out, %in, %tmp, $tmp, $dtmp, @head, @tail );
> #
> # @_ == 4 && (ref($_[1]) eq \'HASH\')
> # or @_ % 2 == 1 && @_ >= 5
> # or "Error::TypeTiny::WrongNumberOfParameters"->throw( got => scalar( @_ ) );
> #
> # @head = splice( @_, 0, 1 );
> #
> # # Parameter $head[0] (type: Int)
> # $tmp = &$coercion_for_head_0( $head[0] );
> # (do { my $tmp = $tmp; defined($tmp) and !ref($tmp) and $tmp =~ /\\A-?[0-9]+\\z/ })
> # or Type::Tiny::_failed_check( 49, "Int", $tmp, varname => "\\$_[0]" );
> # $head[0] = $tmp;
> #
> # @tail = splice( @_, -2 );
> #
> # # Parameter $tail[0] (type: ArrayRef)
> # (ref($tail[0]) eq \'ARRAY\')
> # or Type::Tiny::_failed_check( 21, "ArrayRef", $tail[0], varname => "\\$_[-2]" );
> #
> # # Parameter $tail[1] (type: ArrayRef)
> # (ref($tail[1]) eq \'ARRAY\')
> # or Type::Tiny::_failed_check( 21, "ArrayRef", $tail[1], varname => "\\$_[-1]" );
> #
> # %in = ( @_ == 1 and (ref($_[0]) eq \'HASH\') ) ? %{ $_[0] } : @_;
> #
> # # Parameter bar (type: Optional[ArrayRef])
> # if ( exists( $in{"bar"} ) ) {
> # do { package Type::Tiny; ref($in{"bar"}) eq \'ARRAY\' }
> # or Type::Tiny::_failed_check( 47, "Optional[ArrayRef]", $in{"bar"}, varname => "\\$_{\\"bar\\"}" );
> # $out{"bar"} = $in{"bar"};
> # delete( $in{"bar"} );
> # }
> #
> # # Parameter baz (type: Optional[CodeRef])
> # if ( exists( $in{"baz"} ) ) {
> # do { package Type::Tiny; ref($in{"baz"}) eq \'CODE\' }
> # or Type::Tiny::_failed_check( 48, "Optional[CodeRef]", $in{"baz"}, varname => "\\$_{\\"baz\\"}" );
> # $out{"baz"} = $in{"baz"};
> # delete( $in{"baz"} );
> # }
> #
> # # Parameter foo (type: Num)
> # exists( $in{"foo"} )
> # or "Error::TypeTiny"->throw( message => \'Missing required parameter: foo\' );
> # do { package Type::Tiny; defined($in{"foo"}) && !ref($in{"foo"}) && Scalar::Util::looks_like_number($in{"foo"}) }
> # or Type::Tiny::_failed_check( 12, "Num", $in{"foo"}, varname => "\\$_{\\"foo\\"}" );
> # $out{"foo"} = $in{"foo"} if exists( $in{"foo"} );
> # delete( $in{"foo"} );
> #
> # # Unrecognized parameters
> # "Error::TypeTiny"->throw( message => sprintf( q{Unrecognized parameter%s: %s}, keys( %in ) > 1 ? q{s} : q{}, Type::Utils::english_list( sort keys %in ) ) ) if keys %in;
> #
> # $out{"~~caller"} = "__ANON__::__ANON__";
> #
> # ( @head, bless( \\%out, "Type::Params::OO::Klass1" ), @tail );
> # }'
> # }
> ok 42
> ok 43
> ok 44
> ok 45
> ok 46
> ok 47
> ok 48
> ok 49
> # sub {
> # my ( %out, %in, %tmp, $tmp, $dtmp, @head, @tail );
> #
> # @_ == 4 && (ref($_[1]) eq 'HASH')
> # or @_ % 2 == 1 && @_ >= 5
> # or "Error::TypeTiny::WrongNumberOfParameters"->throw( got => scalar( @_ ) );
> #
> # @head = splice( @_, 0, 1 );
> #
> # # Parameter $head[0] (type: __ANON__)
> # $tmp = ((do { package Type::Tiny; (do { my $tmp = $head[0]; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ }) } && (do { local $_ = $head[0]; 1 }))) ? $head[0] : ((((defined($head[0]) && !ref($head[0]) && Scalar::Util::looks_like_number($head[0]))) && (do { local $_ = $head[0]; 1 }))) ? scalar(do { local $_ = $head[0]; int $_ }) : $head[0];
> # (do { package Type::Tiny; (do { my $tmp = $tmp; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ }) } && (do { local $_ = $tmp; 1 }))
> # or Type::Tiny::_failed_check( 52, "__ANON__", $tmp, varname => "\$_[0]" );
> # $head[0] = $tmp;
> #
> # @tail = splice( @_, -2 );
> #
> # # Parameter $tail[0] (type: __ANON__)
> # (((ref($tail[0]) eq 'ARRAY')) && (do { local $_ = $tail[0]; 1 }))
> # or Type::Tiny::_failed_check( 53, "__ANON__", $tail[0], varname => "\$_[-2]" );
> #
> # # Parameter $tail[1] (type: ArrayRef)
> # (ref($tail[1]) eq 'ARRAY')
> # or Type::Tiny::_failed_check( 21, "ArrayRef", $tail[1], varname => "\$_[-1]" );
> #
> # %in = ( @_ == 1 and (ref($_[0]) eq 'HASH') ) ? %{ $_[0] } : @_;
> #
> # # Parameter bar (type: Optional[ArrayRef])
> # if ( exists( $in{"bar"} ) ) {
> # do { package Type::Tiny; ref($in{"bar"}) eq 'ARRAY' }
> # or Type::Tiny::_failed_check( 47, "Optional[ArrayRef]", $in{"bar"}, varname => "\$_{\"bar\"}" );
> # $out{"bar"} = $in{"bar"};
> # delete( $in{"bar"} );
> # }
> #
> # # Parameter baz (type: Optional[CodeRef])
> # if ( exists( $in{"baz"} ) ) {
> # do { package Type::Tiny; ref($in{"baz"}) eq 'CODE' }
> # or Type::Tiny::_failed_check( 48, "Optional[CodeRef]", $in{"baz"}, varname => "\$_{\"baz\"}" );
> # $out{"baz"} = $in{"baz"};
> # delete( $in{"baz"} );
> # }
> #
> # # Parameter foo (type: Num)
> # exists( $in{"foo"} )
> # or "Error::TypeTiny"->throw( message => 'Missing required parameter: foo' );
> # do { package Type::Tiny; defined($in{"foo"}) && !ref($in{"foo"}) && Scalar::Util::looks_like_number($in{"foo"}) }
> # or Type::Tiny::_failed_check( 12, "Num", $in{"foo"}, varname => "\$_{\"foo\"}" );
> # $out{"foo"} = $in{"foo"} if exists( $in{"foo"} );
> # delete( $in{"foo"} );
> #
> # # Unrecognized parameters
> # "Error::TypeTiny"->throw( message => sprintf( q{Unrecognized parameter%s: %s}, keys( %in ) > 1 ? q{s} : q{}, Type::Utils::english_list( sort keys %in ) ) ) if keys %in;
> #
> # $out{"~~caller"} = "__ANON__::__ANON__";
> #
> # ( @head, bless( \%out, "Type::Params::OO::Klass1" ), @tail );
> # }
> ok 50
> ok 51
> ok 52
> ok 53
> ok 54
> ok 55
> ok 56
> ok 57
> # sub {
> # my ( %out, %in, %tmp, $tmp, $dtmp, @head, @tail );
> #
> # @_ == 4 && (ref($_[1]) eq 'HASH')
> # or @_ % 2 == 1 && @_ >= 5
> # or "Error::TypeTiny::WrongNumberOfParameters"->throw( got => scalar( @_ ) );
> #
> # @head = splice( @_, 0, 1 );
> #
> # # Parameter $head[0] (type: __ANON__)
> # $tmp = &$coercion_for_head_0( $head[0] );
> # &$check_for_head_0( $tmp )
> # or Type::Tiny::_failed_check( 56, "__ANON__", $tmp, varname => "\$_[0]" );
> # $head[0] = $tmp;
> #
> # @tail = splice( @_, -2 );
> #
> # # Parameter $tail[0] (type: __ANON__)
> # &$check_for_tail_0( $tail[0] )
> # or Type::Tiny::_failed_check( 57, "__ANON__", $tail[0], varname => "\$_[-2]" );
> #
> # # Parameter $tail[1] (type: ArrayRef)
> # (ref($tail[1]) eq 'ARRAY')
> # or Type::Tiny::_failed_check( 21, "ArrayRef", $tail[1], varname => "\$_[-1]" );
> #
> # %in = ( @_ == 1 and (ref($_[0]) eq 'HASH') ) ? %{ $_[0] } : @_;
> #
> # # Parameter bar (type: Optional[ArrayRef])
> # if ( exists( $in{"bar"} ) ) {
> # do { package Type::Tiny; ref($in{"bar"}) eq 'ARRAY' }
> # or Type::Tiny::_failed_check( 47, "Optional[ArrayRef]", $in{"bar"}, varname => "\$_{\"bar\"}" );
> # $out{"bar"} = $in{"bar"};
> # delete( $in{"bar"} );
> # }
> #
> # # Parameter baz (type: Optional[CodeRef])
> # if ( exists( $in{"baz"} ) ) {
> # do { package Type::Tiny; ref($in{"baz"}) eq 'CODE' }
> # or Type::Tiny::_failed_check( 48, "Optional[CodeRef]", $in{"baz"}, varname => "\$_{\"baz\"}" );
> # $out{"baz"} = $in{"baz"};
> # delete( $in{"baz"} );
> # }
> #
> # # Parameter foo (type: Num)
> # exists( $in{"foo"} )
> # or "Error::TypeTiny"->throw( message => 'Missing required parameter: foo' );
> # do { package Type::Tiny; defined($in{"foo"}) && !ref($in{"foo"}) && Scalar::Util::looks_like_number($in{"foo"}) }
> # or Type::Tiny::_failed_check( 12, "Num", $in{"foo"}, varname => "\$_{\"foo\"}" );
> # $out{"foo"} = $in{"foo"} if exists( $in{"foo"} );
> # delete( $in{"foo"} );
> #
> # # Unrecognized parameters
> # "Error::TypeTiny"->throw( message => sprintf( q{Unrecognized parameter%s: %s}, keys( %in ) > 1 ? q{s} : q{}, Type::Utils::english_list( sort keys %in ) ) ) if keys %in;
> #
> # $out{"~~caller"} = "__ANON__::__ANON__";
> #
> # ( @head, bless( \%out, "Type::Params::OO::Klass1" ), @tail );
> # }
> ok 58
> ok 59
> ok 60
> ok 61
> ok 62
> ok 63
> ok 64
> ok 65
> ok 66 - ArgsObject
> ok 67 - ArgsObject["Local::Foo::bar"]
> # bless( {
> # 'foo' => 42,
> # '~~caller' => 'Local::Foo::bar'
> # }, 'Type::Params::OO::Klass4' )
> 1..67
> ok
> t/20-modules/Type-Params/compile-named-oo.t ..................
> ok 1 - compile_named_oo returns a coderef
> ok 2 - $object[0] is an object
> ok 3 - Type::Params::OO::Klass1->can(...)
> ok 4 - $object[0]->foo == 42
> ok 5 - $object[0]->bar == 69
> ok 6 - $object[0]->bazz->{quux} == 666
> ok 7 - $object[0]->has_bar
> ok 8 - $object[0]->haz
> ok 9 - no has_foo method
> ok 10 - no has_baz method
> ok 11 - $object[1] is an object
> ok 12 - Type::Params::OO::Klass1->can(...)
> ok 13 - $object[1]->foo == 42
> ok 14 - $object[1]->bar == 69
> ok 15 - $object[1]->bazz->{quux} == 666
> ok 16 - $object[1]->has_bar
> ok 17 - $object[1]->haz
> ok 18 - no has_foo method
> ok 19 - no has_baz method
> ok 20 - $object[2] is an object
> ok 21 - Type::Params::OO::Klass1->can(...)
> ok 22 - $object[2]->foo == 42
> ok 23 - not defined $object[2]->bar
> ok 24 - not defined $object[2]->bazz
> ok 25 - !$object[2]->has_bar
> ok 26 - !$object[2]->haz
> ok 27 - no has_foo method
> ok 28 - no has_baz method
> ok 29 - $object[3] is an object
> ok 30 - Type::Params::OO::Klass1->can(...)
> ok 31 - $object[3]->foo == 42
> ok 32 - not defined $object[3]->bar
> ok 33 - not defined $object[3]->bazz
> ok 34 - !$object[3]->has_bar
> ok 35 - !$object[3]->haz
> ok 36 - no has_foo method
> ok 37 - no has_baz method
> ok 38 - exception thrown for bad accessor name
> ok 39 - correct message
> ok 40 - packages reused when possible
> ok 41 - want_details
> # sub {
> # my ( %out, %in, %tmp, $tmp, $dtmp, @head, @tail );
> #
> # @_ == 4 && (ref($_[1]) eq 'HASH')
> # or @_ % 2 == 1 && @_ >= 5
> # or "Error::TypeTiny::WrongNumberOfParameters"->throw( got => scalar( @_ ) );
> #
> # @head = splice( @_, 0, 1 );
> #
> # # Parameter $head[0] (type: Int)
> # $tmp = &$coercion_for_head_0( $head[0] );
> # (do { my $tmp = $tmp; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ })
> # or Type::Tiny::_failed_check( 49, "Int", $tmp, varname => "\$_[0]" );
> # $head[0] = $tmp;
> #
> # @tail = splice( @_, -2 );
> #
> # # Parameter $tail[0] (type: ArrayRef)
> # (ref($tail[0]) eq 'ARRAY')
> # or Type::Tiny::_failed_check( 21, "ArrayRef", $tail[0], varname => "\$_[-2]" );
> #
> # # Parameter $tail[1] (type: ArrayRef)
> # (ref($tail[1]) eq 'ARRAY')
> # or Type::Tiny::_failed_check( 21, "ArrayRef", $tail[1], varname => "\$_[-1]" );
> #
> # %in = ( @_ == 1 and (ref($_[0]) eq 'HASH') ) ? %{ $_[0] } : @_;
> #
> # # Parameter bar (type: Optional[ArrayRef])
> # if ( exists( $in{"bar"} ) ) {
> # do { package Type::Tiny; ref($in{"bar"}) eq 'ARRAY' }
> # or Type::Tiny::_failed_check( 47, "Optional[ArrayRef]", $in{"bar"}, varname => "\$_{\"bar\"}" );
> # $out{"bar"} = $in{"bar"};
> # delete( $in{"bar"} );
> # }
> #
> # # Parameter baz (type: Optional[CodeRef])
> # if ( exists( $in{"baz"} ) ) {
> # do { package Type::Tiny; ref($in{"baz"}) eq 'CODE' }
> # or Type::Tiny::_failed_check( 48, "Optional[CodeRef]", $in{"baz"}, varname => "\$_{\"baz\"}" );
> # $out{"baz"} = $in{"baz"};
> # delete( $in{"baz"} );
> # }
> #
> # # Parameter foo (type: Num)
> # exists( $in{"foo"} )
> # or "Error::TypeTiny"->throw( message => 'Missing required parameter: foo' );
> # do { package Type::Tiny; defined($in{"foo"}) && !ref($in{"foo"}) && Scalar::Util::looks_like_number($in{"foo"}) }
> # or Type::Tiny::_failed_check( 12, "Num", $in{"foo"}, varname => "\$_{\"foo\"}" );
> # $out{"foo"} = $in{"foo"} if exists( $in{"foo"} );
> # delete( $in{"foo"} );
> #
> # # Unrecognized parameters
> # "Error::TypeTiny"->throw( message => sprintf( q{Unrecognized parameter%s: %s}, keys( %in ) > 1 ? q{s} : q{}, Type::Utils::english_list( sort keys %in ) ) ) if keys %in;
> #
> # $out{"~~caller"} = "__ANON__::__ANON__";
> #
> # ( @head, bless( \%out, "Type::Params::OO::Klass1" ), @tail );
> # }
> ok 42
> ok 43
> ok 44
> ok 45
> ok 46
> ok 47
> ok 48
> ok 49
> # sub {
> # my ( %out, %in, %tmp, $tmp, $dtmp, @head, @tail );
> #
> # @_ == 4 && (ref($_[1]) eq 'HASH')
> # or @_ % 2 == 1 && @_ >= 5
> # or "Error::TypeTiny::WrongNumberOfParameters"->throw( got => scalar( @_ ) );
> #
> # @head = splice( @_, 0, 1 );
> #
> # # Parameter $head[0] (type: __ANON__)
> # $tmp = ((do { package Type::Tiny; (do { my $tmp = $head[0]; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ }) } && (do { local $_ = $head[0]; 1 }))) ? $head[0] : ((((defined($head[0]) && !ref($head[0]) && Scalar::Util::looks_like_number($head[0]))) && (do { local $_ = $head[0]; 1 }))) ? scalar(do { local $_ = $head[0]; int $_ }) : $head[0];
> # (do { package Type::Tiny; (do { my $tmp = $tmp; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ }) } && (do { local $_ = $tmp; 1 }))
> # or Type::Tiny::_failed_check( 52, "__ANON__", $tmp, varname => "\$_[0]" );
> # $head[0] = $tmp;
> #
> # @tail = splice( @_, -2 );
> #
> # # Parameter $tail[0] (type: __ANON__)
> # (((ref($tail[0]) eq 'ARRAY')) && (do { local $_ = $tail[0]; 1 }))
> # or Type::Tiny::_failed_check( 53, "__ANON__", $tail[0], varname => "\$_[-2]" );
> #
> # # Parameter $tail[1] (type: ArrayRef)
> # (ref($tail[1]) eq 'ARRAY')
> # or Type::Tiny::_failed_check( 21, "ArrayRef", $tail[1], varname => "\$_[-1]" );
> #
> # %in = ( @_ == 1 and (ref($_[0]) eq 'HASH') ) ? %{ $_[0] } : @_;
> #
> # # Parameter bar (type: Optional[ArrayRef])
> # if ( exists( $in{"bar"} ) ) {
> # do { package Type::Tiny; ref($in{"bar"}) eq 'ARRAY' }
> # or Type::Tiny::_failed_check( 47, "Optional[ArrayRef]", $in{"bar"}, varname => "\$_{\"bar\"}" );
> # $out{"bar"} = $in{"bar"};
> # delete( $in{"bar"} );
> # }
> #
> # # Parameter baz (type: Optional[CodeRef])
> # if ( exists( $in{"baz"} ) ) {
> # do { package Type::Tiny; ref($in{"baz"}) eq 'CODE' }
> # or Type::Tiny::_failed_check( 48, "Optional[CodeRef]", $in{"baz"}, varname => "\$_{\"baz\"}" );
> # $out{"baz"} = $in{"baz"};
> # delete( $in{"baz"} );
> # }
> #
> # # Parameter foo (type: Num)
> # exists( $in{"foo"} )
> # or "Error::TypeTiny"->throw( message => 'Missing required parameter: foo' );
> # do { package Type::Tiny; defined($in{"foo"}) && !ref($in{"foo"}) && Scalar::Util::looks_like_number($in{"foo"}) }
> # or Type::Tiny::_failed_check( 12, "Num", $in{"foo"}, varname => "\$_{\"foo\"}" );
> # $out{"foo"} = $in{"foo"} if exists( $in{"foo"} );
> # delete( $in{"foo"} );
> #
> # # Unrecognized parameters
> # "Error::TypeTiny"->throw( message => sprintf( q{Unrecognized parameter%s: %s}, keys( %in ) > 1 ? q{s} : q{}, Type::Utils::english_list( sort keys %in ) ) ) if keys %in;
> #
> # $out{"~~caller"} = "__ANON__::__ANON__";
> #
> # ( @head, bless( \%out, "Type::Params::OO::Klass1" ), @tail );
> # }
> ok 50
> ok 51
> ok 52
> ok 53
> ok 54
> ok 55
> ok 56
> ok 57
> # sub {
> # my ( %out, %in, %tmp, $tmp, $dtmp, @head, @tail );
> #
> # @_ == 4 && (ref($_[1]) eq 'HASH')
> # or @_ % 2 == 1 && @_ >= 5
> # or "Error::TypeTiny::WrongNumberOfParameters"->throw( got => scalar( @_ ) );
> #
> # @head = splice( @_, 0, 1 );
> #
> # # Parameter $head[0] (type: __ANON__)
> # $tmp = &$coercion_for_head_0( $head[0] );
> # &$check_for_head_0( $tmp )
> # or Type::Tiny::_failed_check( 56, "__ANON__", $tmp, varname => "\$_[0]" );
> # $head[0] = $tmp;
> #
> # @tail = splice( @_, -2 );
> #
> # # Parameter $tail[0] (type: __ANON__)
> # &$check_for_tail_0( $tail[0] )
> # or Type::Tiny::_failed_check( 57, "__ANON__", $tail[0], varname => "\$_[-2]" );
> #
> # # Parameter $tail[1] (type: ArrayRef)
> # (ref($tail[1]) eq 'ARRAY')
> # or Type::Tiny::_failed_check( 21, "ArrayRef", $tail[1], varname => "\$_[-1]" );
> #
> # %in = ( @_ == 1 and (ref($_[0]) eq 'HASH') ) ? %{ $_[0] } : @_;
> #
> # # Parameter bar (type: Optional[ArrayRef])
> # if ( exists( $in{"bar"} ) ) {
> # do { package Type::Tiny; ref($in{"bar"}) eq 'ARRAY' }
> # or Type::Tiny::_failed_check( 47, "Optional[ArrayRef]", $in{"bar"}, varname => "\$_{\"bar\"}" );
> # $out{"bar"} = $in{"bar"};
> # delete( $in{"bar"} );
> # }
> #
> # # Parameter baz (type: Optional[CodeRef])
> # if ( exists( $in{"baz"} ) ) {
> # do { package Type::Tiny; ref($in{"baz"}) eq 'CODE' }
> # or Type::Tiny::_failed_check( 48, "Optional[CodeRef]", $in{"baz"}, varname => "\$_{\"baz\"}" );
> # $out{"baz"} = $in{"baz"};
> # delete( $in{"baz"} );
> # }
> #
> # # Parameter foo (type: Num)
> # exists( $in{"foo"} )
> # or "Error::TypeTiny"->throw( message => 'Missing required parameter: foo' );
> # do { package Type::Tiny; defined($in{"foo"}) && !ref($in{"foo"}) && Scalar::Util::looks_like_number($in{"foo"}) }
> # or Type::Tiny::_failed_check( 12, "Num", $in{"foo"}, varname => "\$_{\"foo\"}" );
> # $out{"foo"} = $in{"foo"} if exists( $in{"foo"} );
> # delete( $in{"foo"} );
> #
> # # Unrecognized parameters
> # "Error::TypeTiny"->throw( message => sprintf( q{Unrecognized parameter%s: %s}, keys( %in ) > 1 ? q{s} : q{}, Type::Utils::english_list( sort keys %in ) ) ) if keys %in;
> #
> # $out{"~~caller"} = "__ANON__::__ANON__";
> #
> # ( @head, bless( \%out, "Type::Params::OO::Klass1" ), @tail );
> # }
> ok 58
> ok 59
> ok 60
> ok 61
> ok 62
> ok 63
> ok 64
> ok 65
> ok 66 - ArgsObject
> ok 67 - ArgsObject["Local::Foo::bar"]
> ok 68 - !ArgsObject["Local::Foo::barz"]
> # bless( {
> # 'foo' => 42,
> # '~~caller' => 'Local::Foo::bar'
> # }, 'Type::Params::OO::Klass4' )
> 1..68
> ok
> t/20-modules/Type-Params/compile-named.t .....................
> ok 1
> # Subtest: simple test with everything inlineable
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 2 - simple test with everything inlineable
> # Subtest: simple test with inlineable types, but non-inlineable coercion
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 3 - simple test with inlineable types, but non-inlineable coercion
> # Subtest: simple test with everything non-inlineable
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - missing parameter
> 1..15
> ok 2 - compile_named
> 1..2
> ok 4 - simple test with everything non-inlineable
> # Subtest: slurpy test with everything inlineable
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 2 - compile_named
> 1..2
> ok 5 - slurpy test with everything inlineable
> # Subtest: slurpy test with inlineable types, but non-inlineable coercion
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 2 - compile_named
> 1..2
> ok 6 - slurpy test with inlineable types, but non-inlineable coercion
> # Subtest: slurpy test with everything non-inlineable
> # Subtest: validate_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 1 - validate_named
> # Subtest: compile_named
> ok 1 - accept a hash
> ok 2 - accept a hash, with optional parameter
> ok 3 - accept a hash, and coerce
> ok 4 - accept a hash, with optional parameter, and coerce
> ok 5 - accept a hashref
> ok 6 - accept a hashref, with optional parameter
> ok 7 - accept a hashref, and coerce
> ok 8 - accept a hashref, with optional parameter, and coerce
> ok 9 - bad "foo" parameter
> ok 10 - bad "bar" parameter
> ok 11 - two bad parameters; "foo" throws before "bar" gets a chance
> ok 12 - bad optional "baz" parameter
> ok 13 - additional parameter
> ok 14 - additional parameters
> ok 15 - coercion of additional parameters
> ok 16 - missing parameter
> 1..16
> ok 2 - compile_named
> 1..2
> ok 7 - slurpy test with everything non-inlineable
> # Subtest: Shortcuts for Any and Optional[Any]
> ok 1
> ok 2
> ok 3
> ok 4
> 1..4
> ok 8 - Shortcuts for Any and Optional[Any]
> 1..8
> ok
> t/20-modules/Type-Params/defaults.t ..........................
> ok 1 - compile: no exception thrown because of defaulted argument
> ok 2 - compile: default applied correctly
> ok 3 - compile: no exception thrown because of defaulted argument via coderef
> ok 4 - compile: default applied correctly via coderef
> ok 5 - compile: no exception thrown because of defaulted argument via Perl source code
> ok 6 - compile: default applied correctly via Perl source code
> ok 7 - compile: no exception thrown because of defaulted argument via arrayref
> ok 8 - compile: default applied correctly via arrayref
> ok 9 - compile: no exception thrown because of defaulted argument via hashref
> ok 10 - compile: default applied correctly via hashref
> ok 11 - compile: no exception thrown because of defaulted argument via undef
> ok 12 - compile: default applied correctly via undef
> ok 13 - compile_named: no exception thrown because of defaulted argument
> ok 14 - compile_named: default applied correctly
> ok 15 - compile_named: no exception thrown because of defaulted argument via coderef
> ok 16 - compile_named: default applied correctly via coderef
> ok 17 - compile_named: no exception thrown because of defaulted argument via arrayref
> ok 18 - compile_named: default applied correctly via arrayref
> ok 19 - compile_named: no exception thrown because of defaulted argument via hashref
> ok 20 - compile_named: default applied correctly via hashref
> ok 21 - compile_named: no exception thrown because of defaulted argument via undef
> ok 22 - compile_named: default applied correctly via undef
> ok 23 - compile: exception because bad default
> 1..23
> ok
> t/20-modules/Type-Params/goto_next.t .........................
> # Subtest: goto_next => 1
> ok 1 - list context
> ok 2 - scalar context
> 1..2
> ok 1 - goto_next => 1
> # Subtest: goto_next => CODEREF
> ok 1 - list context
> ok 2 - scalar context
> 1..2
> ok 2 - goto_next => CODEREF
> # Subtest: goto_next => CODEREF (assign to glob)
> ok 1 - list context
> ok 2 - scalar context
> ok 3 - meta
> 1..3
> ok 3 - goto_next => CODEREF (assign to glob)
> 1..3
> ok
> t/20-modules/Type-Params/hashorder.t .........................
> # Subtest: predictable error message when problems with two parameters
> ok 1 - Iteration 1, check 1, missing parameters
> ok 2 - Iteration 1, check 1, invalid values
> ok 3 - Iteration 1, check 1, extra values
> ok 4 - Iteration 1, check 2, missing parameters
> ok 5 - Iteration 1, check 2, invalid values
> ok 6 - Iteration 1, check 2, extra values
> ok 7 - Iteration 2, check 1, missing parameters
> ok 8 - Iteration 2, check 1, invalid values
> ok 9 - Iteration 2, check 1, extra values
> ok 10 - Iteration 2, check 2, missing parameters
> ok 11 - Iteration 2, check 2, invalid values
> ok 12 - Iteration 2, check 2, extra values
> ok 13 - Iteration 3, check 1, missing parameters
> ok 14 - Iteration 3, check 1, invalid values
> ok 15 - Iteration 3, check 1, extra values
> ok 16 - Iteration 3, check 2, missing parameters
> ok 17 - Iteration 3, check 2, invalid values
> ok 18 - Iteration 3, check 2, extra values
> ok 19 - Iteration 4, check 1, missing parameters
> ok 20 - Iteration 4, check 1, invalid values
> ok 21 - Iteration 4, check 1, extra values
> ok 22 - Iteration 4, check 2, missing parameters
> ok 23 - Iteration 4, check 2, invalid values
> ok 24 - Iteration 4, check 2, extra values
> ok 25 - Iteration 5, check 1, missing parameters
> ok 26 - Iteration 5, check 1, invalid values
> ok 27 - Iteration 5, check 1, extra values
> ok 28 - Iteration 5, check 2, missing parameters
> ok 29 - Iteration 5, check 2, invalid values
> ok 30 - Iteration 5, check 2, extra values
> ok 31 - Iteration 6, check 1, missing parameters
> ok 32 - Iteration 6, check 1, invalid values
> ok 33 - Iteration 6, check 1, extra values
> ok 34 - Iteration 6, check 2, missing parameters
> ok 35 - Iteration 6, check 2, invalid values
> ok 36 - Iteration 6, check 2, extra values
> ok 37 - Iteration 7, check 1, missing parameters
> ok 38 - Iteration 7, check 1, invalid values
> ok 39 - Iteration 7, check 1, extra values
> ok 40 - Iteration 7, check 2, missing parameters
> ok 41 - Iteration 7, check 2, invalid values
> ok 42 - Iteration 7, check 2, extra values
> ok 43 - Iteration 8, check 1, missing parameters
> ok 44 - Iteration 8, check 1, invalid values
> ok 45 - Iteration 8, check 1, extra values
> ok 46 - Iteration 8, check 2, missing parameters
> ok 47 - Iteration 8, check 2, invalid values
> ok 48 - Iteration 8, check 2, extra values
> ok 49 - Iteration 9, check 1, missing parameters
> ok 50 - Iteration 9, check 1, invalid values
> ok 51 - Iteration 9, check 1, extra values
> ok 52 - Iteration 9, check 2, missing parameters
> ok 53 - Iteration 9, check 2, invalid values
> ok 54 - Iteration 9, check 2, extra values
> ok 55 - Iteration 10, check 1, missing parameters
> ok 56 - Iteration 10, check 1, invalid values
> ok 57 - Iteration 10, check 1, extra values
> ok 58 - Iteration 10, check 2, missing parameters
> ok 59 - Iteration 10, check 2, invalid values
> ok 60 - Iteration 10, check 2, extra values
> ok 61 - Iteration 11, check 1, missing parameters
> ok 62 - Iteration 11, check 1, invalid values
> ok 63 - Iteration 11, check 1, extra values
> ok 64 - Iteration 11, check 2, missing parameters
> ok 65 - Iteration 11, check 2, invalid values
> ok 66 - Iteration 11, check 2, extra values
> ok 67 - Iteration 12, check 1, missing parameters
> ok 68 - Iteration 12, check 1, invalid values
> ok 69 - Iteration 12, check 1, extra values
> ok 70 - Iteration 12, check 2, missing parameters
> ok 71 - Iteration 12, check 2, invalid values
> ok 72 - Iteration 12, check 2, extra values
> ok 73 - Iteration 13, check 1, missing parameters
> ok 74 - Iteration 13, check 1, invalid values
> ok 75 - Iteration 13, check 1, extra values
> ok 76 - Iteration 13, check 2, missing parameters
> ok 77 - Iteration 13, check 2, invalid values
> ok 78 - Iteration 13, check 2, extra values
> ok 79 - Iteration 14, check 1, missing parameters
> ok 80 - Iteration 14, check 1, invalid values
> ok 81 - Iteration 14, check 1, extra values
> ok 82 - Iteration 14, check 2, missing parameters
> ok 83 - Iteration 14, check 2, invalid values
> ok 84 - Iteration 14, check 2, extra values
> ok 85 - Iteration 15, check 1, missing parameters
> ok 86 - Iteration 15, check 1, invalid values
> ok 87 - Iteration 15, check 1, extra values
> ok 88 - Iteration 15, check 2, missing parameters
> ok 89 - Iteration 15, check 2, invalid values
> ok 90 - Iteration 15, check 2, extra values
> ok 91 - Iteration 16, check 1, missing parameters
> ok 92 - Iteration 16, check 1, invalid values
> ok 93 - Iteration 16, check 1, extra values
> ok 94 - Iteration 16, check 2, missing parameters
> ok 95 - Iteration 16, check 2, invalid values
> ok 96 - Iteration 16, check 2, extra values
> ok 97 - Iteration 17, check 1, missing parameters
> ok 98 - Iteration 17, check 1, invalid values
> ok 99 - Iteration 17, check 1, extra values
> ok 100 - Iteration 17, check 2, missing parameters
> ok 101 - Iteration 17, check 2, invalid values
> ok 102 - Iteration 17, check 2, extra values
> ok 103 - Iteration 18, check 1, missing parameters
> ok 104 - Iteration 18, check 1, invalid values
> ok 105 - Iteration 18, check 1, extra values
> ok 106 - Iteration 18, check 2, missing parameters
> ok 107 - Iteration 18, check 2, invalid values
> ok 108 - Iteration 18, check 2, extra values
> ok 109 - Iteration 19, check 1, missing parameters
> ok 110 - Iteration 19, check 1, invalid values
> ok 111 - Iteration 19, check 1, extra values
> ok 112 - Iteration 19, check 2, missing parameters
> ok 113 - Iteration 19, check 2, invalid values
> ok 114 - Iteration 19, check 2, extra values
> ok 115 - Iteration 20, check 1, missing parameters
> ok 116 - Iteration 20, check 1, invalid values
> ok 117 - Iteration 20, check 1, extra values
> ok 118 - Iteration 20, check 2, missing parameters
> ok 119 - Iteration 20, check 2, invalid values
> ok 120 - Iteration 20, check 2, extra values
> 1..120
> ok 1 - predictable error message when problems with two parameters
> 1..1
> ok
> t/20-modules/Type-Params/methods.t ...........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5 - clean operation
> ok 6 - exception calling new() with no args
> ok 7 - exception calling ->new() with no args
> ok 8 - exception calling set() with no args
> 1..8
> ok
> t/20-modules/Type-Params/mixednamed.t ........................
> ok 1
> ok 2
> ok 3
> 1..3
> ok
> t/20-modules/Type-Params/multisig-custom-message.t ...........
> ok 1 - bar(1)
> ok 2 - bar(1) ${^TYPE_PARAMS_MULTISIG}
> ok 3 - bar()
> ok 4 - bar() ${^TYPE_PARAMS_MULTISIG}
> ok 5 - foo($string, num => "x")
> ok 6 - foo($string, num => "x") ${^TYPE_PARAMS_MULTISIG}
> ok 7 - foo([], num => 42)
> ok 8 - foo([], num => 42) ${^TYPE_PARAMS_MULTISIG}
> ok 9 - foo($string, quux => 0)
> ok 10 - foo($string, quux => 0) ${^TYPE_PARAMS_MULTISIG}
> ok 11 - foo($string, [])
> ok 12 - foo($string, []) ${^TYPE_PARAMS_MULTISIG}
> ok 13 - slurpy options
> ok 14 - foo($string, bool => 1)
> ok 15 - foo($string, bool => 1) ${^TYPE_PARAMS_MULTISIG}
> ok 16 - hashref options
> ok 17 - foo($string, { bool => 1 })
> ok 18 - foo($string, { bool => 1 }) ${^TYPE_PARAMS_MULTISIG}
> ok 19 - no options
> ok 20 - foo($string)
> ok 21 - foo($string) ${^TYPE_PARAMS_MULTISIG}
> 1..21
> ok
> t/20-modules/Type-Params/multisig-gotonext.t .................
> ok 1 - MyTest->f( x => 1, y => 2, note => 'foo' )
> ok 2 - MyTest->f( x => 3, y => 4 )
> ok 3 - MyTest->f( { x => 1, y => 2, note => 'foo' } )
> ok 4 - MyTest->f( { x => 3, y => 4 } )
> ok 5 - MyTest->f( 1, 2, 'foo' )
> ok 6 - MyTest->f( 3, 4 )
> ok 7 - MyTest->f( [ 5, 6 ], 'foo' )
> ok 8 - MyTest->f( [ 7, 8 ] )
> 1..8
> ok
> t/20-modules/Type-Params/multisig.t ..........................
> ok 1 - first choice in multi, no coercion, should pass
> ok 2 - ...${^TYPE_PARAMS_MULTISIG}
> ok 3 - first choice in multi, coercion, should pass
> ok 4 - ...${^TYPE_PARAMS_MULTISIG}
> ok 5 - first choice in multi, should fail
> ok 6 - second choice in multi, no coercion, should pass
> ok 7 - ...${^TYPE_PARAMS_MULTISIG}
> ok 8 - second choice in multi, coercion, should pass
> ok 9 - ...${^TYPE_PARAMS_MULTISIG}
> ok 10 - second choice in multi, should fail
> ok 11 - third choice in multi, no coercion, should pass
> ok 12 - ...${^TYPE_PARAMS_MULTISIG}
> ok 13 - third choice in multi, should fail
> ok 14
> ok 15
> ok 16
> ok 17
> ok 18 - on_die works
> 1..18
> ok
> t/20-modules/Type-Params/named-to-list.t .....................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> ok 13
> ok 14
> ok 15
> 1..15
> ok
> t/20-modules/Type-Params/named.t .............................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> 1..5
> ok
> t/20-modules/Type-Params/noninline.t .........................
> ok 1 - (1, 2)
> ok 2 - (1.1, 2)
> ok 3 - ()
> ok 4 - (1)
> ok 5 - (undef, 1)
> ok 6 - (42)
> ok 7 - (42, 11)
> ok 8 - ([1..3], 11)
> ok 9 - ([1..41], 42)
> 1..9
> ok
> t/20-modules/Type-Params/on-die.t ............................
> # Subtest: compile
> ok 1 - No exception thrown
> ok 2 - Correct value returned
> ok 3 - Passed exception to callback
> 1..3
> ok 1 - compile
> # Subtest: compile_named
> ok 1 - No exception thrown
> ok 2 - Correct value returned
> ok 3 - Passed exception to callback
> 1..3
> ok 2 - compile_named
> 1..2
> ok
> t/20-modules/Type-Params/optional.t ..........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> ok 13
> ok 14
> ok 15
> ok 16
> ok 17
> ok 18
> ok 19
> ok 20
> ok 21
> ok 22
> ok 23
> ok 24
> ok 25
> ok 26
> ok 27
> ok 28
> ok 29
> ok 30
> ok 31
> ok 32
> ok 33
> ok 34
> ok 35
> ok 36
> ok 37
> ok 38
> ok 39
> ok 40
> ok 41
> 1..41
> ok
> t/20-modules/Type-Params/positional.t ........................
> ok 1 - empty compile()
> ok 2 - (1, 2)
> ok 3 - (1.1, 2)
> ok 4 - (1)
> ok 5 - (1)
> ok 6 - (undef, 1)
> ok 7 - (1)
> ok 8 - head and tail work
> ok 9
> ok 10
> ok 11
> ok 12
> ok 13
> ok 14
> ok 15
> ok 16
> ok 17
> 1..17
> ok
> t/20-modules/Type-Params/slurpy.t ............................
> ok 1 - simple test
> ok 2 - simple test with ref
> ok 3 - simple test failing type check
> # Subtest: Different styles of slurpy work
> # Subtest: Compiling: Str, slurpy HashRef
> ok 1
> ok 2
> ok 3
> 1..3
> ok 1 - Compiling: Str, slurpy HashRef
> # Subtest: Compiling: Str, Slurpy[HashRef]
> ok 1
> ok 2
> ok 3
> 1..3
> ok 2 - Compiling: Str, Slurpy[HashRef]
> # Subtest: Compiling: Str, HashRef, { slurpy => 1 }
> ok 1
> ok 2
> ok 3
> 1..3
> ok 3 - Compiling: Str, HashRef, { slurpy => 1 }
> # Subtest: Compiling: Str, { slurpy => HashRef }
> ok 1
> ok 2
> ok 3
> 1..3
> ok 4 - Compiling: Str, { slurpy => HashRef }
> 1..4
> ok 4 - Different styles of slurpy work
> # Subtest: slurpy Map works
> ok 1
> ok 2
> 1..2
> ok 5 - slurpy Map works
> # Subtest: slurpy Tuple works
> ok 1
> 1..1
> ok 6 - slurpy Tuple works
> # Subtest: Slurpy[HashRef] works
> ok 1
> ok 2
> # sub {
> # my ( @out, %tmp, $tmp, $dtmp );
> #
> # @_ >= 1
> # or "Error::TypeTiny::WrongNumberOfParameters"->throw( got => scalar( @_ ), minimum => 1 );
> #
> # # Parameter $_[0] (type: Int)
> # (do { my $tmp = $_[0]; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ })
> # or Type::Tiny::_failed_check( 13, "Int", $_[0], varname => "\$_[0]" );
> # push( @out, $_[0] );
> #
> # my $SLURPY = ( $#_ == 1 and ( (ref($_[1]) eq 'HASH') ) ) ? { %{ $_[1] } } : ( ( $#_ - 1 ) % 2 ) ? { @_[ 1 .. $#_ ] } : "Error::TypeTiny"->throw( message => sprintf( "Odd number of elements in %s", "HashRef" ) );
> #
> # # Parameter $SLURPY (type: Slurpy[HashRef])
> # ((ref($SLURPY) eq 'HASH'))
> # or Type::Tiny::_failed_check( 47, "Slurpy[HashRef]", $SLURPY, varname => "\$SLURPY" );
> # push( @out, $SLURPY );
> #
> # ( @out );
> # }
> 1..2
> ok 7 - Slurpy[HashRef] works
> # Subtest: HashRef { slurpy => 1 } works
> ok 1
> ok 2
> 1..2
> ok 8 - HashRef { slurpy => 1 } works
> # Subtest: { slurpy => HashRef } works
> ok 1
> ok 2
> 1..2
> ok 9 - { slurpy => HashRef } works
> # Subtest: Subtype of Slurpy[HashRef] works
> ok 1
> ok 2
> # sub {
> # my ( @out, %tmp, $tmp, $dtmp );
> #
> # @_ >= 1
> # or "Error::TypeTiny::WrongNumberOfParameters"->throw( got => scalar( @_ ), minimum => 1 );
> #
> # # Parameter $_[0] (type: Int)
> # (do { my $tmp = $_[0]; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ })
> # or Type::Tiny::_failed_check( 13, "Int", $_[0], varname => "\$_[0]" );
> # push( @out, $_[0] );
> #
> # my $SLURPY = ( $#_ == 1 and ( (ref($_[1]) eq 'HASH') ) ) ? { %{ $_[1] } } : ( ( $#_ - 1 ) % 2 ) ? { @_[ 1 .. $#_ ] } : "Error::TypeTiny"->throw( message => sprintf( "Odd number of elements in %s", "HashRef" ) );
> #
> # # Parameter $SLURPY (type: __ANON__)
> # ((((ref($SLURPY) eq 'HASH'))) && (do { local $_ = $SLURPY; 1 }))
> # or Type::Tiny::_failed_check( 52, "__ANON__", $SLURPY, varname => "\$SLURPY" );
> # push( @out, $SLURPY );
> #
> # ( @out );
> # }
> 1..2
> ok 10 - Subtype of Slurpy[HashRef] works
> ok 11 - Exception thrown for parameter after a slurpy in positional signature
> ok 12 - Exception thrown for slurpy parameter after a slurpy in positional signature
> ok 13 - Exception thrown for named signature with two slurpies
> ok 14 - Exception thrown for named signature with ArrayRef slurpy
> ok 15 - Named signature may have slurpy parameter before others
> ok 16 - ... and expected behaviour
> ok 17 - Named-to-list => 1 signature may have slurpy parameter before others
> ok 18 - ... and expected behaviour
> ok 19 - Named-to-list => ARRAY signature may have slurpy parameter before others
> ok 20 - ... and expected behaviour
> 1..20
> ok
> t/20-modules/Type-Params/strictness.t ........................
> # Subtest: strictness => CONDITION_STRING
> ok 1 - code contains expected Int check
> ok 2 - code compiles
> 1..2
> ok 1 - strictness => CONDITION_STRING
> # Subtest: strictness => 1
> ok 1 - code contains expected Int check
> ok 2 - code compiles
> 1..2
> ok 2 - strictness => 1
> # Subtest: strictness => 0
> ok 1 - code contains expected Int check
> ok 2 - code compiles
> 1..2
> ok 3 - strictness => 0
> ok 4
> ok 5
> ok 6
> ok 7
> 1..7
> ok
> t/20-modules/Type-Params/v2-defaults.t .......................
> ok 1
> ok 2
> 1..2
> ok
> t/20-modules/Type-Params/v2-delayed-compilation.t ............
> ok 1 - type constraint has not been compiled yet
> ok 2 - function worked
> ok 3 - type constraint has been compiled
> ok 4 - function worked
> ok 5 - type constraint has not been re-compiled
> 1..5
> ok
> t/20-modules/Type-Params/v2-exceptions.t .....................
> # Subtest: signature extra_arg => ( positional => ... )
> ok 1
> ok 2
> 1..2
> ok 1 - signature extra_arg => ( positional => ... )
> # Subtest: signature_for( positional => ... )
> ok 1
> ok 2
> 1..2
> ok 2 - signature_for( positional => ... )
> # Subtest: signature( named => ..., positional => ... )
> ok 1
> ok 2
> 1..2
> ok 3 - signature( named => ..., positional => ... )
> # Subtest: signature_for bleh => ( named => ..., positional => ... )
> ok 1
> ok 2
> 1..2
> ok 4 - signature_for bleh => ( named => ..., positional => ... )
> # Subtest: signature_for function_does_not_exist => ( positional => ... )
> ok 1
> ok 2
> 1..2
> ok 5 - signature_for function_does_not_exist => ( positional => ... )
> # Subtest: signature()
> ok 1
> ok 2
> 1..2
> ok 6 - signature()
> # Subtest: signature_for bleh333 => ()
> ok 1
> ok 2
> 1..2
> ok 7 - signature_for bleh333 => ()
> 1..7
> ok
> t/20-modules/Type-Params/v2-fallback.t .......................
> ok 1
> ok 2
> 1..2
> ok
> t/20-modules/Type-Params/v2-multi.t ..........................
> # Subtest: signature( multi => [...] )
> # sub {
> # my $__INVOCANT__ = $_[0];
> #
> # my $r;
> # undef ${^TYPE_PARAMS_MULTISIG};
> # undef ${^_TYPE_PARAMS_MULTISIG};
> #
> # eval { $r = [ $signature->(@_) ]; ${^TYPE_PARAMS_MULTISIG} = ${^_TYPE_PARAMS_MULTISIG} = 0 }
> # if ( ! $r );
> #
> # eval { local @_ = @_; $r = [ do {
> # my $__INVOCANT__ = $_[0];
> #
> # my ( %out, %in, %tmp, $tmp, $dtmp, @head );
> #
> # @_ == 2 && (ref($_[1]) eq 'HASH')
> # or @_ % 2 == 1 && @_ >= 5
> # or "Error::TypeTiny::WrongNumberOfParameters"->throw( got => scalar( @_ ) );
> #
> # @head = splice( @_, 0, 1 );
> #
> # # Parameter invocant (type: Defined)
> # (defined($head[0]))
> # or Type::Tiny::_failed_check( 12, "Defined", $head[0], varname => "\$_[0]" );
> #
> # %in = ( @_ == 1 and (ref($_[0]) eq 'HASH') ) ? %{ $_[0] } : @_;
> #
> # # Parameter array (type: ArrayRef)
> # exists( $in{"array"} )
> # or "Error::TypeTiny"->throw( message => 'Missing required parameter: array' );
> # do { package Type::Tiny; ref($in{"array"}) eq 'ARRAY' }
> # or Type::Tiny::_failed_check( 26, "ArrayRef", $in{"array"}, varname => "\$_{\"array\"}" );
> # $out{"array"} = $in{"array"} if exists( $in{"array"} );
> # delete( $in{"array"} );
> #
> # # Parameter index (type: Int)
> # for my $alias ( "ix" ) {
> # exists $in{$alias} or next;
> # if ( exists( $in{"index"} ) ) {
> # "Error::TypeTiny"->throw( message => sprintf( 'Superfluous alias "%s" for argument "%s"', $alias, "index" ) );
> # }
> # else {
> # $in{"index"} = delete( $in{$alias} );
> # }
> # }
> # exists( $in{"index"} )
> # or "Error::TypeTiny"->throw( message => 'Missing required parameter: index' );
> # (do { my $tmp = $in{"index"}; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ })
> # or Type::Tiny::_failed_check( 18, "Int", $in{"index"}, varname => "\$_{\"index\"}" );
> # $out{"index"} = $in{"index"} if exists( $in{"index"} );
> # delete( $in{"index"} );
> #
> # # Unrecognized parameters
> # "Error::TypeTiny"->throw( message => sprintf( q{Unrecognized parameter%s: %s}, keys( %in ) > 1 ? q{s} : q{}, Type::Utils::english_list( sort keys %in ) ) ) if keys %in;
> #
> # ( @head, $out{"array"}, $out{"index"} );
> # } ]; ${^TYPE_PARAMS_MULTISIG} = ${^_TYPE_PARAMS_MULTISIG} = 1 }
> # if ( ! $r and @_ >= 2 );
> #
> # eval { $r = [ $signature_2->(@_) ]; ${^TYPE_PARAMS_MULTISIG} = ${^_TYPE_PARAMS_MULTISIG} = 2 }
> # if ( ! $r and @_ == 2 );
> #
> # eval { local @_ = @_; $r = [ do {
> # my $__INVOCANT__ = $_[0];
> #
> # my ( %out, %in, %tmp, $tmp, $dtmp, @head );
> #
> # @_ == 2 && (ref($_[1]) eq 'HASH')
> # or @_ % 2 == 1 && @_ >= 5
> # or "Error::TypeTiny::WrongNumberOfParameters"->throw( got => scalar( @_ ) );
> #
> # @head = splice( @_, 0, 1 );
> #
> # # Parameter invocant (type: Defined)
> # (defined($head[0]))
> # or Type::Tiny::_failed_check( 12, "Defined", $head[0], varname => "\$_[0]" );
> #
> # %in = ( @_ == 1 and (ref($_[0]) eq 'HASH') ) ? %{ $_[0] } : @_;
> #
> # # Parameter ARRAY (type: ArrayRef)
> # exists( $in{"ARRAY"} )
> # or "Error::TypeTiny"->throw( message => 'Missing required parameter: ARRAY' );
> # do { package Type::Tiny; ref($in{"ARRAY"}) eq 'ARRAY' }
> # or Type::Tiny::_failed_check( 26, "ArrayRef", $in{"ARRAY"}, varname => "\$_{\"ARRAY\"}" );
> # $out{"ARRAY"} = $in{"ARRAY"} if exists( $in{"ARRAY"} );
> # delete( $in{"ARRAY"} );
> #
> # # Parameter INDEX (type: Int)
> # exists( $in{"INDEX"} )
> # or "Error::TypeTiny"->throw( message => 'Missing required parameter: INDEX' );
> # (do { my $tmp = $in{"INDEX"}; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ })
> # or Type::Tiny::_failed_check( 18, "Int", $in{"INDEX"}, varname => "\$_{\"INDEX\"}" );
> # $out{"INDEX"} = $in{"INDEX"} if exists( $in{"INDEX"} );
> # delete( $in{"INDEX"} );
> #
> # # Unrecognized parameters
> # "Error::TypeTiny"->throw( message => sprintf( q{Unrecognized parameter%s: %s}, keys( %in ) > 1 ? q{s} : q{}, Type::Utils::english_list( sort keys %in ) ) ) if keys %in;
> #
> # ( @head, $out{"ARRAY"}, $out{"INDEX"} );
> # } ]; ${^TYPE_PARAMS_MULTISIG} = ${^_TYPE_PARAMS_MULTISIG} = 3 }
> # if ( ! $r and @_ >= 2 );
> #
> # eval { $r = [ $signature_3->(@_) ]; ${^TYPE_PARAMS_MULTISIG} = ${^_TYPE_PARAMS_MULTISIG} = 4 }
> # if ( ! $r );
> #
> # my ( %tmp, $tmp );
> #
> #
> # "Error::TypeTiny"->throw( message => "Parameter validation failed" ) unless $r;
> #
> # ( @$r );
> # }
> # {
> # package Type::Params::OO::Klass1;
> # use strict;
> # no warnings;
> # sub INDEX { $_[0]{"INDEX"} }
> # sub LIST { $_[0]{"LIST"} }
> # 1;
> # }
> ok 1 - first alternative
> ok 2 - second alternative
> ok 3 - third alternative (hash)
> ok 4 - third alternative (hashref)
> ok 5 - third alternative (hash, alias)
> ok 6 - third alternative (hashref, alias)
> ok 7 - fourth alternative
> ok 8 - fifth alternative
> ok 9 - final alternative
> ok 10
> ok 11
> 1..11
> ok 1 - signature( multi => [...] )
> # Subtest: signature_for function => ( multi => [...] )
> ok 1 - first alternative
> ok 2
> ok 3 - second alternative
> ok 4
> ok 5 - third alternative (hash)
> ok 6
> ok 7 - third alternative (hashref)
> ok 8
> ok 9 - third alternative (hash, alias)
> ok 10
> ok 11 - third alternative (hashref, alias)
> ok 12
> ok 13 - fourth alternative
> ok 14
> ok 15 - fifth alternative
> ok 16
> ok 17 - final alternative
> ok 18
> ok 19
> ok 20
> 1..20
> ok 2 - signature_for function => ( multi => [...] )
> # Subtest: signature( named => ..., pos => ..., multi => 1 )
> # sub {
> # my $r;
> # undef ${^TYPE_PARAMS_MULTISIG};
> # undef ${^_TYPE_PARAMS_MULTISIG};
> #
> # eval { $r = [ $signature->(@_) ]; ${^TYPE_PARAMS_MULTISIG} = ${^_TYPE_PARAMS_MULTISIG} = 0 }
> # if ( ! $r and @_ >= 1 );
> #
> # eval { local @_ = @_; $r = [ do {
> # my ( %tmp, $tmp );
> #
> # @_ == 1
> # or "Error::TypeTiny::WrongNumberOfParameters"->throw( got => scalar( @_ ), minimum => 1, maximum => 1 );
> #
> # # Parameter $_[0] (type: Int)
> # (do { my $tmp = $_[0]; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ })
> # or Type::Tiny::_failed_check( 18, "Int", $_[0], varname => "\$_[0]" );
> #
> # ( @_ );
> # } ]; ${^TYPE_PARAMS_MULTISIG} = ${^_TYPE_PARAMS_MULTISIG} = 1 }
> # if ( ! $r and @_ == 1 );
> #
> # my ( %tmp, $tmp );
> #
> #
> # "Error::TypeTiny"->throw( message => "Parameter validation failed" ) unless $r;
> #
> # ( @$r );
> # }
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> 1..6
> ok 3 - signature( named => ..., pos => ..., multi => 1 )
> ok 4
> 1..4
> ok
> t/20-modules/Type-Params/v2-named-backcompat.t ...............
> ok 1 - myfunc (happy path)
> ok 2 - myfunc2 (happy path)
> ok 3 - myfunc (type exception)
> ok 4 - myfunc2 (type exception)
> ok 5 - myfunc (param count exception)
> ok 6 - myfunc2 (param count exception)
> 1..6
> ok
> t/20-modules/Type-Params/v2-named-plus-slurpy.t ..............
> ok 1
> ok 2
> ok 3
> 1..3
> ok
> t/20-modules/Type-Params/v2-named.t ..........................
> ok 1 - myfunc (happy path)
> ok 2 - myfunc2 (happy path)
> ok 3 - myfunc (type exception)
> ok 4 - myfunc2 (type exception)
> ok 5 - myfunc (param count exception)
> ok 6 - myfunc2 (param count exception)
> 1..6
> ok
> t/20-modules/Type-Params/v2-positional-backcompat.t ..........
> ok 1 - myfunc (happy path)
> ok 2 - myfunc2 (happy path)
> ok 3 - myfunc (type exception)
> ok 4 - myfunc2 (type exception)
> ok 5 - myfunc (param count exception)
> ok 6 - myfunc2 (param count exception)
> 1..6
> ok
> t/20-modules/Type-Params/v2-positional-plus-slurpy.t .........
> ok 1
> ok 2
> ok 3
> ok 4
> 1..4
> ok
> t/20-modules/Type-Params/v2-positional.t .....................
> ok 1 - myfunc (happy path)
> ok 2 - myfunc2 (happy path)
> ok 3 - myfunc (type exception)
> ok 4 - myfunc2 (type exception)
> ok 5 - myfunc (param count exception)
> ok 6 - myfunc2 (param count exception)
> 1..6
> ok
> t/20-modules/Type-Params/v2-warnings.t .......................
> ok 1 - correct warning
> ok 2 - compilation succeeded
> ok 3 - correct signature behaviour
> ok 4 - no (unexpected) warnings (via done_testing)
> 1..4
> ok
> t/20-modules/Type-Params/v2-wrap-inherited-method.t ..........
> ok 1
> ok 2
> ok 3
> 1..3
> ok
> t/20-modules/Type-Params/wrap.t ..............................
> # Subtest: simple use of wrap_subs
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> 1..6
> ok 1 - simple use of wrap_subs
> # Subtest: simple use of wrap_methods
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> 1..6
> ok 2 - simple use of wrap_methods
> # Subtest: wrap_methods with inheritance
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> 1..8
> ok 3 - wrap_methods with inheritance
> 1..3
> ok
> t/20-modules/Type-Parser/basic.t .............................
> # Basics
> ok 1 - Int eq Int
> ok 2 - (Int) eq Int - redundant parentheses
> ok 3 - ((((Int)))) eq Int - many redundant parentheses
> # Class types
> ok 4 - DateTime:: eq InstanceOf["DateTime"]
> ok 5 - InstanceOf['DateTime'] eq InstanceOf["DateTime"]
> ok 6 - Tied[Foo::] eq Tied["Foo"]
> ok 7 - Tied['Foo'] eq Tied["Foo"]
> # Parameterization
> ok 8 - Int[] eq Int - empty parameterization against non-parameterizable type
> ok 9 - Tuple[] eq Tuple[] - empty parameterization against parameterizble type
> ok 10 - ArrayRef[] eq ArrayRef - empty parameterization against parameterizable type
> ok 11 - ArrayRef[Int] eq ArrayRef[Int] - parameterized type
> ok 12 - Overload[15] eq Overload[15] - numeric parameter (decimal integer)
> ok 13 - Overload[0x0F] eq Overload[15] - numeric parameter (hexadecimal integer)
> ok 14 - Overload[0x0f] eq Overload[15] - numeric parameter (hexadecimal integer, lowercase)
> ok 15 - Overload[-0xF] eq Overload["-15"] - numeric parameter (hexadecimal integer, negative)
> ok 16 - Overload[1.5] eq Overload["1.5"] - numeric parameter (float)
> ok 17 - Ref['HASH'] eq Ref[HASH] - string parameter (singles)
> ok 18 - Ref["HASH"] eq Ref[HASH] - string parameter (doubles)
> ok 19 - Ref[q(HASH)] eq Ref[HASH] - string parameter (q)
> ok 20 - Ref[qq(HASH)] eq Ref[HASH] - string parameter (qq)
> ok 21 - StrMatch[qr{foo}] eq StrMatch[(?^:foo)] - regexp parameter
> # Unions
> ok 22 - Int|HashRef eq Int|HashRef
> ok 23 - Int|HashRef|ArrayRef eq Int|HashRef|ArrayRef
> ok 24 - ArrayRef[Int|HashRef] eq ArrayRef[Int|HashRef] - union as a parameter
> ok 25 - ArrayRef[Int|HashRef[Int]] eq ArrayRef[Int|HashRef[Int]]
> ok 26 - ArrayRef[HashRef[Int]|Int] eq ArrayRef[HashRef[Int]|Int]
> # Intersections
> ok 27 - Int&Num eq Int&Num
> ok 28 - Int&Num&Defined eq Int&Num&Defined
> ok 29 - ArrayRef[Int]&Defined eq ArrayRef[Int]&Defined
> # Union + Intersection
> ok 30 - Int&Num|ArrayRef eq Int&Num|ArrayRef
> ok 31 - (Int&Num)|ArrayRef eq Int&Num|ArrayRef
> ok 32 - Int&(Num|ArrayRef) eq Int&Num|ArrayRef
> ok 33 - Int&Num|ArrayRef&Ref eq Int&Num|ArrayRef&Ref
> # Complementary types
> ok 34 - ~Int eq ~Int
> ok 35 - ~ArrayRef[Int] eq ~ArrayRef[Int]
> ok 36 - ~Int|CodeRef eq ~Int|CodeRef
> ok 37 - ~(Int|CodeRef) eq ~Int|CodeRef - precedence of "~" versus "|"
> # Comma
> ok 38 - Map[Num,Int] eq Map[Num,Int]
> ok 39 - Map[Int,Num] eq Map[Int,Num]
> ok 40 - Map[Int,Int|ArrayRef[Int]] eq Map[Int,Int|ArrayRef[Int]]
> ok 41 - Map[Int,ArrayRef[Int]|Int] eq Map[Int,ArrayRef[Int]|Int]
> ok 42 - Dict[foo=>Int,bar=>Num] eq Dict[bar=>Num,foo=>Int]
> ok 43 - Dict['foo'=>Int,'bar'=>Num] eq Dict[bar=>Num,foo=>Int]
> ok 44 - Dict['foo',Int,'bar',Num] eq Dict[bar=>Num,foo=>Int]
> # Slurpy
> ok 45 - Dict[slurpy=>Int,bar=>Num] eq Dict[bar=>Num,slurpy=>Int]
> ok 46 - Tuple[Str, Int, slurpy ArrayRef[Int]] eq Tuple[Str,Int,Slurpy[ArrayRef[Int]]]
> ok 47 - Tuple[Str, Int, slurpy(ArrayRef[Int])] eq Tuple[Str,Int,Slurpy[ArrayRef[Int]]]
> # Complexity
> ok 48 - ArrayRef[DateTime::]|HashRef[Int|DateTime::]|CodeRef eq ArrayRef[InstanceOf["DateTime"]]|HashRef[Int|InstanceOf["DateTime"]]|CodeRef
> ok 49 - ArrayRef [DateTime::] |HashRef[ Int| DateTime::]|CodeRef eq ArrayRef[InstanceOf["DateTime"]]|HashRef[Int|InstanceOf["DateTime"]]|CodeRef - gratuitous whitespace
> # Bad expressions
> ok 50 - weird token
> ok 51 - weird stuff 1
> ok 52 - weird stuff 2
> # Tail retention
> ok 53 - remainder is ok
> ok 54 - comma can indicate beginning of remainder
> ok 55 - ArrayRef[Int] eq ArrayRef[Int] - extract_type works
> ok 56 - ... and provides proper remainder too
> # Parsing edge cases
> ok 57 - Xyzzy[Foo] - parameter is treated as a type constraint
> ok 58 - Xyzzy["Foo"] - parameter is treated as a string
> ok 59 - Xyzzy[-100] - parameter is treated as a string
> ok 60 - Xyzzy[200] - parameter is treated as a string
> ok 61 - Xyzzy[+20.0] - parameter is treated as a string
> 1..61
> ok
> t/20-modules/Type-Parser/moosextypes.t .......................
> ok 1 - Reference [1,2,3] passes type constraint ArrayRef[MooseX::Types::Common::Numeric::PositiveInt]
> ok 2 - Reference [] passes type constraint ArrayRef[MooseX::Types::Common::Numeric::PositiveInt]
> ok 3 - Reference [1,-2,3] fails type constraint ArrayRef[MooseX::Types::Common::Numeric::PositiveInt]
> 1..3
> ok
> t/20-modules/Type-Registry/automagic.t .......................
> ok 1 - Type::Registry is not automatically loaded
> ok 2 - Type::Registry was auto-populated
> 1..2
> ok
> t/20-modules/Type-Registry/basic.t ...........................
> ok 1 - Type::Registry->for_me works
> ok 2 - Type::Registry->for_class works
> ok 3 - cannot add non-existant type library to registry
> ok 4 - cannot alias non-existant type in registry
> ok 5 - alias works
> ok 6 - alias works via simple_lookup
> ok 7 - alias works via lookup
> ok 8 - prefix works
> ok 9 - type registries are separate
> ok 10 - DESTROY does not cause problems
> ok 11 - Reference [1,2,3] passes type constraint ArrayRef[Int]
> ok 12 - Reference [1,2,"3.14159"] fails type constraint ArrayRef[Int]
> ok 13 - type constraint invalid syntax
> ok 14 - type constraint unknown type
> ok 15 - type constraint unknown type (as method call)
> ok 16 - class type
> ok 17 - Value "Monkey" passes type constraint Enum[Monkey,Nuts]
> ok 18 - Value "Nuts" passes type constraint Enum[Monkey,Nuts]
> ok 19 - Value "Cashews" fails type constraint Enum[Monkey,Nuts]
> ok 20 - DWIM - class type
> ok 21 - DWIM - role type
> ok 22 - DWIM - complex type
> ok 23
> ok 24
> 1..24
> ok
> t/20-modules/Type-Registry/methods.t .........................
> ok 1 - InstanceOf["Foo"] eq InstanceOf["Foo"] - t->make_class_type
> ok 2 - ConsumerOf["Foo"] eq ConsumerOf["Foo"] - t->make_role_type
> ok 3 - ArrayRef|Int eq ArrayRef|Int - t->make_union
> ok 4 - ArrayRef&Int eq ArrayRef&Int - t->make_intersection
> ok 5 - Value "420" passes type constraint PositiveInt
> ok 6 - Value "-42" fails type constraint PositiveInt
> ok 7 - Value "420" passes type constraint PositiveInt
> ok 8 - Value "-42" fails type constraint PositiveInt
> ok 9 - Value "420" passes type constraint PositiveInt
> ok 10 - Value "-42" fails type constraint PositiveInt
> ok 11 - Value "420" passes type constraint __ANON__
> ok 12 - Value "-42" fails type constraint __ANON__
> ok 13 - cannot add an anonymous type without giving it an alias
> 1..13
> ok
> t/20-modules/Type-Registry/moosextypes.t .....................
> ok 1 - Reference [] passes type constraint ArrayRef[MooseX::Types::Common::String::UpperCaseStr]
> ok 2 - Reference ["FOO","BAR"] passes type constraint ArrayRef[MooseX::Types::Common::String::UpperCaseStr]
> ok 3 - Reference ["FOO","Bar"] fails type constraint ArrayRef[MooseX::Types::Common::String::UpperCaseStr]
> ok 4 - Value "8" passes type constraint MooseX::Types::Common::Numeric::SingleDigit
> ok 5 - Value "9" passes type constraint MooseX::Types::Common::Numeric::SingleDigit
> ok 6 - Value "10" fails type constraint MooseX::Types::Common::Numeric::SingleDigit
> ok 7 - Value "10" passes type constraint MooseX::Types::Common::Numeric::PositiveInt
> 1..7
> ok
> t/20-modules/Type-Registry/mousextypes.t ..................... skipped: requires MouseX::Types::Common
> t/20-modules/Type-Registry/parent.t ..........................
> ok 1 - Reference [1,2,3] passes type constraint ArrayRef[Int]
> ok 2 - Reference [1,2,"3.1"] fails type constraint ArrayRef[Int]
> ok 3
> ok 4 - after clearing parent, do not know parent registry types
> 1..4
> ok
> t/20-modules/Type-Registry/refcount.t ........................ skipped: requires Devel::Refcount
> t/20-modules/Type-Tie/01basic.t ..............................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5 - _NEXT_SLOT
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> ok 13
> ok 14
> ok 15
> ok 16
> ok 17
> 1..17
> ok
> t/20-modules/Type-Tie/02moosextypes.t ........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> 1..12
> ok
> t/20-modules/Type-Tie/03prototypicalweirdness.t ..............
> ok 1
> 1..1
> ok
> t/20-modules/Type-Tie/04nots.t ...............................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> 1..12
> ok
> t/20-modules/Type-Tie/05typetiny.t ...........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> 1..12
> ok
> t/20-modules/Type-Tie/06clone.t ..............................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> 1..6
> ok
> t/20-modules/Type-Tie/06storable.t ...........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> 1..6
> ok
> t/20-modules/Type-Tie/basic.t ................................
> # Subtest: tied scalar
> ok 1
> ok 2
> ok 3
> 1..3
> ok 1 - tied scalar
> # Subtest: tied array
> ok 1
> ok 2
> ok 3
> 1..3
> ok 2 - tied array
> # Subtest: tied hash
> ok 1
> ok 2
> ok 3
> 1..3
> ok 3 - tied hash
> 1..3
> ok
> t/20-modules/Type-Tie/very-minimal.t .........................
> ok 1
> ok 2
> 1..2
> ok
> t/20-modules/Type-Tiny-_HalfOp/double-union.t ................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> 1..7
> ok
> t/20-modules/Type-Tiny-_HalfOp/extra-params.t ................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> 1..7
> ok
> t/20-modules/Type-Tiny-_HalfOp/overload-precedence.t .........
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> 1..7
> ok
> t/20-modules/Type-Tiny-Bitfield/basic.t ......................
> ok 1
> ok 2
> ok 3 - Value "0" passes type constraint LineStyle
> ok 4 - Value "1" passes type constraint LineStyle
> ok 5 - Value "2" passes type constraint LineStyle
> ok 6 - Value "3" passes type constraint LineStyle
> ok 7 - Value "4" passes type constraint LineStyle
> ok 8 - Value "5" passes type constraint LineStyle
> ok 9 - Value "6" passes type constraint LineStyle
> ok 10 - Value "7" passes type constraint LineStyle
> ok 11 - Value "64" passes type constraint LineStyle
> ok 12 - Value "65" passes type constraint LineStyle
> ok 13 - Value "66" passes type constraint LineStyle
> ok 14 - Value "67" passes type constraint LineStyle
> ok 15 - Value "68" passes type constraint LineStyle
> ok 16 - Value "69" passes type constraint LineStyle
> ok 17 - Value "70" passes type constraint LineStyle
> ok 18 - Value "71" passes type constraint LineStyle
> ok 19 - Value "8" fails type constraint LineStyle
> ok 20 - Value "9" fails type constraint LineStyle
> ok 21 - Value "10" fails type constraint LineStyle
> ok 22 - Value "11" fails type constraint LineStyle
> ok 23 - Value "12" fails type constraint LineStyle
> ok 24 - Value "13" fails type constraint LineStyle
> ok 25 - Value "14" fails type constraint LineStyle
> ok 26 - Value "15" fails type constraint LineStyle
> ok 27 - Value "62" fails type constraint LineStyle
> ok 28 - Value "63" fails type constraint LineStyle
> ok 29 - Value "72" fails type constraint LineStyle
> ok 30 - Value "RED" fails type constraint LineStyle
> ok 31 - Value "-4" fails type constraint LineStyle
> ok 32 - LineStyle->constant_names
> ok 33 - LINESTYLE_RED
> ok 34 - LINESTYLE_BLUE
> ok 35 - LINESTYLE_GREEN
> ok 36 - LINESTYLE_DOTTED
> ok 37 - LineStyle->RED
> ok 38 - LineStyle->BLUE
> ok 39 - LineStyle->GREEN
> ok 40 - LineStyle->DOTTED
> ok 41 - LineStyle->YELLOW fails
> ok 42 - LineStyle->can( 'RED' )
> ok 43 - !LineStyle->can( 'YELLOW' )
> ok 44 - LineStyle->can( 'GREEN' )->()
> ok 45 - is_LineStyle( LINESTYLE_RED )
> ok 46
> ok 47
> ok 48
> ok 49
> ok 50 - is_LineStyle(0)
> ok 51 - is_LineStyle(1)
> ok 52 - is_LineStyle(2)
> ok 53 - is_LineStyle(3)
> ok 54 - is_LineStyle(4)
> ok 55 - is_LineStyle(5)
> ok 56 - is_LineStyle(6)
> ok 57 - is_LineStyle(7)
> ok 58 - is_LineStyle(64)
> ok 59 - is_LineStyle(65)
> ok 60 - is_LineStyle(66)
> ok 61 - is_LineStyle(67)
> ok 62 - is_LineStyle(68)
> ok 63 - is_LineStyle(69)
> ok 64 - is_LineStyle(70)
> ok 65 - is_LineStyle(71)
> ok 66 - !is_LineStyle(8)
> ok 67 - !is_LineStyle(9)
> ok 68 - !is_LineStyle(10)
> ok 69 - !is_LineStyle(11)
> ok 70 - !is_LineStyle(12)
> ok 71 - !is_LineStyle(13)
> ok 72 - !is_LineStyle(14)
> ok 73 - !is_LineStyle(15)
> ok 74 - !is_LineStyle(62)
> ok 75 - !is_LineStyle(63)
> ok 76 - !is_LineStyle(72)
> # Subtest: Bad bitfield numbering
> ok 1
> ok 2 - error message
> 1..2
> ok 77 - Bad bitfield numbering
> # Subtest: Bad bitfield naming
> ok 1
> ok 2 - error message
> 1..2
> ok 78 - Bad bitfield naming
> ok 79 - can be inlined
> # ( (Type::Tiny::XS::PositiveOrZeroInt($VALUE)) and not $VALUE & ~71 )
> # Subtest: Coercion from string
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> 1..8
> ok 80 - Coercion from string
> # Subtest: Coercion to string
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> 1..6
> ok 81 - Coercion to string
> 1..81
> ok
> t/20-modules/Type-Tiny-Bitfield/errors.t .....................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> 1..7
> ok
> t/20-modules/Type-Tiny-Bitfield/import-options.t .............
> ok 1
> ok 2
> 1..2
> ok
> t/20-modules/Type-Tiny-Bitfield/plus.t .......................
> ok 1 - Colour+Style isa Type::Tiny::Bitfield
> ok 2 - Colour+Style display_name
> ok 3 - Colour+Style is_anon
> ok 4 - Value "0" passes type constraint Colour+Style
> ok 5 - Value "1" passes type constraint Colour+Style
> ok 6 - Value "2" passes type constraint Colour+Style
> ok 7 - Value "3" passes type constraint Colour+Style
> ok 8 - Value "4" passes type constraint Colour+Style
> ok 9 - Value "5" passes type constraint Colour+Style
> ok 10 - Value "6" passes type constraint Colour+Style
> ok 11 - Value "7" passes type constraint Colour+Style
> ok 12 - Value "8" passes type constraint Colour+Style
> ok 13 - Value "9" passes type constraint Colour+Style
> ok 14 - Value "10" passes type constraint Colour+Style
> ok 15 - Value "11" passes type constraint Colour+Style
> ok 16 - Value "12" passes type constraint Colour+Style
> ok 17 - Value "13" passes type constraint Colour+Style
> ok 18 - Value "14" passes type constraint Colour+Style
> ok 19 - Value "15" passes type constraint Colour+Style
> ok 20 - Value "16" passes type constraint Colour+Style
> ok 21 - Value "17" passes type constraint Colour+Style
> ok 22 - Value "18" passes type constraint Colour+Style
> ok 23 - Value "19" passes type constraint Colour+Style
> ok 24 - Value "20" passes type constraint Colour+Style
> ok 25 - Value "21" passes type constraint Colour+Style
> ok 26 - Value "22" passes type constraint Colour+Style
> ok 27 - Value "23" passes type constraint Colour+Style
> ok 28 - Value "24" passes type constraint Colour+Style
> ok 29 - Value "25" passes type constraint Colour+Style
> ok 30 - Value "26" passes type constraint Colour+Style
> ok 31 - Value "27" passes type constraint Colour+Style
> ok 32 - Value "28" passes type constraint Colour+Style
> ok 33 - Value "29" passes type constraint Colour+Style
> ok 34 - Value "30" passes type constraint Colour+Style
> ok 35 - Value "31" passes type constraint Colour+Style
> ok 36 - Value "32" passes type constraint Colour+Style
> ok 37 - Value "33" passes type constraint Colour+Style
> ok 38 - Value "34" passes type constraint Colour+Style
> ok 39 - Value "35" passes type constraint Colour+Style
> ok 40 - Value "36" passes type constraint Colour+Style
> ok 41 - Value "37" passes type constraint Colour+Style
> ok 42 - Value "38" passes type constraint Colour+Style
> ok 43 - Value "39" passes type constraint Colour+Style
> ok 44 - Value "40" passes type constraint Colour+Style
> ok 45 - Value "41" passes type constraint Colour+Style
> ok 46 - Value "42" passes type constraint Colour+Style
> ok 47 - Value "43" passes type constraint Colour+Style
> ok 48 - Value "44" passes type constraint Colour+Style
> ok 49 - Value "45" passes type constraint Colour+Style
> ok 50 - Value "46" passes type constraint Colour+Style
> ok 51 - Value "47" passes type constraint Colour+Style
> ok 52 - Value "48" passes type constraint Colour+Style
> ok 53 - Value "49" passes type constraint Colour+Style
> ok 54 - Value "50" passes type constraint Colour+Style
> ok 55 - Value "51" passes type constraint Colour+Style
> ok 56 - Value "52" passes type constraint Colour+Style
> ok 57 - Value "53" passes type constraint Colour+Style
> ok 58 - Value "54" passes type constraint Colour+Style
> ok 59 - Value "55" passes type constraint Colour+Style
> ok 60 - Value "56" passes type constraint Colour+Style
> ok 61 - Value "57" passes type constraint Colour+Style
> ok 62 - Value "58" passes type constraint Colour+Style
> ok 63 - Value "59" passes type constraint Colour+Style
> ok 64 - Value "60" passes type constraint Colour+Style
> ok 65 - Value "61" passes type constraint Colour+Style
> ok 66 - Value "62" passes type constraint Colour+Style
> ok 67 - Value "63" passes type constraint Colour+Style
> ok 68 - Value "64" fails type constraint Colour+Style
> ok 69 - Value "BLEH" fails type constraint Colour+Style
> ok 70 - Reference [] fails type constraint Colour+Style
> ok 71 - Value "-1" fails type constraint Colour+Style
> ok 72 - Undef fails type constraint Colour+Style
> ok 73 - Reference bless( {"_is_core" => 1,"_overload_coderef" => sub { "DUMMY"...) fails type constraint Colour+Style
> ok 74 - coerce
> ok 75 - Exception when trying to add Bitfield type and non-Bitfield type
> ok 76 - Exception when trying to add non-Bitfield type and Bitfield type
> ok 77 - Exception when trying to add Bitfield type and non-type
> ok 78 - Exception when trying to add non-type and Bitfield type
> ok 79 - Exception when trying to combine conflicting Bitfield types
> # Subtest: Combining Bitfield types with and without coercions works
> ok 1
> ok 2
> ok 3
> ok 4
> 1..4
> ok 80 - Combining Bitfield types with and without coercions works
> 1..80
> ok
> t/20-modules/Type-Tiny-Class/basic.t .........................
> ok 1 - 'FooBar' isa 'Type::Tiny'
> ok 2 - 'FooBar' isa 'Type::Tiny::Class'
> ok 3 - 'FooBaz' isa 'Type::Tiny'
> ok 4 - 'FooBaz' isa 'Type::Tiny::Class'
> ok 5 - 'FooBar->new' isa 'Foo::Bar'
> ok 6 - 'FooBaz->new' isa 'Foo::Baz'
> ok 7 - 'FooBar->class->new' isa 'Foo::Bar'
> ok 8 - 'FooBaz->class->new' isa 'Foo::Baz'
> ok 9 - Reference bless( {}, 'Foo::Bar' ) passes type constraint FooBar
> ok 10 - Reference bless( {}, 'Foo::Baz' ) passes type constraint FooBar
> ok 11 - Reference bless( {}, 'Foo::Bar' ) fails type constraint FooBaz
> ok 12 - Reference bless( {}, 'Foo::Baz' ) passes type constraint FooBaz
> ok 13 - Undef fails type constraint FooBar
> ok 14 - Undef fails type constraint FooBaz
> ok 15 - Reference {} fails type constraint FooBar
> ok 16 - Reference {} fails type constraint FooBaz
> ok 17 - Reference bless( {"_caller_level" => 1,"_overload_coderef" => sub { "D...) fails type constraint FooBar
> ok 18 - Reference bless( {"_caller_level" => 1,"_overload_coderef" => sub { "D...) fails type constraint FooBaz
> ok 19 - Reference bless( {"_caller_level" => 1,"_overload_coderef" => sub { "D...) fails type constraint FooBar
> ok 20 - Reference bless( {"_caller_level" => 1,"_overload_coderef" => sub { "D...) fails type constraint FooBaz
> ok 21 - Value "Foo::Bar" fails type constraint FooBar
> ok 22 - Value "Foo::Bar" fails type constraint FooBaz
> ok 23 - Value "Foo::Baz" fails type constraint FooBar
> ok 24 - Value "Foo::Baz" fails type constraint FooBaz
> ok 25 - DWIM Type::Tiny::Class::new
> ok 26 - constructor can be passed a hash or hashref
> 1..26
> ok
> t/20-modules/Type-Tiny-Class/errors.t ........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> 1..5
> ok
> t/20-modules/Type-Tiny-Class/exporter.t ......................
> ok 1 - 'HTTPTiny' isa 'Type::Tiny'
> ok 2
> ok 3
> 1..3
> ok
> t/20-modules/Type-Tiny-Class/exporter_with_options.t .........
> ok 1 - 'HT' isa 'Type::Tiny'
> ok 2
> ok 3
> 1..3
> ok
> t/20-modules/Type-Tiny-Class/plus-constructors.t .............
> ok 1 - "Person"->meta->get_attribute("addr")->type_constraint->is_a_type_of($Address)
> ok 2 - coercion worked
> ok 3 - coercion worked (plus_constructors with no parameters)
> 1..3
> ok
> t/20-modules/Type-Tiny-ConstrainedObject/basic.t .............
> ok 1 - Class types...
> ok 2 - ... stringifies_to (should pass)
> ok 3 - ... stringifies_to (should fail)
> ok 4 - ... numifies_to (should pass)
> ok 5 - ... numifies_to (should fail)
> ok 6 - ... with_attribute_values (should pass)
> ok 7 - ... with_attribute_values (should fail because of foo)
> ok 8 - ... with_attribute_values (should fail because of bar)
> ok 9 - ... with_attribute_values (should fail because of baz)
> ok 10 - Role types...
> ok 11 - ... stringifies_to (should pass)
> ok 12 - ... stringifies_to (should fail)
> ok 13 - ... numifies_to (should pass)
> ok 14 - ... numifies_to (should fail)
> ok 15 - ... with_attribute_values (should pass)
> ok 16 - ... with_attribute_values (should fail because of foo)
> ok 17 - ... with_attribute_values (should fail because of bar)
> ok 18 - ... with_attribute_values (should fail because of baz)
> ok 19 - Duck types...
> ok 20 - ... stringifies_to (should pass)
> ok 21 - ... stringifies_to (should fail)
> ok 22 - ... numifies_to (should pass)
> ok 23 - ... numifies_to (should fail)
> ok 24 - ... with_attribute_values (should pass)
> ok 25 - ... with_attribute_values (should fail because of foo)
> ok 26 - ... with_attribute_values (should fail because of bar)
> ok 27 - ... with_attribute_values (should fail because of baz)
> 1..27
> ok
> t/20-modules/Type-Tiny-Duck/basic.t ..........................
> ok 1 - 'CanFooBar' isa 'Type::Tiny'
> ok 2 - 'CanFooBar' isa 'Type::Tiny::Duck'
> ok 3 - Reference bless( {}, 'Foo::Bar' ) passes type constraint CanFooBar
> ok 4 - Reference bless( {}, 'Foo::Bar' ) fails type constraint CanFooBaz
> ok 5 - Reference bless( {}, 'Foo::Baz' ) passes type constraint CanFooBar
> ok 6 - Reference bless( {}, 'Foo::Baz' ) passes type constraint CanFooBaz
> ok 7 - Undef fails type constraint CanFooBar
> ok 8 - Reference {} fails type constraint CanFooBar
> ok 9 - Reference bless( {"_caller_level" => 1,"_overload_coderef" => sub { "D...) fails type constraint CanFooBar
> ok 10 - Reference bless( {"_caller_level" => 1,"_overload_coderef" => sub { "D...) fails type constraint CanFooBar
> ok 11 - Reference bless( {"_caller_level" => 1,"_overload_coderef" => sub { "D...) fails type constraint CanFooBar
> ok 12 - Value "Foo::Bar" fails type constraint CanFooBar
> 1..12
> ok
> t/20-modules/Type-Tiny-Duck/cmp.t ............................
> ok 1 - Type1 subtype: Type2, Type3
> ok 2 - Type2 subtype: Type1, Type3
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> ok 13
> ok 14
> 1..14
> ok
> t/20-modules/Type-Tiny-Duck/errors.t .........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> 1..5
> ok
> t/20-modules/Type-Tiny-Duck/exporter.t .......................
> ok 1 - 'HttpClient' isa 'Type::Tiny'
> ok 2
> ok 3
> 1..3
> ok
> t/20-modules/Type-Tiny-Enum/basic.t ..........................
> ok 1 - 'FBB' isa 'Type::Tiny'
> ok 2 - 'FBB' isa 'Type::Tiny::Enum'
> ok 3 - Value "foo" passes type constraint Enum[bar,baz,foo]
> ok 4 - Value "bar" passes type constraint Enum[bar,baz,foo]
> ok 5 - Value "baz" passes type constraint Enum[bar,baz,foo]
> ok 6 - Value "quux" fails type constraint Enum[bar,baz,foo]
> ok 7 - Value " foo" fails type constraint Enum[bar,baz,foo]
> ok 8 - Value "foo\n" fails type constraint Enum[bar,baz,foo]
> ok 9 - Value "\nfoo" fails type constraint Enum[bar,baz,foo]
> ok 10 - Value "\nfoo\n" fails type constraint Enum[bar,baz,foo]
> ok 11 - Value "foo|" fails type constraint Enum[bar,baz,foo]
> ok 12 - Value "|foo" fails type constraint Enum[bar,baz,foo]
> ok 13 - Undef fails type constraint Enum[bar,baz,foo]
> ok 14 - Reference {} fails type constraint Enum[bar,baz,foo]
> ok 15 - Reference \"foo" fails type constraint Enum[bar,baz,foo]
> ok 16 - Reference \"bar" fails type constraint Enum[bar,baz,foo]
> ok 17 - Reference \"baz" fails type constraint Enum[bar,baz,foo]
> ok 18 - FBB->values works
> ok 19 - FBB->values retains order
> ok 20 - overload retains order
> ok 21 - cannot push to overloaded arrayref
> ok 22 - don't create duplicate coderefs
> ok 23 - correct exportables
> ok 24 - exported constant actually works
> ok 25 - correct exportables for non-word-safe enum
> 1..25
> ok
> t/20-modules/Type-Tiny-Enum/cmp.t ............................
> ok 1 - Relationship between Enum[cat,cow,dog,goat,horse,lion,mouse,pig,rabbit,sheep,zebra] and Enum[cat,cow,dog,goat,horse,lion,mouse,pig,rabbit,sheep,zebra]
> ok 2 - Relationship between Enum[cat,cow,dog,goat,horse,lion,mouse,pig,rabbit,sheep,zebra] and Enum[cow,goat,horse,pig,sheep]
> ok 3 - Relationship between Enum[cat,cow,dog,goat,horse,lion,mouse,pig,rabbit,sheep,zebra] and Enum[cat,dog,mouse,rabbit]
> ok 4 - Relationship between Enum[cat,cow,dog,goat,horse,lion,mouse,pig,rabbit,sheep,zebra] and Enum[lion,zebra]
> ok 5 - Relationship between Enum[cow,goat,horse,pig,sheep] and Enum[cat,cow,dog,goat,horse,lion,mouse,pig,rabbit,sheep,zebra]
> ok 6 - Relationship between Enum[cow,goat,horse,pig,sheep] and Enum[cow,goat,horse,pig,sheep]
> ok 7 - Relationship between Enum[cow,goat,horse,pig,sheep] and Enum[cat,dog,mouse,rabbit]
> ok 8 - Relationship between Enum[cow,goat,horse,pig,sheep] and Enum[lion,zebra]
> ok 9 - Relationship between Enum[cat,dog,mouse,rabbit] and Enum[cat,cow,dog,goat,horse,lion,mouse,pig,rabbit,sheep,zebra]
> ok 10 - Relationship between Enum[cat,dog,mouse,rabbit] and Enum[cow,goat,horse,pig,sheep]
> ok 11 - Relationship between Enum[cat,dog,mouse,rabbit] and Enum[cat,dog,mouse,rabbit]
> ok 12 - Relationship between Enum[cat,dog,mouse,rabbit] and Enum[lion,zebra]
> ok 13 - Relationship between Enum[lion,zebra] and Enum[cat,cow,dog,goat,horse,lion,mouse,pig,rabbit,sheep,zebra]
> ok 14 - Relationship between Enum[lion,zebra] and Enum[cow,goat,horse,pig,sheep]
> ok 15 - Relationship between Enum[lion,zebra] and Enum[cat,dog,mouse,rabbit]
> ok 16 - Relationship between Enum[lion,zebra] and Enum[lion,zebra]
> ok 17 - Relationship between Enum[cat,dog,mouse,rabbit] and Enum[cat,lion]
> ok 18 - Relationship between Enum[cat,lion] and Enum[cat,dog,mouse,rabbit]
> ok 19 - Relationship between Enum[cat,lion] and Enum[cat,lion]
> ok 20 - Relationship between Enum[cat,lion] and Enum[cat,lion]
> 1..20
> ok
> t/20-modules/Type-Tiny-Enum/errors.t .........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> 1..5
> ok
> t/20-modules/Type-Tiny-Enum/exporter.t .......................
> ok 1 - 'Status' isa 'Type::Tiny'
> ok 2
> ok 3
> ok 4
> 1..4
> ok
> t/20-modules/Type-Tiny-Enum/exporter_lexical.t ...............
> ok 1 - 'Status' isa 'Type::Tiny'
> ok 2
> ok 3
> ok 4 - nothing added to registry
> ok 5 - no Status function in symbol table
> ok 6 - no is_Status function in symbol table
> ok 7 - no assert_Status function in symbol table
> ok 8 - no to_Status function in symbol table
> ok 9 - no STATUS_DEAD function in symbol table
> ok 10 - no STATUS_ALIVE function in symbol table
> 1..10
> ok
> t/20-modules/Type-Tiny-Enum/sorter.t .........................
> ok 1 - sorted
> 1..1
> ok
> t/20-modules/Type-Tiny-Enum/union_intersection.t .............
> ok 1 - '$foo_union_bar' isa 'Type::Tiny::Enum'
> ok 2 - $foo_union_bar->unique_values
> ok 3 - '$foo_intersect_bar' isa 'Type::Tiny::Enum'
> ok 4 - $foo_intersect_bar->unique_values
> 1..4
> ok
> t/20-modules/Type-Tiny-Intersection/basic.t ..................
> ok 1 - 'FooBarAndDoesQuux' isa 'Type::Tiny::Intersection'
> ok 2 - 'FooBarAndDoesQuux->[0]' isa 'Type::Tiny::Class'
> ok 3 - 'FooBarAndDoesQuux->[1]' isa 'Type::Tiny::Role'
> ok 4 - stringification good
> ok 5 - Reference bless( {}, 'Foo::Bar' ) fails type constraint FooBar&DoesQuux
> ok 6 - Reference bless( {}, 'Foo::Baz' ) passes type constraint FooBar&DoesQuux
> ok 7 - Reference bless( [], 'Something' ) fails type constraint FooBar&DoesQuux
> ok 8 - Reference bless( [], 'Something::Else' ) fails type constraint FooBar&DoesQuux
> ok 9 - Value "Foo::Bar" fails type constraint FooBar&DoesQuux
> ok 10 - Value "Foo::Baz" fails type constraint FooBar&DoesQuux
> ok 11 - intersections don't get unnecessarily deep
> # ((Type::Tiny::XS::AUTO::TC1($X)) and do { package Type::Tiny; Scalar::Util::blessed($X) and do { my $method = $X->can('DOES')||$X->can('isa'); $X->$method(q[Quux]) } } and (ref($X) and Scalar::Util::reftype($X) eq q(ARRAY)))
> ok 12 - Reference bless( [], 'Foo::Baz' ) passes type constraint FooBar&DoesQuux&Ref[ARRAY]
> ok 13 - Reference bless( {}, 'Foo::Baz' ) fails type constraint FooBar&DoesQuux&Ref[ARRAY]
> ok 14 - An object of class 'Type::Tiny::Intersection' isa 'Type::Tiny::Intersection'
> ok 15 - not (SmallInteger&__ANON__)->can_be_inlined
> ok 16 - Value "2" passes type constraint SmallInteger&__ANON__
> ok 17 - Value "20" fails type constraint SmallInteger&__ANON__
> ok 18 - Value "3" fails type constraint SmallInteger&__ANON__
> ok 19 - cannot push to overloaded arrayref
> 1..19
> ok
> t/20-modules/Type-Tiny-Intersection/cmp.t ....................
> ok 1 - Value "2" passes type constraint Even&PositiveInt
> ok 2 - Value "-2" fails type constraint Even&PositiveInt
> ok 3 - Value "1" fails type constraint Even&PositiveInt
> ok 4 - Num subtype: Int, PositiveInt, Even, Even&PositiveInt
> ok 5 - Int subtype: PositiveInt, Even, Even&PositiveInt
> ok 6 - PositiveInt subtype: Even&PositiveInt
> ok 7 - Even subtype: Even&PositiveInt
> ok 8 - __ANON__ subtype: Int, PositiveInt, Even, __ANON__
> ok 9 - __ANON__ subtype: PositiveInt, Even, __ANON__
> ok 10 - __ANON__ subtype: __ANON__
> ok 11 - __ANON__ subtype: __ANON__
> ok 12 - Even&PositiveInt subtype: __ANON__
> ok 13 - Even >
> ok 14 - < Even
> ok 15 - Int >
> ok 16 - < Int
> ok 17 - ==
> 1..17
> ok
> t/20-modules/Type-Tiny-Intersection/constrainedobject.t ......
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> ok 13
> ok 14
> ok 15
> ok 16
> ok 17
> ok 18
> ok 19
> ok 20 - Reference bless( {"as_number" => 42}, 'Local::Class' ) passes type constraint Ref[HASH]&__ANON__
> ok 21 - Reference bless( {"as_number" => 41}, 'Local::Class' ) fails type constraint Ref[HASH]&__ANON__
> 1..21
> ok
> t/20-modules/Type-Tiny-Intersection/errors.t .................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> 1..5
> ok
> t/20-modules/Type-Tiny-Role/basic.t ..........................
> ok 1 - 'DoesQuux' isa 'Type::Tiny'
> ok 2 - 'DoesQuux' isa 'Type::Tiny::Role'
> ok 3 - Reference bless( {}, 'Foo::Bar' ) fails type constraint DoesQuux
> ok 4 - Reference bless( {}, 'Foo::Baz' ) passes type constraint DoesQuux
> ok 5 - Undef fails type constraint DoesQuux
> ok 6 - Reference {} fails type constraint DoesQuux
> ok 7 - Reference bless( {"_caller_level" => 1,"_overload_coderef" => sub { "D...) fails type constraint DoesQuux
> ok 8 - Reference bless( {"_caller_level" => 1,"_overload_coderef" => sub { "D...) fails type constraint DoesQuux
> ok 9 - Reference bless( {"_caller_level" => 1,"_overload_coderef" => sub { "D...) fails type constraint DoesQuux
> ok 10 - Value "Quux" fails type constraint DoesQuux
> ok 11 - constructor can be passed a hash or hashref
> 1..11
> ok
> t/20-modules/Type-Tiny-Role/errors.t .........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> 1..8
> ok
> t/20-modules/Type-Tiny-Role/exporter.t .......................
> ok 1 - 'LocalFoo' isa 'Type::Tiny'
> ok 2
> ok 3
> 1..3
> ok
> t/20-modules/Type-Tiny-Union/basic.t .........................
> ok 1 - 'FooBarOrDoesQuux' isa 'Type::Tiny::Union'
> ok 2 - 'FooBarOrDoesQuux->[0]' isa 'Type::Tiny::Class'
> ok 3 - 'FooBarOrDoesQuux->[1]' isa 'Type::Tiny::Role'
> ok 4 - stringification good
> ok 5 - Reference bless( {}, 'Foo::Bar' ) passes type constraint FooBar|DoesQuux
> ok 6 - Reference bless( {}, 'Foo::Baz' ) passes type constraint FooBar|DoesQuux
> ok 7 - Reference bless( [], 'Something' ) passes type constraint FooBar|DoesQuux
> ok 8 - Reference bless( [], 'Something::Else' ) fails type constraint FooBar|DoesQuux
> ok 9 - Value "Foo::Bar" fails type constraint FooBar|DoesQuux
> ok 10 - Value "Foo::Baz" fails type constraint FooBar|DoesQuux
> ok 11 - unions don't get unnecessarily deep
> ok 12 - can climb up parents of union type constraints to find best common ancestor
> ok 13 - cannot push to overloaded arrayref
> ok 14 - can climb up parents of union type constraints to find best common ancestor (again)
> ok 15 - Union find_type_for
> ok 16 - Union find_type_for (less obvious)
> ok 17 - Union find_type_for (ambiguous)
> ok 18 - Union find_type_for (none)
> ok 19 - Union equals
> ok 20 - Union not equals
> 1..20
> ok
> t/20-modules/Type-Tiny-Union/constrainedobject.t .............
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> 1..7
> ok
> t/20-modules/Type-Tiny-Union/errors.t ........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> 1..5
> ok
> t/20-modules/Type-Tiny-Union/relationships.t .................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> 1..7
> ok
> t/20-modules/Type-Tiny/arithmetic.t ..........................
> ok 1 - Reference \123 fails type constraint ~ScalarRef
> ok 2 - Reference [] fails type constraint ~ArrayRef
> ok 3 - Reference {} fails type constraint ~HashRef
> ok 4 - Reference sub { "DUMMY" } fails type constraint ~CodeRef
> ok 5 - Reference \*::STDOUT fails type constraint ~GlobRef
> ok 6 - Reference \\"Hello" fails type constraint ~Ref
> ok 7 - Reference \*::STDOUT fails type constraint ~FileHandle
> ok 8 - Reference qr/x/ fails type constraint ~RegexpRef
> ok 9 - Value "1" fails type constraint ~Str
> ok 10 - Value "1" fails type constraint ~Num
> ok 11 - Value "1" fails type constraint ~Int
> ok 12 - Value "1" fails type constraint Undef
> ok 13 - Value "1" fails type constraint ~Value
> ok 14 - Undef fails type constraint Defined
> ok 15 - Undef fails type constraint ~Item
> ok 16 - Undef fails type constraint None
> ok 17 - Value "Type::Tiny" fails type constraint ~ClassName
> ok 18 - Value "Type::Library" fails type constraint ~RoleName
> ok 19 - Undef fails type constraint ~Bool
> ok 20 - Value "" fails type constraint ~Bool
> ok 21 - Value "0" fails type constraint ~Bool
> ok 22 - Value "1" fails type constraint ~Bool
> ok 23 - Value "7" passes type constraint ~Bool
> ok 24 - Reference \\"Hello" fails type constraint ~ScalarRef
> ok 25 - Value "Type::Tiny" passes type constraint ~RoleName
> ok 26 - Reference [] passes type constraint ~Str
> ok 27 - Reference [] passes type constraint ~Num
> ok 28 - Reference [] passes type constraint ~Int
> ok 29 - Value "4x4" fails type constraint ~Str
> ok 30 - Value "4x4" passes type constraint ~Num
> ok 31 - Value "4.2" passes type constraint ~Int
> ok 32 - Undef passes type constraint ~Str
> ok 33 - Undef passes type constraint ~Num
> ok 34 - Undef passes type constraint ~Int
> ok 35 - Undef passes type constraint Undef
> ok 36 - Undef passes type constraint ~Value
> ok 37 - Undef passes type constraint ~ClassName
> ok 38 - Reference [] passes type constraint ~ClassName
> ok 39 - Value "Local::Class2" fails type constraint ~ClassName
> ok 40 - Value "Local::Class3" fails type constraint ~ClassName
> ok 41 - Value "Local::Class4" fails type constraint ~ClassName
> ok 42 - Value "Local::Class5" fails type constraint ~ClassName
> ok 43 - Value "Local::Dummy1" passes type constraint ~ClassName
> ok 44 - Reference [] fails type constraint ~ArrayRef[Int]
> ok 45 - Reference [1,2,3] fails type constraint ~ArrayRef[Int]
> ok 46 - Reference ["1.1",2,3] passes type constraint ~ArrayRef[Int]
> ok 47 - Reference [1,2,"3.1"] passes type constraint ~ArrayRef[Int]
> ok 48 - Reference [[]] passes type constraint ~ArrayRef[Int]
> ok 49 - Reference [[3]] fails type constraint ~ArrayRef[ArrayRef[Int]]
> ok 50 - Reference [["A"]] passes type constraint ~ArrayRef[ArrayRef[Int]]
> ok 51 - Undef fails type constraint ~Maybe[Int]
> ok 52 - Value "123" fails type constraint ~Maybe[Int]
> ok 53 - Value "1.3" passes type constraint ~Maybe[Int]
> ok 54 - Value "-2" passes type constraint Even&Negative
> ok 55 - Value "-1" passes type constraint Even&Negative
> ok 56 - Value "0" passes type constraint Even&~Negative&~Positive
> ok 57 - Value "1" passes type constraint Even&Positive
> ok 58 - Value "2" passes type constraint Even&Positive
> ok 59 - Value "3" passes type constraint Even|Even
> ok 60 - Value "4" passes type constraint Even|Even
> ok 61 - Value "5" passes type constraint Negative|Positive
> ok 62 - Value "-6" passes type constraint Negative|Positive
> ok 63 - Value "-3" fails type constraint Even&Negative
> ok 64 - Value "1" fails type constraint Even&Negative
> ok 65 - Value "1" fails type constraint Even&~Negative&~Positive
> ok 66 - Value "2" fails type constraint Even&Positive
> ok 67 - Value "1" fails type constraint Even&Positive
> ok 68 - Value "Str" fails type constraint Even|Even
> ok 69 - Value "1.1" fails type constraint Even|Even
> ok 70 - Value "0" fails type constraint Negative|Positive
> ok 71 - Value "Str" fails type constraint Negative|Positive
> ok 72 - coolio stringification
> ok 73 - Item > Value
> ok 74 - Value > Str
> ok 75 - Str > Num
> ok 76 - Num > Int
> ok 77 - Int > $odd
> ok 78 - Item >= Value
> ok 79 - Value >= Str
> ok 80 - Str >= Num
> ok 81 - Num >= Int
> ok 82 - Int >= $odd
> ok 83 - Value < Item
> ok 84 - Str < Value
> ok 85 - Num < Str
> ok 86 - Int < Num
> ok 87 - $even < Int
> ok 88 - Value <= Item
> ok 89 - Str <= Value
> ok 90 - Num <= Str
> ok 91 - Int <= Num
> ok 92 - $even < Int
> ok 93 - not(Int > Int)
> ok 94 - not(Int < Int)
> ok 95 - Int <= Int
> ok 96 - Int >= Int
> ok 97 - not(ArrayRef[Int] > ArrayRef[Num])
> ok 98 - not(ArrayRef[Int] == ArrayRef[Num])
> ok 99 - ArrayRef[Int] == ArrayRef[Int]
> ok 100 - not(ArrayRef == ArrayRef[Int])
> ok 101 - ArrayRef > ArrayRef[Int]
> 1..101
> ok
> t/20-modules/Type-Tiny/basic.t ...............................
> ok 1 - Type::Tiny can works for valid methods
> ok 2 - Type::Tiny can works for invalid methods
> ok 3 - Any is not anon
> ok 4 - Any is called Any
> ok 5 - Any can be inlined
> ok 6 - Value "1" passes type constraint Any
> ok 7 - Value "1.2" passes type constraint Any
> ok 8 - Value "Hello World" passes type constraint Any
> ok 9 - Reference [] passes type constraint Any
> ok 10 - Reference {} passes type constraint Any
> ok 11 - Undef passes type constraint Any
> ok 12 - Reference \*::STDOUT passes type constraint Any
> ok 13 - bad type constraint name
> ok 14 - $Int is anon
> ok 15 - $Int is called __ANON__
> ok 16 - $Int cannot be inlined
> ok 17 - Value "1" passes type constraint __ANON__
> ok 18 - Value "-1" passes type constraint __ANON__
> ok 19 - Value "0" passes type constraint __ANON__
> ok 20 - Value "100" passes type constraint __ANON__
> ok 21 - Value "10000" passes type constraint __ANON__
> ok 22 - Value "987654" passes type constraint __ANON__
> ok 23 - Value "1.2" fails type constraint __ANON__
> ok 24 - Value "Hello World" fails type constraint __ANON__
> ok 25 - Reference [] fails type constraint __ANON__
> ok 26 - Reference {} fails type constraint __ANON__
> ok 27 - Undef fails type constraint __ANON__
> ok 28 - Reference \*::STDOUT fails type constraint __ANON__
> ok 29 - Any subtype: __ANON__
> ok 30 - Any is_supertype_of $Int
> ok 31 - $Int is_a_type_of Any
> ok 32 - $Int is_a_type_of $Int
> ok 33 - not $Int is_subtype_of $Int
> ok 34 - Below is_parameterizable
> ok 35 - not Below is_parameterized
> ok 36 - Value "1" passes type constraint Below
> ok 37 - Value "-1" passes type constraint Below
> ok 38 - Value "0" passes type constraint Below
> ok 39 - Value "100" passes type constraint Below
> ok 40 - Value "10000" passes type constraint Below
> ok 41 - Value "987654" passes type constraint Below
> ok 42 - Value "1.2" fails type constraint Below
> ok 43 - Value "Hello World" fails type constraint Below
> ok 44 - Reference [] fails type constraint Below
> ok 45 - Reference {} fails type constraint Below
> ok 46 - Undef fails type constraint Below
> ok 47 - Reference \*::STDOUT fails type constraint Below
> ok 48 - $Below5 is anon
> ok 49 - ... but still has a nice display name
> ok 50 - Value "1" passes type constraint Below[5]
> ok 51 - Value "-1" passes type constraint Below[5]
> ok 52 - Value "0" passes type constraint Below[5]
> ok 53 - Value "1.2" fails type constraint Below[5]
> ok 54 - Value "Hello World" fails type constraint Below[5]
> ok 55 - Reference [] fails type constraint Below[5]
> ok 56 - Reference {} fails type constraint Below[5]
> ok 57 - Undef fails type constraint Below[5]
> ok 58 - Reference \*::STDOUT fails type constraint Below[5]
> ok 59 - Value "100" fails type constraint Below[5]
> ok 60 - Value "10000" fails type constraint Below[5]
> ok 61 - Value "987654" fails type constraint Below[5]
> ok 62 - Any subtype: Below[5]
> ok 63 - __ANON__ subtype: Below[5]
> ok 64 - Below subtype: Below[5]
> ok 65 - Below[5] is_parameterized
> ok 66 - has_parameters method works - negative
> ok 67 - has_parameters method works - positive
> ok 68 - parameters method works
> ok 69 - inlining stuff can return a list
> ok 70 - loose subtype comparison 1
> ok 71 - strict subtype comparison 1
> ok 72 - loose supertype comparison 1
> ok 73 - strict supertype comparison 1
> ok 74 - loose subtype comparison 2
> ok 75 - strict subtype comparison 2
> ok 76 - loose supertype comparison 2
> ok 77 - strict supertype comparison 2
> ok 78 - find_parent (scalar context)
> ok 79 - find_parent (list context)
> ok 80 - ... includes a count
> ok 81 - find_parent (null result)
> ok 82 - ... includes an undef count
> ok 83 - find_constraining_type
> 1..83
> ok
> t/20-modules/Type-Tiny/cmp.t .................................
> ok 1 - __ANON__ subtype: __ANON__, __ANON__, __ANON__, __ANON__, __ANON__, __ANON__, __ANON__
> ok 2 - __ANON__ subtype: __ANON__, __ANON__, __ANON__, __ANON__, __ANON__, __ANON__, __ANON__
> ok 3 - __ANON__ subtype: __ANON__, __ANON__, __ANON__, __ANON__, __ANON__
> ok 4 - __ANON__ subtype: __ANON__, __ANON__, __ANON__, __ANON__, __ANON__
> ok 5 - __ANON__ subtype: __ANON__, __ANON__, __ANON__
> ok 6 - __ANON__ subtype: __ANON__, __ANON__, __ANON__
> ok 7 - __ANON__ subtype: __ANON__
> ok 8 - __ANON__ subtype: __ANON__
> ok 9
> ok 10
> ok 11
> ok 12
> ok 13
> ok 14
> ok 15
> ok 16
> ok 17
> ok 18
> ok 19
> ok 20
> ok 21
> ok 22
> ok 23
> ok 24
> ok 25
> ok 26
> ok 27
> ok 28
> ok 29
> ok 30
> ok 31
> ok 32
> ok 33
> ok 34
> ok 35
> ok 36
> ok 37
> ok 38
> ok 39
> ok 40
> ok 41
> ok 42
> ok 43
> 1..43
> ok
> t/20-modules/Type-Tiny/coercion-modifiers.t ..................
> ok 1 - has_coercian_for_type - obvious
> ok 2 - has_coercian_for_type - subtle
> ok 3 - has_coercian_for_type - negative
> ok 4 - plus_coercions - added coercion
> ok 5 - plus_coercions - added coercion
> ok 6 - plus_coercions - retained coercion
> ok 7 - plus_coercions - retained coercion
> ok 8 - minus_coercions - retained coercion
> ok 9 - minus_coercions - removed coercion
> ok 10 - minus_coercions - retained coercion
> ok 11 - minus_coercions - removed coercion
> ok 12 - no_coercions - removed coercion
> ok 13 - no_coercions - removed coercion
> ok 14 - no_coercions - removed coercion
> ok 15 - no_coercions - removed coercion
> 1..15
> ok
> t/20-modules/Type-Tiny/constraint-strings.t ..................
> ok 1 - non-empty string, okay
> ok 2 - 'result of empty string' isa 'Error::TypeTiny'
> ok 3 - non-empty arrayref, okay
> ok 4 - 'result of empty arrayref' isa 'Error::TypeTiny'
> ok 5 - non-empty hashref, okay
> ok 6 - 'result of empty hashref' isa 'Error::TypeTiny'
> 1..6
> ok
> t/20-modules/Type-Tiny/custom-exception-classes.t ............
> ok 1 - An object of class 'Custom::Exception' isa 'Custom::Exception'
> ok 2 - An object of class 'Custom::Exception' isa 'Custom::Exception'
> # do { no warnings "void"; package Type::Tiny; ((do { package Type::Tiny; (do { package Type::Tiny; (do { my $tmp = $value; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ }) } && (do { local $_ = $value; $_ > 3 })) } && (do { local $_ = $value; $_ < 5 }))) or Type::Tiny::_failed_check(41, "__ANON__", $value, "exception_class","Custom::Exception"); $value };
> 1..2
> ok
> t/20-modules/Type-Tiny/definition-context.t ..................
> ok 1 - expected definition context
> 1..1
> ok
> t/20-modules/Type-Tiny/deprecation.t .........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> 1..5
> ok
> t/20-modules/Type-Tiny/esoteric.t ............................
> ok 1 - $type->inline_environment
> ok 2 - $type->_inline_check
> ok 3 - $type->_compiled_type_constraint
> ok 4 - $type->meta
> ok 5 - $type->compile_type_constraint
> ok 6 - $type->_actually_compile_type_constraint
> ok 7 - $type->hand_optimized_type_constraint
> ok 8 - $type->has_hand_optimized_type_constraint
> ok 9 - $type->__is_parameterized
> ok 10 - $type->has_parameterized_from
> ok 11 - $type->_add_type_coercions
> ok 12 - $type->_as_string
> ok 13 - $type->_stringify_no_magic
> ok 14 - $type->_compiled_type_coercion
> ok 15 - $type->_identity
> ok 16 - $type->_unite
> ok 17 - overridden assert_return works (failing value)
> ok 18 - overridden assert_return works (passing value)
> ok 19 - overridden assert_return is used by &{} overload
> ok 20 - $type->____make_key
> 1..20
> ok
> t/20-modules/Type-Tiny/inline-assert.t .......................
> # INLINE ASSERTION, INLINABLE TYPE, NO TYPEVAR
> # do { no warnings "void"; package Type::Tiny; ((do { my $tmp = $VALUE[0]; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ })) or Type::Tiny::_failed_check(13, "Int", $VALUE[0], "exception_class","Error::TypeTiny::Assertion"); $VALUE[0] };
> ok 1 - successful check
> ok 2 - successful throw
> ok 3 - ... with correct exception
> # INLINE ASSERTION, INLINABLE TYPE, WITH TYPEVAR
> # do { no warnings "void"; package Type::Tiny; ((do { my $tmp = $VALUE[0]; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ })) or Type::Tiny::_failed_check($type, "Int", $VALUE[0], "exception_class","Error::TypeTiny::Assertion"); $VALUE[0] };
> ok 4 - successful check
> ok 5 - successful throw
> ok 6 - ... with correct exception
> ok 7 - successful throw even when $type is undef
> ok 8 - ... with correct exception
> ok 9 - ... but the exception does not know which type it was thrown by
> # INLINE ASSERTION, NON-INLINABLE TYPE, NO TYPEVAR
> ok 10 - cannot be done!
> # INLINE ASSERTION, NON-INLINABLE TYPE, WITH TYPEVAR
> # do { no warnings "void"; package Type::Tiny; $type->check($VALUE[0]) or Type::Tiny::_failed_check($type, "__ANON__", $VALUE[0], "exception_class","Error::TypeTiny::Assertion"); $VALUE[0] };
> ok 11 - successful check
> ok 12 - successful throw
> ok 13 - ... with correct exception
> # INLINE ASSERTION, NON-INLINABLE TYPE, WITH TYPEVAR AND EXTRAS
> # do { no warnings "void"; package Type::Tiny; $type->check($VALUE[0]) or Type::Tiny::_failed_check($type, "__ANON__", $VALUE[0], "exception_class","Error::TypeTiny::Assertion","foo","bar"); $VALUE[0] };
> ok 14 - extras work
> 1..14
> ok
> t/20-modules/Type-Tiny/list-methods.t ........................
> # Subtest: Tests with inlineable base types
> ok 1 - Type::Tiny->can('grep')
> ok 2 - Type::Tiny->can('map')
> ok 3 - Type::Tiny->can('sort')
> ok 4 - Type::Tiny->can('rsort')
> ok 5 - Type::Tiny->can('first')
> ok 6 - Type::Tiny->can('any')
> ok 7 - Type::Tiny->can('all')
> ok 8 - Type::Tiny->can('assert_any')
> ok 9 - Type::Tiny->can('assert_all')
> ok 10 - Type::Tiny->can('grep')
> ok 11 - Type::Tiny->can('sort')
> ok 12 - Type::Tiny->can('rsort')
> ok 13 - Type::Tiny->can('first')
> ok 14 - Type::Tiny->can('any')
> ok 15 - Type::Tiny->can('all')
> ok 16 - Type::Tiny->can('assert_any')
> ok 17 - Type::Tiny->can('assert_all')
> ok 18
> ok 19 - Int->grep
> ok 20 - Int->first
> ok 21 - map() requires a coercion
> ok 22 - $Rounded->map
> ok 23 - $Rounded->map with uncoercible values
> ok 24 - Any->sort
> ok 25 - Int->sort
> ok 26 - $Rounded->sort
> ok 27 - Str->sort
> ok 28 - Int->rsort
> ok 29 - $Rounded->rsort
> ok 30 - Str->rsort
> ok 31 - $CrazyInt->sort
> ok 32 - $CrazyInt->rsort
> ok 33 - not Int->any(qw//)
> ok 34 - Int->any(qw/ foo 1 bar /)
> ok 35 - not Int->any(qw/ foo bar /)
> ok 36 - Int->any(qw/ 1 2 3 /)
> ok 37 - Int->all(qw//)
> ok 38 - not Int->all(qw/ foo 1 bar /)
> ok 39 - not Int->all(qw/ foo bar /)
> ok 40 - Int->all(qw/ 1 2 3 /)
> ok 41 - Int->assert_any(qw//) --> exception
> ok 42 - Int->assert_any(qw/ foo 1 bar /)
> ok 43 - Int->assert_any(qw/ foo bar /) --> exception
> ok 44 - Int->assert_any(qw/ 1 2 3 /)
> ok 45 - Int->assert_all(qw//)
> ok 46 - Int->assert_all(qw/ foo 1 bar /) --> exception
> ok 47 - Int->assert_all(qw/ foo bar /) --> exception
> ok 48 - Int->assert_all(qw/ 1 2 3 /)
> ok 49 - Int->_build_util("xxxx") --> exception
> 1..49
> ok 1 - Tests with inlineable base types
> # Subtest: Tests with non-inlineable base types
> ok 1 - Type::Tiny->can('grep')
> ok 2 - Type::Tiny->can('map')
> ok 3 - Type::Tiny->can('sort')
> ok 4 - Type::Tiny->can('rsort')
> ok 5 - Type::Tiny->can('first')
> ok 6 - Type::Tiny->can('any')
> ok 7 - Type::Tiny->can('all')
> ok 8 - Type::Tiny->can('assert_any')
> ok 9 - Type::Tiny->can('assert_all')
> ok 10 - Type::Tiny->can('grep')
> ok 11 - Type::Tiny->can('sort')
> ok 12 - Type::Tiny->can('rsort')
> ok 13 - Type::Tiny->can('first')
> ok 14 - Type::Tiny->can('any')
> ok 15 - Type::Tiny->can('all')
> ok 16 - Type::Tiny->can('assert_any')
> ok 17 - Type::Tiny->can('assert_all')
> ok 18
> ok 19 - Int->grep
> ok 20 - Int->first
> ok 21 - map() requires a coercion
> ok 22 - $Rounded->map
> ok 23 - $Rounded->map with uncoercible values
> ok 24 - Any->sort
> ok 25 - Int->sort
> ok 26 - $Rounded->sort
> ok 27 - Str->sort
> ok 28 - Int->rsort
> ok 29 - $Rounded->rsort
> ok 30 - Str->rsort
> ok 31 - $CrazyInt->sort
> ok 32 - $CrazyInt->rsort
> ok 33 - not Int->any(qw//)
> ok 34 - Int->any(qw/ foo 1 bar /)
> ok 35 - not Int->any(qw/ foo bar /)
> ok 36 - Int->any(qw/ 1 2 3 /)
> ok 37 - Int->all(qw//)
> ok 38 - not Int->all(qw/ foo 1 bar /)
> ok 39 - not Int->all(qw/ foo bar /)
> ok 40 - Int->all(qw/ 1 2 3 /)
> ok 41 - Int->assert_any(qw//) --> exception
> ok 42 - Int->assert_any(qw/ foo 1 bar /)
> ok 43 - Int->assert_any(qw/ foo bar /) --> exception
> ok 44 - Int->assert_any(qw/ 1 2 3 /)
> ok 45 - Int->assert_all(qw//)
> ok 46 - Int->assert_all(qw/ foo 1 bar /) --> exception
> ok 47 - Int->assert_all(qw/ foo bar /) --> exception
> ok 48 - Int->assert_all(qw/ 1 2 3 /)
> ok 49 - Int->_build_util("xxxx") --> exception
> 1..49
> ok 2 - Tests with non-inlineable base types
> 1..2
> ok
> t/20-modules/Type-Tiny/my-methods.t ..........................
> ok 1 - Type::Tiny->can('my_round_off')
> ok 2 - Type::Tiny->can('my_round_off')
> ok 3 - Number my_round_off works
> ok 4 - Number2 my_round_off works
> ok 5 - Number cannot my_smirnoff
> ok 6 - Number2 cannot my_smirnoff
> 1..6
> ok
> t/20-modules/Type-Tiny/parameterization.t ....................
> ok 1 - Avoid duplicating parameterized types
> ok 2 - ... except when necessary!
> ok 3 - Reference ["Bob"] passes type constraint ArrayRef[__ANON__]
> ok 4 - Reference ["Bob","Bob"] passes type constraint ArrayRef[__ANON__]
> ok 5 - Reference ["Bob","Bob","Suzie"] fails type constraint ArrayRef[__ANON__]
> ok 6 - Reference ["Bob"] passes type constraint ArrayRef[__ANON__]
> ok 7 - Reference ["Bob","Bob"] passes type constraint ArrayRef[__ANON__]
> ok 8 - Reference ["Bob","Bob","Suzie"] fails type constraint ArrayRef[__ANON__]
> ok 9 - Reference ["Bob"] passes type constraint ArrayRef[Str&__ANON__]
> ok 10 - Reference ["Bob","Bob"] passes type constraint ArrayRef[Str&__ANON__]
> ok 11 - Reference ["Bob","Bob","Suzie"] fails type constraint ArrayRef[Str&__ANON__]
> ok 12 - error message when a coderef returns false
> ok 13 - error message when a coderef dies
> ok 14 - $p7 and $p8 stringify the same
> ok 15 - $p7 and $p8 are the same
> ok 16
> 1..16
> ok
> t/20-modules/Type-Tiny/refcount.t ............................ skipped: requires Devel::Refcount
> t/20-modules/Type-Tiny/shortcuts.t ...........................
> ok 1 - ->of method works same as ->parameterize
> ok 2 - Reference ["Bob","Alice"] passes type constraint __ANON__
> ok 3 - Reference ["Alice","Bob"] fails type constraint __ANON__
> 1..3
> ok
> t/20-modules/Type-Tiny/smartmatch.t ..........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6 - int
> not ok 7 - regexpref # TODO this would be nice, but probably requires changes to perl
> # Failed (TODO) test 'regexpref'
> # at t/20-modules/Type-Tiny/smartmatch.t line 54.
> 1..7
> ok
> t/20-modules/Type-Tiny/strictmode-off.t ......................
> # Subtest: Type constraint object overloading /
> ok 1 - Reference [] passes type constraint ArrayRef[Str]
> ok 2 - Reference [1,2,3] passes type constraint ArrayRef[Str]
> ok 3 - Reference ["foo","bar"] passes type constraint ArrayRef[Str]
> ok 4 - Reference [{}] fails type constraint ArrayRef[Str]
> ok 5 - Reference {} fails type constraint ArrayRef[Str]
> 1..5
> ok 1 - Type constraint object overloading /
> # Subtest: Type::Parser support for /
> ok 1 - Reference [] passes type constraint ArrayRef[Str]
> ok 2 - Reference [1,2,3] passes type constraint ArrayRef[Str]
> ok 3 - Reference ["foo","bar"] passes type constraint ArrayRef[Str]
> ok 4 - Reference [{}] fails type constraint ArrayRef[Str]
> ok 5 - Reference {} fails type constraint ArrayRef[Str]
> 1..5
> ok 2 - Type::Parser support for /
> 1..2
> ok
> t/20-modules/Type-Tiny/strictmode-on.t .......................
> # Subtest: Type constraint object overloading /
> ok 1 - Reference [] passes type constraint ArrayRef[Int]
> ok 2 - Reference [1,2,3] passes type constraint ArrayRef[Int]
> ok 3 - Reference ["foo","bar"] fails type constraint ArrayRef[Int]
> ok 4 - Reference [{}] fails type constraint ArrayRef[Int]
> ok 5 - Reference {} fails type constraint ArrayRef[Int]
> 1..5
> ok 1 - Type constraint object overloading /
> # Subtest: Type::Parser support for /
> ok 1 - Reference [] passes type constraint ArrayRef[Int]
> ok 2 - Reference [1,2,3] passes type constraint ArrayRef[Int]
> ok 3 - Reference ["foo","bar"] fails type constraint ArrayRef[Int]
> ok 4 - Reference [{}] fails type constraint ArrayRef[Int]
> ok 5 - Reference {} fails type constraint ArrayRef[Int]
> 1..5
> ok 2 - Type::Parser support for /
> 1..2
> ok
> t/20-modules/Type-Tiny/syntax.t ..............................
> ok 1 - $type1==$type2
> ok 2 - $type1==$type3
> ok 3 - $type2==$type3
> 1..3
> ok
> t/20-modules/Type-Tiny/to-moose.t ............................
> ok 1 - '$mAny' isa 'Moose::Meta::TypeConstraint'
> ok 2 - '$mInt' isa 'Moose::Meta::TypeConstraint'
> ok 3 - type constraint inheritance seems right
> ok 4 - Value "42" passes type constraint __ANON__
> ok 5 - Reference [] passes type constraint __ANON__
> ok 6 - Value "42" passes type constraint __ANON__
> ok 7 - Reference [] fails type constraint __ANON__
> 1..7
> ok
> t/20-modules/Type-Tiny/to-mouse.t ............................
> ok 1 - '$mAny' isa 'Mouse::Meta::TypeConstraint'
> ok 2 - '$mInt' isa 'Mouse::Meta::TypeConstraint'
> ok 3 - type constraint inheritance seems right
> ok 4 - Value "42" passes type constraint __ANON__
> ok 5 - Reference [] passes type constraint __ANON__
> ok 6 - Value "42" passes type constraint __ANON__
> ok 7 - Reference [] fails type constraint __ANON__
> 1..7
> ok
> t/20-modules/Type-Tiny/type_default.t ........................
> ok 1 - Any->type_default
> ok 2 - Item->type_default (inherited from Any)
> ok 3 - Defined->type_default (not inherited from Item)
> ok 4 - Str->type_default
> ok 5 - Int->type_default
> ok 6 - Num->type_default
> ok 7 - StrictNum->type_default
> ok 8 - LaxNum->type_default
> ok 9 - Bool->type_default
> ok 10 - Undef->type_default
> ok 11 - Maybe->type_default
> ok 12 - Maybe[Str]->type_default generated for parameterized type
> ok 13 - ArrayRef->type_default
> ok 14 - ArrayRef[Str]->type_default generated for parameterized type
> ok 15 - ArrayRef[Str, 1, 2]->type_default not generated
> ok 16 - HashRef->type_default
> ok 17 - HashRef[Str]->type_default generated for parameterized type
> ok 18 - Map->type_default
> ok 19 - Map[Str, Int]->type_default generated for parameterized type
> # Subtest: quasi-curry
> ok 1 - quasi-curry worked
> ok 2 - quasi-curried arguments
> ok 3 - regular arguments
> 1..3
> ok 20 - quasi-curry
> 1..20
> ok
> t/20-modules/Type-Utils/auto-registry.t ......................
> ok 1 - Declaration functions add types to registries
> ok 2
> ok 3
> ok 4
> 1..4
> ok
> t/20-modules/Type-Utils/classifier.t .........................
> ok 1 - Value "42" classified as Int
> ok 2 - Value "1.1" classified as Num
> ok 3 - Value "Hello world" classified as Str
> ok 4 - Value "42" classified as Int
> ok 5 - Value "1.1" classified as Num
> ok 6 - Reference \undef classified as Ref
> ok 7 - Reference [] classified as ArrayRef
> ok 8 - Reference {} classified as HashRef
> ok 9 - Undef classified as Any
> ok 10 - Reference bless( {"_overload_coderef" => sub { "DUMMY" },"_overrides_a...) classified as InstanceOf["Type::Tiny"]
> 1..10
> ok
> t/20-modules/Type-Utils/dwim-both.t ..........................
> ok 1 - Value "2" fails type constraint FortyFive
> ok 2 - Value "5" passes type constraint FortyFive
> ok 3 - Value "40" passes type constraint FortyFive
> ok 4 - Value "45" fails type constraint FortyFive
> ok 5 - Value "99" fails type constraint FortyFive
> ok 6 - Value "2" fails type constraint FortyFive
> ok 7 - Value "5" fails type constraint FortyFive
> ok 8 - Value "40" fails type constraint FortyFive
> ok 9 - Value "45" passes type constraint FortyFive
> ok 10 - Value "99" fails type constraint FortyFive
> 1..10
> ok
> t/20-modules/Type-Utils/dwim-moose.t .........................
> ok 1 - '$two' isa 'Type::Tiny'
> ok 2 - '$twos' isa 'Type::Tiny'
> ok 3 - Value "2" passes type constraint Two
> ok 4 - Value "3" fails type constraint Two
> ok 5 - Reference [2,2,2] passes type constraint ArrayRef[Two]
> ok 6 - Reference [2,3,2] fails type constraint ArrayRef[Two]
> ok 7 - '$three' isa 'Type::Tiny'
> ok 8 - '$threes' isa 'Type::Tiny'
> ok 9 - Value "3" passes type constraint MyTypes::Three
> ok 10 - Value "4" fails type constraint MyTypes::Three
> ok 11 - Reference [3,3,3] passes type constraint ArrayRef[MyTypes::Three]
> ok 12 - Reference [3,4,3] fails type constraint ArrayRef[MyTypes::Three]
> ok 13 - Reference bless( {}, 'Local::Some::Class' ) passes type constraint InstanceOf["Local::Some::Class"]
> ok 14 - Reference bless( {}, 'main' ) fails type constraint InstanceOf["Local::Some::Class"]
> ok 15 - Reference [bless( {}, 'Local::Some::Class' )] passes type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> ok 16 - Reference [] passes type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> ok 17 - Reference [bless( {}, 'main' )] fails type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> ok 18
> ok 19 - Reference bless( {}, 'Local::Some::Class' ) passes type constraint InstanceOf["Local::Some::Class"]
> ok 20 - Reference bless( {}, 'main' ) fails type constraint InstanceOf["Local::Some::Class"]
> ok 21 - Reference [bless( {}, 'Local::Some::Class' )] passes type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> ok 22 - Reference [] passes type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> ok 23 - Reference [bless( {}, 'main' )] fails type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> 1..23
> ok
> t/20-modules/Type-Utils/dwim-mouse.t .........................
> ok 1 - '$two' isa 'Type::Tiny'
> ok 2 - '$twos' isa 'Type::Tiny'
> ok 3 - Value "2" passes type constraint Two
> ok 4 - Value "3" fails type constraint Two
> ok 5 - Reference [2,2,2] passes type constraint ArrayRef[Two]
> ok 6 - Reference [2,3,2] fails type constraint ArrayRef[Two]
> ok 7 - '$three' isa 'Type::Tiny'
> ok 8 - '$threes' isa 'Type::Tiny'
> ok 9 - Value "3" passes type constraint MyTypes::Three
> ok 10 - Value "4" fails type constraint MyTypes::Three
> ok 11 - Reference [3,3,3] passes type constraint ArrayRef[MyTypes::Three]
> ok 12 - Reference [3,4,3] fails type constraint ArrayRef[MyTypes::Three]
> ok 13 - Reference bless( {}, 'Local::Some::Class' ) passes type constraint InstanceOf["Local::Some::Class"]
> ok 14 - Reference bless( {}, 'main' ) fails type constraint InstanceOf["Local::Some::Class"]
> ok 15 - Reference [bless( {}, 'Local::Some::Class' )] passes type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> ok 16 - Reference [] passes type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> ok 17 - Reference [bless( {}, 'main' )] fails type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> ok 18
> ok 19 - Reference bless( {}, 'Local::Some::Class' ) passes type constraint InstanceOf["Local::Some::Class"]
> ok 20 - Reference bless( {}, 'main' ) fails type constraint InstanceOf["Local::Some::Class"]
> ok 21 - Reference [bless( {}, 'Local::Some::Class' )] passes type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> ok 22 - Reference [] passes type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> ok 23 - Reference [bless( {}, 'main' )] fails type constraint ArrayRef[InstanceOf["Local::Some::Class"]]
> 1..23
> ok
> t/20-modules/Type-Utils/is.t .................................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6 - warning from is(undef, $value)
> ok 7
> ok 8 - warning from is([], $value)
> ok 9
> ok 10
> ok 11
> ok 12 - no (unexpected) warnings (via done_testing)
> 1..12
> ok
> t/20-modules/Type-Utils/match-on-type.t ......................
> ok 1 - to_json using compile_match_on_type works
> ok 2 - to_json_2 using match_on_type works
> ok 3 - fallthrough works for compile_match_on_type
> ok 4 - fallthrough works for match_on_type
> ok 5 - compile_match_on_type returns a coderef
> ok 6 - ... correct result
> ok 7 - ... correct result
> ok 8 - ... correct exception
> ok 9 - match_on_type with no match
> ok 10 - coderef compiled by compile_match_on_type with no match
> ok 11 - match_on_type void context
> ok 12 - match_on_type scalar context
> ok 13 - match_on_type list context
> ok 14 - match_on_type void context (string of code)
> ok 15 - match_on_type scalar context (string of code)
> ok 16 - match_on_type list context (string of code)
> ok 17 - compile_match_on_type void context
> ok 18 - compile_match_on_type scalar context
> ok 19 - compile_match_on_type list context
> 1..19
> ok
> t/20-modules/Type-Utils/warnings.t ...........................
> ok 1 - warning for missing comma
> 1..1
> ok
> t/20-modules/Types-Common-Numeric/basic.t ....................
> ok 1 - SingleDigit 100
> ok 2 - SingleDigit 10
> ok 3 - SingleDigit 9
> ok 4 - SingleDigit 1
> ok 5 - SingleDigit 0
> ok 6 - SingleDigit -1
> ok 7 - SingleDigit -9
> ok 8 - SingleDigit -10
> ok 9 - PositiveInt (-100)
> ok 10 - PositiveInt (0)
> ok 11 - PositiveInt (100.885)
> ok 12 - PositiveInt (100)
> ok 13 - PositiveNum (0)
> ok 14 - PositiveNum (100.885)
> ok 15 - PositiveNum (-100.885)
> ok 16 - PositiveNum (0.0000000001)
> ok 17 - PositiveOrZeroInt (-100)
> ok 18 - PositiveOrZeroInt (0)
> ok 19 - PositiveOrZeroInt (100.885)
> ok 20 - PositiveOrZeroInt (100)
> ok 21 - PositiveOrZeroNum (0)
> ok 22 - PositiveOrZeroNum (100.885)
> ok 23 - PositiveOrZeroNum (-100.885)
> ok 24 - PositiveOrZeroNum (0.0000000001)
> ok 25 - NegativeInt (100)
> ok 26 - NegativeInt (-100.885)
> ok 27 - NegativeInt (-100)
> ok 28 - NegativeInt (0)
> ok 29 - NegativeNum (-100.885)
> ok 30 - NegativeNum (100.885)
> ok 31 - NegativeNum (0)
> ok 32 - NegativeNum (-0.0000000001)
> ok 33 - NegativeOrZeroInt (100)
> ok 34 - NegativeOrZeroInt (-100.885)
> ok 35 - NegativeOrZeroInt (-100)
> ok 36 - NegativeOrZeroInt (0)
> ok 37 - NegativeOrZeroNum (-100.885)
> ok 38 - NegativeOrZeroNum (100.885)
> ok 39 - NegativeOrZeroNum (0)
> ok 40 - NegativeOrZeroNum (-0.0000000001)
> 1..40
> ok
> t/20-modules/Types-Common-Numeric/immutable.t ................
> ok 1
> 1..1
> ok
> t/20-modules/Types-Common-Numeric/ranges.t ...................
> ok 1 - Value "-19" fails type constraint IntRange[10,15]
> ok 2 - Value "-18" fails type constraint IntRange[10,15]
> ok 3 - Value "-17" fails type constraint IntRange[10,15]
> ok 4 - Value "-16" fails type constraint IntRange[10,15]
> ok 5 - Value "-15" fails type constraint IntRange[10,15]
> ok 6 - Value "-14" fails type constraint IntRange[10,15]
> ok 7 - Value "-13" fails type constraint IntRange[10,15]
> ok 8 - Value "-12" fails type constraint IntRange[10,15]
> ok 9 - Value "-11" fails type constraint IntRange[10,15]
> ok 10 - Value "-10" fails type constraint IntRange[10,15]
> ok 11 - Value "-9" fails type constraint IntRange[10,15]
> ok 12 - Value "-8" fails type constraint IntRange[10,15]
> ok 13 - Value "-7" fails type constraint IntRange[10,15]
> ok 14 - Value "-6" fails type constraint IntRange[10,15]
> ok 15 - Value "-5" fails type constraint IntRange[10,15]
> ok 16 - Value "-4" fails type constraint IntRange[10,15]
> ok 17 - Value "-3" fails type constraint IntRange[10,15]
> ok 18 - Value "-2" fails type constraint IntRange[10,15]
> ok 19 - Value "-1" fails type constraint IntRange[10,15]
> ok 20 - Value "0" fails type constraint IntRange[10,15]
> ok 21 - Value "1" fails type constraint IntRange[10,15]
> ok 22 - Value "2" fails type constraint IntRange[10,15]
> ok 23 - Value "3" fails type constraint IntRange[10,15]
> ok 24 - Value "4" fails type constraint IntRange[10,15]
> ok 25 - Value "5" fails type constraint IntRange[10,15]
> ok 26 - Value "6" fails type constraint IntRange[10,15]
> ok 27 - Value "7" fails type constraint IntRange[10,15]
> ok 28 - Value "8" fails type constraint IntRange[10,15]
> ok 29 - Value "9" fails type constraint IntRange[10,15]
> ok 30 - Value "10" passes type constraint IntRange[10,15]
> ok 31 - Value "11" passes type constraint IntRange[10,15]
> ok 32 - Value "12" passes type constraint IntRange[10,15]
> ok 33 - Value "13" passes type constraint IntRange[10,15]
> ok 34 - Value "14" passes type constraint IntRange[10,15]
> ok 35 - Value "15" passes type constraint IntRange[10,15]
> ok 36 - Value "16" fails type constraint IntRange[10,15]
> ok 37 - Value "17" fails type constraint IntRange[10,15]
> ok 38 - Value "18" fails type constraint IntRange[10,15]
> ok 39 - Value "19" fails type constraint IntRange[10,15]
> ok 40 - Value "20" fails type constraint IntRange[10,15]
> ok 41 - Value "-8.5" fails type constraint IntRange[10,15]
> ok 42 - Value "-7.5" fails type constraint IntRange[10,15]
> ok 43 - Value "-6.5" fails type constraint IntRange[10,15]
> ok 44 - Value "-5.5" fails type constraint IntRange[10,15]
> ok 45 - Value "-4.5" fails type constraint IntRange[10,15]
> ok 46 - Value "-3.5" fails type constraint IntRange[10,15]
> ok 47 - Value "-2.5" fails type constraint IntRange[10,15]
> ok 48 - Value "-1.5" fails type constraint IntRange[10,15]
> ok 49 - Value "-0.5" fails type constraint IntRange[10,15]
> ok 50 - Value "0.5" fails type constraint IntRange[10,15]
> ok 51 - Value "1.5" fails type constraint IntRange[10,15]
> ok 52 - Value "2.5" fails type constraint IntRange[10,15]
> ok 53 - Value "3.5" fails type constraint IntRange[10,15]
> ok 54 - Value "4.5" fails type constraint IntRange[10,15]
> ok 55 - Value "5.5" fails type constraint IntRange[10,15]
> ok 56 - Value "6.5" fails type constraint IntRange[10,15]
> ok 57 - Value "7.5" fails type constraint IntRange[10,15]
> ok 58 - Value "8.5" fails type constraint IntRange[10,15]
> ok 59 - Value "9.5" fails type constraint IntRange[10,15]
> ok 60 - Value "10.5" fails type constraint IntRange[10,15]
> ok 61 - Value "11.5" fails type constraint IntRange[10,15]
> ok 62 - Value "12.5" fails type constraint IntRange[10,15]
> ok 63 - Value "13.5" fails type constraint IntRange[10,15]
> ok 64 - Value "14.5" fails type constraint IntRange[10,15]
> ok 65 - Value "15.5" fails type constraint IntRange[10,15]
> ok 66 - Value "16.5" fails type constraint IntRange[10,15]
> ok 67 - Value "17.5" fails type constraint IntRange[10,15]
> ok 68 - Value "18.5" fails type constraint IntRange[10,15]
> ok 69 - Value "19.5" fails type constraint IntRange[10,15]
> ok 70 - Value "20.5" fails type constraint IntRange[10,15]
> ok 71 - Reference [] fails type constraint IntRange[10,15]
> ok 72 - Reference {} fails type constraint IntRange[10,15]
> ok 73 - Reference sub { "DUMMY" } fails type constraint IntRange[10,15]
> ok 74 - Value "hello world" fails type constraint IntRange[10,15]
> ok 75 - Value "-19" fails type constraint IntRange[10]
> ok 76 - Value "-18" fails type constraint IntRange[10]
> ok 77 - Value "-17" fails type constraint IntRange[10]
> ok 78 - Value "-16" fails type constraint IntRange[10]
> ok 79 - Value "-15" fails type constraint IntRange[10]
> ok 80 - Value "-14" fails type constraint IntRange[10]
> ok 81 - Value "-13" fails type constraint IntRange[10]
> ok 82 - Value "-12" fails type constraint IntRange[10]
> ok 83 - Value "-11" fails type constraint IntRange[10]
> ok 84 - Value "-10" fails type constraint IntRange[10]
> ok 85 - Value "-9" fails type constraint IntRange[10]
> ok 86 - Value "-8" fails type constraint IntRange[10]
> ok 87 - Value "-7" fails type constraint IntRange[10]
> ok 88 - Value "-6" fails type constraint IntRange[10]
> ok 89 - Value "-5" fails type constraint IntRange[10]
> ok 90 - Value "-4" fails type constraint IntRange[10]
> ok 91 - Value "-3" fails type constraint IntRange[10]
> ok 92 - Value "-2" fails type constraint IntRange[10]
> ok 93 - Value "-1" fails type constraint IntRange[10]
> ok 94 - Value "0" fails type constraint IntRange[10]
> ok 95 - Value "1" fails type constraint IntRange[10]
> ok 96 - Value "2" fails type constraint IntRange[10]
> ok 97 - Value "3" fails type constraint IntRange[10]
> ok 98 - Value "4" fails type constraint IntRange[10]
> ok 99 - Value "5" fails type constraint IntRange[10]
> ok 100 - Value "6" fails type constraint IntRange[10]
> ok 101 - Value "7" fails type constraint IntRange[10]
> ok 102 - Value "8" fails type constraint IntRange[10]
> ok 103 - Value "9" fails type constraint IntRange[10]
> ok 104 - Value "10" passes type constraint IntRange[10]
> ok 105 - Value "11" passes type constraint IntRange[10]
> ok 106 - Value "12" passes type constraint IntRange[10]
> ok 107 - Value "13" passes type constraint IntRange[10]
> ok 108 - Value "14" passes type constraint IntRange[10]
> ok 109 - Value "15" passes type constraint IntRange[10]
> ok 110 - Value "16" passes type constraint IntRange[10]
> ok 111 - Value "17" passes type constraint IntRange[10]
> ok 112 - Value "18" passes type constraint IntRange[10]
> ok 113 - Value "19" passes type constraint IntRange[10]
> ok 114 - Value "20" passes type constraint IntRange[10]
> ok 115 - Value "21" passes type constraint IntRange[10]
> ok 116 - Value "22" passes type constraint IntRange[10]
> ok 117 - Value "23" passes type constraint IntRange[10]
> ok 118 - Value "24" passes type constraint IntRange[10]
> ok 119 - Value "1000" passes type constraint IntRange[10]
> ok 120 - Value "1000000" passes type constraint IntRange[10]
> ok 121 - Value "-19" fails type constraint NumRange[10,15]
> ok 122 - Value "-18" fails type constraint NumRange[10,15]
> ok 123 - Value "-17" fails type constraint NumRange[10,15]
> ok 124 - Value "-16" fails type constraint NumRange[10,15]
> ok 125 - Value "-15" fails type constraint NumRange[10,15]
> ok 126 - Value "-14" fails type constraint NumRange[10,15]
> ok 127 - Value "-13" fails type constraint NumRange[10,15]
> ok 128 - Value "-12" fails type constraint NumRange[10,15]
> ok 129 - Value "-11" fails type constraint NumRange[10,15]
> ok 130 - Value "-10" fails type constraint NumRange[10,15]
> ok 131 - Value "-9" fails type constraint NumRange[10,15]
> ok 132 - Value "-8" fails type constraint NumRange[10,15]
> ok 133 - Value "-7" fails type constraint NumRange[10,15]
> ok 134 - Value "-6" fails type constraint NumRange[10,15]
> ok 135 - Value "-5" fails type constraint NumRange[10,15]
> ok 136 - Value "-4" fails type constraint NumRange[10,15]
> ok 137 - Value "-3" fails type constraint NumRange[10,15]
> ok 138 - Value "-2" fails type constraint NumRange[10,15]
> ok 139 - Value "-1" fails type constraint NumRange[10,15]
> ok 140 - Value "0" fails type constraint NumRange[10,15]
> ok 141 - Value "1" fails type constraint NumRange[10,15]
> ok 142 - Value "2" fails type constraint NumRange[10,15]
> ok 143 - Value "3" fails type constraint NumRange[10,15]
> ok 144 - Value "4" fails type constraint NumRange[10,15]
> ok 145 - Value "5" fails type constraint NumRange[10,15]
> ok 146 - Value "6" fails type constraint NumRange[10,15]
> ok 147 - Value "7" fails type constraint NumRange[10,15]
> ok 148 - Value "8" fails type constraint NumRange[10,15]
> ok 149 - Value "9" fails type constraint NumRange[10,15]
> ok 150 - Value "10" passes type constraint NumRange[10,15]
> ok 151 - Value "11" passes type constraint NumRange[10,15]
> ok 152 - Value "12" passes type constraint NumRange[10,15]
> ok 153 - Value "13" passes type constraint NumRange[10,15]
> ok 154 - Value "14" passes type constraint NumRange[10,15]
> ok 155 - Value "15" passes type constraint NumRange[10,15]
> ok 156 - Value "16" fails type constraint NumRange[10,15]
> ok 157 - Value "17" fails type constraint NumRange[10,15]
> ok 158 - Value "18" fails type constraint NumRange[10,15]
> ok 159 - Value "19" fails type constraint NumRange[10,15]
> ok 160 - Value "20" fails type constraint NumRange[10,15]
> ok 161 - Value "-8.5" fails type constraint NumRange[10,15]
> ok 162 - Value "-7.5" fails type constraint NumRange[10,15]
> ok 163 - Value "-6.5" fails type constraint NumRange[10,15]
> ok 164 - Value "-5.5" fails type constraint NumRange[10,15]
> ok 165 - Value "-4.5" fails type constraint NumRange[10,15]
> ok 166 - Value "-3.5" fails type constraint NumRange[10,15]
> ok 167 - Value "-2.5" fails type constraint NumRange[10,15]
> ok 168 - Value "-1.5" fails type constraint NumRange[10,15]
> ok 169 - Value "-0.5" fails type constraint NumRange[10,15]
> ok 170 - Value "0.5" fails type constraint NumRange[10,15]
> ok 171 - Value "1.5" fails type constraint NumRange[10,15]
> ok 172 - Value "2.5" fails type constraint NumRange[10,15]
> ok 173 - Value "3.5" fails type constraint NumRange[10,15]
> ok 174 - Value "4.5" fails type constraint NumRange[10,15]
> ok 175 - Value "5.5" fails type constraint NumRange[10,15]
> ok 176 - Value "6.5" fails type constraint NumRange[10,15]
> ok 177 - Value "7.5" fails type constraint NumRange[10,15]
> ok 178 - Value "8.5" fails type constraint NumRange[10,15]
> ok 179 - Value "9.5" fails type constraint NumRange[10,15]
> ok 180 - Value "10.5" passes type constraint NumRange[10,15]
> ok 181 - Value "11.5" passes type constraint NumRange[10,15]
> ok 182 - Value "12.5" passes type constraint NumRange[10,15]
> ok 183 - Value "13.5" passes type constraint NumRange[10,15]
> ok 184 - Value "14.5" passes type constraint NumRange[10,15]
> ok 185 - Value "15.5" fails type constraint NumRange[10,15]
> ok 186 - Value "16.5" fails type constraint NumRange[10,15]
> ok 187 - Value "17.5" fails type constraint NumRange[10,15]
> ok 188 - Value "18.5" fails type constraint NumRange[10,15]
> ok 189 - Value "19.5" fails type constraint NumRange[10,15]
> ok 190 - Value "20.5" fails type constraint NumRange[10,15]
> ok 191 - Reference [] fails type constraint NumRange[10,15]
> ok 192 - Reference {} fails type constraint NumRange[10,15]
> ok 193 - Reference sub { "DUMMY" } fails type constraint NumRange[10,15]
> ok 194 - Value "hello world" fails type constraint NumRange[10,15]
> ok 195 - Value "-19" fails type constraint NumRange[10]
> ok 196 - Value "-18" fails type constraint NumRange[10]
> ok 197 - Value "-17" fails type constraint NumRange[10]
> ok 198 - Value "-16" fails type constraint NumRange[10]
> ok 199 - Value "-15" fails type constraint NumRange[10]
> ok 200 - Value "-14" fails type constraint NumRange[10]
> ok 201 - Value "-13" fails type constraint NumRange[10]
> ok 202 - Value "-12" fails type constraint NumRange[10]
> ok 203 - Value "-11" fails type constraint NumRange[10]
> ok 204 - Value "-10" fails type constraint NumRange[10]
> ok 205 - Value "-9" fails type constraint NumRange[10]
> ok 206 - Value "-8" fails type constraint NumRange[10]
> ok 207 - Value "-7" fails type constraint NumRange[10]
> ok 208 - Value "-6" fails type constraint NumRange[10]
> ok 209 - Value "-5" fails type constraint NumRange[10]
> ok 210 - Value "-4" fails type constraint NumRange[10]
> ok 211 - Value "-3" fails type constraint NumRange[10]
> ok 212 - Value "-2" fails type constraint NumRange[10]
> ok 213 - Value "-1" fails type constraint NumRange[10]
> ok 214 - Value "0" fails type constraint NumRange[10]
> ok 215 - Value "1" fails type constraint NumRange[10]
> ok 216 - Value "2" fails type constraint NumRange[10]
> ok 217 - Value "3" fails type constraint NumRange[10]
> ok 218 - Value "4" fails type constraint NumRange[10]
> ok 219 - Value "5" fails type constraint NumRange[10]
> ok 220 - Value "6" fails type constraint NumRange[10]
> ok 221 - Value "7" fails type constraint NumRange[10]
> ok 222 - Value "8" fails type constraint NumRange[10]
> ok 223 - Value "9" fails type constraint NumRange[10]
> ok 224 - Value "10" passes type constraint NumRange[10]
> ok 225 - Value "11" passes type constraint NumRange[10]
> ok 226 - Value "12" passes type constraint NumRange[10]
> ok 227 - Value "13" passes type constraint NumRange[10]
> ok 228 - Value "14" passes type constraint NumRange[10]
> ok 229 - Value "15" passes type constraint NumRange[10]
> ok 230 - Value "16" passes type constraint NumRange[10]
> ok 231 - Value "17" passes type constraint NumRange[10]
> ok 232 - Value "18" passes type constraint NumRange[10]
> ok 233 - Value "19" passes type constraint NumRange[10]
> ok 234 - Value "20" passes type constraint NumRange[10]
> ok 235 - Value "21" passes type constraint NumRange[10]
> ok 236 - Value "22" passes type constraint NumRange[10]
> ok 237 - Value "23" passes type constraint NumRange[10]
> ok 238 - Value "24" passes type constraint NumRange[10]
> ok 239 - Value "1000" passes type constraint NumRange[10]
> ok 240 - Value "1000000" passes type constraint NumRange[10]
> ok 241 - Value "9.99" fails type constraint NumRange[10,15,0,0]
> ok 242 - Value "10.00" passes type constraint NumRange[10,15,0,0]
> ok 243 - Value "10.01" passes type constraint NumRange[10,15,0,0]
> ok 244 - Value "12.50" passes type constraint NumRange[10,15,0,0]
> ok 245 - Value "14.99" passes type constraint NumRange[10,15,0,0]
> ok 246 - Value "15.00" passes type constraint NumRange[10,15,0,0]
> ok 247 - Value "15.01" fails type constraint NumRange[10,15,0,0]
> ok 248 - Value "9.99" fails type constraint NumRange[10,15,1,0]
> ok 249 - Value "10.00" fails type constraint NumRange[10,15,1,0]
> ok 250 - Value "10.01" passes type constraint NumRange[10,15,1,0]
> ok 251 - Value "12.50" passes type constraint NumRange[10,15,1,0]
> ok 252 - Value "14.99" passes type constraint NumRange[10,15,1,0]
> ok 253 - Value "15.00" passes type constraint NumRange[10,15,1,0]
> ok 254 - Value "15.01" fails type constraint NumRange[10,15,1,0]
> ok 255 - Value "9.99" fails type constraint NumRange[10,15,0,1]
> ok 256 - Value "10.00" passes type constraint NumRange[10,15,0,1]
> ok 257 - Value "10.01" passes type constraint NumRange[10,15,0,1]
> ok 258 - Value "12.50" passes type constraint NumRange[10,15,0,1]
> ok 259 - Value "14.99" passes type constraint NumRange[10,15,0,1]
> ok 260 - Value "15.00" fails type constraint NumRange[10,15,0,1]
> ok 261 - Value "15.01" fails type constraint NumRange[10,15,0,1]
> ok 262 - Value "9.99" fails type constraint NumRange[10,15,1,1]
> ok 263 - Value "10.00" fails type constraint NumRange[10,15,1,1]
> ok 264 - Value "10.01" passes type constraint NumRange[10,15,1,1]
> ok 265 - Value "12.50" passes type constraint NumRange[10,15,1,1]
> ok 266 - Value "14.99" passes type constraint NumRange[10,15,1,1]
> ok 267 - Value "15.00" fails type constraint NumRange[10,15,1,1]
> ok 268 - Value "15.01" fails type constraint NumRange[10,15,1,1]
> ok 269 - Value "1" passes type constraint IntRange
> ok 270 - Reference [] fails type constraint IntRange
> ok 271 - Reference {} fails type constraint IntRange
> ok 272 - Reference sub { "DUMMY" } fails type constraint IntRange
> ok 273 - Value "hello world" fails type constraint IntRange
> ok 274 - Value "1.2345" fails type constraint IntRange
> ok 275 - Value "1" passes type constraint NumRange
> ok 276 - Reference [] fails type constraint NumRange
> ok 277 - Reference {} fails type constraint NumRange
> ok 278 - Reference sub { "DUMMY" } fails type constraint NumRange
> ok 279 - Value "hello world" fails type constraint NumRange
> ok 280 - Value "1.2345" passes type constraint NumRange
> ok 281 - Exception thrown for NumRange non-numeric min
> ok 282 - Exception thrown for NumRange non-numeric max
> ok 283 - Exception thrown for NumRange non-boolean minexcl
> ok 284 - Exception thrown for NumRange non-boolean maxexcl
> ok 285 - Exception thrown for NumRange non-numeric min and max
> ok 286 - Exception thrown for IntRange non-numeric min
> ok 287 - Exception thrown for IntRange non-numeric max
> ok 288 - Exception thrown for IntRange non-boolean minexcl
> ok 289 - Exception thrown for IntRange non-boolean maxexcl
> ok 290 - Exception thrown for IntRange non-numeric min and max
> ok 291 - Exception thrown for IntRange non-integer min
> ok 292 - Exception thrown for IntRange non-integer max
> 1..292
> ok
> t/20-modules/Types-Common-String/basic.t .....................
> ok 1 - SimpleStr
> ok 2 - SimpleStr 2
> ok 3 - SimpleStr 3
> ok 4 - SimpleStr 4
> ok 5 - NonEmptyStr
> ok 6 - NonEmptyStr 2
> ok 7 - NonEmptyStr 3
> ok 8 - NonEmptyStr 4
> ok 9 - NonEmptySimplrStr
> ok 10 - NonEmptyStr 2
> ok 11 - Password
> ok 12 - Password 2
> ok 13 - StrongPassword
> ok 14 - StrongPassword 2
> ok 15 - LowerCaseSimpleStr
> ok 16 - LowerCaseSimpleStr 2
> ok 17 - LowerCaseSimpleStr 3
> ok 18 - LowerCaseSimpleStr 4
> ok 19 - UpperCaseSimpleStr
> ok 20 - UpperCaseSimpleStr 2
> ok 21 - UpperCaseSimpleStr 3
> ok 22 - UpperCaseSimpleStr 4
> ok 23 - LowerCaseStr
> ok 24 - LowerCaseStr 2
> ok 25 - LowerCaseStr 3
> ok 26 - LowerCaseStr 4
> ok 27 - UpperCaseStr
> ok 28 - UpperCaseStr 2
> ok 29 - UpperCaseStr 3
> ok 30 - UpperCaseStr 4
> ok 31 - NumericCode lives
> ok 32 - NumericCode dies
> ok 33 - mixed NumericCode dies
> 1..33
> ok
> t/20-modules/Types-Common-String/coerce.t ....................
> ok 1 - uppercase str
> ok 2 - lowercase str
> ok 3 - uppercase str
> ok 4 - lowercase str
> ok 5 - numeric code
> ok 6 - numeric code
> 1..6
> ok
> t/20-modules/Types-Common-String/immutable.t .................
> ok 1
> 1..1
> ok
> t/20-modules/Types-Common-String/strlength.t .................
> ok 1 - Reference [] fails type constraint StrLength[5,10]
> ok 2 - Reference {} fails type constraint StrLength[5,10]
> ok 3 - Reference sub { "DUMMY" } fails type constraint StrLength[5,10]
> ok 4 - Undef fails type constraint StrLength[5,10]
> ok 5 - Value "" fails type constraint StrLength[5,10]
> ok 6 - Value "123" fails type constraint StrLength[5,10]
> ok 7 - Value "Hiya" fails type constraint StrLength[5,10]
> ok 8 - Value "Hello World" fails type constraint StrLength[5,10]
> ok 9 - Value "Hello" passes type constraint StrLength[5,10]
> ok 10 - Value "Hello!" passes type constraint StrLength[5,10]
> ok 11 - Value " " passes type constraint StrLength[5,10]
> ok 12 - Value "HelloWorld" passes type constraint StrLength[5,10]
> ok 13 - Value "caf\x{e9}" passes type constraint StrLength[4,4]
> ok 14 - Value "\x{2122}\x{137}\x{2079}\x{2014}" passes type constraint StrLength[4,4]
> ok 15 - Reference [] fails type constraint StrLength[4]
> ok 16 - Reference {} fails type constraint StrLength[4]
> ok 17 - Reference sub { "DUMMY" } fails type constraint StrLength[4]
> ok 18 - Undef fails type constraint StrLength[4]
> ok 19 - Value "" fails type constraint StrLength[4]
> ok 20 - Value "123" fails type constraint StrLength[4]
> ok 21 - Value "Hello" passes type constraint StrLength[4]
> ok 22 - Value "Hello!" passes type constraint StrLength[4]
> ok 23 - Value " " passes type constraint StrLength[4]
> ok 24 - Value "HelloWorld" passes type constraint StrLength[4]
> ok 25 - Value "Hiya" passes type constraint StrLength[4]
> ok 26 - Value "Hello World" passes type constraint StrLength[4]
> 1..26
> ok
> t/20-modules/Types-Common-String/unicode.t ...................
> ok 1 - CAF? is uppercase
> ok 2 - CAF? is not (entirely) uppercase
> ok 3 - ----- not entirely uppercase
> ok 4 - ----- not entirely lowercase
> ok 5 - caf? is lowercase
> ok 6 - caf? is not (entirely) lowercase
> ok 7 - CAF? is uppercase
> ok 8 - CAF? is not (entirely) uppercase
> ok 9 - caf? is lowercase
> ok 10 - caf? is not (entirely) lowercase
> 1..10
> ok
> t/20-modules/Types-Common/basic.t ............................
> ok 1 - correct imports
> ok 2 - t() is preloaded
> 1..2
> ok
> t/20-modules/Types-Common/immutable.t ........................
> ok 1
> 1..1
> ok
> t/20-modules/Types-Standard/arrayreflength.t .................
> ok 1 - Reference [] fails type constraint ArrayRef[Int,2]
> ok 2 - Reference [0] fails type constraint ArrayRef[Int,2]
> ok 3 - Reference [0,1] passes type constraint ArrayRef[Int,2]
> ok 4 - Reference [0,1,2] passes type constraint ArrayRef[Int,2]
> ok 5 - Reference [0,1,2,3] passes type constraint ArrayRef[Int,2]
> ok 6 - Reference [0,1,2,3,4] passes type constraint ArrayRef[Int,2]
> ok 7 - Reference [0,1,2,3,4,5] passes type constraint ArrayRef[Int,2]
> ok 8 - Reference [0,1,2,3,4,5,6] passes type constraint ArrayRef[Int,2]
> ok 9 - Reference [0,1,"nope"] fails type constraint ArrayRef[Int,2]
> ok 10 - Reference ["nope",0,1] fails type constraint ArrayRef[Int,2]
> ok 11 - Reference [] fails type constraint ArrayRef[Int,2,4]
> ok 12 - Reference [0] fails type constraint ArrayRef[Int,2,4]
> ok 13 - Reference [0,1] passes type constraint ArrayRef[Int,2,4]
> ok 14 - Reference [0,1,2] passes type constraint ArrayRef[Int,2,4]
> ok 15 - Reference [0,1,2,3] passes type constraint ArrayRef[Int,2,4]
> ok 16 - Reference [0,1,2,3,4] fails type constraint ArrayRef[Int,2,4]
> ok 17 - Reference [0,1,2,3,4,5] fails type constraint ArrayRef[Int,2,4]
> ok 18 - Reference [0,1,2,3,4,5,6] fails type constraint ArrayRef[Int,2,4]
> ok 19 - Reference [0,1,"nope"] fails type constraint ArrayRef[Int,2,4]
> ok 20 - Reference ["nope",0,1] fails type constraint ArrayRef[Int,2,4]
> ok 21 - ArrayRef[Any] optimization
> ok 22 - ArrayRef[Any,2] optimization
> ok 23 - ArrayRef[Any,2,4] optimization
> 1..23
> ok
> t/20-modules/Types-Standard/basic.t ..........................
> ok 1 - ->library method
> ok 2 - Reference \123 passes type constraint ScalarRef
> ok 3 - Reference [] passes type constraint ArrayRef
> ok 4 - Reference {} passes type constraint HashRef
> ok 5 - Reference sub { "DUMMY" } passes type constraint CodeRef
> ok 6 - Reference \*::STDOUT passes type constraint GlobRef
> ok 7 - Reference \\"Hello" passes type constraint Ref
> ok 8 - Reference \*::STDOUT passes type constraint FileHandle
> ok 9 - Reference qr/x/ passes type constraint RegexpRef
> ok 10 - Value "1" passes type constraint Str
> ok 11 - Value "1" passes type constraint Num
> ok 12 - Value "1" passes type constraint Int
> ok 13 - Value "1" passes type constraint Defined
> ok 14 - Value "1" passes type constraint Value
> ok 15 - Undef passes type constraint Undef
> ok 16 - Undef passes type constraint Item
> ok 17 - Undef passes type constraint Any
> ok 18 - Value "Type::Tiny" passes type constraint ClassName
> ok 19 - Value "Type::Library" passes type constraint RoleName
> ok 20 - Undef passes type constraint Bool
> ok 21 - Value "" passes type constraint Bool
> ok 22 - Value "0" passes type constraint Bool
> ok 23 - Value "1" passes type constraint Bool
> ok 24 - Value "7" fails type constraint Bool
> ok 25 - Reference \\"Hello" passes type constraint ScalarRef
> ok 26 - Value "Type::Tiny" fails type constraint RoleName
> ok 27 - Reference [] fails type constraint Str
> ok 28 - Reference [] fails type constraint Num
> ok 29 - Reference [] fails type constraint Int
> ok 30 - Value "4x4" passes type constraint Str
> ok 31 - Value "4x4" fails type constraint Num
> ok 32 - Value "4.2" fails type constraint Int
> ok 33 - Undef fails type constraint Str
> ok 34 - Undef fails type constraint Num
> ok 35 - Undef fails type constraint Int
> ok 36 - Undef fails type constraint Defined
> ok 37 - Undef fails type constraint Value
> ok 38 - Undef fails type constraint ClassName
> ok 39 - Reference [] fails type constraint ClassName
> ok 40 - Value "Local::Class2" passes type constraint ClassName
> ok 41 - Value "Local::Class3" passes type constraint ClassName
> ok 42 - Value "Local::Class4" passes type constraint ClassName
> ok 43 - Value "Local::Dummy1" fails type constraint ClassName
> ok 44 - Reference [] passes type constraint ArrayRef[Int]
> ok 45 - Reference [1,2,3] passes type constraint ArrayRef[Int]
> ok 46 - Reference ["1.1",2,3] fails type constraint ArrayRef[Int]
> ok 47 - Reference [1,2,"3.1"] fails type constraint ArrayRef[Int]
> ok 48 - Reference [[]] fails type constraint ArrayRef[Int]
> ok 49 - Reference [[3]] passes type constraint ArrayRef[ArrayRef[Int]]
> ok 50 - Reference [["A"]] fails type constraint ArrayRef[ArrayRef[Int]]
> ok 51 - ArrayRef[HashRef[ArrayRef[HashRef[Int]]]] can be inlined
> ok 52 - Reference [{"foo1" => 'ARRAY(0x55884ee912c0)'},{"foo2" => 'ARRAY(0x558...] passes type constraint ArrayRef[HashRef[ArrayRef[HashRef[Int]]]]
> ok 53 - Reference [{"foo1" => 'ARRAY(0x55884f17bdc8)'},{"foo2" => 'ARRAY(0x558...] passes type constraint ArrayRef[HashRef[ArrayRef[HashRef[Int]]]]
> ok 54 - Reference [{"foo1" => 'ARRAY(0x55884f17b7e0)'},{"foo2" => 'ARRAY(0x558...] fails type constraint ArrayRef[HashRef[ArrayRef[HashRef[Int]]]]
> ok 55 - Undef passes type constraint Maybe[Int]
> ok 56 - Value "123" passes type constraint Maybe[Int]
> ok 57 - Value "1.3" fails type constraint Maybe[Int]
> ok 58 - Reference \"Hello" passes type constraint ScalarRef[Str]
> ok 59 - Reference \"1.1" passes type constraint ScalarRef[Str]
> ok 60 - Reference \1 passes type constraint ScalarRef[Str]
> ok 61 - Reference \"Hello" fails type constraint ScalarRef[Num]
> ok 62 - Reference \"1.1" passes type constraint ScalarRef[Num]
> ok 63 - Reference \1 passes type constraint ScalarRef[Num]
> ok 64 - Reference \"Hello" fails type constraint ScalarRef[Int]
> ok 65 - Reference \"1.1" fails type constraint ScalarRef[Int]
> ok 66 - Reference \1 passes type constraint ScalarRef[Int]
> ok 67 - Reference bless( [], 'Local::Class4' ) passes type constraint Ref[ARRAY]
> ok 68 - Reference bless( {}, 'Local::Class4' ) passes type constraint Ref[HASH]
> ok 69 - Reference [] passes type constraint Ref[ARRAY]
> ok 70 - Reference {} passes type constraint Ref[HASH]
> ok 71 - Reference bless( [], 'Local::Class4' ) fails type constraint Ref[HASH]
> ok 72 - Reference bless( {}, 'Local::Class4' ) fails type constraint Ref[ARRAY]
> ok 73 - Reference [] fails type constraint Ref[HASH]
> ok 74 - Reference {} fails type constraint Ref[ARRAY]
> ok 75 - ArrayRef["Int"] is not a valid type constraint
> ok 76 - HashRef[[]] is not a valid type constraint
> ok 77 - ScalarRef[undef] is not a valid type constraint
> ok 78 - Ref[{}] is not a valid type constraint
> ok 79 - 'Inf' passes Num unless Types::Standard::STRICTNUM
> ok 80 - '-Inf' passes Num unless Types::Standard::STRICTNUM
> ok 81 - 'Nan' passes Num unless Types::Standard::STRICTNUM
> ok 82 - '0.' passes Num unless Types::Standard::STRICTNUM
> ok 83 - Any subtype: Item
> 1..83
> ok
> t/20-modules/Types-Standard/cycletuple.t .....................
> # Subtest: $type1
> ok 1 - Undef fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 2 - Reference {} fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 3 - Reference [] passes type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 4 - Reference [{}] fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 5 - Reference [1] fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 6 - Reference [1,{}] fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 7 - Reference [1,{},[]] passes type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 8 - Reference [1,{},[],undef] fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 9 - Reference [1,{},[],2] fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 10 - Reference [1,{},[],2,{},[1]] passes type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 11 - automagic coercion
> 1..11
> ok 1 - $type1
> # Subtest: $type2
> ok 1 - Undef fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 2 - Reference {} fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 3 - Reference [] passes type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 4 - Reference [{}] fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 5 - Reference [1] fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 6 - Reference [1,{}] fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 7 - Reference [1,{},[]] passes type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 8 - Reference [1,{},[],undef] fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 9 - Reference [1,{},[],2] fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 10 - Reference [1,{},[],2,{},[1]] passes type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 11 - automagic coercion
> 1..11
> ok 2 - $type2
> # Subtest: $type3
> ok 1 - Undef fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 2 - Reference {} fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 3 - Reference [] passes type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 4 - Reference [{}] fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 5 - Reference [1] fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 6 - Reference [1,{}] fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 7 - Reference [1,{},[]] passes type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 8 - Reference [1,{},[],undef] fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 9 - Reference [1,{},[],2] fails type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 10 - Reference [1,{},[],2,{},[1]] passes type constraint CycleTuple[Int,HashRef,ArrayRef]
> ok 11 - automagic coercion
> 1..11
> ok 3 - $type3
> # Subtest: $type4
> ok 1 - Undef fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 2 - Reference {} fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 3 - Reference [] passes type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 4 - Reference [{}] fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 5 - Reference [1] fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 6 - Reference [1,{}] fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 7 - Reference [1,{},[]] passes type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 8 - Reference [1,{},[],undef] fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 9 - Reference [1,{},[],2] fails type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 10 - Reference [1,{},[],2,{},[1]] passes type constraint CycleTuple[__ANON__,HashRef,ArrayRef]
> ok 11 - automagic coercion
> 1..11
> ok 4 - $type4
> ok 5 - cannot make CycleTuples with optional slots
> ok 6 - cannot make CycleTuples with slurpy slots
> 1..6
> ok
> t/20-modules/Types-Standard/deep-coercions.t .................
> ok 1 - Dict of type without coercion shouldn't have coercion
> ok 2 - Dict of type with coercion should have coercion
> ok 3 - Tuple of type without coercion shouldn't have coercion
> ok 4 - Tuple of type with coercion should have coercion
> ok 5 - Map of type without coercion shouldn't have coercion
> ok 6 - Map of type with coercion should have coercion
> ok 7 - $ArrayOfFoo has coercion
> ok 8 - $ArrayOfFoo does not coerce value that needs no coercion
> ok 9 - $ArrayOfFoo does coerce value that can be coerced
> ok 10 - $ArrayOfFoo does not coerce value that cannot be coerced
> ok 11 - $HashOfFoo has coercion
> ok 12 - $HashOfFoo does not coerce value that needs no coercion
> ok 13 - $HashOfFoo does coerce value that can be coerced
> ok 14 - $HashOfFoo does not coerce value that cannot be coerced
> ok 15 - $RefOfFoo has coercion
> ok 16 - $RefOfFoo does not coerce value that needs no coercion
> ok 17 - $RefOfFoo does coerce value that can be coerced
> ok 18 - $RefOfFoo does not coerce value that cannot be coerced
> ok 19 - $MaybeFoo does not coerce undef
> ok 20 - $MaybeFoo does not coerce integer
> ok 21 - $MaybeFoo does coerce non-integer number
> ok 22 - $MaybeFoo cannot coerce non-number
> ok 23 - $ArrayOfBar has coercion
> ok 24 - $ArrayOfBar coercion can be inlined
> ok 25 - $ArrayOfBar does not coerce value that needs no coercion
> ok 26 - $ArrayOfBar does coerce value that can be coerced
> ok 27 - $ArrayOfBar does not coerce value that cannot be coerced
> ok 28 - $HashOfBar has coercion
> ok 29 - $HashOfBar coercion can be inlined
> ok 30 - $HashOfBar does not coerce value that needs no coercion
> ok 31 - $HashOfBar does coerce value that can be coerced
> ok 32 - $HashOfBar does not coerce value that cannot be coerced
> ok 33 - $RefOfBar has coercion
> ok 34 - $RefOfBar coercion can be inlined
> ok 35 - $RefOfBar does not coerce value that needs no coercion
> ok 36 - $RefOfBar does coerce value that can be coerced
> ok 37 - $RefOfBar does not coerce value that cannot be coerced
> ok 38 - $MaybeBar does not coerce undef
> ok 39 - $MaybeBar does not coerce integer
> ok 40 - $MaybeBar does coerce non-integer number
> ok 41 - $MaybeBar cannot coerce non-number
> ok 42 - Map[IntFromNum,IntFromStr] has an inlinable coercion
> ok 43 - Coercions to Map[IntFromNum,IntFromStr]
> ok 44 - Impossible coercion to Map[IntFromNum,IntFromStr]
> ok 45 - Unneeded coercion to Map[IntFromNum,IntFromStr]
> ok 46 - Map[IntFromNum,IntFromArray] has a coercion, but it cannot be inlined
> ok 47 - Coercions to Map[IntFromNum,IntFromArray]
> ok 48 - Impossible coercion to Map[IntFromNum,IntFromArray]
> ok 49 - Unneeded coercion to Map[IntFromNum,IntFromArray]
> ok 50 - Dict[a=>IntFromStr,b=>IntFromNum,c=>Optional[IntFromNum]] has an inlinable coercion
> ok 51 - Coercion (A) to Dict[a=>IntFromStr,b=>IntFromNum,c=>Optional[IntFromNum]]
> ok 52 - Coercion (B) to Dict[a=>IntFromStr,b=>IntFromNum,c=>Optional[IntFromNum]]
> ok 53 - Coercion (C) to Dict[a=>IntFromStr,b=>IntFromNum,c=>Optional[IntFromNum]] - changed in 0.003_11; the presence of an additional value cancels coercion
> ok 54 - Coercion to Dict[a=>Int,Slurpy[Map[Int,Int]]] (inlined)
> ok 55 - Coercion to Dict[a=>Int,Slurpy[Map[Int,Int]]] (non-inlined)
> ok 56 - Dict[a=>IntFromStr,b=>Optional[Int],c=>Optional[Int]] has a non-inlinable coercion
> ok 57 - Coercion (A) to Dict[a=>IntFromStr,b=>Optional[Int],c=>Optional[Int]]
> ok 58 - Coercion (B) to Dict[a=>IntFromStr,b=>Optional[Int],c=>Optional[Int]]
> ok 59 - Tuple[IntFromNum,Optional[IntFromStr],Slurpy[ArrayRef[IntFromNum]]] has an inlinable coercion
> ok 60 - Coercion (A) to Tuple[IntFromNum,Optional[IntFromStr],Slurpy[ArrayRef[IntFromNum]]]
> ok 61 - Coercion (B) to Tuple[IntFromNum,Optional[IntFromStr],Slurpy[ArrayRef[IntFromNum]]]
> ok 62 - Coercion (A) to Tuple[IntFromNum]
> ok 63 - Coercion (B) to Tuple[IntFromNum] - changed in 0.003_11; the presence of an additional value cancels coercion
> ok 64
> ok 65
> ok 66 - No coercion necessary to Tuple[EvenInt]
> ok 67 - Coercion to Tuple[EvenInt]
> ok 68
> ok 69
> ok 70 - No coercion necessary to Tuple[EvenInt2]
> ok 71 - Coercion to Tuple[EvenInt2]
> ok 72 - coercing Tuple with slurpy arrayref
> ok 73 - inlinable coercion of Tuple with no slurpy given input with extra fields fails
> ok 74 - non-inlinable coercion of Tuple with no slurpy given input with extra fields fails
> ok 75 - Dict where key has inlineable coercion but slurpy has no coercion
> ok 76 - ... all or nothing
> ok 77 - Dict where key has non-inlineable coercion but slurpy has no coercion
> ok 78 - ... all or nothing
> 1..78
> ok
> t/20-modules/Types-Standard/filehandle.t .....................
> ok 1 - Reference bless( \*Symbol::GEN0, 'IO::String' ) passes type constraint FileHandle
> ok 2 - Value "IO::String" fails type constraint FileHandle
> 1..2
> ok
> t/20-modules/Types-Standard/immutable.t ......................
> ok 1
> 1..1
> ok
> t/20-modules/Types-Standard/lockdown.t .......................
> ok 1 - Types::Standard core types are frozen
> ok 2 - Types::Common types are frozen
> ok 3 - Parameterized types are frozen
> 1..3
> ok
> t/20-modules/Types-Standard/mxtmlb-alike.t ...................
> ok 1 - InstanceOf == Object
> ok 2 - InstanceOf["Foo"] == Foo
> ok 3 - InstanceOf["Foo","Bar"] == Foo|Bar
> ok 4 - ConsumerOf == Object
> ok 5 - ConsumerOf["Foo"] == Foo
> ok 6 - ConsumerOf["Foo","Bar"] == Foo&Bar
> ok 7 - HasMethods == Object
> ok 8 - HasMethods["foo"] == CanFoo
> ok 9 - HasMethods["foo","bar"] == CanFooBar
> ok 10 - Enum == Str
> ok 11 - Enum["foo"] == Enum[foo]
> ok 12 - Enum["foo","bar"] == Enum[bar,foo]
> 1..12
> ok
> t/20-modules/Types-Standard/optlist.t ........................
> ok 1 - Reference [] passes type constraint OptList
> ok 2 - Reference [["foo",undef]] passes type constraint OptList
> ok 3 - Reference [["foo",'ARRAY(0x5610c1b1db30)']] passes type constraint OptList
> ok 4 - Reference [["foo",'HASH(0x5610c1202518)']] passes type constraint OptList
> ok 5 - Reference [] passes type constraint OptList
> ok 6 - Reference [["foo",undef]] passes type constraint OptList
> ok 7 - Reference [["foo",'ARRAY(0x5610c1226f40)']] passes type constraint OptList
> ok 8 - Reference [["foo",'HASH(0x5610c1202518)']] passes type constraint OptList
> ok 9 - Reference [[undef]] fails type constraint OptList
> ok 10 - Reference [['ARRAY(0x5610c1f3fd70)']] fails type constraint OptList
> ok 11 - Reference [['HASH(0x5610c1226f40)']] fails type constraint OptList
> ok 12 - Reference [[undef]] fails type constraint OptList
> ok 13 - Reference [['ARRAY(0x5610c1afbdc0)']] fails type constraint OptList
> ok 14 - Reference [['HASH(0x5610c1f3fd70)']] fails type constraint OptList
> ok 15 - not OptList has coercion
> ok 16 - OptList has coercion
> ok 17 - $OM->coerce(undef)
> ok 18 - $OM->coerce([])
> ok 19 - simple $OM coercion test
> ok 20 - another simple $OM coercion test
> 1..20
> ok
> t/20-modules/Types-Standard/overload.t .......................
> ok 1 - Reference bless( [], 'Local::Class' ) passes type constraint Any
> ok 2 - Reference bless( [], 'Local::Class' ) passes type constraint Item
> ok 3 - Reference bless( [], 'Local::Class' ) passes type constraint Defined
> ok 4 - Reference bless( [], 'Local::Class' ) passes type constraint Ref
> ok 5 - Reference bless( [], 'Local::Class' ) passes type constraint Ref[ARRAY]
> ok 6 - Reference bless( [], 'Local::Class' ) passes type constraint Object
> ok 7 - Reference bless( [], 'Local::Class' ) passes type constraint Overload
> ok 8 - Reference bless( [], 'Local::Class' ) passes type constraint Overload["&"]
> ok 9 - Reference bless( [], 'Local::Class' ) fails type constraint Ref[HASH]
> ok 10 - Reference bless( [], 'Local::Class' ) fails type constraint Overload["|"]
> ok 11 - Value "Local::Class" fails type constraint Overload
> ok 12 - Reference [] fails type constraint Overload
> ok 13 - Item subtype: Overload["&"]
> ok 14 - Defined subtype: Overload["&"]
> ok 15 - Ref subtype: Overload["&"]
> ok 16 - Object subtype: Overload["&"]
> ok 17 - Overload subtype: Overload["&"]
> 1..17
> ok
> t/20-modules/Types-Standard/strmatch-allow-callbacks.t .......
> ok 1 - using callbacks, this complex regexp can be inlined
> ok 2 - ... and looks okay
> ok 3 - no (unexpected) warnings (via done_testing)
> 1..3
> ok
> t/20-modules/Types-Standard/strmatch-avoid-callbacks.t .......
> ok 1
> ok 2
> ok 3 - no (unexpected) warnings (via done_testing)
> 1..3
> ok
> t/20-modules/Types-Standard/strmatch.t .......................
> ok 1 - error message 1
> ok 2 - error message 2
> ok 3 - Value "mm" passes type constraint Enum[cm,km,m,mm]
> ok 4 - Value "cm" passes type constraint Enum[cm,km,m,mm]
> ok 5 - Value "m" passes type constraint Enum[cm,km,m,mm]
> ok 6 - Value "km" passes type constraint Enum[cm,km,m,mm]
> ok 7 - Value "MM" fails type constraint Enum[cm,km,m,mm]
> ok 8 - Value "mm " fails type constraint Enum[cm,km,m,mm]
> ok 9 - Value " mm" fails type constraint Enum[cm,km,m,mm]
> ok 10 - Value "miles" fails type constraint Enum[cm,km,m,mm]
> ok 11 - Value "5 km" passes type constraint Distance
> ok 12 - Value "5 mm" passes type constraint Distance
> ok 13 - Value "4 miles" fails type constraint Distance
> ok 14 - Value "5.5 km" fails type constraint Distance
> ok 15 - Reference [5,"km"] fails type constraint Distance
> ok 16 - Value "true" passes type constraint Boolean
> ok 17 - Value "True" passes type constraint Boolean
> ok 18 - Value "TRUE" passes type constraint Boolean
> ok 19 - Value "false" passes type constraint Boolean
> ok 20 - Value "False" passes type constraint Boolean
> ok 21 - Value "FALSE" passes type constraint Boolean
> ok 22 - Value "0" passes type constraint Boolean
> ok 23 - Value "1" passes type constraint Boolean
> ok 24 - Value "True " fails type constraint Boolean
> ok 25 - Value "11" fails type constraint Boolean
> ok 26 - Value "https://www.google.com/" passes type constraint SecureUrl
> ok 27 - Value "http://www.google.com/" fails type constraint SecureUrl
> ok 28 - Value "ab" fails type constraint StrMatch[(?^:\A...\z)]
> ok 29 - Value "abc" passes type constraint StrMatch[(?^:\A...\z)]
> ok 30 - Value "abcd" fails type constraint StrMatch[(?^:\A...\z)]
> ok 31 - Value "ab" fails type constraint StrMatch[(?^:\A...)]
> ok 32 - Value "abc" passes type constraint StrMatch[(?^:\A...)]
> ok 33 - Value "abcd" passes type constraint StrMatch[(?^:\A...)]
> ok 34 - StrMatch->of(...)->compiled_check( $val ) always returns a single value, even in list context
> 1..34
> ok
> t/20-modules/Types-Standard/structured.t .....................
> ok 1 - Reference {"1" => 111,"2" => 222} passes type constraint Map[Int,Num]
> ok 2 - Reference {"1" => "1.1","2" => "2.2"} passes type constraint Map[Int,Num]
> ok 3 - Reference {"1" => "Str","2" => 222} fails type constraint Map[Int,Num]
> ok 4 - Reference {"1.1" => 1,"2" => "2.2"} fails type constraint Map[Int,Num]
> ok 5 - Reference [1,"1.1"] passes type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 6 - Reference [1,"1.1",2] passes type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 7 - Reference [1,"1.1",2,"2.2"] passes type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 8 - Reference [1,"1.1",2,"2.2","2.3"] passes type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 9 - Reference [1,"1.1",2,"2.2","2.3","2.4"] passes type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 10 - Reference {} fails type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 11 - Reference [] fails type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 12 - Reference [1] fails type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 13 - Reference ["1.1","1.1"] fails type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 14 - Reference [1,"1.1","2.1"] fails type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 15 - Reference [1,"1.1","2.1"] fails type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 16 - Reference [1,"1.1",2,"2.2","2.3","2.4","xyz"] fails type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 17 - Reference [1,"1.1",undef] fails type constraint Tuple[Int,Num,Optional[Int],Slurpy[ArrayRef[Num]]]
> ok 18 - Reference [1,"1.1"] passes type constraint Tuple[Int,Num,Optional[Int]]
> ok 19 - Reference [1,"1.1",2] passes type constraint Tuple[Int,Num,Optional[Int]]
> ok 20 - Reference [1,"1.1",2,"2.2"] fails type constraint Tuple[Int,Num,Optional[Int]]
> ok 21 - Reference [1,"1.1",2,"2.2","2.3"] fails type constraint Tuple[Int,Num,Optional[Int]]
> ok 22 - Reference [1,"1.1",2,"2.2","2.3","2.4"] fails type constraint Tuple[Int,Num,Optional[Int]]
> ok 23 - Reference {} fails type constraint Tuple[Int,Num,Optional[Int]]
> ok 24 - Reference [] fails type constraint Tuple[Int,Num,Optional[Int]]
> ok 25 - Reference [1] fails type constraint Tuple[Int,Num,Optional[Int]]
> ok 26 - Reference ["1.1","1.1"] fails type constraint Tuple[Int,Num,Optional[Int]]
> ok 27 - Reference [1,"1.1","2.1"] fails type constraint Tuple[Int,Num,Optional[Int]]
> ok 28 - Reference [1,"1.1","2.1"] fails type constraint Tuple[Int,Num,Optional[Int]]
> ok 29 - Reference [1,"1.1",2,"2.2","2.3","2.4","xyz"] fails type constraint Tuple[Int,Num,Optional[Int]]
> ok 30 - Reference [1,"1.1",undef] fails type constraint Tuple[Int,Num,Optional[Int]]
> ok 31 - Reference {"age" => 40,"height" => "1.76","name" => "Bob"} passes type constraint Dict[age=>Int,height=>Optional[Num],name=>Str]
> ok 32 - Reference {"age" => 40,"name" => "Bob"} passes type constraint Dict[age=>Int,height=>Optional[Num],name=>Str]
> ok 33 - Reference {"name" => "Bob"} fails type constraint Dict[age=>Int,height=>Optional[Num],name=>Str]
> ok 34 - Reference {"age" => 40} fails type constraint Dict[age=>Int,height=>Optional[Num],name=>Str]
> ok 35 - Reference {"age" => "40.1","name" => "Bob"} fails type constraint Dict[age=>Int,height=>Optional[Num],name=>Str]
> ok 36 - Reference {"age" => 40,"name" => "Bob","weight" => "80.3"} fails type constraint Dict[age=>Int,height=>Optional[Num],name=>Str]
> ok 37 - Reference {"age" => 40,"height" => "1.76","name" => "Bob","weight" => "80.3"} fails type constraint Dict[age=>Int,height=>Optional[Num],name=>Str]
> ok 38 - Reference {"age" => 40,"height" => "xyz","name" => "Bob"} fails type constraint Dict[age=>Int,height=>Optional[Num],name=>Str]
> ok 39 - Reference {"age" => 40,"height" => undef,"name" => "Bob"} fails type constraint Dict[age=>Int,height=>Optional[Num],name=>Str]
> ok 40 - Reference {"age" => undef,"height" => "1.76","name" => "Bob"} fails type constraint Dict[age=>Int,height=>Optional[Num],name=>Str]
> ok 41 - Optional[Int] check (1)
> ok 42 - Optional[Int] check ('xxx')
> ok 43 - Reference [[],"1.1",1,"2.1",2] passes type constraint Tuple[ArrayRef,Slurpy[Map[Num,Int]]]
> ok 44 - Reference [[]] passes type constraint Tuple[ArrayRef,Slurpy[Map[Num,Int]]]
> ok 45 - Reference [[],"1.1",1,"xxx",2] fails type constraint Tuple[ArrayRef,Slurpy[Map[Num,Int]]]
> ok 46 - Reference [[],"1.1",1,"2.1",undef] fails type constraint Tuple[ArrayRef,Slurpy[Map[Num,Int]]]
> ok 47 - Reference {"b" => undef,"i" => 42} passes type constraint Dict[b=>Bool,i=>Maybe[Int]]
> ok 48 - Reference {"b" => "","i" => 42} passes type constraint Dict[b=>Bool,i=>Maybe[Int]]
> ok 49 - Reference {"b" => 0,"i" => 42} passes type constraint Dict[b=>Bool,i=>Maybe[Int]]
> ok 50 - Reference {"b" => 1,"i" => 42} passes type constraint Dict[b=>Bool,i=>Maybe[Int]]
> ok 51 - Reference {"b" => 1,"i" => undef} passes type constraint Dict[b=>Bool,i=>Maybe[Int]]
> ok 52 - Reference {"b" => 42,"i" => 1} fails type constraint Dict[b=>Bool,i=>Maybe[Int]]
> ok 53 - Reference {"i" => 42} fails type constraint Dict[b=>Bool,i=>Maybe[Int]]
> ok 54 - Reference {"b" => 1} fails type constraint Dict[b=>Bool,i=>Maybe[Int]]
> ok 55 - Reference {"a" => 1,"b" => 1,"i" => 42} fails type constraint Dict[b=>Bool,i=>Maybe[Int]]
> ok 56 - Reference {"a" => 1,"i" => 42} fails type constraint Dict[b=>Bool,i=>Maybe[Int]]
> ok 57 - Reference {"a" => 42,"b" => 1} fails type constraint Dict[b=>Bool,i=>Maybe[Int]]
> ok 58 - Reference [1,1] passes type constraint Tuple[Any,Any]
> ok 59 - Reference [1,undef] passes type constraint Tuple[Any,Any]
> ok 60 - Reference [undef,undef] passes type constraint Tuple[Any,Any]
> ok 61 - Reference [undef,1] passes type constraint Tuple[Any,Any]
> ok 62 - Reference [1] fails type constraint Tuple[Any,Any]
> ok 63 - Reference [undef] fails type constraint Tuple[Any,Any]
> ok 64 - Reference [1,1,1] fails type constraint Tuple[Any,Any]
> ok 65 - Reference [1,1,undef] fails type constraint Tuple[Any,Any]
> # Tuple[] vs Tuple
> ok 66 - Reference [] passes type constraint Tuple[]
> ok 67 - Reference [1] fails type constraint Tuple[]
> ok 68 - Reference [] passes type constraint Tuple
> ok 69 - Reference [1] passes type constraint Tuple
> # Dict[] vs Dict
> ok 70 - Reference {} passes type constraint Dict[]
> ok 71 - Reference {"foo" => 1} fails type constraint Dict[]
> ok 72 - Reference {} passes type constraint Dict
> ok 73 - Reference {"foo" => 1} passes type constraint Dict
> # Dict[ ..., slurpy ... ]
> ok 74 - Reference {"foo" => 42} passes type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 75 - Reference {"bar" => 666,"foo" => 42} passes type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 76 - Reference {"foo" => "4.2"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 77 - Reference {"bar" => "6.66","foo" => 42} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 78 - Reference {"bar" => "6.66","foo" => "4.2"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 79 - Reference {"foo" => undef} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 80 - Reference {} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 81 - Reference {"baz" => 999,"foo" => 42} passes type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 82 - Reference {"bar" => 666,"baz" => 999,"foo" => 42} passes type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 83 - Reference {"baz" => 999,"foo" => "4.2"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 84 - Reference {"bar" => "6.66","baz" => 999,"foo" => 42} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 85 - Reference {"bar" => "6.66","baz" => 999,"foo" => "4.2"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 86 - Reference {"baz" => 999,"foo" => undef} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 87 - Reference {"baz" => 999} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 88 - Reference {"baz" => "9.99","foo" => 42} passes type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 89 - Reference {"bar" => 666,"baz" => "9.99","foo" => 42} passes type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 90 - Reference {"baz" => "9.99","foo" => "4.2"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 91 - Reference {"bar" => "6.66","baz" => "9.99","foo" => 42} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 92 - Reference {"bar" => "6.66","baz" => "9.99","foo" => "4.2"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 93 - Reference {"baz" => "9.99","foo" => undef} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 94 - Reference {"baz" => "9.99"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 95 - Reference {"baz" => "x","foo" => 42} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 96 - Reference {"bar" => 666,"baz" => "x","foo" => 42} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 97 - Reference {"baz" => "x","foo" => "4.2"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 98 - Reference {"bar" => "6.66","baz" => "x","foo" => 42} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 99 - Reference {"bar" => "6.66","baz" => "x","foo" => "4.2"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 100 - Reference {"baz" => "x","foo" => undef} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 101 - Reference {"baz" => "x"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[HashRef[Num]]]
> ok 102 - Reference {"foo" => 99,"jjj" => "2.2"} passes type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[Map[StrMatch[(?^:^...$)],Num]]]
> ok 103 - Reference {"jjj" => "2.2"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[Map[StrMatch[(?^:^...$)],Num]]]
> ok 104 - Reference {"foo" => 99,"jjjj" => "2.2"} fails type constraint Dict[bar=>Optional[Int],foo=>Int,Slurpy[Map[StrMatch[(?^:^...$)],Num]]]
> ok 105 - Reference {"foo" => 1} fails type constraint Dict[foo=>Int,Slurpy[Num]]
> ok 106 - Reference {} fails type constraint Dict[foo=>Int,Slurpy[Num]]
> # Subtest: slurpy_coderef_thing
> ok 1 - An object of class 'Type::Tiny' isa 'Type::Tiny'
> ok 2 - An object of class 'Type::Tiny' isa 'Type::Tiny'
> ok 3 - Reference [1] passes type constraint Tuple[Int,Slurpy[__ANON__]]
> ok 4 - Reference [1,"extra"] passes type constraint Tuple[Int,Slurpy[__ANON__]]
> ok 5 - Reference [1] passes type constraint Tuple[Int,Slurpy[__ANON__]]
> ok 6 - Reference [1,"extra"] fails type constraint Tuple[Int,Slurpy[__ANON__]]
> 1..6
> ok 107 - slurpy_coderef_thing
> ok 108 - Reference ["foo",123] fails type constraint Dict[foo=>Int,Slurpy[__ANON__]]
> ok 109 - Reference {"foo" => 123} passes type constraint Dict[foo=>Int,Slurpy[__ANON__]]
> ok 110 - Reference {"bar" => 456,"foo" => 123} passes type constraint Dict[foo=>Int,Slurpy[__ANON__]]
> ok 111 - Reference {"bar" => 456} fails type constraint Dict[foo=>Int,Slurpy[__ANON__]]
> # Subtest: my_dict_is_slurpy
> ok 1 - On a non-slurpy Dict
> ok 2 - On a slurpy Dict
> ok 3 - On a child of a non-slurpy Dict
> ok 4 - On a child of a slurpy Dict
> 1..4
> ok 112 - my_dict_is_slurpy
> # Subtest: my_hashref_allows_key
> ok 1 - HashRef allows key "foo"
> ok 2 - HashRef disallows key undef
> ok 3 - HashRef disallows key []
> ok 4 - HashRef[Int] allows key "foo"
> ok 5 - HashRef[Int] disallows key undef
> ok 6 - HashRef[Int] disallows key []
> ok 7 - Map allows key "foo"
> ok 8 - Map disallows key undef
> ok 9 - Map disallows key []
> ok 10 - Map[Int,Int] disallows key "foo"
> ok 11 - Map[Int,Int] disallows key undef
> ok 12 - Map[Int,Int] disallows key []
> ok 13 - Map[Int,Int] allows key "42"
> ok 14 - Dict allows key "foo"
> ok 15 - Dict disallows key undef
> ok 16 - Dict disallows key []
> ok 17 - Dict[] disallows key "foo"
> ok 18 - Dict[] disallows key undef
> ok 19 - Dict[] disallows key []
> ok 20 - Dict[bar=>Int] disallows key "foo"
> ok 21 - Dict[bar=>Int] allows key "bar"
> ok 22 - Dict[bar=>Int] disallows key undef
> ok 23 - Dict[bar=>Int] disallows key []
> ok 24 - Dict[bar=>Int,slurpy Any] allows key "foo"
> ok 25 - Dict[bar=>Int,slurpy Any] allows key "bar"
> ok 26 - Dict[bar=>Int,slurpy Any] disallows key undef
> ok 27 - Dict[bar=>Int,slurpy Any] disallows key []
> ok 28 - Dict[bar=>Int,slurpy Ref] allows key "foo"
> ok 29 - Dict[bar=>Int,slurpy Ref] allows key "bar"
> ok 30 - Dict[bar=>Int,slurpy Ref] disallows key undef
> ok 31 - Dict[bar=>Int,slurpy Ref] disallows key []
> ok 32 - Dict[bar=>Int,slurpy Map[Int,Int]] disallows key "foo"
> ok 33 - Dict[bar=>Int,slurpy Map[Int,Int]] allows key "bar"
> ok 34 - Dict[bar=>Int,slurpy Map[Int,Int]] disallows key undef
> ok 35 - Dict[bar=>Int,slurpy Map[Int,Int]] disallows key []
> ok 36 - Dict[bar=>Int,slurpy Map[Int,Int]] allows key "42"
> ok 37 - A child of HashRef allows key "foo"
> ok 38 - A child of HashRef disallows key undef
> ok 39 - A child of HashRef disallows key []
> ok 40 - A child of HashRef[Int] allows key "foo"
> ok 41 - A child of HashRef[Int] disallows key undef
> ok 42 - A child of HashRef[Int] disallows key []
> ok 43 - A child of Map allows key "foo"
> ok 44 - A child of Map disallows key undef
> ok 45 - A child of Map disallows key []
> ok 46 - A child of Map[Int,Int] disallows key "foo"
> ok 47 - A child of Map[Int,Int] disallows key undef
> ok 48 - A child of Map[Int,Int] disallows key []
> ok 49 - A child of Map[Int,Int] allows key "42"
> ok 50 - A child of Dict allows key "foo"
> ok 51 - A child of Dict disallows key undef
> ok 52 - A child of Dict disallows key []
> ok 53 - A child of Dict[] disallows key "foo"
> ok 54 - A child of Dict[] disallows key undef
> ok 55 - A child of Dict[] disallows key []
> ok 56 - A child of Dict[bar=>Int] disallows key "foo"
> ok 57 - A child of Dict[bar=>Int] allows key "bar"
> ok 58 - A child of Dict[bar=>Int] disallows key undef
> ok 59 - A child of Dict[bar=>Int] disallows key []
> ok 60 - A child of Dict[bar=>Int,slurpy Any] allows key "foo"
> ok 61 - A child of Dict[bar=>Int,slurpy Any] allows key "bar"
> ok 62 - A child of Dict[bar=>Int,slurpy Any] disallows key undef
> ok 63 - A child of Dict[bar=>Int,slurpy Any] disallows key []
> ok 64 - A child of Dict[bar=>Int,slurpy Ref] allows key "foo"
> ok 65 - A child of Dict[bar=>Int,slurpy Ref] allows key "bar"
> ok 66 - A child of Dict[bar=>Int,slurpy Ref] disallows key undef
> ok 67 - A child of Dict[bar=>Int,slurpy Ref] disallows key []
> ok 68 - A child of Dict[bar=>Int,slurpy Map[Int,Int]] disallows key "foo"
> ok 69 - A child of Dict[bar=>Int,slurpy Map[Int,Int]] allows key "bar"
> ok 70 - A child of Dict[bar=>Int,slurpy Map[Int,Int]] disallows key undef
> ok 71 - A child of Dict[bar=>Int,slurpy Map[Int,Int]] disallows key []
> ok 72 - A child of Dict[bar=>Int,slurpy Map[Int,Int]] allows key "42"
> ok 73 - Dict[slurpy Int] disallows key "foo"
> 1..73
> ok 113 - my_hashref_allows_key
> # Subtest: my_hashref_allows_value
> ok 1 - HashRef allows key "foo" with value "bar"
> ok 2 - HashRef allows key "foo" with value undef
> ok 3 - HashRef disallows key undef with value "bar"
> ok 4 - HashRef[Int] disallows key "foo" with value "bar"
> ok 5 - A child of Dict[bar=>Int,slurpy Map[Int,Int]] allows key "bar" with value 42
> ok 6 - A child of Dict[bar=>Int,slurpy Map[Int,Int]] allows key "21" with value 42
> ok 7 - A child of Dict[bar=>Int,slurpy Map[Int,Int]] disallows key "baz" with value 42
> ok 8 - Dict[slurpy Int] disallows key "foo" with value 42
> 1..8
> ok 114 - my_hashref_allows_value
> # Subtest: Invalid parameters
> ok 1 - ScalarRef[INVALID]
> ok 2 - ArrayRef[INVALID]
> ok 3 - HashRef[INVALID]
> ok 4 - Map[INVALID, Str]
> ok 5 - Map[Str, INVALID]
> ok 6 - Tuple[INVALID]
> ok 7 - Tuple[Str, slurpy INVALID]
> ok 8 - Tuple[Optional[Str], Str]
> ok 9 - CycleTuple[INVALID]
> ok 10 - CycleTuple[Optional[Str]]
> ok 11 - CycleTuple[slurpy Str]
> ok 12 - Dict[INVALID]
> ok 13 - Dict[INVALID => Str]
> ok 14 - Dict[foo => INVALID]
> ok 15 - Dict[foo => Str, slurpy INVALID]
> 1..15
> ok 115 - Invalid parameters
> 1..115
> ok
> t/20-modules/Types-Standard/tied.t ...........................
> ok 1 - Reference [] passes type constraint Tied
> ok 2 - Reference {} passes type constraint Tied
> ok 3 - Reference \undef passes type constraint Tied
> ok 4 - Undef fails type constraint Tied
> ok 5 - Reference [] passes type constraint Tied["MyTie::Array"]
> ok 6 - Reference {} fails type constraint Tied["MyTie::Array"]
> ok 7 - Reference \undef fails type constraint Tied["MyTie::Array"]
> ok 8 - Reference [] fails type constraint Tied["MyTie::Hash"]
> ok 9 - Reference {} passes type constraint Tied["MyTie::Hash"]
> ok 10 - Reference \undef fails type constraint Tied["MyTie::Hash"]
> ok 11 - Reference [] fails type constraint Tied["MyTie::Scalar"]
> ok 12 - Reference {} fails type constraint Tied["MyTie::Scalar"]
> ok 13 - Reference \undef passes type constraint Tied["MyTie::Scalar"]
> ok 14 - Reference [] passes type constraint Tied[MyTieArray]
> ok 15 - Reference {} fails type constraint Tied[MyTieArray]
> ok 16 - Reference \undef fails type constraint Tied[MyTieArray]
> ok 17 - Reference [] fails type constraint Tied[MyTieHash]
> ok 18 - Reference {} passes type constraint Tied[MyTieHash]
> ok 19 - Reference \undef fails type constraint Tied[MyTieHash]
> ok 20 - Reference [] fails type constraint Tied[MyTieScalar]
> ok 21 - Reference {} fails type constraint Tied[MyTieScalar]
> ok 22 - Reference \undef passes type constraint Tied[MyTieScalar]
> ok 23 - Reference {} passes type constraint Tied&HashRef
> ok 24 - Reference [] fails type constraint Tied&HashRef
> ok 25 - Reference \undef fails type constraint Tied&HashRef
> ok 26 - Reference {"foo" => 2} fails type constraint Tied&HashRef
> ok 27 - weird exception
> 1..27
> ok
> t/20-modules/Types-TypeTiny/basic.t ..........................
> # Subtest: StringLike
> ok 1 - Value "Hello" passes type constraint StringLike
> ok 2 - Value "" passes type constraint StringLike
> ok 3 - Type::Tiny constraint object passes type constraint StringLike
> ok 4 - Reference bless( {}, 'Overloaded::String' ) passes type constraint StringLike
> ok 5 - Reference {} fails type constraint StringLike
> ok 6 - Undef fails type constraint StringLike
> 1..6
> ok 1 - StringLike
> # Subtest: ArrayLike
> ok 1 - Reference [] passes type constraint ArrayLike
> ok 2 - Reference bless( {}, 'Overloaded::ArrayRef' ) passes type constraint ArrayLike
> ok 3 - Reference {} fails type constraint ArrayLike
> ok 4 - Reference bless( [], 'XXX' ) fails type constraint ArrayLike
> ok 5 - Undef fails type constraint ArrayLike
> 1..5
> ok 2 - ArrayLike
> # Subtest: HashLike
> ok 1 - Reference {} passes type constraint HashLike
> ok 2 - Reference bless( [], 'Overloaded::HashRef' ) passes type constraint HashLike
> ok 3 - Reference [] fails type constraint HashLike
> ok 4 - Reference bless( {}, 'XXX' ) fails type constraint HashLike
> ok 5 - Undef fails type constraint HashLike
> 1..5
> ok 3 - HashLike
> # Subtest: CodeLike
> ok 1 - Reference sub { "DUMMY" } passes type constraint CodeLike
> ok 2 - Type::Tiny constraint object passes type constraint CodeLike
> ok 3 - Reference bless( [], 'Overloaded::CodeRef' ) passes type constraint CodeLike
> ok 4 - Reference {} fails type constraint CodeLike
> ok 5 - Reference bless( sub { "DUMMY" }, 'XXX' ) fails type constraint CodeLike
> ok 6 - Undef fails type constraint CodeLike
> 1..6
> ok 4 - CodeLike
> # Subtest: TypeTiny
> ok 1 - Type::Tiny constraint object passes type constraint TypeTiny
> ok 2 - Reference {} fails type constraint TypeTiny
> ok 3 - Reference sub { "DUMMY" } fails type constraint TypeTiny
> ok 4 - Undef fails type constraint TypeTiny
> 1..4
> ok 5 - TypeTiny
> 1..5
> ok
> t/20-modules/Types-TypeTiny/coercion.t .......................
> ok 1 - TypeTiny->has_coercion
> # Subtest: Coercion from built-in Moose type constraint object
> ok 1 - Reference bless( {"_default_message" => sub { "DUMMY" },"compiled_type...) passes type constraint _ForeignTypeConstraint
> ok 2 - Reference bless( {"_is_core" => 1,"_overload_coderef" => sub { "DUMMY"...) fails type constraint _ForeignTypeConstraint
> ok 3 - to_TypeTiny converted a Moose type constraint to a Type::Tiny one
> ok 4 - ... which has the correct name
> ok 5 - ... and which can be inlined
> # (do { my $tmp = $X; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ })
> # Subtest: ... and it works
> ok 1 - Value "123" passes type constraint Int
> ok 2 - Value "3.3" fails type constraint Int
> 1..2
> ok 6 - ... and it works
> 1..6
> ok 2 - Coercion from built-in Moose type constraint object
> # Subtest: Coercion from custom Moose type constraint object
> ok 1 - Reference bless( {"compiled_type_constraint" => sub { "DUMMY" },"const...) passes type constraint _ForeignTypeConstraint
> ok 2 - Reference bless( {"constraint" => sub { "DUMMY" },"definition_context"...) fails type constraint _ForeignTypeConstraint
> ok 3 - to_TypeTiny converted a Moose type constraint to a Type::Tiny one
> ok 4 - ... which has the correct display_name
> ok 5 - ... and which can be inlined
> # do { package Type::Tiny; ( do { do { ( do { ( do { ( do { defined($X) } ) && !ref($X) } ) && (my $val = $X) =~ /\A-?[0-9]+\z/ } ) } && !( $X % 2 ) } ) }
> # Subtest: ... and it works
> ok 1 - Value "3.3" fails type constraint EvenInt
> ok 2 - Value "123" fails type constraint EvenInt
> ok 3 - Value "124" passes type constraint EvenInt
> 1..3
> ok 6 - ... and it works
> ok 7 - ... and provides proper message
> 1..7
> ok 3 - Coercion from custom Moose type constraint object
> # Subtest: Coercion from Moose parameterizable type constraint object
> # Moose native type, no parameters
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> # Moose native type, parameterized with Moose type
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> ok 13
> ok 14
> # Moose native type, parameterized with TT type
> ok 15
> ok 16
> ok 17
> ok 18
> ok 19
> ok 20
> ok 21
> # TT type, no parameters
> ok 22 - An object of class 'Type::Tiny' isa 'Type::Tiny'
> ok 23
> ok 24 - Reference [] passes type constraint ArrayOrHashRef
> ok 25 - Reference {} passes type constraint ArrayOrHashRef
> ok 26 - Reference [1,2,3,4,5,6,7,8,9,10] passes type constraint ArrayOrHashRef
> ok 27 - Reference {"bar" => 2,"foo" => 1} passes type constraint ArrayOrHashRef
> ok 28 - Reference ["hello world"] passes type constraint ArrayOrHashRef
> ok 29 - Reference \1 fails type constraint ArrayOrHashRef
> ok 30 - Value "42" fails type constraint ArrayOrHashRef
> # TT type, parameterized with Moose type
> ok 31 - Reference [] passes type constraint ArrayOrHashRef[Int]
> ok 32 - Reference {} passes type constraint ArrayOrHashRef[Int]
> ok 33 - Reference [1,2,3,4,5,6,7,8,9,10] passes type constraint ArrayOrHashRef[Int]
> ok 34 - Reference {"bar" => 2,"foo" => 1} passes type constraint ArrayOrHashRef[Int]
> ok 35 - Reference ["hello world"] fails type constraint ArrayOrHashRef[Int]
> ok 36 - Reference \1 fails type constraint ArrayOrHashRef[Int]
> ok 37 - Value "42" fails type constraint ArrayOrHashRef[Int]
> # TT type, parameterized with TT type
> ok 38 - Reference [] passes type constraint ArrayOrHashRef[Int]
> ok 39 - Reference {} passes type constraint ArrayOrHashRef[Int]
> ok 40 - Reference [1,2,3,4,5,6,7,8,9,10] passes type constraint ArrayOrHashRef[Int]
> ok 41 - Reference {"bar" => 2,"foo" => 1} passes type constraint ArrayOrHashRef[Int]
> ok 42 - Reference ["hello world"] fails type constraint ArrayOrHashRef[Int]
> ok 43 - Reference \1 fails type constraint ArrayOrHashRef[Int]
> ok 44 - Value "42" fails type constraint ArrayOrHashRef[Int]
> 1..44
> ok 4 - Coercion from Moose parameterizable type constraint object
> # Subtest: Coercion from Moose parameterizable type constraint object with inlining
> # Moose native type, no parameters
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> # Moose native type, parameterized with Moose type
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> ok 13
> ok 14
> # Moose native type, parameterized with TT type
> ok 15
> ok 16
> ok 17
> ok 18
> ok 19
> ok 20
> ok 21
> # TT type, no parameters
> ok 22 - An object of class 'Type::Tiny' isa 'Type::Tiny'
> ok 23
> ok 24 - Reference [] passes type constraint ArrayOrHashRef2
> ok 25 - Reference {} passes type constraint ArrayOrHashRef2
> ok 26 - Reference [1,2,3,4,5,6,7,8,9,10] passes type constraint ArrayOrHashRef2
> ok 27 - Reference {"bar" => 2,"foo" => 1} passes type constraint ArrayOrHashRef2
> ok 28 - Reference ["hello world"] passes type constraint ArrayOrHashRef2
> ok 29 - Reference \1 fails type constraint ArrayOrHashRef2
> ok 30 - Value "42" fails type constraint ArrayOrHashRef2
> # TT type, parameterized with Moose type
> ok 31 - Reference [] passes type constraint ArrayOrHashRef2[Int]
> ok 32 - Reference {} passes type constraint ArrayOrHashRef2[Int]
> ok 33 - Reference [1,2,3,4,5,6,7,8,9,10] passes type constraint ArrayOrHashRef2[Int]
> ok 34 - Reference {"bar" => 2,"foo" => 1} passes type constraint ArrayOrHashRef2[Int]
> ok 35 - Reference ["hello world"] fails type constraint ArrayOrHashRef2[Int]
> ok 36 - Reference \1 fails type constraint ArrayOrHashRef2[Int]
> ok 37 - Value "42" fails type constraint ArrayOrHashRef2[Int]
> # TT type, parameterized with TT type
> ok 38 - Reference [] passes type constraint ArrayOrHashRef2[Int]
> ok 39 - Reference {} passes type constraint ArrayOrHashRef2[Int]
> ok 40 - Reference [1,2,3,4,5,6,7,8,9,10] passes type constraint ArrayOrHashRef2[Int]
> ok 41 - Reference {"bar" => 2,"foo" => 1} passes type constraint ArrayOrHashRef2[Int]
> ok 42 - Reference ["hello world"] fails type constraint ArrayOrHashRef2[Int]
> ok 43 - Reference \1 fails type constraint ArrayOrHashRef2[Int]
> ok 44 - Value "42" fails type constraint ArrayOrHashRef2[Int]
> # check everything can be inlined
> ok 45
> ok 46
> ok 47
> ok 48
> ok 49
> ok 50
> ok 51
> ok 52
> ok 53
> ok 54
> ok 55
> ok 56
> # do { package Type::Tiny; ( do { do{
> # if (ref($VALUE) eq 'ARRAY') {
> # my $okay = 1;
> # (( do { ( do { ( do { defined($_) } ) && !ref($_) } ) && (my $val = $_) =~ /\A-?[0-9]+\z/ } ) or (($okay=0), last)) for @{$VALUE};
> # $okay;
> # }
> # elsif (ref($VALUE) eq 'HASH') {
> # my $okay = 1;
> # (( do { ( do { ( do { defined($_) } ) && !ref($_) } ) && (my $val = $_) =~ /\A-?[0-9]+\z/ } ) or (($okay=0), last)) for values %{$VALUE};
> # $okay;
> # }
> # else {
> # 0;
> # }
> # } } ) }
> 1..56
> ok 5 - Coercion from Moose parameterizable type constraint object with inlining
> # Subtest: Coercion from Moose enum type constraint
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9 - An object of class 'Type::Tiny::Enum' isa 'Type::Tiny::Enum'
> ok 10
> ok 11
> # Type::Tiny::XS::AUTO::TC1($STR)
> 1..11
> ok 6 - Coercion from Moose enum type constraint
> # Subtest: Coercion from Moose class type constraint
> ok 1 - An object of class 'Type::Tiny::Class' isa 'Type::Tiny::Class'
> ok 2
> ok 3
> # (Type::Tiny::XS::AUTO::TC2($OBJECT))
> 1..3
> ok 7 - Coercion from Moose class type constraint
> # Subtest: Coercion from Moose role type constraint
> ok 1 - An object of class 'Type::Tiny::Role' isa 'Type::Tiny::Role'
> ok 2
> ok 3
> # do { package Type::Tiny; Scalar::Util::blessed($OBJECT) and do { my $method = $OBJECT->can('DOES')||$OBJECT->can('isa'); $OBJECT->$method(q[MyApp::Foo]) } }
> 1..3
> ok 8 - Coercion from Moose role type constraint
> # Subtest: Coercion from Moose duck type constraint
> ok 1 - An object of class 'Type::Tiny::Duck' isa 'Type::Tiny::Duck'
> ok 2
> ok 3
> # (Type::Tiny::XS::AUTO::TC3($OBJECT))
> 1..3
> ok 9 - Coercion from Moose duck type constraint
> # Subtest: Coercion from Moose union type constraint
> ok 1
> ok 2 - An object of class 'Type::Tiny::Union' isa 'Type::Tiny::Union'
> ok 3
> ok 4
> ok 5
> # Type::Tiny::XS::AUTO::TC4($REF)
> 1..5
> ok 10 - Coercion from Moose union type constraint
> # Subtest: Coercion from Mouse type constraint object
> ok 1 - Reference bless( {"compiled_type_constraint" => sub { "DUMMY" },"hand_...) passes type constraint _ForeignTypeConstraint
> ok 2 - Reference bless( {"constraint" => sub { "DUMMY" },"definition_context"...) fails type constraint _ForeignTypeConstraint
> ok 3 - to_TypeTiny converted a Mouse type constraint to a Type::Tiny one
> # Subtest: ... and it works
> ok 1 - Value "123" passes type constraint Int
> ok 2 - Value "3.3" fails type constraint Int
> 1..2
> ok 4 - ... and it works
> ok 5 - ... and provides proper message
> 1..5
> ok 11 - Coercion from Mouse type constraint object
> # Subtest: Coercion from predicate-like coderef
> ok 1 - Reference sub { "DUMMY" } passes type constraint _ForeignTypeConstraint
> ok 2 - Reference bless( {"constraint" => sub { "DUMMY" },"definition_context"...) fails type constraint _ForeignTypeConstraint
> ok 3 - to_TypeTiny converted the coderef to a Type::Tiny object
> # Subtest: ... and it works
> ok 1 - Value "123" passes type constraint __ANON__
> ok 2 - Value "3.3" fails type constraint __ANON__
> 1..2
> ok 4 - ... and it works
> 1..4
> ok 12 - Coercion from predicate-like coderef
> # Subtest: Coercion from assertion-like coderef
> ok 1 - Reference sub { "DUMMY" } passes type constraint _ForeignTypeConstraint
> ok 2 - Reference bless( {"constraint" => sub { "DUMMY" },"definition_context"...) fails type constraint _ForeignTypeConstraint
> ok 3 - to_TypeTiny converted the coderef to a Type::Tiny object
> # Subtest: ... and it works
> ok 1 - Value "123" passes type constraint __ANON__
> ok 2 - Value "3.3" fails type constraint __ANON__
> 1..2
> ok 4 - ... and it works
> ok 5 - ... and provides proper message
> 1..5
> ok 13 - Coercion from assertion-like coderef
> # Subtest: Coercion from Sub::Quote coderef
> ok 1 - Reference sub { "DUMMY" } passes type constraint _ForeignTypeConstraint
> ok 2 - Reference bless( {"constraint" => sub { "DUMMY" },"definition_context"...) fails type constraint _ForeignTypeConstraint
> ok 3 - to_TypeTiny converted the coderef to a Type::Tiny object
> ok 4 - ... which can be inlined
> # do { package Type::Tiny; do { local $_ = $X;local @_ = ($X); !!eval{ # BEGIN quote_sub PRELUDE
> # package main;
> # BEGIN {
> # $^H = 1762;
> # ${^WARNING_BITS} = "UUUUUUUUUUUUUUUUUUUU";
> # %^H = (
> # );
> # }
> # # END quote_sub PRELUDE
> # $_[0] =~ /\A-?[0-9]+\z/ } } }
> # Subtest: ... and it works
> ok 1 - Value "123" passes type constraint __ANON__
> ok 2 - Value "3.3" fails type constraint __ANON__
> 1..2
> ok 5 - ... and it works
> 1..5
> ok 14 - Coercion from Sub::Quote coderef
> 1..14
> ok
> t/20-modules/Types-TypeTiny/meta.t ...........................
> ok 1 - type_names
> ok 2 - has_type(HashLike)
> ok 3 - get_type(HashLike)
> ok 4 - has_type(MonkeyNuts)
> ok 5 - get_type(MonkeyNuts)
> ok 6 - coercion_names
> ok 7 - has_coercion(MonkeyNuts)
> ok 8 - get_coercion(MonkeyNuts)
> 1..8
> ok
> t/20-modules/Types-TypeTiny/moosemouse.t .....................
> # Subtest: TypeTiny
> ok 1 - Type::Tiny constraint object passes type constraint TypeTiny
> ok 2 - Reference {} fails type constraint TypeTiny
> ok 3 - Reference sub { "DUMMY" } fails type constraint TypeTiny
> ok 4 - Moose constraint object fails type constraint TypeTiny
> ok 5 - Mouse constraint object fails type constraint TypeTiny
> ok 6 - Undef fails type constraint TypeTiny
> 1..6
> ok 1 - TypeTiny
> 1..1
> ok
> t/20-modules/Types-TypeTiny/progressiveexporter.t ............
> ok 1
> ok 2
> ok 3
> 1..3
> ok
> t/20-modules/Types-TypeTiny/type-puny.t ......................
> ok 1 - Reference [1,2,3] passes type constraint __ANON__
> ok 2 - Value "Hello world" fails type constraint __ANON__
> ok 3 - get_message worked
> ok 4 - Reference [1,2,3] passes type constraint ArrayRef[__ANON__]
> ok 5 - Reference {} fails type constraint ArrayRef[__ANON__]
> ok 6 - Reference [1,2,3,undef] fails type constraint ArrayRef[__ANON__]
> ok 7 - Type::Puny::PlusCoerce->has_coercion
> ok 8 - Type::Puny::PlusCoerce->coerce
> 1..8
> ok
> t/21-types/_ForeignTypeConstraint.t ..........................
> ok 1 - '_ForeignTypeConstraint' isa 'Type::Tiny'
> ok 2 - _ForeignTypeConstraint has correct name
> ok 3 - _ForeignTypeConstraint has correct display_name
> ok 4 - _ForeignTypeConstraint knows it is in the Types::TypeTiny library
> ok 5 - Types::TypeTiny knows it has type _ForeignTypeConstraint
> ok 6 - _ForeignTypeConstraint is not deprecated
> ok 7 - _ForeignTypeConstraint is not anonymous
> ok 8 - _ForeignTypeConstraint can be inlined
> ok 9 - Inlining _ForeignTypeConstraint doesn't throw an exception
> ok 10 - _ForeignTypeConstraint doesn't have a coercion
> ok 11 - _ForeignTypeConstraint isn't parameterizable
> ok 12 - _ForeignTypeConstraint has no type_default
> ok 13 - Undef should fail _ForeignTypeConstraint
> ok 14 - False should fail _ForeignTypeConstraint
> ok 15 - True should fail _ForeignTypeConstraint
> ok 16 - Zero should fail _ForeignTypeConstraint
> ok 17 - One should fail _ForeignTypeConstraint
> ok 18 - Negative one should fail _ForeignTypeConstraint
> ok 19 - Non integer should fail _ForeignTypeConstraint
> ok 20 - Empty string should fail _ForeignTypeConstraint
> ok 21 - Whitespace should fail _ForeignTypeConstraint
> ok 22 - Line break should fail _ForeignTypeConstraint
> ok 23 - Random string should fail _ForeignTypeConstraint
> ok 24 - Loaded package name should fail _ForeignTypeConstraint
> ok 25 - Unloaded package name should fail _ForeignTypeConstraint
> ok 26 - A reference to undef should fail _ForeignTypeConstraint
> ok 27 - A reference to false should fail _ForeignTypeConstraint
> ok 28 - A reference to true should fail _ForeignTypeConstraint
> ok 29 - A reference to zero should fail _ForeignTypeConstraint
> ok 30 - A reference to one should fail _ForeignTypeConstraint
> ok 31 - A reference to empty string should fail _ForeignTypeConstraint
> ok 32 - A reference to random string should fail _ForeignTypeConstraint
> ok 33 - Blessed scalarref should fail _ForeignTypeConstraint
> ok 34 - Empty arrayref should fail _ForeignTypeConstraint
> ok 35 - Arrayref with one zero should fail _ForeignTypeConstraint
> ok 36 - Arrayref of integers should fail _ForeignTypeConstraint
> ok 37 - Arrayref of numbers should fail _ForeignTypeConstraint
> ok 38 - Blessed arrayref should fail _ForeignTypeConstraint
> ok 39 - Empty hashref should fail _ForeignTypeConstraint
> ok 40 - Hashref should fail _ForeignTypeConstraint
> ok 41 - Blessed hashref should fail _ForeignTypeConstraint
> ok 42 - Coderef should pass _ForeignTypeConstraint
> ok 43 - Blessed coderef should fail _ForeignTypeConstraint
> ok 44 - Glob should fail _ForeignTypeConstraint
> ok 45 - Globref should fail _ForeignTypeConstraint
> ok 46 - Blessed globref should fail _ForeignTypeConstraint
> ok 47 - Regexp should fail _ForeignTypeConstraint
> ok 48 - Blessed regexp should fail _ForeignTypeConstraint
> ok 49 - Filehandle should fail _ForeignTypeConstraint
> ok 50 - Filehandle object should fail _ForeignTypeConstraint
> ok 51 - Ref to scalarref should fail _ForeignTypeConstraint
> ok 52 - Ref to arrayref should fail _ForeignTypeConstraint
> ok 53 - Ref to hashref should fail _ForeignTypeConstraint
> ok 54 - Ref to coderef should fail _ForeignTypeConstraint
> ok 55 - Ref to blessed hashref should fail _ForeignTypeConstraint
> ok 56 - Object stringifying to "" should fail _ForeignTypeConstraint
> ok 57 - Object stringifying to "1" should fail _ForeignTypeConstraint
> ok 58 - Object numifying to 0 should fail _ForeignTypeConstraint
> ok 59 - Object numifying to 1 should fail _ForeignTypeConstraint
> ok 60 - Object overloading arrayref should fail _ForeignTypeConstraint
> ok 61 - Object overloading hashref should fail _ForeignTypeConstraint
> ok 62 - Object overloading coderef should fail _ForeignTypeConstraint
> ok 63 - Object booling to false should fail _ForeignTypeConstraint
> ok 64 - Object booling to true should fail _ForeignTypeConstraint
> ok 65
> ok 66
> ok 67 - Reference bless( [sub { "DUMMY" },"Not a hashref"], 'Local::MyTypeConstraint' ) passes type constraint _ForeignTypeConstraint
> 1..67
> ok
> t/21-types/Any.t .............................................
> ok 1 - 'Any' isa 'Type::Tiny'
> ok 2 - Any has correct name
> ok 3 - Any has correct display_name
> ok 4 - Any knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Any
> ok 6 - Any is not deprecated
> ok 7 - Any is not anonymous
> ok 8 - Any can be inlined
> ok 9 - Inlining Any doesn't throw an exception
> ok 10 - Any doesn't have a coercion
> ok 11 - Any isn't parameterizable
> ok 12 - Any has a type_default
> ok 13 - Any type_default is undef
> ok 14 - Undef should pass Any
> ok 15 - False should pass Any
> ok 16 - True should pass Any
> ok 17 - Zero should pass Any
> ok 18 - One should pass Any
> ok 19 - Negative one should pass Any
> ok 20 - Non integer should pass Any
> ok 21 - Empty string should pass Any
> ok 22 - Whitespace should pass Any
> ok 23 - Line break should pass Any
> ok 24 - Random string should pass Any
> ok 25 - Loaded package name should pass Any
> ok 26 - Unloaded package name should pass Any
> ok 27 - A reference to undef should pass Any
> ok 28 - A reference to false should pass Any
> ok 29 - A reference to true should pass Any
> ok 30 - A reference to zero should pass Any
> ok 31 - A reference to one should pass Any
> ok 32 - A reference to empty string should pass Any
> ok 33 - A reference to random string should pass Any
> ok 34 - Blessed scalarref should pass Any
> ok 35 - Empty arrayref should pass Any
> ok 36 - Arrayref with one zero should pass Any
> ok 37 - Arrayref of integers should pass Any
> ok 38 - Arrayref of numbers should pass Any
> ok 39 - Blessed arrayref should pass Any
> ok 40 - Empty hashref should pass Any
> ok 41 - Hashref should pass Any
> ok 42 - Blessed hashref should pass Any
> ok 43 - Coderef should pass Any
> ok 44 - Blessed coderef should pass Any
> ok 45 - Glob should pass Any
> ok 46 - Globref should pass Any
> ok 47 - Blessed globref should pass Any
> ok 48 - Regexp should pass Any
> ok 49 - Blessed regexp should pass Any
> ok 50 - Filehandle should pass Any
> ok 51 - Filehandle object should pass Any
> ok 52 - Ref to scalarref should pass Any
> ok 53 - Ref to arrayref should pass Any
> ok 54 - Ref to hashref should pass Any
> ok 55 - Ref to coderef should pass Any
> ok 56 - Ref to blessed hashref should pass Any
> ok 57 - Object stringifying to "" should pass Any
> ok 58 - Object stringifying to "1" should pass Any
> ok 59 - Object numifying to 0 should pass Any
> ok 60 - Object numifying to 1 should pass Any
> ok 61 - Object overloading arrayref should pass Any
> ok 62 - Object overloading hashref should pass Any
> ok 63 - Object overloading coderef should pass Any
> ok 64 - Object booling to false should pass Any
> ok 65 - Object booling to true should pass Any
> ok 66 - Complement of Any is None.
> ok 67 - None can be inlined.
> # Subtest: None fails where Any passes and vice versa
> ok 1 - Undef should fail None
> ok 2 - False should fail None
> ok 3 - True should fail None
> ok 4 - Zero should fail None
> ok 5 - One should fail None
> ok 6 - Negative one should fail None
> ok 7 - Non integer should fail None
> ok 8 - Empty string should fail None
> ok 9 - Whitespace should fail None
> ok 10 - Line break should fail None
> ok 11 - Random string should fail None
> ok 12 - Loaded package name should fail None
> ok 13 - Unloaded package name should fail None
> ok 14 - A reference to undef should fail None
> ok 15 - A reference to false should fail None
> ok 16 - A reference to true should fail None
> ok 17 - A reference to zero should fail None
> ok 18 - A reference to one should fail None
> ok 19 - A reference to empty string should fail None
> ok 20 - A reference to random string should fail None
> ok 21 - Blessed scalarref should fail None
> ok 22 - Empty arrayref should fail None
> ok 23 - Arrayref with one zero should fail None
> ok 24 - Arrayref of integers should fail None
> ok 25 - Arrayref of numbers should fail None
> ok 26 - Blessed arrayref should fail None
> ok 27 - Empty hashref should fail None
> ok 28 - Hashref should fail None
> ok 29 - Blessed hashref should fail None
> ok 30 - Coderef should fail None
> ok 31 - Blessed coderef should fail None
> ok 32 - Glob should fail None
> ok 33 - Globref should fail None
> ok 34 - Blessed globref should fail None
> ok 35 - Regexp should fail None
> ok 36 - Blessed regexp should fail None
> ok 37 - Filehandle should fail None
> ok 38 - Filehandle object should fail None
> ok 39 - Ref to scalarref should fail None
> ok 40 - Ref to arrayref should fail None
> ok 41 - Ref to hashref should fail None
> ok 42 - Ref to coderef should fail None
> ok 43 - Ref to blessed hashref should fail None
> ok 44 - Object stringifying to "" should fail None
> ok 45 - Object stringifying to "1" should fail None
> ok 46 - Object numifying to 0 should fail None
> ok 47 - Object numifying to 1 should fail None
> ok 48 - Object overloading arrayref should fail None
> ok 49 - Object overloading hashref should fail None
> ok 50 - Object overloading coderef should fail None
> ok 51 - Object booling to false should fail None
> ok 52 - Object booling to true should fail None
> 1..52
> ok 68 - None fails where Any passes and vice versa
> 1..68
> ok
> t/21-types/ArrayLike.t .......................................
> ok 1 - 'ArrayLike' isa 'Type::Tiny'
> ok 2 - ArrayLike has correct name
> ok 3 - ArrayLike has correct display_name
> ok 4 - ArrayLike knows it is in the Types::TypeTiny library
> ok 5 - Types::TypeTiny knows it has type ArrayLike
> ok 6 - ArrayLike is not deprecated
> ok 7 - ArrayLike is not anonymous
> ok 8 - ArrayLike can be inlined
> ok 9 - Inlining ArrayLike doesn't throw an exception
> ok 10 - ArrayLike doesn't have a coercion
> ok 11 - ArrayLike is parameterizable
> ok 12 - ArrayLike has a type_default
> ok 13 - ArrayLike type_default is []
> ok 14 - Undef should fail ArrayLike
> ok 15 - False should fail ArrayLike
> ok 16 - True should fail ArrayLike
> ok 17 - Zero should fail ArrayLike
> ok 18 - One should fail ArrayLike
> ok 19 - Negative one should fail ArrayLike
> ok 20 - Non integer should fail ArrayLike
> ok 21 - Empty string should fail ArrayLike
> ok 22 - Whitespace should fail ArrayLike
> ok 23 - Line break should fail ArrayLike
> ok 24 - Random string should fail ArrayLike
> ok 25 - Loaded package name should fail ArrayLike
> ok 26 - Unloaded package name should fail ArrayLike
> ok 27 - A reference to undef should fail ArrayLike
> ok 28 - A reference to false should fail ArrayLike
> ok 29 - A reference to true should fail ArrayLike
> ok 30 - A reference to zero should fail ArrayLike
> ok 31 - A reference to one should fail ArrayLike
> ok 32 - A reference to empty string should fail ArrayLike
> ok 33 - A reference to random string should fail ArrayLike
> ok 34 - Blessed scalarref should fail ArrayLike
> ok 35 - Empty arrayref should pass ArrayLike
> ok 36 - Arrayref with one zero should pass ArrayLike
> ok 37 - Arrayref of integers should pass ArrayLike
> ok 38 - Arrayref of numbers should pass ArrayLike
> ok 39 - Blessed arrayref should fail ArrayLike
> ok 40 - Empty hashref should fail ArrayLike
> ok 41 - Hashref should fail ArrayLike
> ok 42 - Blessed hashref should fail ArrayLike
> ok 43 - Coderef should fail ArrayLike
> ok 44 - Blessed coderef should fail ArrayLike
> ok 45 - Glob should fail ArrayLike
> ok 46 - Globref should fail ArrayLike
> ok 47 - Blessed globref should fail ArrayLike
> ok 48 - Regexp should fail ArrayLike
> ok 49 - Blessed regexp should fail ArrayLike
> ok 50 - Filehandle should fail ArrayLike
> ok 51 - Filehandle object should fail ArrayLike
> ok 52 - Ref to scalarref should fail ArrayLike
> ok 53 - Ref to arrayref should fail ArrayLike
> ok 54 - Ref to hashref should fail ArrayLike
> ok 55 - Ref to coderef should fail ArrayLike
> ok 56 - Ref to blessed hashref should fail ArrayLike
> ok 57 - Object stringifying to "" should fail ArrayLike
> ok 58 - Object stringifying to "1" should fail ArrayLike
> ok 59 - Object numifying to 0 should fail ArrayLike
> ok 60 - Object numifying to 1 should fail ArrayLike
> ok 61 - Object overloading arrayref should pass ArrayLike
> ok 62 - Object overloading hashref should fail ArrayLike
> ok 63 - Object overloading coderef should fail ArrayLike
> ok 64 - Object booling to false should fail ArrayLike
> ok 65 - Object booling to true should fail ArrayLike
> ok 66
> ok 67 - Reference [1,2,3] passes type constraint ArrayLike[Int]
> ok 68 - Reference bless( {"array" => [1,2,3]}, 'Local::OL::Array' ) passes type constraint ArrayLike[Int]
> ok 69 - Reference [undef,2,3] fails type constraint ArrayLike[Int]
> ok 70 - Reference bless( {"array" => [undef,2,3]}, 'Local::OL::Array' ) fails type constraint ArrayLike[Int]
> ok 71
> ok 72
> ok 73
> ok 74
> ok 75 - tied array that should pass
> ok 76 - tied array that should fail
> ok 77 - overloaded object yielding regular array that should pass
> ok 78 - overloaded object yielding regular array that should fail
> ok 79 - overloaded object yielding tied array that should pass
> ok 80 - overloaded object yielding tied array that should fail
> 1..80
> ok
> t/21-types/ArrayRef.t ........................................
> ok 1 - 'ArrayRef' isa 'Type::Tiny'
> ok 2 - ArrayRef has correct name
> ok 3 - ArrayRef has correct display_name
> ok 4 - ArrayRef knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type ArrayRef
> ok 6 - ArrayRef is not deprecated
> ok 7 - ArrayRef is not anonymous
> ok 8 - ArrayRef can be inlined
> ok 9 - Inlining ArrayRef doesn't throw an exception
> ok 10 - ArrayRef doesn't have a coercion
> ok 11 - ArrayRef is parameterizable
> ok 12 - ArrayRef has a type_default
> ok 13 - ArrayRef type_default is []
> ok 14 - Undef should fail ArrayRef
> ok 15 - False should fail ArrayRef
> ok 16 - True should fail ArrayRef
> ok 17 - Zero should fail ArrayRef
> ok 18 - One should fail ArrayRef
> ok 19 - Negative one should fail ArrayRef
> ok 20 - Non integer should fail ArrayRef
> ok 21 - Empty string should fail ArrayRef
> ok 22 - Whitespace should fail ArrayRef
> ok 23 - Line break should fail ArrayRef
> ok 24 - Random string should fail ArrayRef
> ok 25 - Loaded package name should fail ArrayRef
> ok 26 - Unloaded package name should fail ArrayRef
> ok 27 - A reference to undef should fail ArrayRef
> ok 28 - A reference to false should fail ArrayRef
> ok 29 - A reference to true should fail ArrayRef
> ok 30 - A reference to zero should fail ArrayRef
> ok 31 - A reference to one should fail ArrayRef
> ok 32 - A reference to empty string should fail ArrayRef
> ok 33 - A reference to random string should fail ArrayRef
> ok 34 - Blessed scalarref should fail ArrayRef
> ok 35 - Empty arrayref should pass ArrayRef
> ok 36 - Arrayref with one zero should pass ArrayRef
> ok 37 - Arrayref of integers should pass ArrayRef
> ok 38 - Arrayref of numbers should pass ArrayRef
> ok 39 - Blessed arrayref should fail ArrayRef
> ok 40 - Empty hashref should fail ArrayRef
> ok 41 - Hashref should fail ArrayRef
> ok 42 - Blessed hashref should fail ArrayRef
> ok 43 - Coderef should fail ArrayRef
> ok 44 - Blessed coderef should fail ArrayRef
> ok 45 - Glob should fail ArrayRef
> ok 46 - Globref should fail ArrayRef
> ok 47 - Blessed globref should fail ArrayRef
> ok 48 - Regexp should fail ArrayRef
> ok 49 - Blessed regexp should fail ArrayRef
> ok 50 - Filehandle should fail ArrayRef
> ok 51 - Filehandle object should fail ArrayRef
> ok 52 - Ref to scalarref should fail ArrayRef
> ok 53 - Ref to arrayref should fail ArrayRef
> ok 54 - Ref to hashref should fail ArrayRef
> ok 55 - Ref to coderef should fail ArrayRef
> ok 56 - Ref to blessed hashref should fail ArrayRef
> ok 57 - Object stringifying to "" should fail ArrayRef
> ok 58 - Object stringifying to "1" should fail ArrayRef
> ok 59 - Object numifying to 0 should fail ArrayRef
> ok 60 - Object numifying to 1 should fail ArrayRef
> ok 61 - Object overloading arrayref should fail ArrayRef
> ok 62 - Object overloading hashref should fail ArrayRef
> ok 63 - Object overloading coderef should fail ArrayRef
> ok 64 - Object booling to false should fail ArrayRef
> ok 65 - Object booling to true should fail ArrayRef
> ok 66 - '$ArrayOfInts' isa 'Type::Tiny'
> ok 67 - $ArrayOfInts has correct display_name
> ok 68 - $ArrayOfInts has no name
> ok 69 - $ArrayOfInts can be inlined
> ok 70 - Inlining $ArrayOfInts doesn't throw an exception
> ok 71 - $ArrayOfInts doesn't have a coercion
> ok 72 - $ArrayOfInts is not parameterizable
> ok 73 - $ArrayOfInts has a type_default
> ok 74 - $ArrayOfInts type_default is []
> ok 75 - ArrayRef subtype: ArrayRef[Int]
> ok 76 - Value "1" fails type constraint ArrayRef[Int]
> ok 77 - Reference {} fails type constraint ArrayRef[Int]
> ok 78 - Reference [] passes type constraint ArrayRef[Int]
> ok 79 - Reference [[]] fails type constraint ArrayRef[Int]
> ok 80 - Reference ["1.1"] fails type constraint ArrayRef[Int]
> ok 81 - Reference [1] passes type constraint ArrayRef[Int]
> ok 82 - Reference [0] passes type constraint ArrayRef[Int]
> ok 83 - Reference [-1] passes type constraint ArrayRef[Int]
> ok 84 - Reference [\1] fails type constraint ArrayRef[Int]
> ok 85 - Reference [1,2] passes type constraint ArrayRef[Int]
> ok 86 - Reference [1,[]] fails type constraint ArrayRef[Int]
> ok 87 - parameterizing with [] has no effect
> ok 88 - parameterizing is cached
> ok 89 - Value "1" fails type constraint ArrayRef[Int,2]
> ok 90 - Reference {} fails type constraint ArrayRef[Int,2]
> ok 91 - Reference [] fails type constraint ArrayRef[Int,2]
> ok 92 - Reference [[]] fails type constraint ArrayRef[Int,2]
> ok 93 - Reference ["1.1"] fails type constraint ArrayRef[Int,2]
> ok 94 - Reference [1] fails type constraint ArrayRef[Int,2]
> ok 95 - Reference [0] fails type constraint ArrayRef[Int,2]
> ok 96 - Reference [-1] fails type constraint ArrayRef[Int,2]
> ok 97 - Reference [\1] fails type constraint ArrayRef[Int,2]
> ok 98 - Reference [1,2] passes type constraint ArrayRef[Int,2]
> ok 99 - Reference [1,[]] fails type constraint ArrayRef[Int,2]
> ok 100 - Reference [1,-1] passes type constraint ArrayRef[Int,2]
> ok 101 - Reference [1,2,3,4,5,6,7,8,9] passes type constraint ArrayRef[Int,2]
> ok 102 - $ArrayOfAtLeastTwoInts has no type_default
> ok 103 - '$ArrayOfRounded' isa 'Type::Tiny'
> ok 104 - $ArrayOfRounded has correct display_name
> ok 105 - $ArrayOfRounded has no name
> ok 106 - $ArrayOfRounded can be inlined
> ok 107 - Inlining $ArrayOfRounded doesn't throw an exception
> ok 108 - $ArrayOfRounded has a coercion
> ok 109 - $ArrayRefOfRounded can coerce from ArrayRef
> ok 110 - $ArrayRefOfRounded can coerce from ArrayRef[Num]
> ok 111 - $ArrayOfRounded is not parameterizable
> ok 112 - ArrayRef subtype: ArrayRef[Int]
> ok 113 - Value "1" fails type constraint ArrayRef[Int]
> ok 114 - Reference {} fails type constraint ArrayRef[Int]
> ok 115 - Reference [] passes type constraint ArrayRef[Int]
> ok 116 - Reference [[]] fails type constraint ArrayRef[Int]
> ok 117 - Reference ["1.1"] fails type constraint ArrayRef[Int]
> ok 118 - Reference [1] passes type constraint ArrayRef[Int]
> ok 119 - Reference [0] passes type constraint ArrayRef[Int]
> ok 120 - Reference [-1] passes type constraint ArrayRef[Int]
> ok 121 - Reference [\1] fails type constraint ArrayRef[Int]
> ok 122 - Reference [1,2] passes type constraint ArrayRef[Int]
> ok 123 - Reference [1,[]] fails type constraint ArrayRef[Int]
> ok 124 - just returned orig unchanged
> ok 125 - coercion happened
> ok 126 - ... and data looks good
> ok 127 - ... and now passes type constraint
> ok 128 - coercion failed, so orig was returned
> ok 129 - Reference [[]] fails type constraint ArrayRef[Int]
> ok 130 - tied array that should pass
> ok 131 - tied array that should fail
> ok 132 - overloaded object yielding regular array that would pass if it weren't for the interleving overloaded object
> ok 133 - overloaded object yielding regular array that should fail
> ok 134 - overloaded object yielding tied array that would pass if it weren't for the interleving overloaded object
> ok 135 - overloaded object yielding tied array that should fail
> 1..135
> ok
> t/21-types/Bool.t ............................................
> ok 1 - 'Bool' isa 'Type::Tiny'
> ok 2 - Bool has correct name
> ok 3 - Bool has correct display_name
> ok 4 - Bool knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Bool
> ok 6 - Bool is not deprecated
> ok 7 - Bool is not anonymous
> ok 8 - Bool can be inlined
> ok 9 - Inlining Bool doesn't throw an exception
> ok 10 - Bool has a coercion
> ok 11 - Bool isn't parameterizable
> ok 12 - Bool has a type_default
> ok 13 - Bool type_default is false
> ok 14 - Undef should pass Bool
> ok 15 - False should pass Bool
> ok 16 - True should pass Bool
> ok 17 - Zero should pass Bool
> ok 18 - One should pass Bool
> ok 19 - Negative one should fail Bool
> ok 20 - Non integer should fail Bool
> ok 21 - Empty string should pass Bool
> ok 22 - Whitespace should fail Bool
> ok 23 - Line break should fail Bool
> ok 24 - Random string should fail Bool
> ok 25 - Loaded package name should fail Bool
> ok 26 - Unloaded package name should fail Bool
> ok 27 - A reference to undef should fail Bool
> ok 28 - A reference to false should fail Bool
> ok 29 - A reference to true should fail Bool
> ok 30 - A reference to zero should fail Bool
> ok 31 - A reference to one should fail Bool
> ok 32 - A reference to empty string should fail Bool
> ok 33 - A reference to random string should fail Bool
> ok 34 - Blessed scalarref should fail Bool
> ok 35 - Empty arrayref should fail Bool
> ok 36 - Arrayref with one zero should fail Bool
> ok 37 - Arrayref of integers should fail Bool
> ok 38 - Arrayref of numbers should fail Bool
> ok 39 - Blessed arrayref should fail Bool
> ok 40 - Empty hashref should fail Bool
> ok 41 - Hashref should fail Bool
> ok 42 - Blessed hashref should fail Bool
> ok 43 - Coderef should fail Bool
> ok 44 - Blessed coderef should fail Bool
> ok 45 - Glob should fail Bool
> ok 46 - Globref should fail Bool
> ok 47 - Blessed globref should fail Bool
> ok 48 - Regexp should fail Bool
> ok 49 - Blessed regexp should fail Bool
> ok 50 - Filehandle should fail Bool
> ok 51 - Filehandle object should fail Bool
> ok 52 - Ref to scalarref should fail Bool
> ok 53 - Ref to arrayref should fail Bool
> ok 54 - Ref to hashref should fail Bool
> ok 55 - Ref to coderef should fail Bool
> ok 56 - Ref to blessed hashref should fail Bool
> ok 57 - Object stringifying to "" should fail Bool
> ok 58 - Object stringifying to "1" should fail Bool
> ok 59 - Object numifying to 0 should fail Bool
> ok 60 - Object numifying to 1 should fail Bool
> ok 61 - Object overloading arrayref should fail Bool
> ok 62 - Object overloading hashref should fail Bool
> ok 63 - Object overloading coderef should fail Bool
> ok 64 - Object booling to false should fail Bool
> ok 65 - Object booling to true should fail Bool
> ok 66 - Bool coerced undef successfully
> ok 67 - Bool coerced undef to false
> ok 68 - Bool coerced false successfully
> ok 69 - Bool coerced false to false
> ok 70 - Bool coerced true successfully
> ok 71 - Bool coerced true to true
> ok 72 - Bool coerced zero successfully
> ok 73 - Bool coerced zero to false
> ok 74 - Bool coerced one successfully
> ok 75 - Bool coerced one to true
> ok 76 - Bool coerced negative one successfully
> ok 77 - Bool coerced negative one to true
> ok 78 - Bool coerced non integer successfully
> ok 79 - Bool coerced non integer to true
> ok 80 - Bool coerced empty string successfully
> ok 81 - Bool coerced empty string to false
> ok 82 - Bool coerced whitespace successfully
> ok 83 - Bool coerced whitespace to true
> ok 84 - Bool coerced line break successfully
> ok 85 - Bool coerced line break to true
> ok 86 - Bool coerced random string successfully
> ok 87 - Bool coerced random string to true
> ok 88 - Bool coerced loaded package name successfully
> ok 89 - Bool coerced loaded package name to true
> ok 90 - Bool coerced unloaded package name successfully
> ok 91 - Bool coerced unloaded package name to true
> ok 92 - Bool coerced a reference to undef successfully
> ok 93 - Bool coerced a reference to undef to true
> ok 94 - Bool coerced a reference to false successfully
> ok 95 - Bool coerced a reference to false to true
> ok 96 - Bool coerced a reference to true successfully
> ok 97 - Bool coerced a reference to true to true
> ok 98 - Bool coerced a reference to zero successfully
> ok 99 - Bool coerced a reference to zero to true
> ok 100 - Bool coerced a reference to one successfully
> ok 101 - Bool coerced a reference to one to true
> ok 102 - Bool coerced a reference to empty string successfully
> ok 103 - Bool coerced a reference to empty string to true
> ok 104 - Bool coerced a reference to random string successfully
> ok 105 - Bool coerced a reference to random string to true
> ok 106 - Bool coerced blessed scalarref successfully
> ok 107 - Bool coerced blessed scalarref to true
> ok 108 - Bool coerced empty arrayref successfully
> ok 109 - Bool coerced empty arrayref to true
> ok 110 - Bool coerced arrayref with one zero successfully
> ok 111 - Bool coerced arrayref with one zero to true
> ok 112 - Bool coerced arrayref of integers successfully
> ok 113 - Bool coerced arrayref of integers to true
> ok 114 - Bool coerced arrayref of numbers successfully
> ok 115 - Bool coerced arrayref of numbers to true
> ok 116 - Bool coerced blessed arrayref successfully
> ok 117 - Bool coerced blessed arrayref to true
> ok 118 - Bool coerced empty hashref successfully
> ok 119 - Bool coerced empty hashref to true
> ok 120 - Bool coerced hashref successfully
> ok 121 - Bool coerced hashref to true
> ok 122 - Bool coerced blessed hashref successfully
> ok 123 - Bool coerced blessed hashref to true
> ok 124 - Bool coerced coderef successfully
> ok 125 - Bool coerced coderef to true
> ok 126 - Bool coerced blessed coderef successfully
> ok 127 - Bool coerced blessed coderef to true
> ok 128 - Bool coerced glob successfully
> ok 129 - Bool coerced glob to true
> ok 130 - Bool coerced globref successfully
> ok 131 - Bool coerced globref to true
> ok 132 - Bool coerced blessed globref successfully
> ok 133 - Bool coerced blessed globref to true
> ok 134 - Bool coerced regexp successfully
> ok 135 - Bool coerced regexp to true
> ok 136 - Bool coerced blessed regexp successfully
> ok 137 - Bool coerced blessed regexp to true
> ok 138 - Bool coerced filehandle successfully
> ok 139 - Bool coerced filehandle to true
> ok 140 - Bool coerced filehandle object successfully
> ok 141 - Bool coerced filehandle object to true
> ok 142 - Bool coerced ref to scalarref successfully
> ok 143 - Bool coerced ref to scalarref to true
> ok 144 - Bool coerced ref to arrayref successfully
> ok 145 - Bool coerced ref to arrayref to true
> ok 146 - Bool coerced ref to hashref successfully
> ok 147 - Bool coerced ref to hashref to true
> ok 148 - Bool coerced ref to coderef successfully
> ok 149 - Bool coerced ref to coderef to true
> ok 150 - Bool coerced ref to blessed hashref successfully
> ok 151 - Bool coerced ref to blessed hashref to true
> ok 152 - Bool coerced object stringifying to "" successfully
> ok 153 - Bool coerced object stringifying to "" to true
> ok 154 - Bool coerced object stringifying to "1" successfully
> ok 155 - Bool coerced object stringifying to "1" to true
> ok 156 - Bool coerced object boolifying to false successfully
> ok 157 - Bool coerced object boolifying to false to false
> ok 158 - Bool coerced object boolifying to true successfully
> ok 159 - Bool coerced object boolifying to true to true
> ok 160 - Bool coerced object numifying to 0 successfully
> ok 161 - Bool coerced object numifying to 0 to true
> ok 162 - Bool coerced object numifying to 1 successfully
> ok 163 - Bool coerced object numifying to 1 to true
> ok 164 - Bool coerced object overloading arrayref successfully
> ok 165 - Bool coerced object overloading arrayref to true
> ok 166 - Bool coerced object overloading hashref successfully
> ok 167 - Bool coerced object overloading hashref to true
> ok 168 - Bool coerced object overloading coderef successfully
> ok 169 - Bool coerced object overloading coderef to true
> ok 170 - JSON::PP::true does NOT pass Bool
> ok 171 - JSON::PP::false does NOT pass Bool
> ok 172 - Bool coerced JSON::PP::true and JSON::PP::false
> ok 173 - Bool coerced JSON::PP::true to true
> ok 174 - Bool coerced JSON::PP::false to false
> 1..174
> ok
> t/21-types/BoolLike.t ........................................
> ok 1 - 'BoolLike' isa 'Type::Tiny'
> ok 2 - BoolLike has correct name
> ok 3 - BoolLike has correct display_name
> ok 4 - BoolLike knows it is in the Types::TypeTiny library
> ok 5 - Types::TypeTiny knows it has type BoolLike
> ok 6 - BoolLike is not deprecated
> ok 7 - BoolLike is not anonymous
> ok 8 - BoolLike can be inlined
> ok 9 - Inlining BoolLike doesn't throw an exception
> ok 10 - BoolLike has no coercion
> ok 11 - BoolLike isn't parameterizable
> ok 12 - BoolLike has a type_default
> ok 13 - BoolLike type_default is false
> ok 14 - Undef should pass Bool
> ok 15 - False should pass Bool
> ok 16 - True should pass Bool
> ok 17 - Zero should pass Bool
> ok 18 - One should pass Bool
> ok 19 - Negative one should fail Bool
> ok 20 - Non integer should fail Bool
> ok 21 - Empty string should pass Bool
> ok 22 - Whitespace should fail Bool
> ok 23 - Line break should fail Bool
> ok 24 - Random string should fail Bool
> ok 25 - Loaded package name should fail Bool
> ok 26 - Unloaded package name should fail Bool
> ok 27 - A reference to undef should fail Bool
> ok 28 - A reference to false should fail Bool
> ok 29 - A reference to true should fail Bool
> ok 30 - A reference to zero should fail Bool
> ok 31 - A reference to one should fail Bool
> ok 32 - A reference to empty string should fail Bool
> ok 33 - A reference to random string should fail Bool
> ok 34 - Blessed scalarref should fail Bool
> ok 35 - Empty arrayref should fail Bool
> ok 36 - Arrayref with one zero should fail Bool
> ok 37 - Arrayref of integers should fail Bool
> ok 38 - Arrayref of numbers should fail Bool
> ok 39 - Blessed arrayref should fail Bool
> ok 40 - Empty hashref should fail Bool
> ok 41 - Hashref should fail Bool
> ok 42 - Blessed hashref should fail Bool
> ok 43 - Coderef should fail Bool
> ok 44 - Blessed coderef should fail Bool
> ok 45 - Glob should fail Bool
> ok 46 - Globref should fail Bool
> ok 47 - Blessed globref should fail Bool
> ok 48 - Regexp should fail Bool
> ok 49 - Blessed regexp should fail Bool
> ok 50 - Filehandle should fail Bool
> ok 51 - Filehandle object should fail Bool
> ok 52 - Ref to scalarref should fail Bool
> ok 53 - Ref to arrayref should fail Bool
> ok 54 - Ref to hashref should fail Bool
> ok 55 - Ref to coderef should fail Bool
> ok 56 - Ref to blessed hashref should fail Bool
> ok 57 - Object stringifying to "" should fail Bool
> ok 58 - Object stringifying to "1" should fail Bool
> ok 59 - Object numifying to 0 should pass Bool
> ok 60 - Object numifying to 1 should pass Bool
> ok 61 - Object overloading arrayref should fail Bool
> ok 62 - Object overloading hashref should fail Bool
> ok 63 - Object overloading coderef should fail Bool
> ok 64 - Object booling to false should pass Bool
> ok 65 - Object booling to true should pass Bool
> 1..65
> ok
> t/21-types/ClassName.t .......................................
> ok 1 - 'ClassName' isa 'Type::Tiny'
> ok 2 - ClassName has correct name
> ok 3 - ClassName has correct display_name
> ok 4 - ClassName knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type ClassName
> ok 6 - ClassName is not deprecated
> ok 7 - ClassName is not anonymous
> ok 8 - ClassName can be inlined
> ok 9 - Inlining ClassName doesn't throw an exception
> ok 10 - ClassName doesn't have a coercion
> ok 11 - ClassName isn't parameterizable
> ok 12 - ClassName has no type_default
> ok 13 - Undef should fail ClassName
> ok 14 - False should fail ClassName
> ok 15 - True should fail ClassName
> ok 16 - Zero should fail ClassName
> ok 17 - One should fail ClassName
> ok 18 - Negative one should fail ClassName
> ok 19 - Non integer should fail ClassName
> ok 20 - Empty string should fail ClassName
> ok 21 - Whitespace should fail ClassName
> ok 22 - Line break should fail ClassName
> ok 23 - Random string should fail ClassName
> ok 24 - Loaded package name should pass ClassName
> ok 25 - Unloaded package name should fail ClassName
> ok 26 - A reference to undef should fail ClassName
> ok 27 - A reference to false should fail ClassName
> ok 28 - A reference to true should fail ClassName
> ok 29 - A reference to zero should fail ClassName
> ok 30 - A reference to one should fail ClassName
> ok 31 - A reference to empty string should fail ClassName
> ok 32 - A reference to random string should fail ClassName
> ok 33 - Blessed scalarref should fail ClassName
> ok 34 - Empty arrayref should fail ClassName
> ok 35 - Arrayref with one zero should fail ClassName
> ok 36 - Arrayref of integers should fail ClassName
> ok 37 - Arrayref of numbers should fail ClassName
> ok 38 - Blessed arrayref should fail ClassName
> ok 39 - Empty hashref should fail ClassName
> ok 40 - Hashref should fail ClassName
> ok 41 - Blessed hashref should fail ClassName
> ok 42 - Coderef should fail ClassName
> ok 43 - Blessed coderef should fail ClassName
> ok 44 - Glob should fail ClassName
> ok 45 - Globref should fail ClassName
> ok 46 - Blessed globref should fail ClassName
> ok 47 - Regexp should fail ClassName
> ok 48 - Blessed regexp should fail ClassName
> ok 49 - Filehandle should fail ClassName
> ok 50 - Filehandle object should fail ClassName
> ok 51 - Ref to scalarref should fail ClassName
> ok 52 - Ref to arrayref should fail ClassName
> ok 53 - Ref to hashref should fail ClassName
> ok 54 - Ref to coderef should fail ClassName
> ok 55 - Ref to blessed hashref should fail ClassName
> ok 56 - Object stringifying to "" should fail ClassName
> ok 57 - Object stringifying to "1" should fail ClassName
> ok 58 - Object numifying to 0 should fail ClassName
> ok 59 - Object numifying to 1 should fail ClassName
> ok 60 - Object overloading arrayref should fail ClassName
> ok 61 - Object overloading hashref should fail ClassName
> ok 62 - Object overloading coderef should fail ClassName
> ok 63 - Object booling to false should fail ClassName
> ok 64 - Object booling to true should fail ClassName
> ok 65 - Value "Local::Class::Moo" passes type constraint ClassName
> ok 66 - Value "Local::Class::Moose" passes type constraint ClassName
> ok 67 - Value "Local::Class::Mouse" passes type constraint ClassName
> ok 68 - Value "Local::Role::RoleTiny" passes type constraint ClassName
> ok 69 - Value "Local::Role::MooRole" passes type constraint ClassName
> ok 70 - Value "Local::Role::MooseRole" passes type constraint ClassName
> ok 71 - Value "Local::Role::MouseRole" passes type constraint ClassName
> ok 72 - Value "Local::Random::Package::One" passes type constraint ClassName
> ok 73 - Value "Local::Random::Package::Two" passes type constraint ClassName
> ok 74 - Value "Local::Random::Package::Three" fails type constraint ClassName
> 1..74
> ok
> t/21-types/CodeLike.t ........................................
> ok 1 - 'CodeLike' isa 'Type::Tiny'
> ok 2 - CodeLike has correct name
> ok 3 - CodeLike has correct display_name
> ok 4 - CodeLike knows it is in the Types::TypeTiny library
> ok 5 - Types::TypeTiny knows it has type CodeLike
> ok 6 - CodeLike is not deprecated
> ok 7 - CodeLike is not anonymous
> ok 8 - CodeLike can be inlined
> ok 9 - Inlining CodeLike doesn't throw an exception
> ok 10 - CodeLike doesn't have a coercion
> ok 11 - CodeLike isn't parameterizable
> ok 12 - CodeLike has a type_default
> ok 13 - CodeLike type_default is sub {}
> ok 14 - Undef should fail CodeLike
> ok 15 - False should fail CodeLike
> ok 16 - True should fail CodeLike
> ok 17 - Zero should fail CodeLike
> ok 18 - One should fail CodeLike
> ok 19 - Negative one should fail CodeLike
> ok 20 - Non integer should fail CodeLike
> ok 21 - Empty string should fail CodeLike
> ok 22 - Whitespace should fail CodeLike
> ok 23 - Line break should fail CodeLike
> ok 24 - Random string should fail CodeLike
> ok 25 - Loaded package name should fail CodeLike
> ok 26 - Unloaded package name should fail CodeLike
> ok 27 - A reference to undef should fail CodeLike
> ok 28 - A reference to false should fail CodeLike
> ok 29 - A reference to true should fail CodeLike
> ok 30 - A reference to zero should fail CodeLike
> ok 31 - A reference to one should fail CodeLike
> ok 32 - A reference to empty string should fail CodeLike
> ok 33 - A reference to random string should fail CodeLike
> ok 34 - Blessed scalarref should fail CodeLike
> ok 35 - Empty arrayref should fail CodeLike
> ok 36 - Arrayref with one zero should fail CodeLike
> ok 37 - Arrayref of integers should fail CodeLike
> ok 38 - Arrayref of numbers should fail CodeLike
> ok 39 - Blessed arrayref should fail CodeLike
> ok 40 - Empty hashref should fail CodeLike
> ok 41 - Hashref should fail CodeLike
> ok 42 - Blessed hashref should fail CodeLike
> ok 43 - Coderef should pass CodeLike
> ok 44 - Blessed coderef should fail CodeLike
> ok 45 - Glob should fail CodeLike
> ok 46 - Globref should fail CodeLike
> ok 47 - Blessed globref should fail CodeLike
> ok 48 - Regexp should fail CodeLike
> ok 49 - Blessed regexp should fail CodeLike
> ok 50 - Filehandle should fail CodeLike
> ok 51 - Filehandle object should fail CodeLike
> ok 52 - Ref to scalarref should fail CodeLike
> ok 53 - Ref to arrayref should fail CodeLike
> ok 54 - Ref to hashref should fail CodeLike
> ok 55 - Ref to coderef should fail CodeLike
> ok 56 - Ref to blessed hashref should fail CodeLike
> ok 57 - Object stringifying to "" should fail CodeLike
> ok 58 - Object stringifying to "1" should fail CodeLike
> ok 59 - Object numifying to 0 should fail CodeLike
> ok 60 - Object numifying to 1 should fail CodeLike
> ok 61 - Object overloading arrayref should fail CodeLike
> ok 62 - Object overloading hashref should fail CodeLike
> ok 63 - Object overloading coderef should pass CodeLike
> ok 64 - Object booling to false should fail CodeLike
> ok 65 - Object booling to true should fail CodeLike
> 1..65
> ok
> t/21-types/CodeRef.t .........................................
> ok 1 - 'CodeRef' isa 'Type::Tiny'
> ok 2 - CodeRef has correct name
> ok 3 - CodeRef has correct display_name
> ok 4 - CodeRef knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type CodeRef
> ok 6 - CodeRef is not deprecated
> ok 7 - CodeRef is not anonymous
> ok 8 - CodeRef can be inlined
> ok 9 - Inlining CodeRef doesn't throw an exception
> ok 10 - CodeRef doesn't have a coercion
> ok 11 - CodeRef isn't parameterizable
> ok 12 - CodeRef has a type_default
> ok 13 - CodeRef type_default is sub {}
> ok 14 - Undef should fail CodeRef
> ok 15 - False should fail CodeRef
> ok 16 - True should fail CodeRef
> ok 17 - Zero should fail CodeRef
> ok 18 - One should fail CodeRef
> ok 19 - Negative one should fail CodeRef
> ok 20 - Non integer should fail CodeRef
> ok 21 - Empty string should fail CodeRef
> ok 22 - Whitespace should fail CodeRef
> ok 23 - Line break should fail CodeRef
> ok 24 - Random string should fail CodeRef
> ok 25 - Loaded package name should fail CodeRef
> ok 26 - Unloaded package name should fail CodeRef
> ok 27 - A reference to undef should fail CodeRef
> ok 28 - A reference to false should fail CodeRef
> ok 29 - A reference to true should fail CodeRef
> ok 30 - A reference to zero should fail CodeRef
> ok 31 - A reference to one should fail CodeRef
> ok 32 - A reference to empty string should fail CodeRef
> ok 33 - A reference to random string should fail CodeRef
> ok 34 - Blessed scalarref should fail CodeRef
> ok 35 - Empty arrayref should fail CodeRef
> ok 36 - Arrayref with one zero should fail CodeRef
> ok 37 - Arrayref of integers should fail CodeRef
> ok 38 - Arrayref of numbers should fail CodeRef
> ok 39 - Blessed arrayref should fail CodeRef
> ok 40 - Empty hashref should fail CodeRef
> ok 41 - Hashref should fail CodeRef
> ok 42 - Blessed hashref should fail CodeRef
> ok 43 - Coderef should pass CodeRef
> ok 44 - Blessed coderef should fail CodeRef
> ok 45 - Glob should fail CodeRef
> ok 46 - Globref should fail CodeRef
> ok 47 - Blessed globref should fail CodeRef
> ok 48 - Regexp should fail CodeRef
> ok 49 - Blessed regexp should fail CodeRef
> ok 50 - Filehandle should fail CodeRef
> ok 51 - Filehandle object should fail CodeRef
> ok 52 - Ref to scalarref should fail CodeRef
> ok 53 - Ref to arrayref should fail CodeRef
> ok 54 - Ref to hashref should fail CodeRef
> ok 55 - Ref to coderef should fail CodeRef
> ok 56 - Ref to blessed hashref should fail CodeRef
> ok 57 - Object stringifying to "" should fail CodeRef
> ok 58 - Object stringifying to "1" should fail CodeRef
> ok 59 - Object numifying to 0 should fail CodeRef
> ok 60 - Object numifying to 1 should fail CodeRef
> ok 61 - Object overloading arrayref should fail CodeRef
> ok 62 - Object overloading hashref should fail CodeRef
> ok 63 - Object overloading coderef should fail CodeRef
> ok 64 - Object booling to false should fail CodeRef
> ok 65 - Object booling to true should fail CodeRef
> 1..65
> ok
> t/21-types/ConsumerOf.t ......................................
> ok 1 - 'ConsumerOf' isa 'Type::Tiny'
> ok 2 - ConsumerOf has correct name
> ok 3 - ConsumerOf has correct display_name
> ok 4 - ConsumerOf knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type ConsumerOf
> ok 6 - ConsumerOf is not deprecated
> ok 7 - ConsumerOf is not anonymous
> ok 8 - ConsumerOf can be inlined
> ok 9 - Inlining ConsumerOf doesn't throw an exception
> ok 10 - ConsumerOf doesn't have a coercion
> ok 11 - ConsumerOf is parameterizable
> ok 12 - ConsumerOf has no type_default
> ok 13 - Undef should fail ConsumerOf
> ok 14 - False should fail ConsumerOf
> ok 15 - True should fail ConsumerOf
> ok 16 - Zero should fail ConsumerOf
> ok 17 - One should fail ConsumerOf
> ok 18 - Negative one should fail ConsumerOf
> ok 19 - Non integer should fail ConsumerOf
> ok 20 - Empty string should fail ConsumerOf
> ok 21 - Whitespace should fail ConsumerOf
> ok 22 - Line break should fail ConsumerOf
> ok 23 - Random string should fail ConsumerOf
> ok 24 - Loaded package name should fail ConsumerOf
> ok 25 - Unloaded package name should fail ConsumerOf
> ok 26 - A reference to undef should fail ConsumerOf
> ok 27 - A reference to false should fail ConsumerOf
> ok 28 - A reference to true should fail ConsumerOf
> ok 29 - A reference to zero should fail ConsumerOf
> ok 30 - A reference to one should fail ConsumerOf
> ok 31 - A reference to empty string should fail ConsumerOf
> ok 32 - A reference to random string should fail ConsumerOf
> ok 33 - Blessed scalarref should pass ConsumerOf
> ok 34 - Empty arrayref should fail ConsumerOf
> ok 35 - Arrayref with one zero should fail ConsumerOf
> ok 36 - Arrayref of integers should fail ConsumerOf
> ok 37 - Arrayref of numbers should fail ConsumerOf
> ok 38 - Blessed arrayref should pass ConsumerOf
> ok 39 - Empty hashref should fail ConsumerOf
> ok 40 - Hashref should fail ConsumerOf
> ok 41 - Blessed hashref should pass ConsumerOf
> ok 42 - Coderef should fail ConsumerOf
> ok 43 - Blessed coderef should pass ConsumerOf
> ok 44 - Glob should fail ConsumerOf
> ok 45 - Globref should fail ConsumerOf
> ok 46 - Blessed globref should pass ConsumerOf
> # UNDEFINED OUTCOME: regexp
> ok 47 - Blessed regexp should pass ConsumerOf
> ok 48 - Filehandle should fail ConsumerOf
> ok 49 - Filehandle object should pass ConsumerOf
> ok 50 - Ref to scalarref should fail ConsumerOf
> ok 51 - Ref to arrayref should fail ConsumerOf
> ok 52 - Ref to hashref should fail ConsumerOf
> ok 53 - Ref to coderef should fail ConsumerOf
> ok 54 - Ref to blessed hashref should fail ConsumerOf
> ok 55 - Object stringifying to "" should pass ConsumerOf
> ok 56 - Object stringifying to "1" should pass ConsumerOf
> ok 57 - Object numifying to 0 should pass ConsumerOf
> ok 58 - Object numifying to 1 should pass ConsumerOf
> ok 59 - Object overloading arrayref should pass ConsumerOf
> ok 60 - Object overloading hashref should pass ConsumerOf
> ok 61 - Object overloading coderef should pass ConsumerOf
> ok 62 - Object booling to false should pass ConsumerOf
> ok 63 - Object booling to true should pass ConsumerOf
> ok 64 - Reference bless( {"coercion" => bless( {"_compiled_type_constraint_che...) passes type constraint ConsumerOf["Type::Tiny::Role"]
> ok 65 - Reference bless( {"coercion" => bless( {"_compiled_type_constraint_che...) passes type constraint ConsumerOf["Type::Tiny"]
> ok 66 - Reference bless( [], 'Foo::Bar' ) passes type constraint ConsumerOf["Foo::Bar"]
> ok 67 - Reference bless( [], 'Foo::Bar' ) passes type constraint ConsumerOf["Foo"]
> ok 68 - Reference bless( [], 'Foo' ) fails type constraint ConsumerOf["Foo::Bar"]
> ok 69 - Reference bless( [], 'Foo' ) passes type constraint ConsumerOf["Foo"]
> ok 70 - Reference bless( {"coercion" => bless( {"_compiled_type_constraint_che...) passes type constraint ConsumerOf["Type::Tiny::Intersection"]
> ok 71 - Reference bless( {"coercion" => bless( {"_compiled_type_constraint_che...) passes type constraint ConsumerOf["Type::Tiny"]
> ok 72
> ok 73 - Reference bless( {"compiled_type_constraint" => sub { "DUMMY" },"defin...) passes type constraint ConsumerOf["Type::Tiny::Role"]
> ok 74 - Reference bless( {"compiled_type_constraint" => sub { "DUMMY" },"defin...) passes type constraint ConsumerOf["Type::Tiny::Role"]
> ok 75 - Reference bless( [], 'MyConsumer' ) passes type constraint ConsumerOf["Foo","Bar"]
> ok 76 - Reference bless( {}, 'My::MooClass' ) passes type constraint ConsumerOf["My::MooRole"]
> ok 77 - Reference bless( {}, 'My::MooClass' ) passes type constraint ConsumerOf["My::MooClass"]
> ok 78 - Reference bless( {}, 'My::MooseClass' ) passes type constraint ConsumerOf["My::MooseRole"]
> ok 79 - Reference bless( {}, 'My::MooseClass' ) passes type constraint ConsumerOf["My::MooseClass"]
> ok 80 - Reference bless( {}, 'My::MouseClass' ) passes type constraint ConsumerOf["My::MouseRole"]
> ok 81 - Reference bless( {}, 'My::MouseClass' ) passes type constraint ConsumerOf["My::MouseClass"]
> 1..81
> ok
> t/21-types/CycleTuple.t ......................................
> ok 1 - 'CycleTuple' isa 'Type::Tiny'
> ok 2 - CycleTuple has correct name
> ok 3 - CycleTuple has correct display_name
> ok 4 - CycleTuple knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type CycleTuple
> ok 6 - CycleTuple is not deprecated
> ok 7 - CycleTuple is not anonymous
> ok 8 - CycleTuple can be inlined
> ok 9 - Inlining CycleTuple doesn't throw an exception
> ok 10 - CycleTuple doesn't have a coercion
> ok 11 - CycleTuple is parameterizable
> ok 12 - CycleTuple has a type_default
> ok 13 - CycleTuple type_default is []
> ok 14 - Undef should fail CycleTuple
> ok 15 - False should fail CycleTuple
> ok 16 - True should fail CycleTuple
> ok 17 - Zero should fail CycleTuple
> ok 18 - One should fail CycleTuple
> ok 19 - Negative one should fail CycleTuple
> ok 20 - Non integer should fail CycleTuple
> ok 21 - Empty string should fail CycleTuple
> ok 22 - Whitespace should fail CycleTuple
> ok 23 - Line break should fail CycleTuple
> ok 24 - Random string should fail CycleTuple
> ok 25 - Loaded package name should fail CycleTuple
> ok 26 - Unloaded package name should fail CycleTuple
> ok 27 - A reference to undef should fail CycleTuple
> ok 28 - A reference to false should fail CycleTuple
> ok 29 - A reference to true should fail CycleTuple
> ok 30 - A reference to zero should fail CycleTuple
> ok 31 - A reference to one should fail CycleTuple
> ok 32 - A reference to empty string should fail CycleTuple
> ok 33 - A reference to random string should fail CycleTuple
> ok 34 - Blessed scalarref should fail CycleTuple
> ok 35 - Empty arrayref should pass CycleTuple
> ok 36 - Arrayref with one zero should pass CycleTuple
> ok 37 - Arrayref of integers should pass CycleTuple
> ok 38 - Arrayref of numbers should pass CycleTuple
> ok 39 - Blessed arrayref should fail CycleTuple
> ok 40 - Empty hashref should fail CycleTuple
> ok 41 - Hashref should fail CycleTuple
> ok 42 - Blessed hashref should fail CycleTuple
> ok 43 - Coderef should fail CycleTuple
> ok 44 - Blessed coderef should fail CycleTuple
> ok 45 - Glob should fail CycleTuple
> ok 46 - Globref should fail CycleTuple
> ok 47 - Blessed globref should fail CycleTuple
> ok 48 - Regexp should fail CycleTuple
> ok 49 - Blessed regexp should fail CycleTuple
> ok 50 - Filehandle should fail CycleTuple
> ok 51 - Filehandle object should fail CycleTuple
> ok 52 - Ref to scalarref should fail CycleTuple
> ok 53 - Ref to arrayref should fail CycleTuple
> ok 54 - Ref to hashref should fail CycleTuple
> ok 55 - Ref to coderef should fail CycleTuple
> ok 56 - Ref to blessed hashref should fail CycleTuple
> ok 57 - Object stringifying to "" should fail CycleTuple
> ok 58 - Object stringifying to "1" should fail CycleTuple
> ok 59 - Object numifying to 0 should fail CycleTuple
> ok 60 - Object numifying to 1 should fail CycleTuple
> ok 61 - Object overloading arrayref should fail CycleTuple
> ok 62 - Object overloading hashref should fail CycleTuple
> ok 63 - Object overloading coderef should fail CycleTuple
> ok 64 - Object booling to false should fail CycleTuple
> ok 65 - Object booling to true should fail CycleTuple
> ok 66 - Reference [1,{},qr//] passes type constraint CycleTuple[Int,HashRef,RegexpRef]
> ok 67 - Reference [1,{},qr//,2,{},qr//] passes type constraint CycleTuple[Int,HashRef,RegexpRef]
> ok 68 - Reference [1,{},qr//,2,{},qr//,3,{},qr//] passes type constraint CycleTuple[Int,HashRef,RegexpRef]
> ok 69 - Reference [1,{},qr//,2,{},qr//,3,{},qr//,4,{},qr//] passes type constraint CycleTuple[Int,HashRef,RegexpRef]
> ok 70 - Reference [1,{},qr//,2,{},qr//,3,{},qr//,4,{}] fails type constraint CycleTuple[Int,HashRef,RegexpRef]
> ok 71 - Reference [1,{},qr//,2,{},qr//,3,{},qr//,4,{},[]] fails type constraint CycleTuple[Int,HashRef,RegexpRef]
> ok 72
> ok 73
> ok 74
> ok 75 - Reference [] passes type constraint CycleTuple[Int,HashRef,RegexpRef]
> ok 76 - Reference [] fails type constraint __ANON__
> ok 77 - Reference [] fails type constraint ArrayRef[Any,1]&CycleTuple[Int,HashRef,RegexpRef]
> ok 78 - correct exception
> ok 79 - coercion worked
> 1..79
> ok
> t/21-types/Defined.t .........................................
> ok 1 - 'Defined' isa 'Type::Tiny'
> ok 2 - Defined has correct name
> ok 3 - Defined has correct display_name
> ok 4 - Defined knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Defined
> ok 6 - Defined is not deprecated
> ok 7 - Defined is not anonymous
> ok 8 - Defined can be inlined
> ok 9 - Inlining Defined doesn't throw an exception
> ok 10 - Defined doesn't have a coercion
> ok 11 - Defined isn't parameterizable
> ok 12 - Defined has no type_default
> ok 13 - Undef should fail Defined
> ok 14 - False should pass Defined
> ok 15 - True should pass Defined
> ok 16 - Zero should pass Defined
> ok 17 - One should pass Defined
> ok 18 - Negative one should pass Defined
> ok 19 - Non integer should pass Defined
> ok 20 - Empty string should pass Defined
> ok 21 - Whitespace should pass Defined
> ok 22 - Line break should pass Defined
> ok 23 - Random string should pass Defined
> ok 24 - Loaded package name should pass Defined
> ok 25 - Unloaded package name should pass Defined
> ok 26 - A reference to undef should pass Defined
> ok 27 - A reference to false should pass Defined
> ok 28 - A reference to true should pass Defined
> ok 29 - A reference to zero should pass Defined
> ok 30 - A reference to one should pass Defined
> ok 31 - A reference to empty string should pass Defined
> ok 32 - A reference to random string should pass Defined
> ok 33 - Blessed scalarref should pass Defined
> ok 34 - Empty arrayref should pass Defined
> ok 35 - Arrayref with one zero should pass Defined
> ok 36 - Arrayref of integers should pass Defined
> ok 37 - Arrayref of numbers should pass Defined
> ok 38 - Blessed arrayref should pass Defined
> ok 39 - Empty hashref should pass Defined
> ok 40 - Hashref should pass Defined
> ok 41 - Blessed hashref should pass Defined
> ok 42 - Coderef should pass Defined
> ok 43 - Blessed coderef should pass Defined
> ok 44 - Glob should pass Defined
> ok 45 - Globref should pass Defined
> ok 46 - Blessed globref should pass Defined
> ok 47 - Regexp should pass Defined
> ok 48 - Blessed regexp should pass Defined
> ok 49 - Filehandle should pass Defined
> ok 50 - Filehandle object should pass Defined
> ok 51 - Ref to scalarref should pass Defined
> ok 52 - Ref to arrayref should pass Defined
> ok 53 - Ref to hashref should pass Defined
> ok 54 - Ref to coderef should pass Defined
> ok 55 - Ref to blessed hashref should pass Defined
> ok 56 - Object stringifying to "" should pass Defined
> ok 57 - Object stringifying to "1" should pass Defined
> ok 58 - Object numifying to 0 should pass Defined
> ok 59 - Object numifying to 1 should pass Defined
> ok 60 - Object overloading arrayref should pass Defined
> ok 61 - Object overloading hashref should pass Defined
> ok 62 - Object overloading coderef should pass Defined
> ok 63 - Object booling to false should pass Defined
> ok 64 - Object booling to true should pass Defined
> ok 65 - The complement of Defined is Undef
> 1..65
> ok
> t/21-types/DelimitedStr.t ....................................
> ok 1 - 'DelimitedStr' isa 'Type::Tiny'
> ok 2 - DelimitedStr has correct name
> ok 3 - DelimitedStr has correct display_name
> ok 4 - DelimitedStr knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type DelimitedStr
> ok 6 - DelimitedStr is not deprecated
> ok 7 - DelimitedStr is not anonymous
> ok 8 - DelimitedStr can be inlined
> ok 9 - Inlining DelimitedStr doesn't throw an exception
> ok 10 - DelimitedStr has a coercion
> ok 11 - DelimitedStr is parameterizable
> ok 12 - DelimitedStr has a type_default
> ok 13 - Undef should fail DelimitedStr
> ok 14 - False should pass DelimitedStr
> ok 15 - True should pass DelimitedStr
> ok 16 - Zero should pass DelimitedStr
> ok 17 - One should pass DelimitedStr
> ok 18 - Negative one should pass DelimitedStr
> ok 19 - Non integer should pass DelimitedStr
> ok 20 - Empty string should pass DelimitedStr
> ok 21 - Whitespace should pass DelimitedStr
> ok 22 - Line break should pass DelimitedStr
> ok 23 - Random string should pass DelimitedStr
> ok 24 - Loaded package name should pass DelimitedStr
> ok 25 - Unloaded package name should pass DelimitedStr
> ok 26 - A reference to undef should fail DelimitedStr
> ok 27 - A reference to false should fail DelimitedStr
> ok 28 - A reference to true should fail DelimitedStr
> ok 29 - A reference to zero should fail DelimitedStr
> ok 30 - A reference to one should fail DelimitedStr
> ok 31 - A reference to empty string should fail DelimitedStr
> ok 32 - A reference to random string should fail DelimitedStr
> ok 33 - Blessed scalarref should fail DelimitedStr
> ok 34 - Empty arrayref should fail DelimitedStr
> ok 35 - Arrayref with one zero should fail DelimitedStr
> ok 36 - Arrayref of integers should fail DelimitedStr
> ok 37 - Arrayref of numbers should fail DelimitedStr
> ok 38 - Blessed arrayref should fail DelimitedStr
> ok 39 - Empty hashref should fail DelimitedStr
> ok 40 - Hashref should fail DelimitedStr
> ok 41 - Blessed hashref should fail DelimitedStr
> ok 42 - Coderef should fail DelimitedStr
> ok 43 - Blessed coderef should fail DelimitedStr
> ok 44 - Glob should fail DelimitedStr
> ok 45 - Globref should fail DelimitedStr
> ok 46 - Blessed globref should fail DelimitedStr
> ok 47 - Regexp should fail DelimitedStr
> ok 48 - Blessed regexp should fail DelimitedStr
> ok 49 - Filehandle should fail DelimitedStr
> ok 50 - Filehandle object should fail DelimitedStr
> ok 51 - Ref to scalarref should fail DelimitedStr
> ok 52 - Ref to arrayref should fail DelimitedStr
> ok 53 - Ref to hashref should fail DelimitedStr
> ok 54 - Ref to coderef should fail DelimitedStr
> ok 55 - Ref to blessed hashref should fail DelimitedStr
> ok 56 - Object string to "" should fail DelimitedStr
> ok 57 - Object string to "1" should fail DelimitedStr
> ok 58 - Object numifying to 0 should fail DelimitedStr
> ok 59 - Object numifying to 1 should fail DelimitedStr
> ok 60 - Object overloading arrayref should fail DelimitedStr
> ok 61 - Object overloading hashref should fail DelimitedStr
> ok 62 - Object overloading coderef should fail DelimitedStr
> ok 63 - Object booling to false should fail DelimitedStr
> ok 64 - Object booling to true should fail DelimitedStr
> ok 65 - The unparameterized type coerces by joining with $"
> ok 66 - ... and again
> ok 67 - ... and again
> ok 68 - $SomeInts->can_be_inlined
> ok 69 - $SomeInts->coercion->can_be_inlined
> ok 70 - $SomeInts->display_name is DelimitedStr[",",Int,2,3,1]
> ok 71 - Value "1,2,3" passes type constraint DelimitedStr[",",Int,2,3,1]
> ok 72 - Value "1, 2, 3" passes type constraint DelimitedStr[",",Int,2,3,1]
> ok 73 - Value " 1,2,3 \t\n\t" passes type constraint DelimitedStr[",",Int,2,3,1]
> ok 74 - Value "1" fails type constraint DelimitedStr[",",Int,2,3,1]
> ok 75 - Value "1,2,3,4" fails type constraint DelimitedStr[",",Int,2,3,1]
> ok 76 - Value "foo,bar,baz" fails type constraint DelimitedStr[",",Int,2,3,1]
> ok 77 - Value "1,,3" fails type constraint DelimitedStr[",",Int,2,3,1]
> ok 78 - DelimitedStr[",",Int,2,3,1] has a coercion from an appropriate arrayref
> ok 79 - ... and it works
> ok 80 - DelimitedStr[",",Int,2,3,1] does not have a coercion from a posentially inappropriate arrayref
> 1..80
> ok
> t/21-types/Dict.t ............................................
> ok 1 - 'Dict' isa 'Type::Tiny'
> ok 2 - Dict has correct name
> ok 3 - Dict has correct display_name
> ok 4 - Dict knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Dict
> ok 6 - Dict is not deprecated
> ok 7 - Dict is not anonymous
> ok 8 - Dict can be inlined
> ok 9 - Inlining Dict doesn't throw an exception
> ok 10 - Dict doesn't have a coercion
> ok 11 - Dict is parameterizable
> ok 12 - Dict has a type_default
> ok 13 - Dict type_default is {}
> ok 14 - Undef should fail Dict
> ok 15 - False should fail Dict
> ok 16 - True should fail Dict
> ok 17 - Zero should fail Dict
> ok 18 - One should fail Dict
> ok 19 - Negative one should fail Dict
> ok 20 - Non integer should fail Dict
> ok 21 - Empty string should fail Dict
> ok 22 - Whitespace should fail Dict
> ok 23 - Line break should fail Dict
> ok 24 - Random string should fail Dict
> ok 25 - Loaded package name should fail Dict
> ok 26 - Unloaded package name should fail Dict
> ok 27 - A reference to undef should fail Dict
> ok 28 - A reference to false should fail Dict
> ok 29 - A reference to true should fail Dict
> ok 30 - A reference to zero should fail Dict
> ok 31 - A reference to one should fail Dict
> ok 32 - A reference to empty string should fail Dict
> ok 33 - A reference to random string should fail Dict
> ok 34 - Blessed scalarref should fail Dict
> ok 35 - Empty arrayref should fail Dict
> ok 36 - Arrayref with one zero should fail Dict
> ok 37 - Arrayref of integers should fail Dict
> ok 38 - Arrayref of numbers should fail Dict
> ok 39 - Blessed arrayref should fail Dict
> ok 40 - Empty hashref should pass Dict
> ok 41 - Hashref should pass Dict
> ok 42 - Blessed hashref should fail Dict
> ok 43 - Coderef should fail Dict
> ok 44 - Blessed coderef should fail Dict
> ok 45 - Glob should fail Dict
> ok 46 - Globref should fail Dict
> ok 47 - Blessed globref should fail Dict
> ok 48 - Regexp should fail Dict
> ok 49 - Blessed regexp should fail Dict
> ok 50 - Filehandle should fail Dict
> ok 51 - Filehandle object should fail Dict
> ok 52 - Ref to scalarref should fail Dict
> ok 53 - Ref to arrayref should fail Dict
> ok 54 - Ref to hashref should fail Dict
> ok 55 - Ref to coderef should fail Dict
> ok 56 - Ref to blessed hashref should fail Dict
> ok 57 - Object stringifying to "" should fail Dict
> ok 58 - Object stringifying to "1" should fail Dict
> ok 59 - Object numifying to 0 should fail Dict
> ok 60 - Object numifying to 1 should fail Dict
> ok 61 - Object overloading arrayref should fail Dict
> ok 62 - Object overloading hashref should fail Dict
> ok 63 - Object overloading coderef should fail Dict
> ok 64 - Object booling to false should fail Dict
> ok 65 - Object booling to true should fail Dict
> ok 66 - Reference {"bar" => qr//,"foo" => 42} passes type constraint Dict[bar=>RegexpRef,foo=>Int]
> ok 67 - Reference {"bar" => qr//,"foo" => []} fails type constraint Dict[bar=>RegexpRef,foo=>Int]
> ok 68 - Reference {"bar" => 1234,"foo" => 42} fails type constraint Dict[bar=>RegexpRef,foo=>Int]
> ok 69 - Reference {"bar" => 1234,"foo" => []} fails type constraint Dict[bar=>RegexpRef,foo=>Int]
> ok 70 - Reference {"foo" => 42} fails type constraint Dict[bar=>RegexpRef,foo=>Int]
> ok 71 - Reference {"bar" => qr//} fails type constraint Dict[bar=>RegexpRef,foo=>Int]
> ok 72 - Reference ["foo",42,"bar",qr//] fails type constraint Dict[bar=>RegexpRef,foo=>Int]
> ok 73 - Reference {"bar" => qr//,"baz" => undef,"foo" => 42} fails type constraint Dict[bar=>RegexpRef,foo=>Int]
> ok 74 - my_hashref_allows_key("bar")
> ok 75 - !my_hashref_allows_key("baz")
> ok 76 - my_hashref_allows_value("bar", qr//)
> ok 77 - !my_hashref_allows_value("bar", 1234)
> ok 78 - Dict[bar=>RegexpRef,foo=>Int] has no type_default
> ok 79 - Reference {"bar" => qr//,"foo" => 42} passes type constraint Dict[bar=>Optional[RegexpRef],foo=>Int]
> ok 80 - Reference {"bar" => qr//,"foo" => []} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>Int]
> ok 81 - Reference {"bar" => 1234,"foo" => 42} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>Int]
> ok 82 - Reference {"bar" => 1234,"foo" => []} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>Int]
> ok 83 - Reference {"foo" => 42} passes type constraint Dict[bar=>Optional[RegexpRef],foo=>Int]
> ok 84 - Reference {"bar" => qr//} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>Int]
> ok 85 - Reference ["foo",42,"bar",qr//] fails type constraint Dict[bar=>Optional[RegexpRef],foo=>Int]
> ok 86 - Reference {"bar" => qr//,"baz" => undef,"foo" => 42} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>Int]
> ok 87 - my_hashref_allows_key("bar")
> ok 88 - !my_hashref_allows_key("baz")
> ok 89 - my_hashref_allows_value("bar", qr//)
> ok 90 - !my_hashref_allows_value("bar", 1234)
> ok 91 - Reference {"bar" => qr//,"foo" => 42} passes type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 92 - Reference {"bar" => qr//,"foo" => []} fails type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 93 - Reference {"bar" => 1234,"foo" => 42} fails type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 94 - Reference {"bar" => 1234,"foo" => []} fails type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 95 - Reference {"foo" => 42} fails type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 96 - Reference {"bar" => qr//} fails type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 97 - Reference ["foo",42,"bar",qr//] fails type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 98 - Reference {"bar" => qr//,"baz" => undef,"foo" => 42} fails type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 99 - Reference {"123" => [],"bar" => qr//,"foo" => 42} passes type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 100 - Reference {"123" => [],"456" => [],"bar" => qr//,"foo" => 42} passes type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 101 - Reference {"123" => qr//,"bar" => qr//,"foo" => 42} fails type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 102 - Reference {"123" => qr//,"456" => [],"bar" => qr//,"foo" => 42} fails type constraint Dict[bar=>RegexpRef,foo=>Int,Slurpy[Map[Int,ArrayRef]]]
> ok 103 - my_hashref_allows_key("bar")
> ok 104 - !my_hashref_allows_key("baz")
> ok 105 - my_hashref_allows_value("bar", qr//)
> ok 106 - !my_hashref_allows_value("bar", 1234)
> ok 107 - my_hashref_allows_key("123")
> ok 108 - my_hashref_allows_value("123", [])
> ok 109 - !my_hashref_allows_value("123", qr//)
> ok 110 - Reference {"bar" => qr//,"foo" => 42} passes type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 111 - Reference {"bar" => qr//,"foo" => 41} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 112 - Reference {"bar" => qr//,"foo" => []} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 113 - Reference {"bar" => 1234,"foo" => 42} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 114 - Reference {"bar" => 1234,"foo" => []} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 115 - Reference {"foo" => 42} passes type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 116 - Reference {"bar" => qr//} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 117 - Reference ["foo",42,"bar",qr//] fails type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 118 - Reference {"bar" => qr//,"baz" => undef,"foo" => 42} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 119 - Reference {"123" => [],"bar" => qr//,"foo" => 42} passes type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 120 - Reference {"123" => [],"456" => [],"bar" => qr//,"foo" => 42} passes type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 121 - Reference {"123" => qr//,"bar" => qr//,"foo" => 42} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 122 - Reference {"123" => qr//,"456" => [],"bar" => qr//,"foo" => 42} fails type constraint Dict[bar=>Optional[RegexpRef],foo=>__ANON__,Slurpy[Map[Int,ArrayRef]]]
> ok 123 - my_hashref_allows_key("bar")
> ok 124 - !my_hashref_allows_key("baz")
> ok 125 - my_hashref_allows_value("bar", qr//)
> ok 126 - !my_hashref_allows_value("bar", 1234)
> ok 127 - my_hashref_allows_key("123")
> ok 128 - my_hashref_allows_value("123", [])
> ok 129 - !my_hashref_allows_value("123", qr//)
> ok 130 - my_hashref_allows_value("foo", 20)
> ok 131 - !my_hashref_allows_value("foo", 21)
> ok 132 - deep coercion
> ok 133 - cowardly refuses to drop keys to allow coercion to work
> ok 134 - deep coercion
> ok 135 - can coerce optional slots
> ok 136 - cowardly refuses to drop keys to allow coercion to work
> ok 137 - deep coercion
> ok 138 - can coerce optional slots
> ok 139 - can coerce slurpy
> ok 140 - cowardly refuses to drop keys to allow coercion to work
> ok 141 - deep coercion
> ok 142 - can coerce optional slots
> ok 143 - can coerce slurpy
> ok 144 - cowardly refuses to drop keys to allow coercion to work
> 1..144
> ok
> t/21-types/Enum.t ............................................
> ok 1 - 'Enum' isa 'Type::Tiny'
> ok 2 - Enum has correct name
> ok 3 - Enum has correct display_name
> ok 4 - Enum knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Enum
> ok 6 - Enum is not deprecated
> ok 7 - Enum is not anonymous
> ok 8 - Enum can be inlined
> ok 9 - Inlining Enum doesn't throw an exception
> ok 10 - Enum doesn't have a coercion
> ok 11 - Enum is parameterizable
> ok 12 - Enum has no type_default
> ok 13 - Undef should fail Enum
> ok 14 - False should pass Enum
> ok 15 - True should pass Enum
> ok 16 - Zero should pass Enum
> ok 17 - One should pass Enum
> ok 18 - Negative one should pass Enum
> ok 19 - Non integer should pass Enum
> ok 20 - Empty string should pass Enum
> ok 21 - Whitespace should pass Enum
> ok 22 - Line break should pass Enum
> ok 23 - Random string should pass Enum
> ok 24 - Loaded package name should pass Enum
> ok 25 - Unloaded package name should pass Enum
> ok 26 - A reference to undef should fail Enum
> ok 27 - A reference to false should fail Enum
> ok 28 - A reference to true should fail Enum
> ok 29 - A reference to zero should fail Enum
> ok 30 - A reference to one should fail Enum
> ok 31 - A reference to empty string should fail Enum
> ok 32 - A reference to random string should fail Enum
> ok 33 - Blessed scalarref should fail Enum
> ok 34 - Empty arrayref should fail Enum
> ok 35 - Arrayref with one zero should fail Enum
> ok 36 - Arrayref of integers should fail Enum
> ok 37 - Arrayref of numbers should fail Enum
> ok 38 - Blessed arrayref should fail Enum
> ok 39 - Empty hashref should fail Enum
> ok 40 - Hashref should fail Enum
> ok 41 - Blessed hashref should fail Enum
> ok 42 - Coderef should fail Enum
> ok 43 - Blessed coderef should fail Enum
> ok 44 - Glob should fail Enum
> ok 45 - Globref should fail Enum
> ok 46 - Blessed globref should fail Enum
> ok 47 - Regexp should fail Enum
> ok 48 - Blessed regexp should fail Enum
> ok 49 - Filehandle should fail Enum
> ok 50 - Filehandle object should fail Enum
> ok 51 - Ref to scalarref should fail Enum
> ok 52 - Ref to arrayref should fail Enum
> ok 53 - Ref to hashref should fail Enum
> ok 54 - Ref to coderef should fail Enum
> ok 55 - Ref to blessed hashref should fail Enum
> ok 56 - Object stringifying to "" should fail Enum
> ok 57 - Object stringifying to "1" should fail Enum
> ok 58 - Object numifying to 0 should fail Enum
> ok 59 - Object numifying to 1 should fail Enum
> ok 60 - Object overloading arrayref should fail Enum
> ok 61 - Object overloading hashref should fail Enum
> ok 62 - Object overloading coderef should fail Enum
> ok 63 - Object booling to false should fail Enum
> ok 64 - Object booling to true should fail Enum
> ok 65 - Value "foo" passes type constraint Enum["foo","bar","bar","baz"]
> ok 66 - Value "bar" passes type constraint Enum["foo","bar","bar","baz"]
> ok 67 - Value "baz" passes type constraint Enum["foo","bar","bar","baz"]
> ok 68 - Value "bat" fails type constraint Enum["foo","bar","bar","baz"]
> ok 69
> ok 70
> ok 71
> ok 72
> ok 73
> ok 74
> ok 75
> ok 76
> ok 77
> ok 78
> ok 79
> ok 80
> ok 81
> ok 82
> ok 83
> ok 84 - Unknown flags passed to as_regexp
> ok 85 - Value "foo" passes type constraint Enum["foo","bar","bar","baz"]
> ok 86 - Value "bar" passes type constraint Enum["foo","bar","bar","baz"]
> ok 87 - Value "baz" passes type constraint Enum["foo","bar","bar","baz"]
> ok 88 - Value "bat" fails type constraint Enum["foo","bar","bar","baz"]
> ok 89 - Reference bless( do{\(my $o = "foo")}, 'Local::Stringy' ) fails type constraint Enum["foo","bar","bar","baz"]
> ok 90
> ok 91
> ok 92
> ok 93 - "foo" comes before "baz" because they were listed in that order when $enum1 was defined
> ok 94
> ok 95
> ok 96
> ok 97
> ok 98
> ok 99
> ok 100
> ok 101
> ok 102
> ok 103
> ok 104
> ok 105
> ok 106
> ok 107
> 1..107
> ok
> t/21-types/FileHandle.t ......................................
> ok 1 - 'FileHandle' isa 'Type::Tiny'
> ok 2 - FileHandle has correct name
> ok 3 - FileHandle has correct display_name
> ok 4 - FileHandle knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type FileHandle
> ok 6 - FileHandle is not deprecated
> ok 7 - FileHandle is not anonymous
> ok 8 - FileHandle can be inlined
> ok 9 - Inlining FileHandle doesn't throw an exception
> ok 10 - FileHandle doesn't have a coercion
> ok 11 - FileHandle isn't parameterizable
> ok 12 - FileHandle has no type_default
> ok 13 - Undef should fail FileHandle
> ok 14 - False should fail FileHandle
> ok 15 - True should fail FileHandle
> ok 16 - Zero should fail FileHandle
> ok 17 - One should fail FileHandle
> ok 18 - Negative one should fail FileHandle
> ok 19 - Non integer should fail FileHandle
> ok 20 - Empty string should fail FileHandle
> ok 21 - Whitespace should fail FileHandle
> ok 22 - Line break should fail FileHandle
> ok 23 - Random string should fail FileHandle
> ok 24 - Loaded package name should fail FileHandle
> ok 25 - Unloaded package name should fail FileHandle
> ok 26 - A reference to undef should fail FileHandle
> ok 27 - A reference to false should fail FileHandle
> ok 28 - A reference to true should fail FileHandle
> ok 29 - A reference to zero should fail FileHandle
> ok 30 - A reference to one should fail FileHandle
> ok 31 - A reference to empty string should fail FileHandle
> ok 32 - A reference to random string should fail FileHandle
> ok 33 - Blessed scalarref should fail FileHandle
> ok 34 - Empty arrayref should fail FileHandle
> ok 35 - Arrayref with one zero should fail FileHandle
> ok 36 - Arrayref of integers should fail FileHandle
> ok 37 - Arrayref of numbers should fail FileHandle
> ok 38 - Blessed arrayref should fail FileHandle
> ok 39 - Empty hashref should fail FileHandle
> ok 40 - Hashref should fail FileHandle
> ok 41 - Blessed hashref should fail FileHandle
> ok 42 - Coderef should fail FileHandle
> ok 43 - Blessed coderef should fail FileHandle
> ok 44 - Glob should fail FileHandle
> ok 45 - Globref should fail FileHandle
> ok 46 - Blessed globref should fail FileHandle
> ok 47 - Regexp should fail FileHandle
> ok 48 - Blessed regexp should fail FileHandle
> ok 49 - Filehandle should pass FileHandle
> ok 50 - Filehandle object should pass FileHandle
> ok 51 - Ref to scalarref should fail FileHandle
> ok 52 - Ref to arrayref should fail FileHandle
> ok 53 - Ref to hashref should fail FileHandle
> ok 54 - Ref to coderef should fail FileHandle
> ok 55 - Ref to blessed hashref should fail FileHandle
> ok 56 - Object stringifying to "" should fail FileHandle
> ok 57 - Object stringifying to "1" should fail FileHandle
> ok 58 - Object numifying to 0 should fail FileHandle
> ok 59 - Object numifying to 1 should fail FileHandle
> ok 60 - Object overloading arrayref should fail FileHandle
> ok 61 - Object overloading hashref should fail FileHandle
> ok 62 - Object overloading coderef should fail FileHandle
> ok 63 - Object booling to false should fail FileHandle
> ok 64 - Object booling to true should fail FileHandle
> 1..64
> ok
> t/21-types/GlobRef.t .........................................
> ok 1 - 'GlobRef' isa 'Type::Tiny'
> ok 2 - GlobRef has correct name
> ok 3 - GlobRef has correct display_name
> ok 4 - GlobRef knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type GlobRef
> ok 6 - GlobRef is not deprecated
> ok 7 - GlobRef is not anonymous
> ok 8 - GlobRef can be inlined
> ok 9 - Inlining GlobRef doesn't throw an exception
> ok 10 - GlobRef doesn't have a coercion
> ok 11 - GlobRef isn't parameterizable
> ok 12 - GlobRef has no type_default
> ok 13 - Undef should fail GlobRef
> ok 14 - False should fail GlobRef
> ok 15 - True should fail GlobRef
> ok 16 - Zero should fail GlobRef
> ok 17 - One should fail GlobRef
> ok 18 - Negative one should fail GlobRef
> ok 19 - Non integer should fail GlobRef
> ok 20 - Empty string should fail GlobRef
> ok 21 - Whitespace should fail GlobRef
> ok 22 - Line break should fail GlobRef
> ok 23 - Random string should fail GlobRef
> ok 24 - Loaded package name should fail GlobRef
> ok 25 - Unloaded package name should fail GlobRef
> ok 26 - A reference to undef should fail GlobRef
> ok 27 - A reference to false should fail GlobRef
> ok 28 - A reference to true should fail GlobRef
> ok 29 - A reference to zero should fail GlobRef
> ok 30 - A reference to one should fail GlobRef
> ok 31 - A reference to empty string should fail GlobRef
> ok 32 - A reference to random string should fail GlobRef
> ok 33 - Blessed scalarref should fail GlobRef
> ok 34 - Empty arrayref should fail GlobRef
> ok 35 - Arrayref with one zero should fail GlobRef
> ok 36 - Arrayref of integers should fail GlobRef
> ok 37 - Arrayref of numbers should fail GlobRef
> ok 38 - Blessed arrayref should fail GlobRef
> ok 39 - Empty hashref should fail GlobRef
> ok 40 - Hashref should fail GlobRef
> ok 41 - Blessed hashref should fail GlobRef
> ok 42 - Coderef should fail GlobRef
> ok 43 - Blessed coderef should fail GlobRef
> ok 44 - Glob should fail GlobRef
> ok 45 - Globref should pass GlobRef
> ok 46 - Blessed globref should fail GlobRef
> ok 47 - Regexp should fail GlobRef
> ok 48 - Blessed regexp should fail GlobRef
> ok 49 - Filehandle should pass GlobRef
> ok 50 - Filehandle object should fail GlobRef
> ok 51 - Ref to scalarref should fail GlobRef
> ok 52 - Ref to arrayref should fail GlobRef
> ok 53 - Ref to hashref should fail GlobRef
> ok 54 - Ref to coderef should fail GlobRef
> ok 55 - Ref to blessed hashref should fail GlobRef
> ok 56 - Object stringifying to "" should fail GlobRef
> ok 57 - Object stringifying to "1" should fail GlobRef
> ok 58 - Object numifying to 0 should fail GlobRef
> ok 59 - Object numifying to 1 should fail GlobRef
> ok 60 - Object overloading arrayref should fail GlobRef
> ok 61 - Object overloading hashref should fail GlobRef
> ok 62 - Object overloading coderef should fail GlobRef
> ok 63 - Object booling to false should fail GlobRef
> ok 64 - Object booling to true should fail GlobRef
> 1..64
> ok
> t/21-types/HashLike.t ........................................
> ok 1 - 'HashLike' isa 'Type::Tiny'
> ok 2 - HashLike has correct name
> ok 3 - HashLike has correct display_name
> ok 4 - HashLike knows it is in the Types::TypeTiny library
> ok 5 - Types::TypeTiny knows it has type HashLike
> ok 6 - HashLike is not deprecated
> ok 7 - HashLike is not anonymous
> ok 8 - HashLike can be inlined
> ok 9 - Inlining HashLike doesn't throw an exception
> ok 10 - HashLike doesn't have a coercion
> ok 11 - HashLike is parameterizable
> ok 12 - HashLike has a type_default
> ok 13 - HashLike type_default is {}
> ok 14 - Undef should fail HashLike
> ok 15 - False should fail HashLike
> ok 16 - True should fail HashLike
> ok 17 - Zero should fail HashLike
> ok 18 - One should fail HashLike
> ok 19 - Negative one should fail HashLike
> ok 20 - Non integer should fail HashLike
> ok 21 - Empty string should fail HashLike
> ok 22 - Whitespace should fail HashLike
> ok 23 - Line break should fail HashLike
> ok 24 - Random string should fail HashLike
> ok 25 - Loaded package name should fail HashLike
> ok 26 - Unloaded package name should fail HashLike
> ok 27 - A reference to undef should fail HashLike
> ok 28 - A reference to false should fail HashLike
> ok 29 - A reference to true should fail HashLike
> ok 30 - A reference to zero should fail HashLike
> ok 31 - A reference to one should fail HashLike
> ok 32 - A reference to empty string should fail HashLike
> ok 33 - A reference to random string should fail HashLike
> ok 34 - Blessed scalarref should fail HashLike
> ok 35 - Empty arrayref should fail HashLike
> ok 36 - Arrayref with one zero should fail HashLike
> ok 37 - Arrayref of integers should fail HashLike
> ok 38 - Arrayref of numbers should fail HashLike
> ok 39 - Blessed arrayref should fail HashLike
> ok 40 - Empty hashref should pass HashLike
> ok 41 - Hashref should pass HashLike
> ok 42 - Blessed hashref should fail HashLike
> ok 43 - Coderef should fail HashLike
> ok 44 - Blessed coderef should fail HashLike
> ok 45 - Glob should fail HashLike
> ok 46 - Globref should fail HashLike
> ok 47 - Blessed globref should fail HashLike
> ok 48 - Regexp should fail HashLike
> ok 49 - Blessed regexp should fail HashLike
> ok 50 - Filehandle should fail HashLike
> ok 51 - Filehandle object should fail HashLike
> ok 52 - Ref to scalarref should fail HashLike
> ok 53 - Ref to arrayref should fail HashLike
> ok 54 - Ref to hashref should fail HashLike
> ok 55 - Ref to coderef should fail HashLike
> ok 56 - Ref to blessed hashref should fail HashLike
> ok 57 - Object stringifying to "" should fail HashLike
> ok 58 - Object stringifying to "1" should fail HashLike
> ok 59 - Object numifying to 0 should fail HashLike
> ok 60 - Object numifying to 1 should fail HashLike
> ok 61 - Object overloading arrayref should fail HashLike
> ok 62 - Object overloading hashref should pass HashLike
> ok 63 - Object overloading coderef should fail HashLike
> ok 64 - Object booling to false should fail HashLike
> ok 65 - Object booling to true should fail HashLike
> ok 66
> ok 67 - Reference {"bar" => 2,"foo" => 1} passes type constraint HashLike[Int]
> ok 68 - Reference bless( [{"bar" => 2,"foo" => 1}], 'Local::OL::Hash' ) passes type constraint HashLike[Int]
> ok 69 - Reference {"bar" => undef,"foo" => 1} fails type constraint HashLike[Int]
> ok 70 - Reference bless( [{"bar" => undef,"foo" => 1}], 'Local::OL::Hash' ) fails type constraint HashLike[Int]
> ok 71
> ok 72
> ok 73
> ok 74
> ok 75 - tied hash that should pass
> ok 76 - tied hash that should fail
> ok 77 - overloaded object yielding regular hash that should pass
> ok 78 - overloaded object yielding regular hash that should fail
> ok 79 - overloaded object yielding tied hash that should pass
> ok 80 - overloaded object yielding tied hash that should fail
> 1..80
> ok
> t/21-types/HashRef.t .........................................
> ok 1 - 'HashRef' isa 'Type::Tiny'
> ok 2 - HashRef has correct name
> ok 3 - HashRef has correct display_name
> ok 4 - HashRef knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type HashRef
> ok 6 - HashRef is not deprecated
> ok 7 - HashRef is not anonymous
> ok 8 - HashRef can be inlined
> ok 9 - Inlining HashRef doesn't throw an exception
> ok 10 - HashRef doesn't have a coercion
> ok 11 - HashRef is parameterizable
> ok 12 - HashRef has a type_default
> ok 13 - HashRef type_default is {}
> ok 14 - Undef should fail HashRef
> ok 15 - False should fail HashRef
> ok 16 - True should fail HashRef
> ok 17 - Zero should fail HashRef
> ok 18 - One should fail HashRef
> ok 19 - Negative one should fail HashRef
> ok 20 - Non integer should fail HashRef
> ok 21 - Empty string should fail HashRef
> ok 22 - Whitespace should fail HashRef
> ok 23 - Line break should fail HashRef
> ok 24 - Random string should fail HashRef
> ok 25 - Loaded package name should fail HashRef
> ok 26 - Unloaded package name should fail HashRef
> ok 27 - A reference to undef should fail HashRef
> ok 28 - A reference to false should fail HashRef
> ok 29 - A reference to true should fail HashRef
> ok 30 - A reference to zero should fail HashRef
> ok 31 - A reference to one should fail HashRef
> ok 32 - A reference to empty string should fail HashRef
> ok 33 - A reference to random string should fail HashRef
> ok 34 - Blessed scalarref should fail HashRef
> ok 35 - Empty arrayref should fail HashRef
> ok 36 - Arrayref with one zero should fail HashRef
> ok 37 - Arrayref of integers should fail HashRef
> ok 38 - Arrayref of numbers should fail HashRef
> ok 39 - Blessed arrayref should fail HashRef
> ok 40 - Empty hashref should pass HashRef
> ok 41 - Hashref should pass HashRef
> ok 42 - Blessed hashref should fail HashRef
> ok 43 - Coderef should fail HashRef
> ok 44 - Blessed coderef should fail HashRef
> ok 45 - Glob should fail HashRef
> ok 46 - Globref should fail HashRef
> ok 47 - Blessed globref should fail HashRef
> ok 48 - Regexp should fail HashRef
> ok 49 - Blessed regexp should fail HashRef
> ok 50 - Filehandle should fail HashRef
> ok 51 - Filehandle object should fail HashRef
> ok 52 - Ref to scalarref should fail HashRef
> ok 53 - Ref to arrayref should fail HashRef
> ok 54 - Ref to hashref should fail HashRef
> ok 55 - Ref to coderef should fail HashRef
> ok 56 - Ref to blessed hashref should fail HashRef
> ok 57 - Object stringifying to "" should fail HashRef
> ok 58 - Object stringifying to "1" should fail HashRef
> ok 59 - Object numifying to 0 should fail HashRef
> ok 60 - Object numifying to 1 should fail HashRef
> ok 61 - Object overloading arrayref should fail HashRef
> ok 62 - Object overloading hashref should fail HashRef
> ok 63 - Object overloading coderef should fail HashRef
> ok 64 - Object booling to false should fail HashRef
> ok 65 - Object booling to true should fail HashRef
> ok 66 - '$HashOfInts' isa 'Type::Tiny'
> ok 67 - $HashOfInts has correct display_name
> ok 68 - $HashOfInts has no name
> ok 69 - $HashOfInts can be inlined
> ok 70 - Inlining $HashOfInts doesn't throw an exception
> ok 71 - $HashOfInts doesn't have a coercion
> ok 72 - $HashOfInts is not parameterizable
> ok 73 - $HashOfInts has a type_default
> ok 74 - $HashOfInts type_default is {}
> ok 75 - HashRef subtype: HashRef[Int]
> ok 76 - Value "1" fails type constraint HashRef[Int]
> ok 77 - Reference [] fails type constraint HashRef[Int]
> ok 78 - Reference {} passes type constraint HashRef[Int]
> ok 79 - Reference {"foo" => []} fails type constraint HashRef[Int]
> ok 80 - Reference {"foo" => "1.1"} fails type constraint HashRef[Int]
> ok 81 - Reference {"foo" => 1} passes type constraint HashRef[Int]
> ok 82 - Reference {"foo" => 0} passes type constraint HashRef[Int]
> ok 83 - Reference {"foo" => -1} passes type constraint HashRef[Int]
> ok 84 - Reference {"foo" => \1} fails type constraint HashRef[Int]
> ok 85 - Reference {"123" => \1} fails type constraint HashRef[Int]
> ok 86 - Reference {"123" => 1} passes type constraint HashRef[Int]
> ok 87 - Reference {"bar" => 2,"foo" => 1} passes type constraint HashRef[Int]
> ok 88 - Reference {"bar" => [],"foo" => 1} fails type constraint HashRef[Int]
> ok 89 - my_hashref_allows_key('foo')
> ok 90 - my_hashref_allows_value('foo', 1234)
> ok 91 - !my_hashref_allows_value('foo', qr//)
> ok 92 - '$HashOfRounded' isa 'Type::Tiny'
> ok 93 - $HashOfRounded has correct display_name
> ok 94 - $HashOfRounded has no name
> ok 95 - $HashOfRounded can be inlined
> ok 96 - Inlining $HashOfRounded doesn't throw an exception
> ok 97 - $HashOfRounded has a coercion
> ok 98 - $HashRefOfRounded can coerce from HashRef
> ok 99 - $HashRefOfRounded can coerce from HashRef[Num]
> ok 100 - $HashOfRounded is not parameterizable
> ok 101 - HashRef subtype: HashRef[Int]
> ok 102 - Value "1" fails type constraint HashRef[Int]
> ok 103 - Reference [] fails type constraint HashRef[Int]
> ok 104 - Reference {} passes type constraint HashRef[Int]
> ok 105 - Reference {"foo" => []} fails type constraint HashRef[Int]
> ok 106 - Reference {"foo" => "1.1"} fails type constraint HashRef[Int]
> ok 107 - Reference {"foo" => 1} passes type constraint HashRef[Int]
> ok 108 - Reference {"foo" => 0} passes type constraint HashRef[Int]
> ok 109 - Reference {"foo" => -1} passes type constraint HashRef[Int]
> ok 110 - Reference {"foo" => \1} fails type constraint HashRef[Int]
> ok 111 - Reference {"123" => \1} fails type constraint HashRef[Int]
> ok 112 - Reference {"123" => 1} passes type constraint HashRef[Int]
> ok 113 - Reference {"bar" => 2,"foo" => 1} passes type constraint HashRef[Int]
> ok 114 - Reference {"bar" => [],"foo" => 1} fails type constraint HashRef[Int]
> ok 115 - just returned orig unchanged
> ok 116 - coercion happened
> ok 117 - ... and data looks good
> ok 118 - ... and now passes type constraint
> ok 119 - coercion failed, so orig was returned
> ok 120 - Reference {"foo" => []} fails type constraint HashRef[Int]
> ok 121 - can only be parameterized with another type
> ok 122 - tied hash that should pass
> ok 123 - tied hash that should fail
> ok 124 - overloaded object yielding regular hash that would pass if it weren't for the interleving overloaded object
> ok 125 - overloaded object yielding regular hash that should fail
> ok 126 - overloaded object yielding tied hash that would pass if it weren't for the interleving overloaded object
> ok 127 - overloaded object yielding tied hash that should fail
> 1..127
> ok
> t/21-types/HasMethods.t ......................................
> ok 1 - 'HasMethods' isa 'Type::Tiny'
> ok 2 - HasMethods has correct name
> ok 3 - HasMethods has correct display_name
> ok 4 - HasMethods knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type HasMethods
> ok 6 - HasMethods is not deprecated
> ok 7 - HasMethods is not anonymous
> ok 8 - HasMethods can be inlined
> ok 9 - Inlining HasMethods doesn't throw an exception
> ok 10 - HasMethods doesn't have a coercion
> ok 11 - HasMethods is parameterizable
> ok 12 - HasMethods has no type_default
> ok 13 - Undef should fail HasMethods
> ok 14 - False should fail HasMethods
> ok 15 - True should fail HasMethods
> ok 16 - Zero should fail HasMethods
> ok 17 - One should fail HasMethods
> ok 18 - Negative one should fail HasMethods
> ok 19 - Non integer should fail HasMethods
> ok 20 - Empty string should fail HasMethods
> ok 21 - Whitespace should fail HasMethods
> ok 22 - Line break should fail HasMethods
> ok 23 - Random string should fail HasMethods
> ok 24 - Loaded package name should fail HasMethods
> ok 25 - Unloaded package name should fail HasMethods
> ok 26 - A reference to undef should fail HasMethods
> ok 27 - A reference to false should fail HasMethods
> ok 28 - A reference to true should fail HasMethods
> ok 29 - A reference to zero should fail HasMethods
> ok 30 - A reference to one should fail HasMethods
> ok 31 - A reference to empty string should fail HasMethods
> ok 32 - A reference to random string should fail HasMethods
> ok 33 - Blessed scalarref should pass HasMethods
> ok 34 - Empty arrayref should fail HasMethods
> ok 35 - Arrayref with one zero should fail HasMethods
> ok 36 - Arrayref of integers should fail HasMethods
> ok 37 - Arrayref of numbers should fail HasMethods
> ok 38 - Blessed arrayref should pass HasMethods
> ok 39 - Empty hashref should fail HasMethods
> ok 40 - Hashref should fail HasMethods
> ok 41 - Blessed hashref should pass HasMethods
> ok 42 - Coderef should fail HasMethods
> ok 43 - Blessed coderef should pass HasMethods
> ok 44 - Glob should fail HasMethods
> ok 45 - Globref should fail HasMethods
> ok 46 - Blessed globref should pass HasMethods
> # UNDEFINED OUTCOME: regexp
> ok 47 - Blessed regexp should pass HasMethods
> ok 48 - Filehandle should fail HasMethods
> ok 49 - Filehandle object should pass HasMethods
> ok 50 - Ref to scalarref should fail HasMethods
> ok 51 - Ref to arrayref should fail HasMethods
> ok 52 - Ref to hashref should fail HasMethods
> ok 53 - Ref to coderef should fail HasMethods
> ok 54 - Ref to blessed hashref should fail HasMethods
> ok 55 - Object stringifying to "" should pass HasMethods
> ok 56 - Object stringifying to "1" should pass HasMethods
> ok 57 - Object numifying to 0 should pass HasMethods
> ok 58 - Object numifying to 1 should pass HasMethods
> ok 59 - Object overloading arrayref should pass HasMethods
> ok 60 - Object overloading hashref should pass HasMethods
> ok 61 - Object overloading coderef should pass HasMethods
> ok 62 - Object booling to false should pass HasMethods
> ok 63 - Object booling to true should pass HasMethods
> ok 64 - parameterizing with [] has no effect
> ok 65 - parameterizing is cached
> ok 66 - Parameterized with one method name
> ok 67 - Parameterized with multiple method names
> ok 68 - ... acts as intersection (requires the object to support ALL the methods)
> ok 69 - HasMethods should believe $object->can() if it returns false.
> ok 70 - HasMethods should believe $object->can() if it returns true.
> ok 71 - HasMethods does't work on class names, even if they can do a method.
> 1..71
> ok
> t/21-types/InstanceOf.t ......................................
> ok 1 - 'InstanceOf' isa 'Type::Tiny'
> ok 2 - InstanceOf has correct name
> ok 3 - InstanceOf has correct display_name
> ok 4 - InstanceOf knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type InstanceOf
> ok 6 - InstanceOf is not deprecated
> ok 7 - InstanceOf is not anonymous
> ok 8 - InstanceOf can be inlined
> ok 9 - Inlining InstanceOf doesn't throw an exception
> ok 10 - InstanceOf doesn't have a coercion
> ok 11 - InstanceOf is parameterizable
> ok 12 - InstanceOf has no type_default
> ok 13 - Undef should fail InstanceOf
> ok 14 - False should fail InstanceOf
> ok 15 - True should fail InstanceOf
> ok 16 - Zero should fail InstanceOf
> ok 17 - One should fail InstanceOf
> ok 18 - Negative one should fail InstanceOf
> ok 19 - Non integer should fail InstanceOf
> ok 20 - Empty string should fail InstanceOf
> ok 21 - Whitespace should fail InstanceOf
> ok 22 - Line break should fail InstanceOf
> ok 23 - Random string should fail InstanceOf
> ok 24 - Loaded package name should fail InstanceOf
> ok 25 - Unloaded package name should fail InstanceOf
> ok 26 - A reference to undef should fail InstanceOf
> ok 27 - A reference to false should fail InstanceOf
> ok 28 - A reference to true should fail InstanceOf
> ok 29 - A reference to zero should fail InstanceOf
> ok 30 - A reference to one should fail InstanceOf
> ok 31 - A reference to empty string should fail InstanceOf
> ok 32 - A reference to random string should fail InstanceOf
> ok 33 - Blessed scalarref should pass InstanceOf
> ok 34 - Empty arrayref should fail InstanceOf
> ok 35 - Arrayref with one zero should fail InstanceOf
> ok 36 - Arrayref of integers should fail InstanceOf
> ok 37 - Arrayref of numbers should fail InstanceOf
> ok 38 - Blessed arrayref should pass InstanceOf
> ok 39 - Empty hashref should fail InstanceOf
> ok 40 - Hashref should fail InstanceOf
> ok 41 - Blessed hashref should pass InstanceOf
> ok 42 - Coderef should fail InstanceOf
> ok 43 - Blessed coderef should pass InstanceOf
> ok 44 - Glob should fail InstanceOf
> ok 45 - Globref should fail InstanceOf
> ok 46 - Blessed globref should pass InstanceOf
> # UNDEFINED OUTCOME: regexp
> ok 47 - Blessed regexp should pass InstanceOf
> ok 48 - Filehandle should fail InstanceOf
> ok 49 - Filehandle object should pass InstanceOf
> ok 50 - Ref to scalarref should fail InstanceOf
> ok 51 - Ref to arrayref should fail InstanceOf
> ok 52 - Ref to hashref should fail InstanceOf
> ok 53 - Ref to coderef should fail InstanceOf
> ok 54 - Ref to blessed hashref should fail InstanceOf
> ok 55 - Object stringifying to "" should pass InstanceOf
> ok 56 - Object stringifying to "1" should pass InstanceOf
> ok 57 - Object numifying to 0 should pass InstanceOf
> ok 58 - Object numifying to 1 should pass InstanceOf
> ok 59 - Object overloading arrayref should pass InstanceOf
> ok 60 - Object overloading hashref should pass InstanceOf
> ok 61 - Object overloading coderef should pass InstanceOf
> ok 62 - Object booling to false should pass InstanceOf
> ok 63 - Object booling to true should pass InstanceOf
> ok 64 - Reference bless( {"class" => "Foo","coercion" => bless( {"_compiled_ty...) passes type constraint InstanceOf["Type::Tiny::Class"]
> ok 65 - Reference bless( {"class" => "Foo","coercion" => bless( {"_compiled_ty...) passes type constraint InstanceOf["Type::Tiny"]
> ok 66 - Reference bless( [], 'Foo::Bar' ) passes type constraint InstanceOf["Foo::Bar"]
> ok 67 - Reference bless( [], 'Foo::Bar' ) passes type constraint InstanceOf["Foo"]
> ok 68 - Reference bless( [], 'Foo' ) fails type constraint InstanceOf["Foo::Bar"]
> ok 69 - Reference bless( [], 'Foo' ) passes type constraint InstanceOf["Foo"]
> ok 70 - Reference bless( [], 'Foo::Baz' ) passes type constraint InstanceOf["Foo::Baz"]
> ok 71 - Reference bless( [], 'Foo::Baz' ) passes type constraint InstanceOf["Foo"]
> ok 72 - Reference bless( [], 'Foo' ) fails type constraint InstanceOf["Foo::Baz"]
> ok 73 - Reference bless( [], 'Foo' ) passes type constraint InstanceOf["Foo"]
> ok 74 - Reference bless( {"coercion" => bless( {"_union_of" => 'ARRAY(0x561c9c...) passes type constraint InstanceOf["Type::Tiny::Union"]
> ok 75 - Reference bless( {"coercion" => bless( {"_union_of" => 'ARRAY(0x561c9c...) passes type constraint InstanceOf["Type::Tiny"]
> ok 76
> ok 77 - Reference bless( {"class" => "Foo","compiled_type_constraint" => sub {...) passes type constraint InstanceOf["Type::Tiny::Class"]
> ok 78 - Reference bless( {"class" => "Bar","compiled_type_constraint" => sub {...) passes type constraint InstanceOf["Type::Tiny::Class"]
> ok 79 - Reference bless( [], 'Foo' ) passes type constraint InstanceOf["Foo","Bar"]
> ok 80 - Reference bless( [], 'Bar' ) passes type constraint InstanceOf["Foo","Bar"]
> ok 81
> ok 82 - Reference bless( {"gender" => "f","name" => "Alice"}, 'Local::Person' ) passes type constraint InstanceOf["Local::Person"]
> ok 83 - Reference bless( {"gender" => "m","name" => "Bob"}, 'Local::Person' ) passes type constraint InstanceOf["Local::Person"]
> ok 84 - Reference bless( {"gender" => "f","name" => "Alice"}, 'Local::Person' ) fails type constraint __ANON__
> ok 85 - Reference bless( {"gender" => "m","name" => "Bob"}, 'Local::Person' ) passes type constraint __ANON__
> 1..85
> ok
> t/21-types/Int.t .............................................
> ok 1 - 'Int' isa 'Type::Tiny'
> ok 2 - Int has correct name
> ok 3 - Int has correct display_name
> ok 4 - Int knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Int
> ok 6 - Int is not deprecated
> ok 7 - Int is not anonymous
> ok 8 - Int can be inlined
> ok 9 - Inlining Int doesn't throw an exception
> ok 10 - Int doesn't have a coercion
> ok 11 - Int isn't parameterizable
> ok 12 - Int has a type_default
> ok 13 - Int type_default is zero
> ok 14 - Undef should fail Int
> # UNDEFINED OUTCOME: false
> ok 15 - True should pass Int
> ok 16 - Zero should pass Int
> ok 17 - One should pass Int
> ok 18 - Negative one should pass Int
> ok 19 - Non integer should fail Int
> ok 20 - Empty string should fail Int
> ok 21 - Whitespace should fail Int
> ok 22 - Line break should fail Int
> ok 23 - Random string should fail Int
> ok 24 - Loaded package name should fail Int
> ok 25 - Unloaded package name should fail Int
> ok 26 - A reference to undef should fail Int
> ok 27 - A reference to false should fail Int
> ok 28 - A reference to true should fail Int
> ok 29 - A reference to zero should fail Int
> ok 30 - A reference to one should fail Int
> ok 31 - A reference to empty string should fail Int
> ok 32 - A reference to random string should fail Int
> ok 33 - Blessed scalarref should fail Int
> ok 34 - Empty arrayref should fail Int
> ok 35 - Arrayref with one zero should fail Int
> ok 36 - Arrayref of integers should fail Int
> ok 37 - Arrayref of numbers should fail Int
> ok 38 - Blessed arrayref should fail Int
> ok 39 - Empty hashref should fail Int
> ok 40 - Hashref should fail Int
> ok 41 - Blessed hashref should fail Int
> ok 42 - Coderef should fail Int
> ok 43 - Blessed coderef should fail Int
> ok 44 - Glob should fail Int
> ok 45 - Globref should fail Int
> ok 46 - Blessed globref should fail Int
> ok 47 - Regexp should fail Int
> ok 48 - Blessed regexp should fail Int
> ok 49 - Filehandle should fail Int
> ok 50 - Filehandle object should fail Int
> ok 51 - Ref to scalarref should fail Int
> ok 52 - Ref to arrayref should fail Int
> ok 53 - Ref to hashref should fail Int
> ok 54 - Ref to coderef should fail Int
> ok 55 - Ref to blessed hashref should fail Int
> ok 56 - Object stringifying to "" should fail Int
> ok 57 - Object stringifying to "1" should fail Int
> ok 58 - Object numifying to 0 should fail Int
> ok 59 - Object numifying to 1 should fail Int
> ok 60 - Object overloading arrayref should fail Int
> ok 61 - Object overloading hashref should fail Int
> ok 62 - Object overloading coderef should fail Int
> ok 63 - Object booling to false should fail Int
> ok 64 - Object booling to true should fail Int
> 1..64
> ok
> t/21-types/IntRange.t ........................................
> ok 1 - 'IntRange' isa 'Type::Tiny'
> ok 2 - IntRange has correct name
> ok 3 - IntRange has correct display_name
> ok 4 - IntRange knows it is in the Types::Common::Numeric library
> ok 5 - Types::Common::Numeric knows it has type IntRange
> ok 6 - IntRange is not deprecated
> ok 7 - IntRange is not anonymous
> ok 8 - IntRange can be inlined
> ok 9 - Inlining IntRange doesn't throw an exception
> ok 10 - IntRange doesn't have a coercion
> ok 11 - IntRange is parameterizable
> ok 12 - IntRange has a type_default
> ok 13 - IntRange type_default is zero
> ok 14 - Undef should fail IntRange
> # UNDEFINED OUTCOME: false
> ok 15 - True should pass IntRange
> ok 16 - Zero should pass IntRange
> ok 17 - One should pass IntRange
> ok 18 - Negative one should pass IntRange
> ok 19 - Non integer should fail IntRange
> ok 20 - Empty string should fail IntRange
> ok 21 - Whitespace should fail IntRange
> ok 22 - Line break should fail IntRange
> ok 23 - Random string should fail IntRange
> ok 24 - Loaded package name should fail IntRange
> ok 25 - Unloaded package name should fail IntRange
> ok 26 - A reference to undef should fail IntRange
> ok 27 - A reference to false should fail IntRange
> ok 28 - A reference to true should fail IntRange
> ok 29 - A reference to zero should fail IntRange
> ok 30 - A reference to one should fail IntRange
> ok 31 - A reference to empty string should fail IntRange
> ok 32 - A reference to random string should fail IntRange
> ok 33 - Blessed scalarref should fail IntRange
> ok 34 - Empty arrayref should fail IntRange
> ok 35 - Arrayref with one zero should fail IntRange
> ok 36 - Arrayref of integers should fail IntRange
> ok 37 - Arrayref of numbers should fail IntRange
> ok 38 - Blessed arrayref should fail IntRange
> ok 39 - Empty hashref should fail IntRange
> ok 40 - Hashref should fail IntRange
> ok 41 - Blessed hashref should fail IntRange
> ok 42 - Coderef should fail IntRange
> ok 43 - Blessed coderef should fail IntRange
> ok 44 - Glob should fail IntRange
> ok 45 - Globref should fail IntRange
> ok 46 - Blessed globref should fail IntRange
> ok 47 - Regexp should fail IntRange
> ok 48 - Blessed regexp should fail IntRange
> ok 49 - Filehandle should fail IntRange
> ok 50 - Filehandle object should fail IntRange
> ok 51 - Ref to scalarref should fail IntRange
> ok 52 - Ref to arrayref should fail IntRange
> ok 53 - Ref to hashref should fail IntRange
> ok 54 - Ref to coderef should fail IntRange
> ok 55 - Ref to blessed hashref should fail IntRange
> ok 56 - Object stringifying to "" should fail IntRange
> ok 57 - Object stringifying to "1" should fail IntRange
> ok 58 - Object numifying to 0 should fail IntRange
> ok 59 - Object numifying to 1 should fail IntRange
> ok 60 - Object overloading arrayref should fail IntRange
> ok 61 - Object overloading hashref should fail IntRange
> ok 62 - Object overloading coderef should fail IntRange
> ok 63 - Object booling to false should fail IntRange
> ok 64 - Object booling to true should fail IntRange
> ok 65 - Value "-2" fails type constraint IntRange[2]
> ok 66 - Value "-1" fails type constraint IntRange[2]
> ok 67 - Value "0" fails type constraint IntRange[2]
> ok 68 - Value "1" fails type constraint IntRange[2]
> ok 69 - Value "2" passes type constraint IntRange[2]
> ok 70 - Value "3" passes type constraint IntRange[2]
> ok 71 - Value "4" passes type constraint IntRange[2]
> ok 72 - Value "5" passes type constraint IntRange[2]
> ok 73 - Value "6" passes type constraint IntRange[2]
> ok 74 - Value "3.1416" fails type constraint IntRange[2]
> ok 75 - Reference [] fails type constraint IntRange[2]
> ok 76 - IntRange[2] has no type_default
> ok 77 - Value "-2" fails type constraint IntRange[2,4]
> ok 78 - Value "-1" fails type constraint IntRange[2,4]
> ok 79 - Value "0" fails type constraint IntRange[2,4]
> ok 80 - Value "1" fails type constraint IntRange[2,4]
> ok 81 - Value "2" passes type constraint IntRange[2,4]
> ok 82 - Value "3" passes type constraint IntRange[2,4]
> ok 83 - Value "4" passes type constraint IntRange[2,4]
> ok 84 - Value "5" fails type constraint IntRange[2,4]
> ok 85 - Value "6" fails type constraint IntRange[2,4]
> ok 86 - Value "3.1416" fails type constraint IntRange[2,4]
> ok 87 - Reference [] fails type constraint IntRange[2,4]
> ok 88 - Value "-2" fails type constraint IntRange[2,4,1,1]
> ok 89 - Value "-1" fails type constraint IntRange[2,4,1,1]
> ok 90 - Value "0" fails type constraint IntRange[2,4,1,1]
> ok 91 - Value "1" fails type constraint IntRange[2,4,1,1]
> ok 92 - Value "2" fails type constraint IntRange[2,4,1,1]
> ok 93 - Value "3" passes type constraint IntRange[2,4,1,1]
> ok 94 - Value "4" fails type constraint IntRange[2,4,1,1]
> ok 95 - Value "5" fails type constraint IntRange[2,4,1,1]
> ok 96 - Value "6" fails type constraint IntRange[2,4,1,1]
> ok 97 - Value "3.1416" fails type constraint IntRange[2,4,1,1]
> ok 98 - Reference [] fails type constraint IntRange[2,4,1,1]
> ok 99 - bad parameter
> 1..99
> ok
> t/21-types/Item.t ............................................
> ok 1 - 'Item' isa 'Type::Tiny'
> ok 2 - Item has correct name
> ok 3 - Item has correct display_name
> ok 4 - Item knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Item
> ok 6 - Item is not deprecated
> ok 7 - Item is not anonymous
> ok 8 - Item can be inlined
> ok 9 - Inlining Item doesn't throw an exception
> ok 10 - Item doesn't have a coercion
> ok 11 - Item isn't parameterizable
> ok 12 - Item has a type_default
> ok 13 - Item type_default is undef
> ok 14 - Undef should pass Item
> ok 15 - False should pass Item
> ok 16 - True should pass Item
> ok 17 - Zero should pass Item
> ok 18 - One should pass Item
> ok 19 - Negative one should pass Item
> ok 20 - Non integer should pass Item
> ok 21 - Empty string should pass Item
> ok 22 - Whitespace should pass Item
> ok 23 - Line break should pass Item
> ok 24 - Random string should pass Item
> ok 25 - Loaded package name should pass Item
> ok 26 - Unloaded package name should pass Item
> ok 27 - A reference to undef should pass Item
> ok 28 - A reference to false should pass Item
> ok 29 - A reference to true should pass Item
> ok 30 - A reference to zero should pass Item
> ok 31 - A reference to one should pass Item
> ok 32 - A reference to empty string should pass Item
> ok 33 - A reference to random string should pass Item
> ok 34 - Blessed scalarref should pass Item
> ok 35 - Empty arrayref should pass Item
> ok 36 - Arrayref with one zero should pass Item
> ok 37 - Arrayref of integers should pass Item
> ok 38 - Arrayref of numbers should pass Item
> ok 39 - Blessed arrayref should pass Item
> ok 40 - Empty hashref should pass Item
> ok 41 - Hashref should pass Item
> ok 42 - Blessed hashref should pass Item
> ok 43 - Coderef should pass Item
> ok 44 - Blessed coderef should pass Item
> ok 45 - Glob should pass Item
> ok 46 - Globref should pass Item
> ok 47 - Blessed globref should pass Item
> ok 48 - Regexp should pass Item
> ok 49 - Blessed regexp should pass Item
> ok 50 - Filehandle should pass Item
> ok 51 - Filehandle object should pass Item
> ok 52 - Ref to scalarref should pass Item
> ok 53 - Ref to arrayref should pass Item
> ok 54 - Ref to hashref should pass Item
> ok 55 - Ref to coderef should pass Item
> ok 56 - Ref to blessed hashref should pass Item
> ok 57 - Object stringifying to "" should pass Item
> ok 58 - Object stringifying to "1" should pass Item
> ok 59 - Object numifying to 0 should pass Item
> ok 60 - Object numifying to 1 should pass Item
> ok 61 - Object overloading arrayref should pass Item
> ok 62 - Object overloading hashref should pass Item
> ok 63 - Object overloading coderef should pass Item
> ok 64 - Object booling to false should pass Item
> ok 65 - Object booling to true should pass Item
> 1..65
> ok
> t/21-types/LaxNum.t ..........................................
> ok 1 - 'LaxNum' isa 'Type::Tiny'
> ok 2 - LaxNum has correct name
> ok 3 - LaxNum has correct display_name
> ok 4 - LaxNum knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type LaxNum
> ok 6 - LaxNum is not deprecated
> ok 7 - LaxNum is not anonymous
> ok 8 - LaxNum can be inlined
> ok 9 - Inlining LaxNum doesn't throw an exception
> ok 10 - LaxNum doesn't have a coercion
> ok 11 - LaxNum isn't parameterizable
> ok 12 - LaxNum has a type_default
> ok 13 - LaxNum type_default is zero
> ok 14 - Undef should fail LaxNum
> ok 15 - False should fail LaxNum
> ok 16 - True should pass LaxNum
> ok 17 - Zero should pass LaxNum
> ok 18 - One should pass LaxNum
> ok 19 - Negative one should pass LaxNum
> ok 20 - Non integer should pass LaxNum
> ok 21 - Empty string should fail LaxNum
> ok 22 - Whitespace should fail LaxNum
> ok 23 - Line break should fail LaxNum
> ok 24 - Random string should fail LaxNum
> ok 25 - Loaded package name should fail LaxNum
> ok 26 - Unloaded package name should fail LaxNum
> ok 27 - A reference to undef should fail LaxNum
> ok 28 - A reference to false should fail LaxNum
> ok 29 - A reference to true should fail LaxNum
> ok 30 - A reference to zero should fail LaxNum
> ok 31 - A reference to one should fail LaxNum
> ok 32 - A reference to empty string should fail LaxNum
> ok 33 - A reference to random string should fail LaxNum
> ok 34 - Blessed scalarref should fail LaxNum
> ok 35 - Empty arrayref should fail LaxNum
> ok 36 - Arrayref with one zero should fail LaxNum
> ok 37 - Arrayref of integers should fail LaxNum
> ok 38 - Arrayref of numbers should fail LaxNum
> ok 39 - Blessed arrayref should fail LaxNum
> ok 40 - Empty hashref should fail LaxNum
> ok 41 - Hashref should fail LaxNum
> ok 42 - Blessed hashref should fail LaxNum
> ok 43 - Coderef should fail LaxNum
> ok 44 - Blessed coderef should fail LaxNum
> ok 45 - Glob should fail LaxNum
> ok 46 - Globref should fail LaxNum
> ok 47 - Blessed globref should fail LaxNum
> ok 48 - Regexp should fail LaxNum
> ok 49 - Blessed regexp should fail LaxNum
> ok 50 - Filehandle should fail LaxNum
> ok 51 - Filehandle object should fail LaxNum
> ok 52 - Ref to scalarref should fail LaxNum
> ok 53 - Ref to arrayref should fail LaxNum
> ok 54 - Ref to hashref should fail LaxNum
> ok 55 - Ref to coderef should fail LaxNum
> ok 56 - Ref to blessed hashref should fail LaxNum
> ok 57 - Object stringifying to "" should fail LaxNum
> ok 58 - Object stringifying to "1" should fail LaxNum
> ok 59 - Object numifying to 0 should fail LaxNum
> ok 60 - Object numifying to 1 should fail LaxNum
> ok 61 - Object overloading arrayref should fail LaxNum
> ok 62 - Object overloading hashref should fail LaxNum
> ok 63 - Object overloading coderef should fail LaxNum
> ok 64 - Object booling to false should fail LaxNum
> ok 65 - Object booling to true should fail LaxNum
> ok 66 - Numeric sorting
> 1..66
> ok
> t/21-types/LowerCaseSimpleStr.t ..............................
> ok 1 - 'LowerCaseSimpleStr' isa 'Type::Tiny'
> ok 2 - LowerCaseSimpleStr has correct name
> ok 3 - LowerCaseSimpleStr has correct display_name
> ok 4 - LowerCaseSimpleStr knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type LowerCaseSimpleStr
> ok 6 - LowerCaseSimpleStr is not deprecated
> ok 7 - LowerCaseSimpleStr is not anonymous
> ok 8 - LowerCaseSimpleStr can be inlined
> ok 9 - Inlining LowerCaseSimpleStr doesn't throw an exception
> ok 10 - LowerCaseSimpleStr has a coercion
> ok 11 - LowerCaseSimpleStr isn't parameterizable
> ok 12 - LowerCaseSimpleStr has no type_default
> ok 13 - Undef should fail LowerCaseSimpleStr
> ok 14 - False should fail LowerCaseSimpleStr
> ok 15 - True should pass LowerCaseSimpleStr
> ok 16 - Zero should pass LowerCaseSimpleStr
> ok 17 - One should pass LowerCaseSimpleStr
> ok 18 - Negative one should pass LowerCaseSimpleStr
> ok 19 - Non integer should pass LowerCaseSimpleStr
> ok 20 - Empty string should fail LowerCaseSimpleStr
> ok 21 - Whitespace should pass LowerCaseSimpleStr
> ok 22 - Line break should fail LowerCaseSimpleStr
> ok 23 - Random string should pass LowerCaseSimpleStr
> ok 24 - Loaded package name should fail LowerCaseSimpleStr
> ok 25 - Unloaded package name should fail LowerCaseSimpleStr
> ok 26 - A reference to undef should fail LowerCaseSimpleStr
> ok 27 - A reference to false should fail LowerCaseSimpleStr
> ok 28 - A reference to true should fail LowerCaseSimpleStr
> ok 29 - A reference to zero should fail LowerCaseSimpleStr
> ok 30 - A reference to one should fail LowerCaseSimpleStr
> ok 31 - A reference to empty string should fail LowerCaseSimpleStr
> ok 32 - A reference to random string should fail LowerCaseSimpleStr
> ok 33 - Blessed scalarref should fail LowerCaseSimpleStr
> ok 34 - Empty arrayref should fail LowerCaseSimpleStr
> ok 35 - Arrayref with one zero should fail LowerCaseSimpleStr
> ok 36 - Arrayref of integers should fail LowerCaseSimpleStr
> ok 37 - Arrayref of numbers should fail LowerCaseSimpleStr
> ok 38 - Blessed arrayref should fail LowerCaseSimpleStr
> ok 39 - Empty hashref should fail LowerCaseSimpleStr
> ok 40 - Hashref should fail LowerCaseSimpleStr
> ok 41 - Blessed hashref should fail LowerCaseSimpleStr
> ok 42 - Coderef should fail LowerCaseSimpleStr
> ok 43 - Blessed coderef should fail LowerCaseSimpleStr
> ok 44 - Glob should fail LowerCaseSimpleStr
> ok 45 - Globref should fail LowerCaseSimpleStr
> ok 46 - Blessed globref should fail LowerCaseSimpleStr
> ok 47 - Regexp should fail LowerCaseSimpleStr
> ok 48 - Blessed regexp should fail LowerCaseSimpleStr
> ok 49 - Filehandle should fail LowerCaseSimpleStr
> ok 50 - Filehandle object should fail LowerCaseSimpleStr
> ok 51 - Ref to scalarref should fail LowerCaseSimpleStr
> ok 52 - Ref to arrayref should fail LowerCaseSimpleStr
> ok 53 - Ref to hashref should fail LowerCaseSimpleStr
> ok 54 - Ref to coderef should fail LowerCaseSimpleStr
> ok 55 - Ref to blessed hashref should fail LowerCaseSimpleStr
> ok 56 - Object stringifying to "" should fail LowerCaseSimpleStr
> ok 57 - Object stringifying to "1" should fail LowerCaseSimpleStr
> ok 58 - Object numifying to 0 should fail LowerCaseSimpleStr
> ok 59 - Object numifying to 1 should fail LowerCaseSimpleStr
> ok 60 - Object overloading arrayref should fail LowerCaseSimpleStr
> ok 61 - Object overloading hashref should fail LowerCaseSimpleStr
> ok 62 - Object overloading coderef should fail LowerCaseSimpleStr
> ok 63 - Object booling to false should fail LowerCaseSimpleStr
> ok 64 - Object booling to true should fail LowerCaseSimpleStr
> ok 65 - Value "\x{436}" passes type constraint LowerCaseSimpleStr
> ok 66 - Value "\x{416}" fails type constraint LowerCaseSimpleStr
> ok 67 - Value "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" passes type constraint LowerCaseSimpleStr
> ok 68 - Value "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" fails type constraint LowerCaseSimpleStr
> ok 69 - Value "\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}" passes type constraint LowerCaseSimpleStr
> ok 70 - Value "\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}" fails type constraint LowerCaseSimpleStr
> ok 71 - Value "ABCDEF" fails type constraint LowerCaseSimpleStr
> ok 72 - Value "ABC123" fails type constraint LowerCaseSimpleStr
> ok 73 - Value "abc123" passes type constraint LowerCaseSimpleStr
> ok 74 - Value "abcdef" passes type constraint LowerCaseSimpleStr
> ok 75 - Value "123456" passes type constraint LowerCaseSimpleStr
> ok 76 - Value " " passes type constraint LowerCaseSimpleStr
> ok 77 - Value "" fails type constraint LowerCaseSimpleStr
> ok 78 - coercion success
> ok 79 - does not coerce non-strings
> 1..79
> ok
> t/21-types/LowerCaseStr.t ....................................
> ok 1 - 'LowerCaseStr' isa 'Type::Tiny'
> ok 2 - LowerCaseStr has correct name
> ok 3 - LowerCaseStr has correct display_name
> ok 4 - LowerCaseStr knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type LowerCaseStr
> ok 6 - LowerCaseStr is not deprecated
> ok 7 - LowerCaseStr is not anonymous
> ok 8 - LowerCaseStr can be inlined
> ok 9 - Inlining LowerCaseStr doesn't throw an exception
> ok 10 - LowerCaseStr has a coercion
> ok 11 - LowerCaseStr isn't parameterizable
> ok 12 - LowerCaseStr has no type_default
> ok 13 - Undef should fail LowerCaseStr
> ok 14 - False should fail LowerCaseStr
> ok 15 - True should pass LowerCaseStr
> ok 16 - Zero should pass LowerCaseStr
> ok 17 - One should pass LowerCaseStr
> ok 18 - Negative one should pass LowerCaseStr
> ok 19 - Non integer should pass LowerCaseStr
> ok 20 - Empty string should fail LowerCaseStr
> ok 21 - Whitespace should pass LowerCaseStr
> ok 22 - Line break should pass LowerCaseStr
> ok 23 - Random string should pass LowerCaseStr
> ok 24 - Loaded package name should fail LowerCaseStr
> ok 25 - Unloaded package name should fail LowerCaseStr
> ok 26 - A reference to undef should fail LowerCaseStr
> ok 27 - A reference to false should fail LowerCaseStr
> ok 28 - A reference to true should fail LowerCaseStr
> ok 29 - A reference to zero should fail LowerCaseStr
> ok 30 - A reference to one should fail LowerCaseStr
> ok 31 - A reference to empty string should fail LowerCaseStr
> ok 32 - A reference to random string should fail LowerCaseStr
> ok 33 - Blessed scalarref should fail LowerCaseStr
> ok 34 - Empty arrayref should fail LowerCaseStr
> ok 35 - Arrayref with one zero should fail LowerCaseStr
> ok 36 - Arrayref of integers should fail LowerCaseStr
> ok 37 - Arrayref of numbers should fail LowerCaseStr
> ok 38 - Blessed arrayref should fail LowerCaseStr
> ok 39 - Empty hashref should fail LowerCaseStr
> ok 40 - Hashref should fail LowerCaseStr
> ok 41 - Blessed hashref should fail LowerCaseStr
> ok 42 - Coderef should fail LowerCaseStr
> ok 43 - Blessed coderef should fail LowerCaseStr
> ok 44 - Glob should fail LowerCaseStr
> ok 45 - Globref should fail LowerCaseStr
> ok 46 - Blessed globref should fail LowerCaseStr
> ok 47 - Regexp should fail LowerCaseStr
> ok 48 - Blessed regexp should fail LowerCaseStr
> ok 49 - Filehandle should fail LowerCaseStr
> ok 50 - Filehandle object should fail LowerCaseStr
> ok 51 - Ref to scalarref should fail LowerCaseStr
> ok 52 - Ref to arrayref should fail LowerCaseStr
> ok 53 - Ref to hashref should fail LowerCaseStr
> ok 54 - Ref to coderef should fail LowerCaseStr
> ok 55 - Ref to blessed hashref should fail LowerCaseStr
> ok 56 - Object stringifying to "" should fail LowerCaseStr
> ok 57 - Object stringifying to "1" should fail LowerCaseStr
> ok 58 - Object numifying to 0 should fail LowerCaseStr
> ok 59 - Object numifying to 1 should fail LowerCaseStr
> ok 60 - Object overloading arrayref should fail LowerCaseStr
> ok 61 - Object overloading hashref should fail LowerCaseStr
> ok 62 - Object overloading coderef should fail LowerCaseStr
> ok 63 - Object booling to false should fail LowerCaseStr
> ok 64 - Object booling to true should fail LowerCaseStr
> ok 65 - Value "\x{436}" passes type constraint LowerCaseStr
> ok 66 - Value "\x{416}" fails type constraint LowerCaseStr
> ok 67 - Value "ABCDEF" fails type constraint LowerCaseStr
> ok 68 - Value "ABC123" fails type constraint LowerCaseStr
> ok 69 - Value "abc123" passes type constraint LowerCaseStr
> ok 70 - Value "abcdef" passes type constraint LowerCaseStr
> ok 71 - Value "123456" passes type constraint LowerCaseStr
> ok 72 - Value " " passes type constraint LowerCaseStr
> ok 73 - Value "" fails type constraint LowerCaseStr
> ok 74 - coercion success
> ok 75 - does not coerce non-strings
> 1..75
> ok
> t/21-types/Map.t .............................................
> ok 1 - 'Map' isa 'Type::Tiny'
> ok 2 - Map has correct name
> ok 3 - Map has correct display_name
> ok 4 - Map knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Map
> ok 6 - Map is not deprecated
> ok 7 - Map is not anonymous
> ok 8 - Map can be inlined
> ok 9 - Inlining Map doesn't throw an exception
> ok 10 - Map doesn't have a coercion
> ok 11 - Map is parameterizable
> ok 12 - Map has a type_default
> ok 13 - Map type_default is {}
> ok 14 - Undef should fail Map
> ok 15 - False should fail Map
> ok 16 - True should fail Map
> ok 17 - Zero should fail Map
> ok 18 - One should fail Map
> ok 19 - Negative one should fail Map
> ok 20 - Non integer should fail Map
> ok 21 - Empty string should fail Map
> ok 22 - Whitespace should fail Map
> ok 23 - Line break should fail Map
> ok 24 - Random string should fail Map
> ok 25 - Loaded package name should fail Map
> ok 26 - Unloaded package name should fail Map
> ok 27 - A reference to undef should fail Map
> ok 28 - A reference to false should fail Map
> ok 29 - A reference to true should fail Map
> ok 30 - A reference to zero should fail Map
> ok 31 - A reference to one should fail Map
> ok 32 - A reference to empty string should fail Map
> ok 33 - A reference to random string should fail Map
> ok 34 - Blessed scalarref should fail Map
> ok 35 - Empty arrayref should fail Map
> ok 36 - Arrayref with one zero should fail Map
> ok 37 - Arrayref of integers should fail Map
> ok 38 - Arrayref of numbers should fail Map
> ok 39 - Blessed arrayref should fail Map
> ok 40 - Empty hashref should pass Map
> ok 41 - Hashref should pass Map
> ok 42 - Blessed hashref should fail Map
> ok 43 - Coderef should fail Map
> ok 44 - Blessed coderef should fail Map
> ok 45 - Glob should fail Map
> ok 46 - Globref should fail Map
> ok 47 - Blessed globref should fail Map
> ok 48 - Regexp should fail Map
> ok 49 - Blessed regexp should fail Map
> ok 50 - Filehandle should fail Map
> ok 51 - Filehandle object should fail Map
> ok 52 - Ref to scalarref should fail Map
> ok 53 - Ref to arrayref should fail Map
> ok 54 - Ref to hashref should fail Map
> ok 55 - Ref to coderef should fail Map
> ok 56 - Ref to blessed hashref should fail Map
> ok 57 - Object stringifying to "" should fail Map
> ok 58 - Object stringifying to "1" should fail Map
> ok 59 - Object numifying to 0 should fail Map
> ok 60 - Object numifying to 1 should fail Map
> ok 61 - Object overloading arrayref should fail Map
> ok 62 - Object overloading hashref should fail Map
> ok 63 - Object overloading coderef should fail Map
> ok 64 - Object booling to false should fail Map
> ok 65 - Object booling to true should fail Map
> ok 66 - '$MapWithIntKeys' isa 'Type::Tiny'
> ok 67 - $MapWithIntKeys has correct display_name
> ok 68 - $MapWithIntKeys has no name
> ok 69 - $MapWithIntKeys can be inlined
> ok 70 - Inlining $MapWithIntKeys doesn't throw an exception
> ok 71 - $MapWithIntKeys doesn't have a coercion
> ok 72 - $MapWithIntKeys is not parameterizable
> ok 73 - $MapWithIntKeys has a type_default
> ok 74 - $MapWithIntKeys type_default is {}
> ok 75 - HashRef subtype: Map[Int,Any]
> ok 76 - Value "1" fails type constraint Map[Int,Any]
> ok 77 - Reference [] fails type constraint Map[Int,Any]
> ok 78 - Reference {} passes type constraint Map[Int,Any]
> ok 79 - Reference {"1.1" => []} fails type constraint Map[Int,Any]
> ok 80 - Reference {"1" => 1} passes type constraint Map[Int,Any]
> ok 81 - Reference {"1" => 0} passes type constraint Map[Int,Any]
> ok 82 - Reference {"1" => -1} passes type constraint Map[Int,Any]
> ok 83 - Reference {"1" => \1} passes type constraint Map[Int,Any]
> ok 84 - Reference {"-1" => -1} passes type constraint Map[Int,Any]
> ok 85 - Reference {"foo" => 1} fails type constraint Map[Int,Any]
> ok 86 - my_hashref_allows_key('1234')
> ok 87 - !my_hashref_allows_key('abc')
> ok 88 - '$HashOfInts' isa 'Type::Tiny'
> ok 89 - $HashOfInts has correct display_name
> ok 90 - $HashOfInts has no name
> ok 91 - $HashOfInts can be inlined
> ok 92 - Inlining $HashOfInts doesn't throw an exception
> ok 93 - $HashOfInts doesn't have a coercion
> ok 94 - $HashOfInts is not parameterizable
> ok 95 - HashRef subtype: Map[Any,Int]
> ok 96 - Value "1" fails type constraint Map[Any,Int]
> ok 97 - Reference [] fails type constraint Map[Any,Int]
> ok 98 - Reference {} passes type constraint Map[Any,Int]
> ok 99 - Reference {"foo" => []} fails type constraint Map[Any,Int]
> ok 100 - Reference {"foo" => "1.1"} fails type constraint Map[Any,Int]
> ok 101 - Reference {"foo" => 1} passes type constraint Map[Any,Int]
> ok 102 - Reference {"foo" => 0} passes type constraint Map[Any,Int]
> ok 103 - Reference {"foo" => -1} passes type constraint Map[Any,Int]
> ok 104 - Reference {"foo" => \1} fails type constraint Map[Any,Int]
> ok 105 - Reference {"123" => \1} fails type constraint Map[Any,Int]
> ok 106 - Reference {"123" => 1} passes type constraint Map[Any,Int]
> ok 107 - Reference {"bar" => 2,"foo" => 1} passes type constraint Map[Any,Int]
> ok 108 - Reference {"bar" => [],"foo" => 1} fails type constraint Map[Any,Int]
> ok 109 - my_hashref_allows_key('foo')
> ok 110 - my_hashref_allows_value('foo', 1234)
> ok 111 - !my_hashref_allows_value('foo', qr//)
> ok 112 - just returned orig unchanged
> ok 113 - coercion happened
> ok 114 - ... and data looks good
> ok 115 - ... and now passes type constraint
> ok 116 - coercion failed, so orig was returned
> ok 117 - Reference {"foo" => []} fails type constraint Map[Int,Int]
> ok 118 - bad parameters
> 1..118
> ok
> t/21-types/Maybe.t ...........................................
> ok 1 - 'Maybe' isa 'Type::Tiny'
> ok 2 - Maybe has correct name
> ok 3 - Maybe has correct display_name
> ok 4 - Maybe knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Maybe
> ok 6 - Maybe is not deprecated
> ok 7 - Maybe is not anonymous
> ok 8 - Maybe can be inlined
> ok 9 - Inlining Maybe doesn't throw an exception
> ok 10 - Maybe doesn't have a coercion
> ok 11 - Maybe is parameterizable
> ok 12 - Maybe has a type_default
> ok 13 - Maybe type_default is undef
> ok 14 - Undef should pass Maybe
> ok 15 - False should pass Maybe
> ok 16 - True should pass Maybe
> ok 17 - Zero should pass Maybe
> ok 18 - One should pass Maybe
> ok 19 - Negative one should pass Maybe
> ok 20 - Non integer should pass Maybe
> ok 21 - Empty string should pass Maybe
> ok 22 - Whitespace should pass Maybe
> ok 23 - Line break should pass Maybe
> ok 24 - Random string should pass Maybe
> ok 25 - Loaded package name should pass Maybe
> ok 26 - Unloaded package name should pass Maybe
> ok 27 - A reference to undef should pass Maybe
> ok 28 - A reference to false should pass Maybe
> ok 29 - A reference to true should pass Maybe
> ok 30 - A reference to zero should pass Maybe
> ok 31 - A reference to one should pass Maybe
> ok 32 - A reference to empty string should pass Maybe
> ok 33 - A reference to random string should pass Maybe
> ok 34 - Blessed scalarref should pass Maybe
> ok 35 - Empty arrayref should pass Maybe
> ok 36 - Arrayref with one zero should pass Maybe
> ok 37 - Arrayref of integers should pass Maybe
> ok 38 - Arrayref of numbers should pass Maybe
> ok 39 - Blessed arrayref should pass Maybe
> ok 40 - Empty hashref should pass Maybe
> ok 41 - Hashref should pass Maybe
> ok 42 - Blessed hashref should pass Maybe
> ok 43 - Coderef should pass Maybe
> ok 44 - Blessed coderef should pass Maybe
> ok 45 - Glob should pass Maybe
> ok 46 - Globref should pass Maybe
> ok 47 - Blessed globref should pass Maybe
> ok 48 - Regexp should pass Maybe
> ok 49 - Blessed regexp should pass Maybe
> ok 50 - Filehandle should pass Maybe
> ok 51 - Filehandle object should pass Maybe
> ok 52 - Ref to scalarref should pass Maybe
> ok 53 - Ref to arrayref should pass Maybe
> ok 54 - Ref to hashref should pass Maybe
> ok 55 - Ref to coderef should pass Maybe
> ok 56 - Ref to blessed hashref should pass Maybe
> ok 57 - Object stringifying to "" should pass Maybe
> ok 58 - Object stringifying to "1" should pass Maybe
> ok 59 - Object numifying to 0 should pass Maybe
> ok 60 - Object numifying to 1 should pass Maybe
> ok 61 - Object overloading arrayref should pass Maybe
> ok 62 - Object overloading hashref should pass Maybe
> ok 63 - Object overloading coderef should pass Maybe
> ok 64 - Object booling to false should pass Maybe
> ok 65 - Object booling to true should pass Maybe
> ok 66 - Value "0" passes type constraint Maybe[Int]
> ok 67 - Value "1" passes type constraint Maybe[Int]
> ok 68 - Value "1.1" fails type constraint Maybe[Int]
> ok 69 - Undef passes type constraint Maybe[Int]
> ok 70 - Maybe[Int] has a type_default, because Int does
> ok 71 - Maybe[Int] type_default is 0
> ok 72 - Maybe[Defined] has a type_default, even though Defined doesn't
> ok 73 - Maybe[Defined] type_default is undef
> 1..73
> ok
> t/21-types/NegativeInt.t .....................................
> ok 1 - 'NegativeInt' isa 'Type::Tiny'
> ok 2 - NegativeInt has correct name
> ok 3 - NegativeInt has correct display_name
> ok 4 - NegativeInt knows it is in the Types::Common::Numeric library
> ok 5 - Types::Common::Numeric knows it has type NegativeInt
> ok 6 - NegativeInt is not deprecated
> ok 7 - NegativeInt is not anonymous
> ok 8 - NegativeInt can be inlined
> ok 9 - Inlining NegativeInt doesn't throw an exception
> ok 10 - NegativeInt doesn't have a coercion
> ok 11 - NegativeInt isn't parameterizable
> ok 12 - NegativeInt has no type_default
> ok 13 - Undef should fail NegativeInt
> ok 14 - False should fail NegativeInt
> ok 15 - True should fail NegativeInt
> ok 16 - Zero should fail NegativeInt
> ok 17 - One should fail NegativeInt
> ok 18 - Negative one should pass NegativeInt
> ok 19 - Non integer should fail NegativeInt
> ok 20 - Empty string should fail NegativeInt
> ok 21 - Whitespace should fail NegativeInt
> ok 22 - Line break should fail NegativeInt
> ok 23 - Random string should fail NegativeInt
> ok 24 - Loaded package name should fail NegativeInt
> ok 25 - Unloaded package name should fail NegativeInt
> ok 26 - A reference to undef should fail NegativeInt
> ok 27 - A reference to false should fail NegativeInt
> ok 28 - A reference to true should fail NegativeInt
> ok 29 - A reference to zero should fail NegativeInt
> ok 30 - A reference to one should fail NegativeInt
> ok 31 - A reference to empty string should fail NegativeInt
> ok 32 - A reference to random string should fail NegativeInt
> ok 33 - Blessed scalarref should fail NegativeInt
> ok 34 - Empty arrayref should fail NegativeInt
> ok 35 - Arrayref with one zero should fail NegativeInt
> ok 36 - Arrayref of integers should fail NegativeInt
> ok 37 - Arrayref of numbers should fail NegativeInt
> ok 38 - Blessed arrayref should fail NegativeInt
> ok 39 - Empty hashref should fail NegativeInt
> ok 40 - Hashref should fail NegativeInt
> ok 41 - Blessed hashref should fail NegativeInt
> ok 42 - Coderef should fail NegativeInt
> ok 43 - Blessed coderef should fail NegativeInt
> ok 44 - Glob should fail NegativeInt
> ok 45 - Globref should fail NegativeInt
> ok 46 - Blessed globref should fail NegativeInt
> ok 47 - Regexp should fail NegativeInt
> ok 48 - Blessed regexp should fail NegativeInt
> ok 49 - Filehandle should fail NegativeInt
> ok 50 - Filehandle object should fail NegativeInt
> ok 51 - Ref to scalarref should fail NegativeInt
> ok 52 - Ref to arrayref should fail NegativeInt
> ok 53 - Ref to hashref should fail NegativeInt
> ok 54 - Ref to coderef should fail NegativeInt
> ok 55 - Ref to blessed hashref should fail NegativeInt
> ok 56 - Object stringifying to "" should fail NegativeInt
> ok 57 - Object stringifying to "1" should fail NegativeInt
> ok 58 - Object numifying to 0 should fail NegativeInt
> ok 59 - Object numifying to 1 should fail NegativeInt
> ok 60 - Object overloading arrayref should fail NegativeInt
> ok 61 - Object overloading hashref should fail NegativeInt
> ok 62 - Object overloading coderef should fail NegativeInt
> ok 63 - Object booling to false should fail NegativeInt
> ok 64 - Object booling to true should fail NegativeInt
> 1..64
> ok
> t/21-types/NegativeNum.t .....................................
> ok 1 - 'NegativeNum' isa 'Type::Tiny'
> ok 2 - NegativeNum has correct name
> ok 3 - NegativeNum has correct display_name
> ok 4 - NegativeNum knows it is in the Types::Common::Numeric library
> ok 5 - Types::Common::Numeric knows it has type NegativeNum
> ok 6 - NegativeNum is not deprecated
> ok 7 - NegativeNum is not anonymous
> ok 8 - NegativeNum can be inlined
> ok 9 - Inlining NegativeNum doesn't throw an exception
> ok 10 - NegativeNum doesn't have a coercion
> ok 11 - NegativeNum isn't parameterizable
> ok 12 - NegativeNum has no type_default
> ok 13 - Undef should fail NegativeNum
> ok 14 - False should fail NegativeNum
> ok 15 - True should fail NegativeNum
> ok 16 - Zero should fail NegativeNum
> ok 17 - One should fail NegativeNum
> ok 18 - Negative one should pass NegativeNum
> ok 19 - Non integer should fail NegativeNum
> ok 20 - Empty string should fail NegativeNum
> ok 21 - Whitespace should fail NegativeNum
> ok 22 - Line break should fail NegativeNum
> ok 23 - Random string should fail NegativeNum
> ok 24 - Loaded package name should fail NegativeNum
> ok 25 - Unloaded package name should fail NegativeNum
> ok 26 - A reference to undef should fail NegativeNum
> ok 27 - A reference to false should fail NegativeNum
> ok 28 - A reference to true should fail NegativeNum
> ok 29 - A reference to zero should fail NegativeNum
> ok 30 - A reference to one should fail NegativeNum
> ok 31 - A reference to empty string should fail NegativeNum
> ok 32 - A reference to random string should fail NegativeNum
> ok 33 - Blessed scalarref should fail NegativeNum
> ok 34 - Empty arrayref should fail NegativeNum
> ok 35 - Arrayref with one zero should fail NegativeNum
> ok 36 - Arrayref of integers should fail NegativeNum
> ok 37 - Arrayref of numbers should fail NegativeNum
> ok 38 - Blessed arrayref should fail NegativeNum
> ok 39 - Empty hashref should fail NegativeNum
> ok 40 - Hashref should fail NegativeNum
> ok 41 - Blessed hashref should fail NegativeNum
> ok 42 - Coderef should fail NegativeNum
> ok 43 - Blessed coderef should fail NegativeNum
> ok 44 - Glob should fail NegativeNum
> ok 45 - Globref should fail NegativeNum
> ok 46 - Blessed globref should fail NegativeNum
> ok 47 - Regexp should fail NegativeNum
> ok 48 - Blessed regexp should fail NegativeNum
> ok 49 - Filehandle should fail NegativeNum
> ok 50 - Filehandle object should fail NegativeNum
> ok 51 - Ref to scalarref should fail NegativeNum
> ok 52 - Ref to arrayref should fail NegativeNum
> ok 53 - Ref to hashref should fail NegativeNum
> ok 54 - Ref to coderef should fail NegativeNum
> ok 55 - Ref to blessed hashref should fail NegativeNum
> ok 56 - Object stringifying to "" should fail NegativeNum
> ok 57 - Object stringifying to "1" should fail NegativeNum
> ok 58 - Object numifying to 0 should fail NegativeNum
> ok 59 - Object numifying to 1 should fail NegativeNum
> ok 60 - Object overloading arrayref should fail NegativeNum
> ok 61 - Object overloading hashref should fail NegativeNum
> ok 62 - Object overloading coderef should fail NegativeNum
> ok 63 - Object booling to false should fail NegativeNum
> ok 64 - Object booling to true should fail NegativeNum
> 1..64
> ok
> t/21-types/NegativeOrZeroInt.t ...............................
> ok 1 - 'NegativeOrZeroInt' isa 'Type::Tiny'
> ok 2 - NegativeOrZeroInt has correct name
> ok 3 - NegativeOrZeroInt has correct display_name
> ok 4 - NegativeOrZeroInt knows it is in the Types::Common::Numeric library
> ok 5 - Types::Common::Numeric knows it has type NegativeOrZeroInt
> ok 6 - NegativeOrZeroInt is not deprecated
> ok 7 - NegativeOrZeroInt is not anonymous
> ok 8 - NegativeOrZeroInt can be inlined
> ok 9 - Inlining NegativeOrZeroInt doesn't throw an exception
> ok 10 - NegativeOrZeroInt doesn't have a coercion
> ok 11 - NegativeOrZeroInt isn't parameterizable
> ok 12 - NegativeOrZeroInt has a type_default
> ok 13 - NegativeOrZeroInt type_default is zero
> ok 14 - Undef should fail NegativeOrZeroInt
> ok 15 - False should fail NegativeOrZeroInt
> ok 16 - True should fail NegativeOrZeroInt
> ok 17 - Zero should pass NegativeOrZeroInt
> ok 18 - One should fail NegativeOrZeroInt
> ok 19 - Negative one should pass NegativeOrZeroInt
> ok 20 - Non integer should fail NegativeOrZeroInt
> ok 21 - Empty string should fail NegativeOrZeroInt
> ok 22 - Whitespace should fail NegativeOrZeroInt
> ok 23 - Line break should fail NegativeOrZeroInt
> ok 24 - Random string should fail NegativeOrZeroInt
> ok 25 - Loaded package name should fail NegativeOrZeroInt
> ok 26 - Unloaded package name should fail NegativeOrZeroInt
> ok 27 - A reference to undef should fail NegativeOrZeroInt
> ok 28 - A reference to false should fail NegativeOrZeroInt
> ok 29 - A reference to true should fail NegativeOrZeroInt
> ok 30 - A reference to zero should fail NegativeOrZeroInt
> ok 31 - A reference to one should fail NegativeOrZeroInt
> ok 32 - A reference to empty string should fail NegativeOrZeroInt
> ok 33 - A reference to random string should fail NegativeOrZeroInt
> ok 34 - Blessed scalarref should fail NegativeOrZeroInt
> ok 35 - Empty arrayref should fail NegativeOrZeroInt
> ok 36 - Arrayref with one zero should fail NegativeOrZeroInt
> ok 37 - Arrayref of integers should fail NegativeOrZeroInt
> ok 38 - Arrayref of numbers should fail NegativeOrZeroInt
> ok 39 - Blessed arrayref should fail NegativeOrZeroInt
> ok 40 - Empty hashref should fail NegativeOrZeroInt
> ok 41 - Hashref should fail NegativeOrZeroInt
> ok 42 - Blessed hashref should fail NegativeOrZeroInt
> ok 43 - Coderef should fail NegativeOrZeroInt
> ok 44 - Blessed coderef should fail NegativeOrZeroInt
> ok 45 - Glob should fail NegativeOrZeroInt
> ok 46 - Globref should fail NegativeOrZeroInt
> ok 47 - Blessed globref should fail NegativeOrZeroInt
> ok 48 - Regexp should fail NegativeOrZeroInt
> ok 49 - Blessed regexp should fail NegativeOrZeroInt
> ok 50 - Filehandle should fail NegativeOrZeroInt
> ok 51 - Filehandle object should fail NegativeOrZeroInt
> ok 52 - Ref to scalarref should fail NegativeOrZeroInt
> ok 53 - Ref to arrayref should fail NegativeOrZeroInt
> ok 54 - Ref to hashref should fail NegativeOrZeroInt
> ok 55 - Ref to coderef should fail NegativeOrZeroInt
> ok 56 - Ref to blessed hashref should fail NegativeOrZeroInt
> ok 57 - Object stringifying to "" should fail NegativeOrZeroInt
> ok 58 - Object stringifying to "1" should fail NegativeOrZeroInt
> ok 59 - Object numifying to 0 should fail NegativeOrZeroInt
> ok 60 - Object numifying to 1 should fail NegativeOrZeroInt
> ok 61 - Object overloading arrayref should fail NegativeOrZeroInt
> ok 62 - Object overloading hashref should fail NegativeOrZeroInt
> ok 63 - Object overloading coderef should fail NegativeOrZeroInt
> ok 64 - Object booling to false should fail NegativeOrZeroInt
> ok 65 - Object booling to true should fail NegativeOrZeroInt
> 1..65
> ok
> t/21-types/NegativeOrZeroNum.t ...............................
> ok 1 - 'NegativeOrZeroNum' isa 'Type::Tiny'
> ok 2 - NegativeOrZeroNum has correct name
> ok 3 - NegativeOrZeroNum has correct display_name
> ok 4 - NegativeOrZeroNum knows it is in the Types::Common::Numeric library
> ok 5 - Types::Common::Numeric knows it has type NegativeOrZeroNum
> ok 6 - NegativeOrZeroNum is not deprecated
> ok 7 - NegativeOrZeroNum is not anonymous
> ok 8 - NegativeOrZeroNum can be inlined
> ok 9 - Inlining NegativeOrZeroNum doesn't throw an exception
> ok 10 - NegativeOrZeroNum doesn't have a coercion
> ok 11 - NegativeOrZeroNum isn't parameterizable
> ok 12 - NegativeOrZeroNum has a type_default
> ok 13 - NegativeOrZeroNum type_default is zero
> ok 14 - Undef should fail NegativeOrZeroNum
> ok 15 - False should fail NegativeOrZeroNum
> ok 16 - True should fail NegativeOrZeroNum
> ok 17 - Zero should pass NegativeOrZeroNum
> ok 18 - One should fail NegativeOrZeroNum
> ok 19 - Negative one should pass NegativeOrZeroNum
> ok 20 - Non integer should fail NegativeOrZeroNum
> ok 21 - Empty string should fail NegativeOrZeroNum
> ok 22 - Whitespace should fail NegativeOrZeroNum
> ok 23 - Line break should fail NegativeOrZeroNum
> ok 24 - Random string should fail NegativeOrZeroNum
> ok 25 - Loaded package name should fail NegativeOrZeroNum
> ok 26 - Unloaded package name should fail NegativeOrZeroNum
> ok 27 - A reference to undef should fail NegativeOrZeroNum
> ok 28 - A reference to false should fail NegativeOrZeroNum
> ok 29 - A reference to true should fail NegativeOrZeroNum
> ok 30 - A reference to zero should fail NegativeOrZeroNum
> ok 31 - A reference to one should fail NegativeOrZeroNum
> ok 32 - A reference to empty string should fail NegativeOrZeroNum
> ok 33 - A reference to random string should fail NegativeOrZeroNum
> ok 34 - Blessed scalarref should fail NegativeOrZeroNum
> ok 35 - Empty arrayref should fail NegativeOrZeroNum
> ok 36 - Arrayref with one zero should fail NegativeOrZeroNum
> ok 37 - Arrayref of integers should fail NegativeOrZeroNum
> ok 38 - Arrayref of numbers should fail NegativeOrZeroNum
> ok 39 - Blessed arrayref should fail NegativeOrZeroNum
> ok 40 - Empty hashref should fail NegativeOrZeroNum
> ok 41 - Hashref should fail NegativeOrZeroNum
> ok 42 - Blessed hashref should fail NegativeOrZeroNum
> ok 43 - Coderef should fail NegativeOrZeroNum
> ok 44 - Blessed coderef should fail NegativeOrZeroNum
> ok 45 - Glob should fail NegativeOrZeroNum
> ok 46 - Globref should fail NegativeOrZeroNum
> ok 47 - Blessed globref should fail NegativeOrZeroNum
> ok 48 - Regexp should fail NegativeOrZeroNum
> ok 49 - Blessed regexp should fail NegativeOrZeroNum
> ok 50 - Filehandle should fail NegativeOrZeroNum
> ok 51 - Filehandle object should fail NegativeOrZeroNum
> ok 52 - Ref to scalarref should fail NegativeOrZeroNum
> ok 53 - Ref to arrayref should fail NegativeOrZeroNum
> ok 54 - Ref to hashref should fail NegativeOrZeroNum
> ok 55 - Ref to coderef should fail NegativeOrZeroNum
> ok 56 - Ref to blessed hashref should fail NegativeOrZeroNum
> ok 57 - Object stringifying to "" should fail NegativeOrZeroNum
> ok 58 - Object stringifying to "1" should fail NegativeOrZeroNum
> ok 59 - Object numifying to 0 should fail NegativeOrZeroNum
> ok 60 - Object numifying to 1 should fail NegativeOrZeroNum
> ok 61 - Object overloading arrayref should fail NegativeOrZeroNum
> ok 62 - Object overloading hashref should fail NegativeOrZeroNum
> ok 63 - Object overloading coderef should fail NegativeOrZeroNum
> ok 64 - Object booling to false should fail NegativeOrZeroNum
> ok 65 - Object booling to true should fail NegativeOrZeroNum
> 1..65
> ok
> t/21-types/NonEmptySimpleStr.t ...............................
> ok 1 - 'NonEmptySimpleStr' isa 'Type::Tiny'
> ok 2 - NonEmptySimpleStr has correct name
> ok 3 - NonEmptySimpleStr has correct display_name
> ok 4 - NonEmptySimpleStr knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type NonEmptySimpleStr
> ok 6 - NonEmptySimpleStr is not deprecated
> ok 7 - NonEmptySimpleStr is not anonymous
> ok 8 - NonEmptySimpleStr can be inlined
> ok 9 - Inlining NonEmptySimpleStr doesn't throw an exception
> ok 10 - NonEmptySimpleStr doesn't have a coercion
> ok 11 - NonEmptySimpleStr isn't parameterizable
> ok 12 - NonEmptySimpleStr has no type_default
> ok 13 - Undef should fail NonEmptySimpleStr
> ok 14 - False should fail NonEmptySimpleStr
> ok 15 - True should pass NonEmptySimpleStr
> ok 16 - Zero should pass NonEmptySimpleStr
> ok 17 - One should pass NonEmptySimpleStr
> ok 18 - Negative one should pass NonEmptySimpleStr
> ok 19 - Non integer should pass NonEmptySimpleStr
> ok 20 - Empty string should fail NonEmptySimpleStr
> ok 21 - Whitespace should pass NonEmptySimpleStr
> ok 22 - Line break should fail NonEmptySimpleStr
> ok 23 - Random string should pass NonEmptySimpleStr
> ok 24 - Loaded package name should pass NonEmptySimpleStr
> ok 25 - Unloaded package name should pass NonEmptySimpleStr
> ok 26 - A reference to undef should fail NonEmptySimpleStr
> ok 27 - A reference to false should fail NonEmptySimpleStr
> ok 28 - A reference to true should fail NonEmptySimpleStr
> ok 29 - A reference to zero should fail NonEmptySimpleStr
> ok 30 - A reference to one should fail NonEmptySimpleStr
> ok 31 - A reference to empty string should fail NonEmptySimpleStr
> ok 32 - A reference to random string should fail NonEmptySimpleStr
> ok 33 - Blessed scalarref should fail NonEmptySimpleStr
> ok 34 - Empty arrayref should fail NonEmptySimpleStr
> ok 35 - Arrayref with one zero should fail NonEmptySimpleStr
> ok 36 - Arrayref of integers should fail NonEmptySimpleStr
> ok 37 - Arrayref of numbers should fail NonEmptySimpleStr
> ok 38 - Blessed arrayref should fail NonEmptySimpleStr
> ok 39 - Empty hashref should fail NonEmptySimpleStr
> ok 40 - Hashref should fail NonEmptySimpleStr
> ok 41 - Blessed hashref should fail NonEmptySimpleStr
> ok 42 - Coderef should fail NonEmptySimpleStr
> ok 43 - Blessed coderef should fail NonEmptySimpleStr
> ok 44 - Glob should fail NonEmptySimpleStr
> ok 45 - Globref should fail NonEmptySimpleStr
> ok 46 - Blessed globref should fail NonEmptySimpleStr
> ok 47 - Regexp should fail NonEmptySimpleStr
> ok 48 - Blessed regexp should fail NonEmptySimpleStr
> ok 49 - Filehandle should fail NonEmptySimpleStr
> ok 50 - Filehandle object should fail NonEmptySimpleStr
> ok 51 - Ref to scalarref should fail NonEmptySimpleStr
> ok 52 - Ref to arrayref should fail NonEmptySimpleStr
> ok 53 - Ref to hashref should fail NonEmptySimpleStr
> ok 54 - Ref to coderef should fail NonEmptySimpleStr
> ok 55 - Ref to blessed hashref should fail NonEmptySimpleStr
> ok 56 - Object stringifying to "" should fail NonEmptySimpleStr
> ok 57 - Object stringifying to "1" should fail NonEmptySimpleStr
> ok 58 - Object numifying to 0 should fail NonEmptySimpleStr
> ok 59 - Object numifying to 1 should fail NonEmptySimpleStr
> ok 60 - Object overloading arrayref should fail NonEmptySimpleStr
> ok 61 - Object overloading hashref should fail NonEmptySimpleStr
> ok 62 - Object overloading coderef should fail NonEmptySimpleStr
> ok 63 - Object booling to false should fail NonEmptySimpleStr
> ok 64 - Object booling to true should fail NonEmptySimpleStr
> 1..64
> ok
> t/21-types/NonEmptyStr.t .....................................
> ok 1 - 'NonEmptyStr' isa 'Type::Tiny'
> ok 2 - NonEmptyStr has correct name
> ok 3 - NonEmptyStr has correct display_name
> ok 4 - NonEmptyStr knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type NonEmptyStr
> ok 6 - NonEmptyStr is not deprecated
> ok 7 - NonEmptyStr is not anonymous
> ok 8 - NonEmptyStr can be inlined
> ok 9 - Inlining NonEmptyStr doesn't throw an exception
> ok 10 - NonEmptyStr doesn't have a coercion
> ok 11 - NonEmptyStr isn't parameterizable
> ok 12 - NonEmptyStr has no type_default
> ok 13 - Undef should fail NonEmptyStr
> ok 14 - False should fail NonEmptyStr
> ok 15 - True should pass NonEmptyStr
> ok 16 - Zero should pass NonEmptyStr
> ok 17 - One should pass NonEmptyStr
> ok 18 - Negative one should pass NonEmptyStr
> ok 19 - Non integer should pass NonEmptyStr
> ok 20 - Empty string should fail NonEmptyStr
> ok 21 - Whitespace should pass NonEmptyStr
> ok 22 - Line break should pass NonEmptyStr
> ok 23 - Random string should pass NonEmptyStr
> ok 24 - Loaded package name should pass NonEmptyStr
> ok 25 - Unloaded package name should pass NonEmptyStr
> ok 26 - A reference to undef should fail NonEmptyStr
> ok 27 - A reference to false should fail NonEmptyStr
> ok 28 - A reference to true should fail NonEmptyStr
> ok 29 - A reference to zero should fail NonEmptyStr
> ok 30 - A reference to one should fail NonEmptyStr
> ok 31 - A reference to empty string should fail NonEmptyStr
> ok 32 - A reference to random string should fail NonEmptyStr
> ok 33 - Blessed scalarref should fail NonEmptyStr
> ok 34 - Empty arrayref should fail NonEmptyStr
> ok 35 - Arrayref with one zero should fail NonEmptyStr
> ok 36 - Arrayref of integers should fail NonEmptyStr
> ok 37 - Arrayref of numbers should fail NonEmptyStr
> ok 38 - Blessed arrayref should fail NonEmptyStr
> ok 39 - Empty hashref should fail NonEmptyStr
> ok 40 - Hashref should fail NonEmptyStr
> ok 41 - Blessed hashref should fail NonEmptyStr
> ok 42 - Coderef should fail NonEmptyStr
> ok 43 - Blessed coderef should fail NonEmptyStr
> ok 44 - Glob should fail NonEmptyStr
> ok 45 - Globref should fail NonEmptyStr
> ok 46 - Blessed globref should fail NonEmptyStr
> ok 47 - Regexp should fail NonEmptyStr
> ok 48 - Blessed regexp should fail NonEmptyStr
> ok 49 - Filehandle should fail NonEmptyStr
> ok 50 - Filehandle object should fail NonEmptyStr
> ok 51 - Ref to scalarref should fail NonEmptyStr
> ok 52 - Ref to arrayref should fail NonEmptyStr
> ok 53 - Ref to hashref should fail NonEmptyStr
> ok 54 - Ref to coderef should fail NonEmptyStr
> ok 55 - Ref to blessed hashref should fail NonEmptyStr
> ok 56 - Object stringifying to "" should fail NonEmptyStr
> ok 57 - Object stringifying to "1" should fail NonEmptyStr
> ok 58 - Object numifying to 0 should fail NonEmptyStr
> ok 59 - Object numifying to 1 should fail NonEmptyStr
> ok 60 - Object overloading arrayref should fail NonEmptyStr
> ok 61 - Object overloading hashref should fail NonEmptyStr
> ok 62 - Object overloading coderef should fail NonEmptyStr
> ok 63 - Object booling to false should fail NonEmptyStr
> ok 64 - Object booling to true should fail NonEmptyStr
> 1..64
> ok
> t/21-types/Num.t .............................................
> ok 1 - 'Num' isa 'Type::Tiny'
> ok 2 - Num has correct name
> ok 3 - Num has correct display_name
> ok 4 - Num knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Num
> ok 6 - Num is not deprecated
> ok 7 - Num is not anonymous
> ok 8 - Num can be inlined
> ok 9 - Inlining Num doesn't throw an exception
> ok 10 - Num doesn't have a coercion
> ok 11 - Num isn't parameterizable
> ok 12 - Num has a type_default
> ok 13 - Num type_default is zero
> ok 14 - Undef should fail Num
> ok 15 - False should fail Num
> ok 16 - True should pass Num
> ok 17 - Zero should pass Num
> ok 18 - One should pass Num
> ok 19 - Negative one should pass Num
> ok 20 - Non integer should pass Num
> ok 21 - Empty string should fail Num
> ok 22 - Whitespace should fail Num
> ok 23 - Line break should fail Num
> ok 24 - Random string should fail Num
> ok 25 - Loaded package name should fail Num
> ok 26 - Unloaded package name should fail Num
> ok 27 - A reference to undef should fail Num
> ok 28 - A reference to false should fail Num
> ok 29 - A reference to true should fail Num
> ok 30 - A reference to zero should fail Num
> ok 31 - A reference to one should fail Num
> ok 32 - A reference to empty string should fail Num
> ok 33 - A reference to random string should fail Num
> ok 34 - Blessed scalarref should fail Num
> ok 35 - Empty arrayref should fail Num
> ok 36 - Arrayref with one zero should fail Num
> ok 37 - Arrayref of integers should fail Num
> ok 38 - Arrayref of numbers should fail Num
> ok 39 - Blessed arrayref should fail Num
> ok 40 - Empty hashref should fail Num
> ok 41 - Hashref should fail Num
> ok 42 - Blessed hashref should fail Num
> ok 43 - Coderef should fail Num
> ok 44 - Blessed coderef should fail Num
> ok 45 - Glob should fail Num
> ok 46 - Globref should fail Num
> ok 47 - Blessed globref should fail Num
> ok 48 - Regexp should fail Num
> ok 49 - Blessed regexp should fail Num
> ok 50 - Filehandle should fail Num
> ok 51 - Filehandle object should fail Num
> ok 52 - Ref to scalarref should fail Num
> ok 53 - Ref to arrayref should fail Num
> ok 54 - Ref to hashref should fail Num
> ok 55 - Ref to coderef should fail Num
> ok 56 - Ref to blessed hashref should fail Num
> ok 57 - Object stringifying to "" should fail Num
> ok 58 - Object stringifying to "1" should fail Num
> ok 59 - Object numifying to 0 should fail Num
> ok 60 - Object numifying to 1 should fail Num
> ok 61 - Object overloading arrayref should fail Num
> ok 62 - Object overloading hashref should fail Num
> ok 63 - Object overloading coderef should fail Num
> ok 64 - Object booling to false should fail Num
> ok 65 - Object booling to true should fail Num
> 1..65
> ok
> t/21-types/NumericCode.t .....................................
> ok 1 - 'NumericCode' isa 'Type::Tiny'
> ok 2 - NumericCode has correct name
> ok 3 - NumericCode has correct display_name
> ok 4 - NumericCode knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type NumericCode
> ok 6 - NumericCode is not deprecated
> ok 7 - NumericCode is not anonymous
> ok 8 - NumericCode can be inlined
> ok 9 - Inlining NumericCode doesn't throw an exception
> ok 10 - NumericCode has a coercion
> ok 11 - NumericCode isn't parameterizable
> ok 12 - NumericCode has no type_default
> ok 13 - Undef should fail NumericCode
> ok 14 - False should fail NumericCode
> ok 15 - True should pass NumericCode
> ok 16 - Zero should pass NumericCode
> ok 17 - One should pass NumericCode
> ok 18 - Negative one should fail NumericCode
> ok 19 - Non integer should fail NumericCode
> ok 20 - Empty string should fail NumericCode
> ok 21 - Whitespace should fail NumericCode
> ok 22 - Line break should fail NumericCode
> ok 23 - Random string should fail NumericCode
> ok 24 - Loaded package name should fail NumericCode
> ok 25 - Unloaded package name should fail NumericCode
> ok 26 - A reference to undef should fail NumericCode
> ok 27 - A reference to false should fail NumericCode
> ok 28 - A reference to true should fail NumericCode
> ok 29 - A reference to zero should fail NumericCode
> ok 30 - A reference to one should fail NumericCode
> ok 31 - A reference to empty string should fail NumericCode
> ok 32 - A reference to random string should fail NumericCode
> ok 33 - Blessed scalarref should fail NumericCode
> ok 34 - Empty arrayref should fail NumericCode
> ok 35 - Arrayref with one zero should fail NumericCode
> ok 36 - Arrayref of integers should fail NumericCode
> ok 37 - Arrayref of numbers should fail NumericCode
> ok 38 - Blessed arrayref should fail NumericCode
> ok 39 - Empty hashref should fail NumericCode
> ok 40 - Hashref should fail NumericCode
> ok 41 - Blessed hashref should fail NumericCode
> ok 42 - Coderef should fail NumericCode
> ok 43 - Blessed coderef should fail NumericCode
> ok 44 - Glob should fail NumericCode
> ok 45 - Globref should fail NumericCode
> ok 46 - Blessed globref should fail NumericCode
> ok 47 - Regexp should fail NumericCode
> ok 48 - Blessed regexp should fail NumericCode
> ok 49 - Filehandle should fail NumericCode
> ok 50 - Filehandle object should fail NumericCode
> ok 51 - Ref to scalarref should fail NumericCode
> ok 52 - Ref to arrayref should fail NumericCode
> ok 53 - Ref to hashref should fail NumericCode
> ok 54 - Ref to coderef should fail NumericCode
> ok 55 - Ref to blessed hashref should fail NumericCode
> ok 56 - Object stringifying to "" should fail NumericCode
> ok 57 - Object stringifying to "1" should fail NumericCode
> ok 58 - Object numifying to 0 should fail NumericCode
> ok 59 - Object numifying to 1 should fail NumericCode
> ok 60 - Object overloading arrayref should fail NumericCode
> ok 61 - Object overloading hashref should fail NumericCode
> ok 62 - Object overloading coderef should fail NumericCode
> ok 63 - Object booling to false should fail NumericCode
> ok 64 - Object booling to true should fail NumericCode
> ok 65 - coercion from string
> 1..65
> ok
> t/21-types/NumRange.t ........................................
> ok 1 - 'NumRange' isa 'Type::Tiny'
> ok 2 - NumRange has correct name
> ok 3 - NumRange has correct display_name
> ok 4 - NumRange knows it is in the Types::Common::Numeric library
> ok 5 - Types::Common::Numeric knows it has type NumRange
> ok 6 - NumRange is not deprecated
> ok 7 - NumRange is not anonymous
> ok 8 - NumRange can be inlined
> ok 9 - Inlining NumRange doesn't throw an exception
> ok 10 - NumRange doesn't have a coercion
> ok 11 - NumRange is parameterizable
> ok 12 - NumRange has a type_default
> ok 13 - NumRange type_default is zero
> ok 14 - Undef should fail NumRange
> ok 15 - False should fail NumRange
> ok 16 - True should pass NumRange
> ok 17 - Zero should pass NumRange
> ok 18 - One should pass NumRange
> ok 19 - Negative one should pass NumRange
> ok 20 - Non integer should pass NumRange
> ok 21 - Empty string should fail NumRange
> ok 22 - Whitespace should fail NumRange
> ok 23 - Line break should fail NumRange
> ok 24 - Random string should fail NumRange
> ok 25 - Loaded package name should fail NumRange
> ok 26 - Unloaded package name should fail NumRange
> ok 27 - A reference to undef should fail NumRange
> ok 28 - A reference to false should fail NumRange
> ok 29 - A reference to true should fail NumRange
> ok 30 - A reference to zero should fail NumRange
> ok 31 - A reference to one should fail NumRange
> ok 32 - A reference to empty string should fail NumRange
> ok 33 - A reference to random string should fail NumRange
> ok 34 - Blessed scalarref should fail NumRange
> ok 35 - Empty arrayref should fail NumRange
> ok 36 - Arrayref with one zero should fail NumRange
> ok 37 - Arrayref of integers should fail NumRange
> ok 38 - Arrayref of numbers should fail NumRange
> ok 39 - Blessed arrayref should fail NumRange
> ok 40 - Empty hashref should fail NumRange
> ok 41 - Hashref should fail NumRange
> ok 42 - Blessed hashref should fail NumRange
> ok 43 - Coderef should fail NumRange
> ok 44 - Blessed coderef should fail NumRange
> ok 45 - Glob should fail NumRange
> ok 46 - Globref should fail NumRange
> ok 47 - Blessed globref should fail NumRange
> ok 48 - Regexp should fail NumRange
> ok 49 - Blessed regexp should fail NumRange
> ok 50 - Filehandle should fail NumRange
> ok 51 - Filehandle object should fail NumRange
> ok 52 - Ref to scalarref should fail NumRange
> ok 53 - Ref to arrayref should fail NumRange
> ok 54 - Ref to hashref should fail NumRange
> ok 55 - Ref to coderef should fail NumRange
> ok 56 - Ref to blessed hashref should fail NumRange
> ok 57 - Object stringifying to "" should fail NumRange
> ok 58 - Object stringifying to "1" should fail NumRange
> ok 59 - Object numifying to 0 should fail NumRange
> ok 60 - Object numifying to 1 should fail NumRange
> ok 61 - Object overloading arrayref should fail NumRange
> ok 62 - Object overloading hashref should fail NumRange
> ok 63 - Object overloading coderef should fail NumRange
> ok 64 - Object booling to false should fail NumRange
> ok 65 - Object booling to true should fail NumRange
> ok 66 - Value "-2" fails type constraint NumRange[2]
> ok 67 - Value "-1" fails type constraint NumRange[2]
> ok 68 - Value "0" fails type constraint NumRange[2]
> ok 69 - Value "1" fails type constraint NumRange[2]
> ok 70 - Value "2" passes type constraint NumRange[2]
> ok 71 - Value "3" passes type constraint NumRange[2]
> ok 72 - Value "4" passes type constraint NumRange[2]
> ok 73 - Value "5" passes type constraint NumRange[2]
> ok 74 - Value "6" passes type constraint NumRange[2]
> ok 75 - Value "3.1416" passes type constraint NumRange[2]
> ok 76 - Reference [] fails type constraint NumRange[2]
> ok 77 - NumRange[2] has no type_default
> ok 78 - Value "-2" fails type constraint NumRange[2,4]
> ok 79 - Value "-1" fails type constraint NumRange[2,4]
> ok 80 - Value "0" fails type constraint NumRange[2,4]
> ok 81 - Value "1" fails type constraint NumRange[2,4]
> ok 82 - Value "2" passes type constraint NumRange[2,4]
> ok 83 - Value "3" passes type constraint NumRange[2,4]
> ok 84 - Value "4" passes type constraint NumRange[2,4]
> ok 85 - Value "5" fails type constraint NumRange[2,4]
> ok 86 - Value "6" fails type constraint NumRange[2,4]
> ok 87 - Value "3.1416" passes type constraint NumRange[2,4]
> ok 88 - Reference [] fails type constraint NumRange[2,4]
> ok 89 - Value "-2" fails type constraint NumRange[2,4,1,1]
> ok 90 - Value "-1" fails type constraint NumRange[2,4,1,1]
> ok 91 - Value "0" fails type constraint NumRange[2,4,1,1]
> ok 92 - Value "1" fails type constraint NumRange[2,4,1,1]
> ok 93 - Value "2" fails type constraint NumRange[2,4,1,1]
> ok 94 - Value "3" passes type constraint NumRange[2,4,1,1]
> ok 95 - Value "4" fails type constraint NumRange[2,4,1,1]
> ok 96 - Value "5" fails type constraint NumRange[2,4,1,1]
> ok 97 - Value "6" fails type constraint NumRange[2,4,1,1]
> ok 98 - Value "3.1416" passes type constraint NumRange[2,4,1,1]
> ok 99 - Reference [] fails type constraint NumRange[2,4,1,1]
> ok 100 - Value "-2" fails type constraint NumRange["1.5","3.5"]
> ok 101 - Value "-1" fails type constraint NumRange["1.5","3.5"]
> ok 102 - Value "0" fails type constraint NumRange["1.5","3.5"]
> ok 103 - Value "1" fails type constraint NumRange["1.5","3.5"]
> ok 104 - Value "2" passes type constraint NumRange["1.5","3.5"]
> ok 105 - Value "3" passes type constraint NumRange["1.5","3.5"]
> ok 106 - Value "4" fails type constraint NumRange["1.5","3.5"]
> ok 107 - Value "5" fails type constraint NumRange["1.5","3.5"]
> ok 108 - Value "6" fails type constraint NumRange["1.5","3.5"]
> ok 109 - Value "3.1416" passes type constraint NumRange["1.5","3.5"]
> ok 110 - Reference [] fails type constraint NumRange["1.5","3.5"]
> ok 111 - bad parameter
> 1..111
> ok
> t/21-types/Object.t ..........................................
> ok 1 - 'Object' isa 'Type::Tiny'
> ok 2 - Object has correct name
> ok 3 - Object has correct display_name
> ok 4 - Object knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Object
> ok 6 - Object is not deprecated
> ok 7 - Object is not anonymous
> ok 8 - Object can be inlined
> ok 9 - Inlining Object doesn't throw an exception
> ok 10 - Object doesn't have a coercion
> ok 11 - Object isn't parameterizable
> ok 12 - Object has no type_default
> ok 13 - Undef should fail Object
> ok 14 - False should fail Object
> ok 15 - True should fail Object
> ok 16 - Zero should fail Object
> ok 17 - One should fail Object
> ok 18 - Negative one should fail Object
> ok 19 - Non integer should fail Object
> ok 20 - Empty string should fail Object
> ok 21 - Whitespace should fail Object
> ok 22 - Line break should fail Object
> ok 23 - Random string should fail Object
> ok 24 - Loaded package name should fail Object
> ok 25 - Unloaded package name should fail Object
> ok 26 - A reference to undef should fail Object
> ok 27 - A reference to false should fail Object
> ok 28 - A reference to true should fail Object
> ok 29 - A reference to zero should fail Object
> ok 30 - A reference to one should fail Object
> ok 31 - A reference to empty string should fail Object
> ok 32 - A reference to random string should fail Object
> ok 33 - Blessed scalarref should pass Object
> ok 34 - Empty arrayref should fail Object
> ok 35 - Arrayref with one zero should fail Object
> ok 36 - Arrayref of integers should fail Object
> ok 37 - Arrayref of numbers should fail Object
> ok 38 - Blessed arrayref should pass Object
> ok 39 - Empty hashref should fail Object
> ok 40 - Hashref should fail Object
> ok 41 - Blessed hashref should pass Object
> ok 42 - Coderef should fail Object
> ok 43 - Blessed coderef should pass Object
> ok 44 - Glob should fail Object
> ok 45 - Globref should fail Object
> ok 46 - Blessed globref should pass Object
> # UNDEFINED OUTCOME: regexp
> ok 47 - Blessed regexp should pass Object
> ok 48 - Filehandle should fail Object
> ok 49 - Filehandle object should pass Object
> ok 50 - Ref to scalarref should fail Object
> ok 51 - Ref to arrayref should fail Object
> ok 52 - Ref to hashref should fail Object
> ok 53 - Ref to coderef should fail Object
> ok 54 - Ref to blessed hashref should fail Object
> ok 55 - Object stringifying to "" should pass Object
> ok 56 - Object stringifying to "1" should pass Object
> ok 57 - Object numifying to 0 should pass Object
> ok 58 - Object numifying to 1 should pass Object
> ok 59 - Object overloading arrayref should pass Object
> ok 60 - Object overloading hashref should pass Object
> ok 61 - Object overloading coderef should pass Object
> ok 62 - Object booling to false should pass Object
> ok 63 - Object booling to true should pass Object
> ok 64
> ok 65 - Reference bless( {"gender" => "f","name" => "Alice"}, 'Local::Person' ) passes type constraint Object
> ok 66 - Reference bless( {"gender" => "m","name" => "Bob"}, 'Local::Person' ) passes type constraint Object
> ok 67 - Reference bless( {"gender" => "f","name" => "Alice"}, 'Local::Person' ) fails type constraint __ANON__
> ok 68 - Reference bless( {"gender" => "m","name" => "Bob"}, 'Local::Person' ) passes type constraint __ANON__
> 1..68
> ok
> t/21-types/Optional.t ........................................
> ok 1 - 'Optional' isa 'Type::Tiny'
> ok 2 - Optional has correct name
> ok 3 - Optional has correct display_name
> ok 4 - Optional knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Optional
> ok 6 - Optional is not deprecated
> ok 7 - Optional is not anonymous
> ok 8 - Optional can be inlined
> ok 9 - Inlining Optional doesn't throw an exception
> ok 10 - Optional doesn't have a coercion
> ok 11 - Optional is parameterizable
> ok 12 - Optional has a type_default
> ok 13 - Optional type_default is undef
> ok 14 - Undef should pass Optional
> ok 15 - False should pass Optional
> ok 16 - True should pass Optional
> ok 17 - Zero should pass Optional
> ok 18 - One should pass Optional
> ok 19 - Negative one should pass Optional
> ok 20 - Non integer should pass Optional
> ok 21 - Empty string should pass Optional
> ok 22 - Whitespace should pass Optional
> ok 23 - Line break should pass Optional
> ok 24 - Random string should pass Optional
> ok 25 - Loaded package name should pass Optional
> ok 26 - Unloaded package name should pass Optional
> ok 27 - A reference to undef should pass Optional
> ok 28 - A reference to false should pass Optional
> ok 29 - A reference to true should pass Optional
> ok 30 - A reference to zero should pass Optional
> ok 31 - A reference to one should pass Optional
> ok 32 - A reference to empty string should pass Optional
> ok 33 - A reference to random string should pass Optional
> ok 34 - Blessed scalarref should pass Optional
> ok 35 - Empty arrayref should pass Optional
> ok 36 - Arrayref with one zero should pass Optional
> ok 37 - Arrayref of integers should pass Optional
> ok 38 - Arrayref of numbers should pass Optional
> ok 39 - Blessed arrayref should pass Optional
> ok 40 - Empty hashref should pass Optional
> ok 41 - Hashref should pass Optional
> ok 42 - Blessed hashref should pass Optional
> ok 43 - Coderef should pass Optional
> ok 44 - Blessed coderef should pass Optional
> ok 45 - Glob should pass Optional
> ok 46 - Globref should pass Optional
> ok 47 - Blessed globref should pass Optional
> ok 48 - Regexp should pass Optional
> ok 49 - Blessed regexp should pass Optional
> ok 50 - Filehandle should pass Optional
> ok 51 - Filehandle object should pass Optional
> ok 52 - Ref to scalarref should pass Optional
> ok 53 - Ref to arrayref should pass Optional
> ok 54 - Ref to hashref should pass Optional
> ok 55 - Ref to coderef should pass Optional
> ok 56 - Ref to blessed hashref should pass Optional
> ok 57 - Object stringifying to "" should pass Optional
> ok 58 - Object stringifying to "1" should pass Optional
> ok 59 - Object numifying to 0 should pass Optional
> ok 60 - Object numifying to 1 should pass Optional
> ok 61 - Object overloading arrayref should pass Optional
> ok 62 - Object overloading hashref should pass Optional
> ok 63 - Object overloading coderef should pass Optional
> ok 64 - Object booling to false should pass Optional
> ok 65 - Object booling to true should pass Optional
> ok 66 - Value "0" passes type constraint Optional[Int]
> ok 67 - Value "1" passes type constraint Optional[Int]
> ok 68 - Value "1.1" fails type constraint Optional[Int]
> ok 69 - Undef fails type constraint Optional[Int]
> ok 70 - Optional[Int] has a type_default
> ok 71 - Optional[Int] type_default is zero, because of Int's type_default
> ok 72
> ok 73
> ok 74
> ok 75
> ok 76
> ok 77
> ok 78
> ok 79
> ok 80
> ok 81
> ok 82
> ok 83
> 1..83
> ok
> t/21-types/OptList.t .........................................
> ok 1 - 'OptList' isa 'Type::Tiny'
> ok 2 - OptList has correct name
> ok 3 - OptList has correct display_name
> ok 4 - OptList knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type OptList
> ok 6 - OptList is not deprecated
> ok 7 - OptList is not anonymous
> ok 8 - OptList can be inlined
> ok 9 - Inlining OptList doesn't throw an exception
> ok 10 - OptList doesn't have a coercion
> ok 11 - OptList isn't parameterizable
> ok 12 - OptList has a type_default
> ok 13 - OptList type_default is []
> ok 14 - Undef should fail OptList
> ok 15 - False should fail OptList
> ok 16 - True should fail OptList
> ok 17 - Zero should fail OptList
> ok 18 - One should fail OptList
> ok 19 - Negative one should fail OptList
> ok 20 - Non integer should fail OptList
> ok 21 - Empty string should fail OptList
> ok 22 - Whitespace should fail OptList
> ok 23 - Line break should fail OptList
> ok 24 - Random string should fail OptList
> ok 25 - Loaded package name should fail OptList
> ok 26 - Unloaded package name should fail OptList
> ok 27 - A reference to undef should fail OptList
> ok 28 - A reference to false should fail OptList
> ok 29 - A reference to true should fail OptList
> ok 30 - A reference to zero should fail OptList
> ok 31 - A reference to one should fail OptList
> ok 32 - A reference to empty string should fail OptList
> ok 33 - A reference to random string should fail OptList
> ok 34 - Blessed scalarref should fail OptList
> ok 35 - Empty arrayref should pass OptList
> ok 36 - Arrayref with one zero should fail OptList
> ok 37 - Arrayref of integers should fail OptList
> ok 38 - Arrayref of numbers should fail OptList
> ok 39 - Blessed arrayref should fail OptList
> ok 40 - Empty hashref should fail OptList
> ok 41 - Hashref should fail OptList
> ok 42 - Blessed hashref should fail OptList
> ok 43 - Coderef should fail OptList
> ok 44 - Blessed coderef should fail OptList
> ok 45 - Glob should fail OptList
> ok 46 - Globref should fail OptList
> ok 47 - Blessed globref should fail OptList
> ok 48 - Regexp should fail OptList
> ok 49 - Blessed regexp should fail OptList
> ok 50 - Filehandle should fail OptList
> ok 51 - Filehandle object should fail OptList
> ok 52 - Ref to scalarref should fail OptList
> ok 53 - Ref to arrayref should fail OptList
> ok 54 - Ref to hashref should fail OptList
> ok 55 - Ref to coderef should fail OptList
> ok 56 - Ref to blessed hashref should fail OptList
> ok 57 - Object stringifying to "" should fail OptList
> ok 58 - Object stringifying to "1" should fail OptList
> ok 59 - Object numifying to 0 should fail OptList
> ok 60 - Object numifying to 1 should fail OptList
> ok 61 - Object overloading arrayref should fail OptList
> ok 62 - Object overloading hashref should fail OptList
> ok 63 - Object overloading coderef should fail OptList
> ok 64 - Object booling to false should fail OptList
> ok 65 - Object booling to true should fail OptList
> 1..65
> ok
> t/21-types/Overload.t ........................................
> ok 1 - 'Overload' isa 'Type::Tiny'
> ok 2 - Overload has correct name
> ok 3 - Overload has correct display_name
> ok 4 - Overload knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Overload
> ok 6 - Overload is not deprecated
> ok 7 - Overload is not anonymous
> ok 8 - Overload can be inlined
> ok 9 - Inlining Overload doesn't throw an exception
> ok 10 - Overload doesn't have a coercion
> ok 11 - Overload is parameterizable
> ok 12 - Overload has no type_default
> ok 13 - Undef should fail Overload
> ok 14 - False should fail Overload
> ok 15 - True should fail Overload
> ok 16 - Zero should fail Overload
> ok 17 - One should fail Overload
> ok 18 - Negative one should fail Overload
> ok 19 - Non integer should fail Overload
> ok 20 - Empty string should fail Overload
> ok 21 - Whitespace should fail Overload
> ok 22 - Line break should fail Overload
> ok 23 - Random string should fail Overload
> ok 24 - Loaded package name should fail Overload
> ok 25 - Unloaded package name should fail Overload
> ok 26 - A reference to undef should fail Overload
> ok 27 - A reference to false should fail Overload
> ok 28 - A reference to true should fail Overload
> ok 29 - A reference to zero should fail Overload
> ok 30 - A reference to one should fail Overload
> ok 31 - A reference to empty string should fail Overload
> ok 32 - A reference to random string should fail Overload
> ok 33 - Blessed scalarref should fail Overload
> ok 34 - Empty arrayref should fail Overload
> ok 35 - Arrayref with one zero should fail Overload
> ok 36 - Arrayref of integers should fail Overload
> ok 37 - Arrayref of numbers should fail Overload
> ok 38 - Blessed arrayref should fail Overload
> ok 39 - Empty hashref should fail Overload
> ok 40 - Hashref should fail Overload
> ok 41 - Blessed hashref should fail Overload
> ok 42 - Coderef should fail Overload
> ok 43 - Blessed coderef should fail Overload
> ok 44 - Glob should fail Overload
> ok 45 - Globref should fail Overload
> ok 46 - Blessed globref should fail Overload
> ok 47 - Regexp should fail Overload
> ok 48 - Blessed regexp should fail Overload
> ok 49 - Filehandle should fail Overload
> ok 50 - Filehandle object should fail Overload
> ok 51 - Ref to scalarref should fail Overload
> ok 52 - Ref to arrayref should fail Overload
> ok 53 - Ref to hashref should fail Overload
> ok 54 - Ref to coderef should fail Overload
> ok 55 - Ref to blessed hashref should fail Overload
> ok 56 - Object stringifying to "" should pass Overload
> ok 57 - Object stringifying to "1" should pass Overload
> ok 58 - Object numifying to 0 should pass Overload
> ok 59 - Object numifying to 1 should pass Overload
> ok 60 - Object overloading arrayref should pass Overload
> ok 61 - Object overloading hashref should pass Overload
> ok 62 - Object overloading coderef should pass Overload
> ok 63 - Object booling to false should pass Overload
> ok 64 - Object booling to true should pass Overload
> ok 65 - Reference bless( {"_overload_coderef" => sub { "DUMMY" },"_overrides_a...) passes type constraint Overload["&{}"]
> ok 66 - Reference bless( {"_overload_coderef" => sub { "DUMMY" },"_overrides_a...) passes type constraint Overload["\"\""]
> ok 67 - Reference bless( {"_overload_coderef" => sub { "DUMMY" },"_overrides_a...) fails type constraint Overload["\${}"]
> ok 68 - Reference bless( {"_overload_coderef" => sub { "DUMMY" },"_overrides_a...) passes type constraint Overload["&{}","\"\""]
> ok 69 - Reference bless( {"_overload_coderef" => sub { "DUMMY" },"_overrides_a...) fails type constraint Overload["\"\"","\${}"]
> ok 70 - Reference bless( {"_overload_coderef" => sub { "DUMMY" },"_overrides_a...) fails type constraint Overload["&{}","\${}"]
> ok 71 - Reference bless( do{\(my $o = 42)}, 'Local::OL::NoFallback' ) passes type constraint Overload["0+"]
> ok 72 - Reference bless( do{\(my $o = 42)}, 'Local::OL::WithFallback' ) passes type constraint Overload["0+"]
> ok 73 - Reference bless( do{\(my $o = 42)}, 'Local::OL::NoFallback' ) fails type constraint Overload["+"]
> ok 74 - Reference bless( do{\(my $o = 42)}, 'Local::OL::WithFallback' ) fails type constraint Overload["+"]
> 1..74
> ok
> t/21-types/Password.t ........................................
> ok 1 - 'Password' isa 'Type::Tiny'
> ok 2 - Password has correct name
> ok 3 - Password has correct display_name
> ok 4 - Password knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type Password
> ok 6 - Password is not deprecated
> ok 7 - Password is not anonymous
> ok 8 - Password can be inlined
> ok 9 - Inlining Password doesn't throw an exception
> ok 10 - Password doesn't have a coercion
> ok 11 - Password isn't parameterizable
> ok 12 - Password has no type_default
> ok 13 - Undef should fail Password
> ok 14 - False should fail Password
> ok 15 - True should fail Password
> ok 16 - Zero should fail Password
> ok 17 - One should fail Password
> ok 18 - Negative one should fail Password
> ok 19 - Non integer should pass Password
> ok 20 - Empty string should fail Password
> ok 21 - Whitespace should fail Password
> ok 22 - Line break should fail Password
> ok 23 - Random string should pass Password
> ok 24 - Loaded package name should pass Password
> ok 25 - Unloaded package name should pass Password
> ok 26 - A reference to undef should fail Password
> ok 27 - A reference to false should fail Password
> ok 28 - A reference to true should fail Password
> ok 29 - A reference to zero should fail Password
> ok 30 - A reference to one should fail Password
> ok 31 - A reference to empty string should fail Password
> ok 32 - A reference to random string should fail Password
> ok 33 - Blessed scalarref should fail Password
> ok 34 - Empty arrayref should fail Password
> ok 35 - Arrayref with one zero should fail Password
> ok 36 - Arrayref of integers should fail Password
> ok 37 - Arrayref of numbers should fail Password
> ok 38 - Blessed arrayref should fail Password
> ok 39 - Empty hashref should fail Password
> ok 40 - Hashref should fail Password
> ok 41 - Blessed hashref should fail Password
> ok 42 - Coderef should fail Password
> ok 43 - Blessed coderef should fail Password
> ok 44 - Glob should fail Password
> ok 45 - Globref should fail Password
> ok 46 - Blessed globref should fail Password
> ok 47 - Regexp should fail Password
> ok 48 - Blessed regexp should fail Password
> ok 49 - Filehandle should fail Password
> ok 50 - Filehandle object should fail Password
> ok 51 - Ref to scalarref should fail Password
> ok 52 - Ref to arrayref should fail Password
> ok 53 - Ref to hashref should fail Password
> ok 54 - Ref to coderef should fail Password
> ok 55 - Ref to blessed hashref should fail Password
> ok 56 - Object stringifying to "" should fail Password
> ok 57 - Object stringifying to "1" should fail Password
> ok 58 - Object numifying to 0 should fail Password
> ok 59 - Object numifying to 1 should fail Password
> ok 60 - Object overloading arrayref should fail Password
> ok 61 - Object overloading hashref should fail Password
> ok 62 - Object overloading coderef should fail Password
> ok 63 - Object booling to false should fail Password
> ok 64 - Object booling to true should fail Password
> 1..64
> ok
> t/21-types/PositiveInt.t .....................................
> ok 1 - 'PositiveInt' isa 'Type::Tiny'
> ok 2 - PositiveInt has correct name
> ok 3 - PositiveInt has correct display_name
> ok 4 - PositiveInt knows it is in the Types::Common::Numeric library
> ok 5 - Types::Common::Numeric knows it has type PositiveInt
> ok 6 - PositiveInt is not deprecated
> ok 7 - PositiveInt is not anonymous
> ok 8 - PositiveInt can be inlined
> ok 9 - Inlining PositiveInt doesn't throw an exception
> ok 10 - PositiveInt doesn't have a coercion
> ok 11 - PositiveInt isn't parameterizable
> ok 12 - PositiveInt has no type_default
> ok 13 - Undef should fail PositiveInt
> ok 14 - False should fail PositiveInt
> ok 15 - True should pass PositiveInt
> ok 16 - Zero should fail PositiveInt
> ok 17 - One should pass PositiveInt
> ok 18 - Negative one should fail PositiveInt
> ok 19 - Non integer should fail PositiveInt
> ok 20 - Empty string should fail PositiveInt
> ok 21 - Whitespace should fail PositiveInt
> ok 22 - Line break should fail PositiveInt
> ok 23 - Random string should fail PositiveInt
> ok 24 - Loaded package name should fail PositiveInt
> ok 25 - Unloaded package name should fail PositiveInt
> ok 26 - A reference to undef should fail PositiveInt
> ok 27 - A reference to false should fail PositiveInt
> ok 28 - A reference to true should fail PositiveInt
> ok 29 - A reference to zero should fail PositiveInt
> ok 30 - A reference to one should fail PositiveInt
> ok 31 - A reference to empty string should fail PositiveInt
> ok 32 - A reference to random string should fail PositiveInt
> ok 33 - Blessed scalarref should fail PositiveInt
> ok 34 - Empty arrayref should fail PositiveInt
> ok 35 - Arrayref with one zero should fail PositiveInt
> ok 36 - Arrayref of integers should fail PositiveInt
> ok 37 - Arrayref of numbers should fail PositiveInt
> ok 38 - Blessed arrayref should fail PositiveInt
> ok 39 - Empty hashref should fail PositiveInt
> ok 40 - Hashref should fail PositiveInt
> ok 41 - Blessed hashref should fail PositiveInt
> ok 42 - Coderef should fail PositiveInt
> ok 43 - Blessed coderef should fail PositiveInt
> ok 44 - Glob should fail PositiveInt
> ok 45 - Globref should fail PositiveInt
> ok 46 - Blessed globref should fail PositiveInt
> ok 47 - Regexp should fail PositiveInt
> ok 48 - Blessed regexp should fail PositiveInt
> ok 49 - Filehandle should fail PositiveInt
> ok 50 - Filehandle object should fail PositiveInt
> ok 51 - Ref to scalarref should fail PositiveInt
> ok 52 - Ref to arrayref should fail PositiveInt
> ok 53 - Ref to hashref should fail PositiveInt
> ok 54 - Ref to coderef should fail PositiveInt
> ok 55 - Ref to blessed hashref should fail PositiveInt
> ok 56 - Object stringifying to "" should fail PositiveInt
> ok 57 - Object stringifying to "1" should fail PositiveInt
> ok 58 - Object numifying to 0 should fail PositiveInt
> ok 59 - Object numifying to 1 should fail PositiveInt
> ok 60 - Object overloading arrayref should fail PositiveInt
> ok 61 - Object overloading hashref should fail PositiveInt
> ok 62 - Object overloading coderef should fail PositiveInt
> ok 63 - Object booling to false should fail PositiveInt
> ok 64 - Object booling to true should fail PositiveInt
> 1..64
> ok
> t/21-types/PositiveNum.t .....................................
> ok 1 - 'PositiveNum' isa 'Type::Tiny'
> ok 2 - PositiveNum has correct name
> ok 3 - PositiveNum has correct display_name
> ok 4 - PositiveNum knows it is in the Types::Common::Numeric library
> ok 5 - Types::Common::Numeric knows it has type PositiveNum
> ok 6 - PositiveNum is not deprecated
> ok 7 - PositiveNum is not anonymous
> ok 8 - PositiveNum can be inlined
> ok 9 - Inlining PositiveNum doesn't throw an exception
> ok 10 - PositiveNum doesn't have a coercion
> ok 11 - PositiveNum isn't parameterizable
> ok 12 - PositiveNum has no type_default
> ok 13 - Undef should fail PositiveNum
> ok 14 - False should fail PositiveNum
> ok 15 - True should pass PositiveNum
> ok 16 - Zero should fail PositiveNum
> ok 17 - One should pass PositiveNum
> ok 18 - Negative one should fail PositiveNum
> ok 19 - Non integer should pass PositiveNum
> ok 20 - Empty string should fail PositiveNum
> ok 21 - Whitespace should fail PositiveNum
> ok 22 - Line break should fail PositiveNum
> ok 23 - Random string should fail PositiveNum
> ok 24 - Loaded package name should fail PositiveNum
> ok 25 - Unloaded package name should fail PositiveNum
> ok 26 - A reference to undef should fail PositiveNum
> ok 27 - A reference to false should fail PositiveNum
> ok 28 - A reference to true should fail PositiveNum
> ok 29 - A reference to zero should fail PositiveNum
> ok 30 - A reference to one should fail PositiveNum
> ok 31 - A reference to empty string should fail PositiveNum
> ok 32 - A reference to random string should fail PositiveNum
> ok 33 - Blessed scalarref should fail PositiveNum
> ok 34 - Empty arrayref should fail PositiveNum
> ok 35 - Arrayref with one zero should fail PositiveNum
> ok 36 - Arrayref of integers should fail PositiveNum
> ok 37 - Arrayref of numbers should fail PositiveNum
> ok 38 - Blessed arrayref should fail PositiveNum
> ok 39 - Empty hashref should fail PositiveNum
> ok 40 - Hashref should fail PositiveNum
> ok 41 - Blessed hashref should fail PositiveNum
> ok 42 - Coderef should fail PositiveNum
> ok 43 - Blessed coderef should fail PositiveNum
> ok 44 - Glob should fail PositiveNum
> ok 45 - Globref should fail PositiveNum
> ok 46 - Blessed globref should fail PositiveNum
> ok 47 - Regexp should fail PositiveNum
> ok 48 - Blessed regexp should fail PositiveNum
> ok 49 - Filehandle should fail PositiveNum
> ok 50 - Filehandle object should fail PositiveNum
> ok 51 - Ref to scalarref should fail PositiveNum
> ok 52 - Ref to arrayref should fail PositiveNum
> ok 53 - Ref to hashref should fail PositiveNum
> ok 54 - Ref to coderef should fail PositiveNum
> ok 55 - Ref to blessed hashref should fail PositiveNum
> ok 56 - Object stringifying to "" should fail PositiveNum
> ok 57 - Object stringifying to "1" should fail PositiveNum
> ok 58 - Object numifying to 0 should fail PositiveNum
> ok 59 - Object numifying to 1 should fail PositiveNum
> ok 60 - Object overloading arrayref should fail PositiveNum
> ok 61 - Object overloading hashref should fail PositiveNum
> ok 62 - Object overloading coderef should fail PositiveNum
> ok 63 - Object booling to false should fail PositiveNum
> ok 64 - Object booling to true should fail PositiveNum
> 1..64
> ok
> t/21-types/PositiveOrZeroInt.t ...............................
> ok 1 - 'PositiveOrZeroInt' isa 'Type::Tiny'
> ok 2 - PositiveOrZeroInt has correct name
> ok 3 - PositiveOrZeroInt has correct display_name
> ok 4 - PositiveOrZeroInt knows it is in the Types::Common::Numeric library
> ok 5 - Types::Common::Numeric knows it has type PositiveOrZeroInt
> ok 6 - PositiveOrZeroInt is not deprecated
> ok 7 - PositiveOrZeroInt is not anonymous
> ok 8 - PositiveOrZeroInt can be inlined
> ok 9 - Inlining PositiveOrZeroInt doesn't throw an exception
> ok 10 - PositiveOrZeroInt doesn't have a coercion
> ok 11 - PositiveOrZeroInt isn't parameterizable
> ok 12 - PositiveOrZeroInt has a type_default
> ok 13 - PositiveOrZeroInt type_default is zero
> ok 14 - Undef should fail PositiveOrZeroInt
> ok 15 - False should fail PositiveOrZeroInt
> ok 16 - True should pass PositiveOrZeroInt
> ok 17 - Zero should pass PositiveOrZeroInt
> ok 18 - One should pass PositiveOrZeroInt
> ok 19 - Negative one should fail PositiveOrZeroInt
> ok 20 - Non integer should fail PositiveOrZeroInt
> ok 21 - Empty string should fail PositiveOrZeroInt
> ok 22 - Whitespace should fail PositiveOrZeroInt
> ok 23 - Line break should fail PositiveOrZeroInt
> ok 24 - Random string should fail PositiveOrZeroInt
> ok 25 - Loaded package name should fail PositiveOrZeroInt
> ok 26 - Unloaded package name should fail PositiveOrZeroInt
> ok 27 - A reference to undef should fail PositiveOrZeroInt
> ok 28 - A reference to false should fail PositiveOrZeroInt
> ok 29 - A reference to true should fail PositiveOrZeroInt
> ok 30 - A reference to zero should fail PositiveOrZeroInt
> ok 31 - A reference to one should fail PositiveOrZeroInt
> ok 32 - A reference to empty string should fail PositiveOrZeroInt
> ok 33 - A reference to random string should fail PositiveOrZeroInt
> ok 34 - Blessed scalarref should fail PositiveOrZeroInt
> ok 35 - Empty arrayref should fail PositiveOrZeroInt
> ok 36 - Arrayref with one zero should fail PositiveOrZeroInt
> ok 37 - Arrayref of integers should fail PositiveOrZeroInt
> ok 38 - Arrayref of numbers should fail PositiveOrZeroInt
> ok 39 - Blessed arrayref should fail PositiveOrZeroInt
> ok 40 - Empty hashref should fail PositiveOrZeroInt
> ok 41 - Hashref should fail PositiveOrZeroInt
> ok 42 - Blessed hashref should fail PositiveOrZeroInt
> ok 43 - Coderef should fail PositiveOrZeroInt
> ok 44 - Blessed coderef should fail PositiveOrZeroInt
> ok 45 - Glob should fail PositiveOrZeroInt
> ok 46 - Globref should fail PositiveOrZeroInt
> ok 47 - Blessed globref should fail PositiveOrZeroInt
> ok 48 - Regexp should fail PositiveOrZeroInt
> ok 49 - Blessed regexp should fail PositiveOrZeroInt
> ok 50 - Filehandle should fail PositiveOrZeroInt
> ok 51 - Filehandle object should fail PositiveOrZeroInt
> ok 52 - Ref to scalarref should fail PositiveOrZeroInt
> ok 53 - Ref to arrayref should fail PositiveOrZeroInt
> ok 54 - Ref to hashref should fail PositiveOrZeroInt
> ok 55 - Ref to coderef should fail PositiveOrZeroInt
> ok 56 - Ref to blessed hashref should fail PositiveOrZeroInt
> ok 57 - Object stringifying to "" should fail PositiveOrZeroInt
> ok 58 - Object stringifying to "1" should fail PositiveOrZeroInt
> ok 59 - Object numifying to 0 should fail PositiveOrZeroInt
> ok 60 - Object numifying to 1 should fail PositiveOrZeroInt
> ok 61 - Object overloading arrayref should fail PositiveOrZeroInt
> ok 62 - Object overloading hashref should fail PositiveOrZeroInt
> ok 63 - Object overloading coderef should fail PositiveOrZeroInt
> ok 64 - Object booling to false should fail PositiveOrZeroInt
> ok 65 - Object booling to true should fail PositiveOrZeroInt
> 1..65
> ok
> t/21-types/PositiveOrZeroNum.t ...............................
> ok 1 - 'PositiveOrZeroNum' isa 'Type::Tiny'
> ok 2 - PositiveOrZeroNum has correct name
> ok 3 - PositiveOrZeroNum has correct display_name
> ok 4 - PositiveOrZeroNum knows it is in the Types::Common::Numeric library
> ok 5 - Types::Common::Numeric knows it has type PositiveOrZeroNum
> ok 6 - PositiveOrZeroNum is not deprecated
> ok 7 - PositiveOrZeroNum is not anonymous
> ok 8 - PositiveOrZeroNum can be inlined
> ok 9 - Inlining PositiveOrZeroNum doesn't throw an exception
> ok 10 - PositiveOrZeroNum doesn't have a coercion
> ok 11 - PositiveOrZeroNum isn't parameterizable
> ok 12 - PositiveOrZeroNum has a type_default
> ok 13 - PositiveOrZeroNum type_default is zero
> ok 14 - Undef should fail PositiveOrZeroNum
> ok 15 - False should fail PositiveOrZeroNum
> ok 16 - True should pass PositiveOrZeroNum
> ok 17 - Zero should pass PositiveOrZeroNum
> ok 18 - One should pass PositiveOrZeroNum
> ok 19 - Negative one should fail PositiveOrZeroNum
> ok 20 - Non integer should pass PositiveOrZeroNum
> ok 21 - Empty string should fail PositiveOrZeroNum
> ok 22 - Whitespace should fail PositiveOrZeroNum
> ok 23 - Line break should fail PositiveOrZeroNum
> ok 24 - Random string should fail PositiveOrZeroNum
> ok 25 - Loaded package name should fail PositiveOrZeroNum
> ok 26 - Unloaded package name should fail PositiveOrZeroNum
> ok 27 - A reference to undef should fail PositiveOrZeroNum
> ok 28 - A reference to false should fail PositiveOrZeroNum
> ok 29 - A reference to true should fail PositiveOrZeroNum
> ok 30 - A reference to zero should fail PositiveOrZeroNum
> ok 31 - A reference to one should fail PositiveOrZeroNum
> ok 32 - A reference to empty string should fail PositiveOrZeroNum
> ok 33 - A reference to random string should fail PositiveOrZeroNum
> ok 34 - Blessed scalarref should fail PositiveOrZeroNum
> ok 35 - Empty arrayref should fail PositiveOrZeroNum
> ok 36 - Arrayref with one zero should fail PositiveOrZeroNum
> ok 37 - Arrayref of integers should fail PositiveOrZeroNum
> ok 38 - Arrayref of numbers should fail PositiveOrZeroNum
> ok 39 - Blessed arrayref should fail PositiveOrZeroNum
> ok 40 - Empty hashref should fail PositiveOrZeroNum
> ok 41 - Hashref should fail PositiveOrZeroNum
> ok 42 - Blessed hashref should fail PositiveOrZeroNum
> ok 43 - Coderef should fail PositiveOrZeroNum
> ok 44 - Blessed coderef should fail PositiveOrZeroNum
> ok 45 - Glob should fail PositiveOrZeroNum
> ok 46 - Globref should fail PositiveOrZeroNum
> ok 47 - Blessed globref should fail PositiveOrZeroNum
> ok 48 - Regexp should fail PositiveOrZeroNum
> ok 49 - Blessed regexp should fail PositiveOrZeroNum
> ok 50 - Filehandle should fail PositiveOrZeroNum
> ok 51 - Filehandle object should fail PositiveOrZeroNum
> ok 52 - Ref to scalarref should fail PositiveOrZeroNum
> ok 53 - Ref to arrayref should fail PositiveOrZeroNum
> ok 54 - Ref to hashref should fail PositiveOrZeroNum
> ok 55 - Ref to coderef should fail PositiveOrZeroNum
> ok 56 - Ref to blessed hashref should fail PositiveOrZeroNum
> ok 57 - Object stringifying to "" should fail PositiveOrZeroNum
> ok 58 - Object stringifying to "1" should fail PositiveOrZeroNum
> ok 59 - Object numifying to 0 should fail PositiveOrZeroNum
> ok 60 - Object numifying to 1 should fail PositiveOrZeroNum
> ok 61 - Object overloading arrayref should fail PositiveOrZeroNum
> ok 62 - Object overloading hashref should fail PositiveOrZeroNum
> ok 63 - Object overloading coderef should fail PositiveOrZeroNum
> ok 64 - Object booling to false should fail PositiveOrZeroNum
> ok 65 - Object booling to true should fail PositiveOrZeroNum
> 1..65
> ok
> t/21-types/Ref.t .............................................
> ok 1 - 'Ref' isa 'Type::Tiny'
> ok 2 - Ref has correct name
> ok 3 - Ref has correct display_name
> ok 4 - Ref knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Ref
> ok 6 - Ref is not deprecated
> ok 7 - Ref is not anonymous
> ok 8 - Ref can be inlined
> ok 9 - Inlining Ref doesn't throw an exception
> ok 10 - Ref doesn't have a coercion
> ok 11 - Ref is parameterizable
> ok 12 - Ref has no type_default
> ok 13 - Undef should fail Ref
> ok 14 - False should fail Ref
> ok 15 - True should fail Ref
> ok 16 - Zero should fail Ref
> ok 17 - One should fail Ref
> ok 18 - Negative one should fail Ref
> ok 19 - Non integer should fail Ref
> ok 20 - Empty string should fail Ref
> ok 21 - Whitespace should fail Ref
> ok 22 - Line break should fail Ref
> ok 23 - Random string should fail Ref
> ok 24 - Loaded package name should fail Ref
> ok 25 - Unloaded package name should fail Ref
> ok 26 - A reference to undef should pass Ref
> ok 27 - A reference to false should pass Ref
> ok 28 - A reference to true should pass Ref
> ok 29 - A reference to zero should pass Ref
> ok 30 - A reference to one should pass Ref
> ok 31 - A reference to empty string should pass Ref
> ok 32 - A reference to random string should pass Ref
> ok 33 - Blessed scalarref should pass Ref
> ok 34 - Empty arrayref should pass Ref
> ok 35 - Arrayref with one zero should pass Ref
> ok 36 - Arrayref of integers should pass Ref
> ok 37 - Arrayref of numbers should pass Ref
> ok 38 - Blessed arrayref should pass Ref
> ok 39 - Empty hashref should pass Ref
> ok 40 - Hashref should pass Ref
> ok 41 - Blessed hashref should pass Ref
> ok 42 - Coderef should pass Ref
> ok 43 - Blessed coderef should pass Ref
> ok 44 - Glob should fail Ref
> ok 45 - Globref should pass Ref
> ok 46 - Blessed globref should pass Ref
> ok 47 - Regexp should pass Ref
> ok 48 - Blessed regexp should pass Ref
> ok 49 - Filehandle should pass Ref
> ok 50 - Filehandle object should pass Ref
> ok 51 - Ref to scalarref should pass Ref
> ok 52 - Ref to arrayref should pass Ref
> ok 53 - Ref to hashref should pass Ref
> ok 54 - Ref to coderef should pass Ref
> ok 55 - Ref to blessed hashref should pass Ref
> ok 56 - Object stringifying to "" should pass Ref
> ok 57 - Object stringifying to "1" should pass Ref
> ok 58 - Object numifying to 0 should pass Ref
> ok 59 - Object numifying to 1 should pass Ref
> ok 60 - Object overloading arrayref should pass Ref
> ok 61 - Object overloading hashref should pass Ref
> ok 62 - Object overloading coderef should pass Ref
> ok 63 - Object booling to false should pass Ref
> ok 64 - Object booling to true should pass Ref
> # == Ref[ARRAY] ==
> ok 65 - '$type' isa 'Type::Tiny'
> ok 66 - $type is not anonymous
> ok 67 - $type can be inlined
> ok 68 - Inlining $type doesn't throw an exception
> ok 69 - $type doesn't have a coercion
> ok 70 - $type isn't parameterizable
> ok 71 - $type is parameterized
> ok 72 - $type's parent is Ref
> ok 73 - Reference [] passes type constraint Ref[ARRAY]
> ok 74 - Reference bless( [], 'Foo' ) passes type constraint Ref[ARRAY]
> ok 75 - Reference sub { "DUMMY" } fails type constraint Ref[ARRAY]
> ok 76 - Reference bless( sub { "DUMMY" }, 'Foo' ) fails type constraint Ref[ARRAY]
> ok 77 - Reference \*::BLEH fails type constraint Ref[ARRAY]
> ok 78 - Reference bless( \*::BLEH2, 'Foo' ) fails type constraint Ref[ARRAY]
> ok 79 - Reference {} fails type constraint Ref[ARRAY]
> ok 80 - Reference bless( {}, 'Foo' ) fails type constraint Ref[ARRAY]
> ok 81 - Reference \undef fails type constraint Ref[ARRAY]
> ok 82 - Reference bless( do{\(my $o = undef)}, 'Foo' ) fails type constraint Ref[ARRAY]
> # == Ref[CODE] ==
> ok 83 - '$type' isa 'Type::Tiny'
> ok 84 - $type is not anonymous
> ok 85 - $type can be inlined
> ok 86 - Inlining $type doesn't throw an exception
> ok 87 - $type doesn't have a coercion
> ok 88 - $type isn't parameterizable
> ok 89 - $type is parameterized
> ok 90 - $type's parent is Ref
> ok 91 - Reference [] fails type constraint Ref[CODE]
> ok 92 - Reference bless( [], 'Foo' ) fails type constraint Ref[CODE]
> ok 93 - Reference sub { "DUMMY" } passes type constraint Ref[CODE]
> ok 94 - Reference bless( sub { "DUMMY" }, 'Foo' ) passes type constraint Ref[CODE]
> ok 95 - Reference \*::BLEH fails type constraint Ref[CODE]
> ok 96 - Reference bless( \*::BLEH2, 'Foo' ) fails type constraint Ref[CODE]
> ok 97 - Reference {} fails type constraint Ref[CODE]
> ok 98 - Reference bless( {}, 'Foo' ) fails type constraint Ref[CODE]
> ok 99 - Reference \undef fails type constraint Ref[CODE]
> ok 100 - Reference bless( do{\(my $o = undef)}, 'Foo' ) fails type constraint Ref[CODE]
> # == Ref[GLOB] ==
> ok 101 - '$type' isa 'Type::Tiny'
> ok 102 - $type is not anonymous
> ok 103 - $type can be inlined
> ok 104 - Inlining $type doesn't throw an exception
> ok 105 - $type doesn't have a coercion
> ok 106 - $type isn't parameterizable
> ok 107 - $type is parameterized
> ok 108 - $type's parent is Ref
> ok 109 - Reference [] fails type constraint Ref[GLOB]
> ok 110 - Reference bless( [], 'Foo' ) fails type constraint Ref[GLOB]
> ok 111 - Reference sub { "DUMMY" } fails type constraint Ref[GLOB]
> ok 112 - Reference bless( sub { "DUMMY" }, 'Foo' ) fails type constraint Ref[GLOB]
> ok 113 - Reference \*::BLEH passes type constraint Ref[GLOB]
> ok 114 - Reference bless( \*::BLEH2, 'Foo' ) passes type constraint Ref[GLOB]
> ok 115 - Reference {} fails type constraint Ref[GLOB]
> ok 116 - Reference bless( {}, 'Foo' ) fails type constraint Ref[GLOB]
> ok 117 - Reference \undef fails type constraint Ref[GLOB]
> ok 118 - Reference bless( do{\(my $o = undef)}, 'Foo' ) fails type constraint Ref[GLOB]
> # == Ref[HASH] ==
> ok 119 - '$type' isa 'Type::Tiny'
> ok 120 - $type is not anonymous
> ok 121 - $type can be inlined
> ok 122 - Inlining $type doesn't throw an exception
> ok 123 - $type doesn't have a coercion
> ok 124 - $type isn't parameterizable
> ok 125 - $type is parameterized
> ok 126 - $type's parent is Ref
> ok 127 - Reference [] fails type constraint Ref[HASH]
> ok 128 - Reference bless( [], 'Foo' ) fails type constraint Ref[HASH]
> ok 129 - Reference sub { "DUMMY" } fails type constraint Ref[HASH]
> ok 130 - Reference bless( sub { "DUMMY" }, 'Foo' ) fails type constraint Ref[HASH]
> ok 131 - Reference \*::BLEH fails type constraint Ref[HASH]
> ok 132 - Reference bless( \*::BLEH2, 'Foo' ) fails type constraint Ref[HASH]
> ok 133 - Reference {} passes type constraint Ref[HASH]
> ok 134 - Reference bless( {}, 'Foo' ) passes type constraint Ref[HASH]
> ok 135 - Reference \undef fails type constraint Ref[HASH]
> ok 136 - Reference bless( do{\(my $o = undef)}, 'Foo' ) fails type constraint Ref[HASH]
> # == Ref[SCALAR] ==
> ok 137 - '$type' isa 'Type::Tiny'
> ok 138 - $type is not anonymous
> ok 139 - $type can be inlined
> ok 140 - Inlining $type doesn't throw an exception
> ok 141 - $type doesn't have a coercion
> ok 142 - $type isn't parameterizable
> ok 143 - $type is parameterized
> ok 144 - $type's parent is Ref
> ok 145 - Reference [] fails type constraint Ref[SCALAR]
> ok 146 - Reference bless( [], 'Foo' ) fails type constraint Ref[SCALAR]
> ok 147 - Reference sub { "DUMMY" } fails type constraint Ref[SCALAR]
> ok 148 - Reference bless( sub { "DUMMY" }, 'Foo' ) fails type constraint Ref[SCALAR]
> ok 149 - Reference \*::BLEH fails type constraint Ref[SCALAR]
> ok 150 - Reference bless( \*::BLEH2, 'Foo' ) fails type constraint Ref[SCALAR]
> ok 151 - Reference {} fails type constraint Ref[SCALAR]
> ok 152 - Reference bless( {}, 'Foo' ) fails type constraint Ref[SCALAR]
> ok 153 - Reference \undef passes type constraint Ref[SCALAR]
> ok 154 - Reference bless( do{\(my $o = undef)}, 'Foo' ) passes type constraint Ref[SCALAR]
> 1..154
> ok
> t/21-types/RegexpRef.t .......................................
> ok 1 - 'RegexpRef' isa 'Type::Tiny'
> ok 2 - RegexpRef has correct name
> ok 3 - RegexpRef has correct display_name
> ok 4 - RegexpRef knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type RegexpRef
> ok 6 - RegexpRef is not deprecated
> ok 7 - RegexpRef is not anonymous
> ok 8 - RegexpRef can be inlined
> ok 9 - Inlining RegexpRef doesn't throw an exception
> ok 10 - RegexpRef doesn't have a coercion
> ok 11 - RegexpRef isn't parameterizable
> ok 12 - RegexpRef has a type_default
> ok 13 - RegexpRef type_default is qr//
> ok 14 - Undef should fail RegexpRef
> ok 15 - False should fail RegexpRef
> ok 16 - True should fail RegexpRef
> ok 17 - Zero should fail RegexpRef
> ok 18 - One should fail RegexpRef
> ok 19 - Negative one should fail RegexpRef
> ok 20 - Non integer should fail RegexpRef
> ok 21 - Empty string should fail RegexpRef
> ok 22 - Whitespace should fail RegexpRef
> ok 23 - Line break should fail RegexpRef
> ok 24 - Random string should fail RegexpRef
> ok 25 - Loaded package name should fail RegexpRef
> ok 26 - Unloaded package name should fail RegexpRef
> ok 27 - A reference to undef should fail RegexpRef
> ok 28 - A reference to false should fail RegexpRef
> ok 29 - A reference to true should fail RegexpRef
> ok 30 - A reference to zero should fail RegexpRef
> ok 31 - A reference to one should fail RegexpRef
> ok 32 - A reference to empty string should fail RegexpRef
> ok 33 - A reference to random string should fail RegexpRef
> ok 34 - Blessed scalarref should fail RegexpRef
> ok 35 - Empty arrayref should fail RegexpRef
> ok 36 - Arrayref with one zero should fail RegexpRef
> ok 37 - Arrayref of integers should fail RegexpRef
> ok 38 - Arrayref of numbers should fail RegexpRef
> ok 39 - Blessed arrayref should fail RegexpRef
> ok 40 - Empty hashref should fail RegexpRef
> ok 41 - Hashref should fail RegexpRef
> ok 42 - Blessed hashref should fail RegexpRef
> ok 43 - Coderef should fail RegexpRef
> ok 44 - Blessed coderef should fail RegexpRef
> ok 45 - Glob should fail RegexpRef
> ok 46 - Globref should fail RegexpRef
> ok 47 - Blessed globref should fail RegexpRef
> ok 48 - Regexp should pass RegexpRef
> ok 49 - Blessed regexp should pass RegexpRef
> ok 50 - Filehandle should fail RegexpRef
> ok 51 - Filehandle object should fail RegexpRef
> ok 52 - Ref to scalarref should fail RegexpRef
> ok 53 - Ref to arrayref should fail RegexpRef
> ok 54 - Ref to hashref should fail RegexpRef
> ok 55 - Ref to coderef should fail RegexpRef
> ok 56 - Ref to blessed hashref should fail RegexpRef
> ok 57 - Object stringifying to "" should fail RegexpRef
> ok 58 - Object stringifying to "1" should fail RegexpRef
> ok 59 - Object numifying to 0 should fail RegexpRef
> ok 60 - Object numifying to 1 should fail RegexpRef
> ok 61 - Object overloading arrayref should fail RegexpRef
> ok 62 - Object overloading hashref should fail RegexpRef
> ok 63 - Object overloading coderef should fail RegexpRef
> ok 64 - Object booling to false should fail RegexpRef
> ok 65 - Object booling to true should fail RegexpRef
> 1..65
> ok
> t/21-types/RoleName.t ........................................
> ok 1 - 'RoleName' isa 'Type::Tiny'
> ok 2 - RoleName has correct name
> ok 3 - RoleName has correct display_name
> ok 4 - RoleName knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type RoleName
> ok 6 - RoleName is not deprecated
> ok 7 - RoleName is not anonymous
> ok 8 - RoleName can be inlined
> ok 9 - Inlining RoleName doesn't throw an exception
> ok 10 - RoleName doesn't have a coercion
> ok 11 - RoleName isn't parameterizable
> ok 12 - RoleName has no type_default
> ok 13 - Undef should fail RoleName
> ok 14 - False should fail RoleName
> ok 15 - True should fail RoleName
> ok 16 - Zero should fail RoleName
> ok 17 - One should fail RoleName
> ok 18 - Negative one should fail RoleName
> ok 19 - Non integer should fail RoleName
> ok 20 - Empty string should fail RoleName
> ok 21 - Whitespace should fail RoleName
> ok 22 - Line break should fail RoleName
> ok 23 - Random string should fail RoleName
> ok 24 - Loaded package name should fail RoleName
> ok 25 - Unloaded package name should fail RoleName
> ok 26 - A reference to undef should fail RoleName
> ok 27 - A reference to false should fail RoleName
> ok 28 - A reference to true should fail RoleName
> ok 29 - A reference to zero should fail RoleName
> ok 30 - A reference to one should fail RoleName
> ok 31 - A reference to empty string should fail RoleName
> ok 32 - A reference to random string should fail RoleName
> ok 33 - Blessed scalarref should fail RoleName
> ok 34 - Empty arrayref should fail RoleName
> ok 35 - Arrayref with one zero should fail RoleName
> ok 36 - Arrayref of integers should fail RoleName
> ok 37 - Arrayref of numbers should fail RoleName
> ok 38 - Blessed arrayref should fail RoleName
> ok 39 - Empty hashref should fail RoleName
> ok 40 - Hashref should fail RoleName
> ok 41 - Blessed hashref should fail RoleName
> ok 42 - Coderef should fail RoleName
> ok 43 - Blessed coderef should fail RoleName
> ok 44 - Glob should fail RoleName
> ok 45 - Globref should fail RoleName
> ok 46 - Blessed globref should fail RoleName
> ok 47 - Regexp should fail RoleName
> ok 48 - Blessed regexp should fail RoleName
> ok 49 - Filehandle should fail RoleName
> ok 50 - Filehandle object should fail RoleName
> ok 51 - Ref to scalarref should fail RoleName
> ok 52 - Ref to arrayref should fail RoleName
> ok 53 - Ref to hashref should fail RoleName
> ok 54 - Ref to coderef should fail RoleName
> ok 55 - Ref to blessed hashref should fail RoleName
> ok 56 - Object stringifying to "" should fail RoleName
> ok 57 - Object stringifying to "1" should fail RoleName
> ok 58 - Object numifying to 0 should fail RoleName
> ok 59 - Object numifying to 1 should fail RoleName
> ok 60 - Object overloading arrayref should fail RoleName
> ok 61 - Object overloading hashref should fail RoleName
> ok 62 - Object overloading coderef should fail RoleName
> ok 63 - Object booling to false should fail RoleName
> ok 64 - Object booling to true should fail RoleName
> ok 65 - Value "Local::Role::RoleTiny" passes type constraint RoleName
> ok 66 - Value "Local::Role::MooRole" passes type constraint RoleName
> ok 67 - Value "Local::Role::MooseRole" passes type constraint RoleName
> ok 68 - Value "Local::Role::MouseRole" passes type constraint RoleName
> ok 69 - Value "Local::Class::Moo" fails type constraint RoleName
> ok 70 - Value "Local::Class::Moose" fails type constraint RoleName
> ok 71 - Value "Local::Class::Mouse" fails type constraint RoleName
> 1..71
> ok
> t/21-types/ScalarRef.t .......................................
> ok 1 - 'ScalarRef' isa 'Type::Tiny'
> ok 2 - ScalarRef has correct name
> ok 3 - ScalarRef has correct display_name
> ok 4 - ScalarRef knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type ScalarRef
> ok 6 - ScalarRef is not deprecated
> ok 7 - ScalarRef is not anonymous
> ok 8 - ScalarRef can be inlined
> ok 9 - Inlining ScalarRef doesn't throw an exception
> ok 10 - ScalarRef doesn't have a coercion
> ok 11 - ScalarRef is parameterizable
> ok 12 - ScalarRef has a type_default
> ok 13 - ScalarRef type_default is a reference to undef
> ok 14 - Undef should fail ScalarRef
> ok 15 - False should fail ScalarRef
> ok 16 - True should fail ScalarRef
> ok 17 - Zero should fail ScalarRef
> ok 18 - One should fail ScalarRef
> ok 19 - Negative one should fail ScalarRef
> ok 20 - Non integer should fail ScalarRef
> ok 21 - Empty string should fail ScalarRef
> ok 22 - Whitespace should fail ScalarRef
> ok 23 - Line break should fail ScalarRef
> ok 24 - Random string should fail ScalarRef
> ok 25 - Loaded package name should fail ScalarRef
> ok 26 - Unloaded package name should fail ScalarRef
> ok 27 - A reference to undef should pass ScalarRef
> ok 28 - A reference to false should pass ScalarRef
> ok 29 - A reference to true should pass ScalarRef
> ok 30 - A reference to zero should pass ScalarRef
> ok 31 - A reference to one should pass ScalarRef
> ok 32 - A reference to empty string should pass ScalarRef
> ok 33 - A reference to random string should pass ScalarRef
> ok 34 - Blessed scalarref should fail ScalarRef
> ok 35 - Empty arrayref should fail ScalarRef
> ok 36 - Arrayref with one zero should fail ScalarRef
> ok 37 - Arrayref of integers should fail ScalarRef
> ok 38 - Arrayref of numbers should fail ScalarRef
> ok 39 - Blessed arrayref should fail ScalarRef
> ok 40 - Empty hashref should fail ScalarRef
> ok 41 - Hashref should fail ScalarRef
> ok 42 - Blessed hashref should fail ScalarRef
> ok 43 - Coderef should fail ScalarRef
> ok 44 - Blessed coderef should fail ScalarRef
> ok 45 - Glob should fail ScalarRef
> ok 46 - Globref should fail ScalarRef
> ok 47 - Blessed globref should fail ScalarRef
> ok 48 - Regexp should fail ScalarRef
> ok 49 - Blessed regexp should fail ScalarRef
> ok 50 - Filehandle should fail ScalarRef
> ok 51 - Filehandle object should fail ScalarRef
> ok 52 - Ref to scalarref should pass ScalarRef
> ok 53 - Ref to arrayref should pass ScalarRef
> ok 54 - Ref to hashref should pass ScalarRef
> ok 55 - Ref to coderef should pass ScalarRef
> ok 56 - Ref to blessed hashref should pass ScalarRef
> ok 57 - Object stringifying to "" should fail ScalarRef
> ok 58 - Object stringifying to "1" should fail ScalarRef
> ok 59 - Object numifying to 0 should fail ScalarRef
> ok 60 - Object numifying to 1 should fail ScalarRef
> ok 61 - Object overloading arrayref should fail ScalarRef
> ok 62 - Object overloading hashref should fail ScalarRef
> ok 63 - Object overloading coderef should fail ScalarRef
> ok 64 - Object booling to false should fail ScalarRef
> ok 65 - Object booling to true should fail ScalarRef
> ok 66 - parameterizing with [] has no effect
> ok 67 - Reference \1 passes type constraint ScalarRef[Int]
> ok 68 - Reference \"1.2" fails type constraint ScalarRef[Int]
> ok 69 - Reference \"abc" fails type constraint ScalarRef[Int]
> ok 70 - Reference \1 passes type constraint ScalarRef[Int]
> ok 71 - Reference \"1.2" fails type constraint ScalarRef[Int]
> ok 72 - Reference \"abc" fails type constraint ScalarRef[Int]
> ok 73
> ok 74
> ok 75 - Reference \[] passes type constraint ScalarRef[ArrayRef[Int]]
> ok 76 - Reference \[1] passes type constraint ScalarRef[ArrayRef[Int]]
> ok 77 - Reference \["1.2"] fails type constraint ScalarRef[ArrayRef[Int]]
> ok 78 - Reference \["abc"] fails type constraint ScalarRef[ArrayRef[Int]]
> ok 79 - Reference [] fails type constraint ScalarRef[ArrayRef[Int]]
> ok 80 - Reference [1] fails type constraint ScalarRef[ArrayRef[Int]]
> ok 81 - Reference ["1.2"] fails type constraint ScalarRef[ArrayRef[Int]]
> ok 82 - Reference ["abc"] fails type constraint ScalarRef[ArrayRef[Int]]
> ok 83
> ok 84
> 1..84
> ok
> t/21-types/SimpleStr.t .......................................
> ok 1 - 'SimpleStr' isa 'Type::Tiny'
> ok 2 - SimpleStr has correct name
> ok 3 - SimpleStr has correct display_name
> ok 4 - SimpleStr knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type SimpleStr
> ok 6 - SimpleStr is not deprecated
> ok 7 - SimpleStr is not anonymous
> ok 8 - SimpleStr can be inlined
> ok 9 - Inlining SimpleStr doesn't throw an exception
> ok 10 - SimpleStr doesn't have a coercion
> ok 11 - SimpleStr isn't parameterizable
> ok 12 - SimpleStr has a type_default
> ok 13 - SimpleStr type_default is the empty string
> ok 14 - Undef should fail SimpleStr
> ok 15 - False should pass SimpleStr
> ok 16 - True should pass SimpleStr
> ok 17 - Zero should pass SimpleStr
> ok 18 - One should pass SimpleStr
> ok 19 - Negative one should pass SimpleStr
> ok 20 - Non integer should pass SimpleStr
> ok 21 - Empty string should pass SimpleStr
> ok 22 - Whitespace should pass SimpleStr
> ok 23 - Line break should fail SimpleStr
> ok 24 - Random string should pass SimpleStr
> ok 25 - Loaded package name should pass SimpleStr
> ok 26 - Unloaded package name should pass SimpleStr
> ok 27 - A reference to undef should fail SimpleStr
> ok 28 - A reference to false should fail SimpleStr
> ok 29 - A reference to true should fail SimpleStr
> ok 30 - A reference to zero should fail SimpleStr
> ok 31 - A reference to one should fail SimpleStr
> ok 32 - A reference to empty string should fail SimpleStr
> ok 33 - A reference to random string should fail SimpleStr
> ok 34 - Blessed scalarref should fail SimpleStr
> ok 35 - Empty arrayref should fail SimpleStr
> ok 36 - Arrayref with one zero should fail SimpleStr
> ok 37 - Arrayref of integers should fail SimpleStr
> ok 38 - Arrayref of numbers should fail SimpleStr
> ok 39 - Blessed arrayref should fail SimpleStr
> ok 40 - Empty hashref should fail SimpleStr
> ok 41 - Hashref should fail SimpleStr
> ok 42 - Blessed hashref should fail SimpleStr
> ok 43 - Coderef should fail SimpleStr
> ok 44 - Blessed coderef should fail SimpleStr
> ok 45 - Glob should fail SimpleStr
> ok 46 - Globref should fail SimpleStr
> ok 47 - Blessed globref should fail SimpleStr
> ok 48 - Regexp should fail SimpleStr
> ok 49 - Blessed regexp should fail SimpleStr
> ok 50 - Filehandle should fail SimpleStr
> ok 51 - Filehandle object should fail SimpleStr
> ok 52 - Ref to scalarref should fail SimpleStr
> ok 53 - Ref to arrayref should fail SimpleStr
> ok 54 - Ref to hashref should fail SimpleStr
> ok 55 - Ref to coderef should fail SimpleStr
> ok 56 - Ref to blessed hashref should fail SimpleStr
> ok 57 - Object stringifying to "" should fail SimpleStr
> ok 58 - Object stringifying to "1" should fail SimpleStr
> ok 59 - Object numifying to 0 should fail SimpleStr
> ok 60 - Object numifying to 1 should fail SimpleStr
> ok 61 - Object overloading arrayref should fail SimpleStr
> ok 62 - Object overloading hashref should fail SimpleStr
> ok 63 - Object overloading coderef should fail SimpleStr
> ok 64 - Object booling to false should fail SimpleStr
> ok 65 - Object booling to true should fail SimpleStr
> 1..65
> ok
> t/21-types/SingleDigit.t .....................................
> ok 1 - 'SingleDigit' isa 'Type::Tiny'
> ok 2 - SingleDigit has correct name
> ok 3 - SingleDigit has correct display_name
> ok 4 - SingleDigit knows it is in the Types::Common::Numeric library
> ok 5 - Types::Common::Numeric knows it has type SingleDigit
> ok 6 - SingleDigit is not deprecated
> ok 7 - SingleDigit is not anonymous
> ok 8 - SingleDigit can be inlined
> ok 9 - Inlining SingleDigit doesn't throw an exception
> ok 10 - SingleDigit doesn't have a coercion
> ok 11 - SingleDigit isn't parameterizable
> ok 12 - SingleDigit has a type_default
> ok 13 - SingleDigit type_default is zero
> ok 14 - Undef should fail SingleDigit
> ok 15 - False should fail SingleDigit
> ok 16 - True should pass SingleDigit
> ok 17 - Zero should pass SingleDigit
> ok 18 - One should pass SingleDigit
> ok 19 - Negative one should pass SingleDigit
> ok 20 - Non integer should fail SingleDigit
> ok 21 - Empty string should fail SingleDigit
> ok 22 - Whitespace should fail SingleDigit
> ok 23 - Line break should fail SingleDigit
> ok 24 - Random string should fail SingleDigit
> ok 25 - Loaded package name should fail SingleDigit
> ok 26 - Unloaded package name should fail SingleDigit
> ok 27 - A reference to undef should fail SingleDigit
> ok 28 - A reference to false should fail SingleDigit
> ok 29 - A reference to true should fail SingleDigit
> ok 30 - A reference to zero should fail SingleDigit
> ok 31 - A reference to one should fail SingleDigit
> ok 32 - A reference to empty string should fail SingleDigit
> ok 33 - A reference to random string should fail SingleDigit
> ok 34 - Blessed scalarref should fail SingleDigit
> ok 35 - Empty arrayref should fail SingleDigit
> ok 36 - Arrayref with one zero should fail SingleDigit
> ok 37 - Arrayref of integers should fail SingleDigit
> ok 38 - Arrayref of numbers should fail SingleDigit
> ok 39 - Blessed arrayref should fail SingleDigit
> ok 40 - Empty hashref should fail SingleDigit
> ok 41 - Hashref should fail SingleDigit
> ok 42 - Blessed hashref should fail SingleDigit
> ok 43 - Coderef should fail SingleDigit
> ok 44 - Blessed coderef should fail SingleDigit
> ok 45 - Glob should fail SingleDigit
> ok 46 - Globref should fail SingleDigit
> ok 47 - Blessed globref should fail SingleDigit
> ok 48 - Regexp should fail SingleDigit
> ok 49 - Blessed regexp should fail SingleDigit
> ok 50 - Filehandle should fail SingleDigit
> ok 51 - Filehandle object should fail SingleDigit
> ok 52 - Ref to scalarref should fail SingleDigit
> ok 53 - Ref to arrayref should fail SingleDigit
> ok 54 - Ref to hashref should fail SingleDigit
> ok 55 - Ref to coderef should fail SingleDigit
> ok 56 - Ref to blessed hashref should fail SingleDigit
> ok 57 - Object stringifying to "" should fail SingleDigit
> ok 58 - Object stringifying to "1" should fail SingleDigit
> ok 59 - Object numifying to 0 should fail SingleDigit
> ok 60 - Object numifying to 1 should fail SingleDigit
> ok 61 - Object overloading arrayref should fail SingleDigit
> ok 62 - Object overloading hashref should fail SingleDigit
> ok 63 - Object overloading coderef should fail SingleDigit
> ok 64 - Object booling to false should fail SingleDigit
> ok 65 - Object booling to true should fail SingleDigit
> 1..65
> ok
> t/21-types/Slurpy.t ..........................................
> ok 1 - 'Slurpy' isa 'Type::Tiny'
> ok 2 - Slurpy has correct name
> ok 3 - Slurpy has correct display_name
> ok 4 - Slurpy knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Slurpy
> ok 6 - Slurpy is not deprecated
> ok 7 - Slurpy is not anonymous
> ok 8 - Slurpy can be inlined
> ok 9 - Inlining Slurpy doesn't throw an exception
> ok 10 - Slurpy doesn't have a coercion
> ok 11 - Slurpy is parameterizable
> ok 12 - Slurpy has a type_default
> ok 13 - Slurpy type_default is undef
> ok 14 - Undef should pass Slurpy
> ok 15 - False should pass Slurpy
> ok 16 - True should pass Slurpy
> ok 17 - Zero should pass Slurpy
> ok 18 - One should pass Slurpy
> ok 19 - Negative one should pass Slurpy
> ok 20 - Non integer should pass Slurpy
> ok 21 - Empty string should pass Slurpy
> ok 22 - Whitespace should pass Slurpy
> ok 23 - Line break should pass Slurpy
> ok 24 - Random string should pass Slurpy
> ok 25 - Loaded package name should pass Slurpy
> ok 26 - Unloaded package name should pass Slurpy
> ok 27 - A reference to undef should pass Slurpy
> ok 28 - A reference to false should pass Slurpy
> ok 29 - A reference to true should pass Slurpy
> ok 30 - A reference to zero should pass Slurpy
> ok 31 - A reference to one should pass Slurpy
> ok 32 - A reference to empty string should pass Slurpy
> ok 33 - A reference to random string should pass Slurpy
> ok 34 - Blessed scalarref should pass Slurpy
> ok 35 - Empty arrayref should pass Slurpy
> ok 36 - Arrayref with one zero should pass Slurpy
> ok 37 - Arrayref of integers should pass Slurpy
> ok 38 - Arrayref of numbers should pass Slurpy
> ok 39 - Blessed arrayref should pass Slurpy
> ok 40 - Empty hashref should pass Slurpy
> ok 41 - Hashref should pass Slurpy
> ok 42 - Blessed hashref should pass Slurpy
> ok 43 - Coderef should pass Slurpy
> ok 44 - Blessed coderef should pass Slurpy
> ok 45 - Glob should pass Slurpy
> ok 46 - Globref should pass Slurpy
> ok 47 - Blessed globref should pass Slurpy
> ok 48 - Regexp should pass Slurpy
> ok 49 - Blessed regexp should pass Slurpy
> ok 50 - Filehandle should pass Slurpy
> ok 51 - Filehandle object should pass Slurpy
> ok 52 - Ref to scalarref should pass Slurpy
> ok 53 - Ref to arrayref should pass Slurpy
> ok 54 - Ref to hashref should pass Slurpy
> ok 55 - Ref to coderef should pass Slurpy
> ok 56 - Ref to blessed hashref should pass Slurpy
> ok 57 - Object stringifying to "" should pass Slurpy
> ok 58 - Object stringifying to "1" should pass Slurpy
> ok 59 - Object numifying to 0 should pass Slurpy
> ok 60 - Object numifying to 1 should pass Slurpy
> ok 61 - Object overloading arrayref should pass Slurpy
> ok 62 - Object overloading hashref should pass Slurpy
> ok 63 - Object overloading coderef should pass Slurpy
> ok 64 - Object booling to false should pass Slurpy
> ok 65 - Object booling to true should pass Slurpy
> ok 66 - Undef should fail Slurpy[CodeRef]
> ok 67 - False should fail Slurpy[CodeRef]
> ok 68 - True should fail Slurpy[CodeRef]
> ok 69 - Zero should fail Slurpy[CodeRef]
> ok 70 - One should fail Slurpy[CodeRef]
> ok 71 - Negative one should fail Slurpy[CodeRef]
> ok 72 - Non integer should fail Slurpy[CodeRef]
> ok 73 - Empty string should fail Slurpy[CodeRef]
> ok 74 - Whitespace should fail Slurpy[CodeRef]
> ok 75 - Line break should fail Slurpy[CodeRef]
> ok 76 - Random string should fail Slurpy[CodeRef]
> ok 77 - Loaded package name should fail Slurpy[CodeRef]
> ok 78 - Unloaded package name should fail Slurpy[CodeRef]
> ok 79 - A reference to undef should fail Slurpy[CodeRef]
> ok 80 - A reference to false should fail Slurpy[CodeRef]
> ok 81 - A reference to true should fail Slurpy[CodeRef]
> ok 82 - A reference to zero should fail Slurpy[CodeRef]
> ok 83 - A reference to one should fail Slurpy[CodeRef]
> ok 84 - A reference to empty string should fail Slurpy[CodeRef]
> ok 85 - A reference to random string should fail Slurpy[CodeRef]
> ok 86 - Blessed scalarref should fail Slurpy[CodeRef]
> ok 87 - Empty arrayref should fail Slurpy[CodeRef]
> ok 88 - Arrayref with one zero should fail Slurpy[CodeRef]
> ok 89 - Arrayref of integers should fail Slurpy[CodeRef]
> ok 90 - Arrayref of numbers should fail Slurpy[CodeRef]
> ok 91 - Blessed arrayref should fail Slurpy[CodeRef]
> ok 92 - Empty hashref should fail Slurpy[CodeRef]
> ok 93 - Hashref should fail Slurpy[CodeRef]
> ok 94 - Blessed hashref should fail Slurpy[CodeRef]
> ok 95 - Coderef should pass Slurpy[CodeRef]
> ok 96 - Blessed coderef should fail Slurpy[CodeRef]
> ok 97 - Glob should fail Slurpy[CodeRef]
> ok 98 - Globref should fail Slurpy[CodeRef]
> ok 99 - Blessed globref should fail Slurpy[CodeRef]
> ok 100 - Regexp should fail Slurpy[CodeRef]
> ok 101 - Blessed regexp should fail Slurpy[CodeRef]
> ok 102 - Filehandle should fail Slurpy[CodeRef]
> ok 103 - Filehandle object should fail Slurpy[CodeRef]
> ok 104 - Ref to scalarref should fail Slurpy[CodeRef]
> ok 105 - Ref to arrayref should fail Slurpy[CodeRef]
> ok 106 - Ref to hashref should fail Slurpy[CodeRef]
> ok 107 - Ref to coderef should fail Slurpy[CodeRef]
> ok 108 - Ref to blessed hashref should fail Slurpy[CodeRef]
> ok 109 - Slurpy[HashRef] has a type_default
> ok 110 - Slurpy[HashRef] type_default is {}
> ok 111 - Slurpy[Defined] has no type_default
> ok 112
> ok 113
> ok 114
> ok 115
> ok 116
> ok 117
> ok 118
> 1..118
> ok
> t/21-types/Str.t .............................................
> ok 1 - 'Str' isa 'Type::Tiny'
> ok 2 - Str has correct name
> ok 3 - Str has correct display_name
> ok 4 - Str knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Str
> ok 6 - Str is not deprecated
> ok 7 - Str is not anonymous
> ok 8 - Str can be inlined
> ok 9 - Inlining Str doesn't throw an exception
> ok 10 - Str doesn't have a coercion
> ok 11 - Str isn't parameterizable
> ok 12 - Str has a type_default
> ok 13 - Str type_default is the empty string
> ok 14 - Undef should fail Str
> ok 15 - False should pass Str
> ok 16 - True should pass Str
> ok 17 - Zero should pass Str
> ok 18 - One should pass Str
> ok 19 - Negative one should pass Str
> ok 20 - Non integer should pass Str
> ok 21 - Empty string should pass Str
> ok 22 - Whitespace should pass Str
> ok 23 - Line break should pass Str
> ok 24 - Random string should pass Str
> ok 25 - Loaded package name should pass Str
> ok 26 - Unloaded package name should pass Str
> ok 27 - A reference to undef should fail Str
> ok 28 - A reference to false should fail Str
> ok 29 - A reference to true should fail Str
> ok 30 - A reference to zero should fail Str
> ok 31 - A reference to one should fail Str
> ok 32 - A reference to empty string should fail Str
> ok 33 - A reference to random string should fail Str
> ok 34 - Blessed scalarref should fail Str
> ok 35 - Empty arrayref should fail Str
> ok 36 - Arrayref with one zero should fail Str
> ok 37 - Arrayref of integers should fail Str
> ok 38 - Arrayref of numbers should fail Str
> ok 39 - Blessed arrayref should fail Str
> ok 40 - Empty hashref should fail Str
> ok 41 - Hashref should fail Str
> ok 42 - Blessed hashref should fail Str
> ok 43 - Coderef should fail Str
> ok 44 - Blessed coderef should fail Str
> ok 45 - Glob should fail Str
> ok 46 - Globref should fail Str
> ok 47 - Blessed globref should fail Str
> ok 48 - Regexp should fail Str
> ok 49 - Blessed regexp should fail Str
> ok 50 - Filehandle should fail Str
> ok 51 - Filehandle object should fail Str
> ok 52 - Ref to scalarref should fail Str
> ok 53 - Ref to arrayref should fail Str
> ok 54 - Ref to hashref should fail Str
> ok 55 - Ref to coderef should fail Str
> ok 56 - Ref to blessed hashref should fail Str
> ok 57 - Object stringifying to "" should fail Str
> ok 58 - Object stringifying to "1" should fail Str
> ok 59 - Object numifying to 0 should fail Str
> ok 60 - Object numifying to 1 should fail Str
> ok 61 - Object overloading arrayref should fail Str
> ok 62 - Object overloading hashref should fail Str
> ok 63 - Object overloading coderef should fail Str
> ok 64 - Object booling to false should fail Str
> ok 65 - Object booling to true should fail Str
> ok 66 - String sorting
> 1..66
> ok
> t/21-types/StrictNum.t .......................................
> ok 1 - 'StrictNum' isa 'Type::Tiny'
> ok 2 - StrictNum has correct name
> ok 3 - StrictNum has correct display_name
> ok 4 - StrictNum knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type StrictNum
> ok 6 - StrictNum is not deprecated
> ok 7 - StrictNum is not anonymous
> ok 8 - StrictNum can be inlined
> ok 9 - Inlining StrictNum doesn't throw an exception
> ok 10 - StrictNum doesn't have a coercion
> ok 11 - StrictNum isn't parameterizable
> ok 12 - StrictNum has a type_default
> ok 13 - StrictNum type_default is zero
> ok 14 - Undef should fail StrictNum
> ok 15 - False should fail StrictNum
> ok 16 - True should pass StrictNum
> ok 17 - Zero should pass StrictNum
> ok 18 - One should pass StrictNum
> ok 19 - Negative one should pass StrictNum
> ok 20 - Non integer should pass StrictNum
> ok 21 - Empty string should fail StrictNum
> ok 22 - Whitespace should fail StrictNum
> ok 23 - Line break should fail StrictNum
> ok 24 - Random string should fail StrictNum
> ok 25 - Loaded package name should fail StrictNum
> ok 26 - Unloaded package name should fail StrictNum
> ok 27 - A reference to undef should fail StrictNum
> ok 28 - A reference to false should fail StrictNum
> ok 29 - A reference to true should fail StrictNum
> ok 30 - A reference to zero should fail StrictNum
> ok 31 - A reference to one should fail StrictNum
> ok 32 - A reference to empty string should fail StrictNum
> ok 33 - A reference to random string should fail StrictNum
> ok 34 - Blessed scalarref should fail StrictNum
> ok 35 - Empty arrayref should fail StrictNum
> ok 36 - Arrayref with one zero should fail StrictNum
> ok 37 - Arrayref of integers should fail StrictNum
> ok 38 - Arrayref of numbers should fail StrictNum
> ok 39 - Blessed arrayref should fail StrictNum
> ok 40 - Empty hashref should fail StrictNum
> ok 41 - Hashref should fail StrictNum
> ok 42 - Blessed hashref should fail StrictNum
> ok 43 - Coderef should fail StrictNum
> ok 44 - Blessed coderef should fail StrictNum
> ok 45 - Glob should fail StrictNum
> ok 46 - Globref should fail StrictNum
> ok 47 - Blessed globref should fail StrictNum
> ok 48 - Regexp should fail StrictNum
> ok 49 - Blessed regexp should fail StrictNum
> ok 50 - Filehandle should fail StrictNum
> ok 51 - Filehandle object should fail StrictNum
> ok 52 - Ref to scalarref should fail StrictNum
> ok 53 - Ref to arrayref should fail StrictNum
> ok 54 - Ref to hashref should fail StrictNum
> ok 55 - Ref to coderef should fail StrictNum
> ok 56 - Ref to blessed hashref should fail StrictNum
> ok 57 - Object stringifying to "" should fail StrictNum
> ok 58 - Object stringifying to "1" should fail StrictNum
> ok 59 - Object numifying to 0 should fail StrictNum
> ok 60 - Object numifying to 1 should fail StrictNum
> ok 61 - Object overloading arrayref should fail StrictNum
> ok 62 - Object overloading hashref should fail StrictNum
> ok 63 - Object overloading coderef should fail StrictNum
> ok 64 - Object booling to false should fail StrictNum
> ok 65 - Object booling to true should fail StrictNum
> ok 66 - Numeric sorting
> 1..66
> ok
> t/21-types/StringLike.t ......................................
> ok 1 - 'StringLike' isa 'Type::Tiny'
> ok 2 - StringLike has correct name
> ok 3 - StringLike has correct display_name
> ok 4 - StringLike knows it is in the Types::TypeTiny library
> ok 5 - Types::TypeTiny knows it has type StringLike
> ok 6 - StringLike is not deprecated
> ok 7 - StringLike is not anonymous
> ok 8 - StringLike can be inlined
> ok 9 - Inlining StringLike doesn't throw an exception
> ok 10 - StringLike doesn't have a coercion
> ok 11 - StringLike isn't parameterizable
> ok 12 - StringLike has a type_default
> ok 13 - StringLike type_default is the empty string
> ok 14 - Undef should fail StringLike
> ok 15 - False should pass StringLike
> ok 16 - True should pass StringLike
> ok 17 - Zero should pass StringLike
> ok 18 - One should pass StringLike
> ok 19 - Negative one should pass StringLike
> ok 20 - Non integer should pass StringLike
> ok 21 - Empty string should pass StringLike
> ok 22 - Whitespace should pass StringLike
> ok 23 - Line break should pass StringLike
> ok 24 - Random string should pass StringLike
> ok 25 - Loaded package name should pass StringLike
> ok 26 - Unloaded package name should pass StringLike
> ok 27 - A reference to undef should fail StringLike
> ok 28 - A reference to false should fail StringLike
> ok 29 - A reference to true should fail StringLike
> ok 30 - A reference to zero should fail StringLike
> ok 31 - A reference to one should fail StringLike
> ok 32 - A reference to empty string should fail StringLike
> ok 33 - A reference to random string should fail StringLike
> ok 34 - Blessed scalarref should fail StringLike
> ok 35 - Empty arrayref should fail StringLike
> ok 36 - Arrayref with one zero should fail StringLike
> ok 37 - Arrayref of integers should fail StringLike
> ok 38 - Arrayref of numbers should fail StringLike
> ok 39 - Blessed arrayref should fail StringLike
> ok 40 - Empty hashref should fail StringLike
> ok 41 - Hashref should fail StringLike
> ok 42 - Blessed hashref should fail StringLike
> ok 43 - Coderef should fail StringLike
> ok 44 - Blessed coderef should fail StringLike
> # UNDEFINED OUTCOME: glob
> ok 45 - Globref should fail StringLike
> ok 46 - Blessed globref should fail StringLike
> ok 47 - Regexp should fail StringLike
> ok 48 - Blessed regexp should fail StringLike
> ok 49 - Filehandle should fail StringLike
> ok 50 - Filehandle object should fail StringLike
> ok 51 - Ref to scalarref should fail StringLike
> ok 52 - Ref to arrayref should fail StringLike
> ok 53 - Ref to hashref should fail StringLike
> ok 54 - Ref to coderef should fail StringLike
> ok 55 - Ref to blessed hashref should fail StringLike
> ok 56 - Object stringifying to "" should pass StringLike
> ok 57 - Object stringifying to "1" should pass StringLike
> ok 58 - Object numifying to 0 should fail StringLike
> ok 59 - Object numifying to 1 should fail StringLike
> ok 60 - Object overloading arrayref should fail StringLike
> ok 61 - Object overloading hashref should fail StringLike
> ok 62 - Object overloading coderef should fail StringLike
> ok 63 - Object booling to false should fail StringLike
> ok 64 - Object booling to true should fail StringLike
> 1..64
> ok
> t/21-types/StrLength.t .......................................
> ok 1 - 'StrLength' isa 'Type::Tiny'
> ok 2 - StrLength has correct name
> ok 3 - StrLength has correct display_name
> ok 4 - StrLength knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type StrLength
> ok 6 - StrLength is not deprecated
> ok 7 - StrLength is not anonymous
> ok 8 - StrLength can be inlined
> ok 9 - Inlining StrLength doesn't throw an exception
> ok 10 - StrLength doesn't have a coercion
> ok 11 - StrLength is parameterizable
> ok 12 - StrLength has a type_default
> ok 13 - StrLength type_default is the empty string
> ok 14 - Undef should fail StrLength
> ok 15 - False should pass StrLength
> ok 16 - True should pass StrLength
> ok 17 - Zero should pass StrLength
> ok 18 - One should pass StrLength
> ok 19 - Negative one should pass StrLength
> ok 20 - Non integer should pass StrLength
> ok 21 - Empty string should pass StrLength
> ok 22 - Whitespace should pass StrLength
> ok 23 - Line break should pass StrLength
> ok 24 - Random string should pass StrLength
> ok 25 - Loaded package name should pass StrLength
> ok 26 - Unloaded package name should pass StrLength
> ok 27 - A reference to undef should fail StrLength
> ok 28 - A reference to false should fail StrLength
> ok 29 - A reference to true should fail StrLength
> ok 30 - A reference to zero should fail StrLength
> ok 31 - A reference to one should fail StrLength
> ok 32 - A reference to empty string should fail StrLength
> ok 33 - A reference to random string should fail StrLength
> ok 34 - Blessed scalarref should fail StrLength
> ok 35 - Empty arrayref should fail StrLength
> ok 36 - Arrayref with one zero should fail StrLength
> ok 37 - Arrayref of integers should fail StrLength
> ok 38 - Arrayref of numbers should fail StrLength
> ok 39 - Blessed arrayref should fail StrLength
> ok 40 - Empty hashref should fail StrLength
> ok 41 - Hashref should fail StrLength
> ok 42 - Blessed hashref should fail StrLength
> ok 43 - Coderef should fail StrLength
> ok 44 - Blessed coderef should fail StrLength
> ok 45 - Glob should fail StrLength
> ok 46 - Globref should fail StrLength
> ok 47 - Blessed globref should fail StrLength
> ok 48 - Regexp should fail StrLength
> ok 49 - Blessed regexp should fail StrLength
> ok 50 - Filehandle should fail StrLength
> ok 51 - Filehandle object should fail StrLength
> ok 52 - Ref to scalarref should fail StrLength
> ok 53 - Ref to arrayref should fail StrLength
> ok 54 - Ref to hashref should fail StrLength
> ok 55 - Ref to coderef should fail StrLength
> ok 56 - Ref to blessed hashref should fail StrLength
> ok 57 - Object stringifying to "" should fail StrLength
> ok 58 - Object stringifying to "1" should fail StrLength
> ok 59 - Object numifying to 0 should fail StrLength
> ok 60 - Object numifying to 1 should fail StrLength
> ok 61 - Object overloading arrayref should fail StrLength
> ok 62 - Object overloading hashref should fail StrLength
> ok 63 - Object overloading coderef should fail StrLength
> ok 64 - Object booling to false should fail StrLength
> ok 65 - Object booling to true should fail StrLength
> ok 66 - Value "" fails type constraint StrLength[2]
> ok 67 - Value "1" fails type constraint StrLength[2]
> ok 68 - Value "12" passes type constraint StrLength[2]
> ok 69 - Value "123" passes type constraint StrLength[2]
> ok 70 - Value "1234" passes type constraint StrLength[2]
> ok 71 - Value "12345" passes type constraint StrLength[2]
> ok 72 - Value "123456" passes type constraint StrLength[2]
> ok 73 - Value "1234567" passes type constraint StrLength[2]
> ok 74 - Value "12345678" passes type constraint StrLength[2]
> ok 75 - Value "123456789" passes type constraint StrLength[2]
> ok 76 - StrLength[2] has no type_default
> ok 77 - Value "\x{436}" fails type constraint StrLength[2]
> ok 78 - Value "\x{436}\x{436}" passes type constraint StrLength[2]
> ok 79 - Value "\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}" passes type constraint StrLength[2]
> ok 80 - Value "" fails type constraint StrLength[2,5]
> ok 81 - Value "1" fails type constraint StrLength[2,5]
> ok 82 - Value "12" passes type constraint StrLength[2,5]
> ok 83 - Value "123" passes type constraint StrLength[2,5]
> ok 84 - Value "1234" passes type constraint StrLength[2,5]
> ok 85 - Value "12345" passes type constraint StrLength[2,5]
> ok 86 - Value "123456" fails type constraint StrLength[2,5]
> ok 87 - Value "1234567" fails type constraint StrLength[2,5]
> ok 88 - Value "12345678" fails type constraint StrLength[2,5]
> ok 89 - Value "123456789" fails type constraint StrLength[2,5]
> ok 90 - Value "\x{436}" fails type constraint StrLength[2,5]
> ok 91 - Value "\x{436}\x{436}" passes type constraint StrLength[2,5]
> ok 92 - Value "\x{436}\x{436}\x{436}\x{436}\x{436}\x{436}" fails type constraint StrLength[2,5]
> ok 93
> ok 94 - Reference bless( do{\(my $o = "abc")}, 'Local::OL::Stringy' ) fails type constraint StrLength[2,5]
> ok 95 - Reference bless( do{\(my $o = "abc")}, 'Local::OL::Stringy' ) passes type constraint __ANON__
> ok 96 - Value "abc" fails type constraint __ANON__
> ok 97 - Reference bless( do{\(my $o = "abc")}, 'Local::OL::Stringy' ) passes type constraint StrLength[2,5]|__ANON__
> ok 98 - Value "abc" passes type constraint StrLength[2,5]|__ANON__
> 1..98
> ok
> t/21-types/StrMatch-more.t ...................................
> ok 1 - Value "foo" passes type constraint StrMatch[(?^:f(?{ ++$xxx })oo)]
> ok 2 - Value "bar" fails type constraint StrMatch[(?^:f(?{ ++$xxx })oo)]
> ok 3 - Embedded code executed
> # $xxx is 1
> ok 4 - It can still be inlined!
> # do { package Type::Tiny; !ref($STRING) and !!( $STRING =~ $Types::Standard::StrMatch::expressions{"Regexp|(?^:f(?{ ++\$xxx })oo)"} ) }
> ok 5 - The inlining needed to use a callback!
> ok 6 - Value "foo" passes type constraint StrMatch[(?^:f(?{ ++$xxx })oo)]
> ok 7 - Value "bar" fails type constraint StrMatch[(?^:f(?{ ++$xxx })oo)]
> ok 8 - The inlining needed to use a callback!
> ok 9 - no (unexpected) warnings (via done_testing)
> 1..9
> ok
> t/21-types/StrMatch.t ........................................
> ok 1 - 'StrMatch' isa 'Type::Tiny'
> ok 2 - StrMatch has correct name
> ok 3 - StrMatch has correct display_name
> ok 4 - StrMatch knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type StrMatch
> ok 6 - StrMatch is not deprecated
> ok 7 - StrMatch is not anonymous
> ok 8 - StrMatch can be inlined
> ok 9 - Inlining StrMatch doesn't throw an exception
> ok 10 - StrMatch doesn't have a coercion
> ok 11 - StrMatch is parameterizable
> ok 12 - StrMatch has a type_default
> ok 13 - StrMatch type_default is the empty string
> ok 14 - Undef should fail StrMatch
> ok 15 - False should pass StrMatch
> ok 16 - True should pass StrMatch
> ok 17 - Zero should pass StrMatch
> ok 18 - One should pass StrMatch
> ok 19 - Negative one should pass StrMatch
> ok 20 - Non integer should pass StrMatch
> ok 21 - Empty string should pass StrMatch
> ok 22 - Whitespace should pass StrMatch
> ok 23 - Line break should pass StrMatch
> ok 24 - Random string should pass StrMatch
> ok 25 - Loaded package name should pass StrMatch
> ok 26 - Unloaded package name should pass StrMatch
> ok 27 - A reference to undef should fail StrMatch
> ok 28 - A reference to false should fail StrMatch
> ok 29 - A reference to true should fail StrMatch
> ok 30 - A reference to zero should fail StrMatch
> ok 31 - A reference to one should fail StrMatch
> ok 32 - A reference to empty string should fail StrMatch
> ok 33 - A reference to random string should fail StrMatch
> ok 34 - Blessed scalarref should fail StrMatch
> ok 35 - Empty arrayref should fail StrMatch
> ok 36 - Arrayref with one zero should fail StrMatch
> ok 37 - Arrayref of integers should fail StrMatch
> ok 38 - Arrayref of numbers should fail StrMatch
> ok 39 - Blessed arrayref should fail StrMatch
> ok 40 - Empty hashref should fail StrMatch
> ok 41 - Hashref should fail StrMatch
> ok 42 - Blessed hashref should fail StrMatch
> ok 43 - Coderef should fail StrMatch
> ok 44 - Blessed coderef should fail StrMatch
> ok 45 - Glob should fail StrMatch
> ok 46 - Globref should fail StrMatch
> ok 47 - Blessed globref should fail StrMatch
> ok 48 - Regexp should fail StrMatch
> ok 49 - Blessed regexp should fail StrMatch
> ok 50 - Filehandle should fail StrMatch
> ok 51 - Filehandle object should fail StrMatch
> ok 52 - Ref to scalarref should fail StrMatch
> ok 53 - Ref to arrayref should fail StrMatch
> ok 54 - Ref to hashref should fail StrMatch
> ok 55 - Ref to coderef should fail StrMatch
> ok 56 - Ref to blessed hashref should fail StrMatch
> ok 57 - Object stringifying to "" should fail StrMatch
> ok 58 - Object stringifying to "1" should fail StrMatch
> ok 59 - Object numifying to 0 should fail StrMatch
> ok 60 - Object numifying to 1 should fail StrMatch
> ok 61 - Object overloading arrayref should fail StrMatch
> ok 62 - Object overloading hashref should fail StrMatch
> ok 63 - Object overloading coderef should fail StrMatch
> ok 64 - Object booling to false should fail StrMatch
> ok 65 - Object booling to true should fail StrMatch
> ok 66 - Value "abc" passes type constraint StrMatch[(?^i:a[b]c)]
> ok 67 - Value "ABC" passes type constraint StrMatch[(?^i:a[b]c)]
> ok 68 - Value "fooabcbar" passes type constraint StrMatch[(?^i:a[b]c)]
> ok 69 - Value "fooABCbar" passes type constraint StrMatch[(?^i:a[b]c)]
> ok 70 - Value "a[b]c" fails type constraint StrMatch[(?^i:a[b]c)]
> ok 71 - StrMatch[(?^i:a[b]c)] has no type_default
> ok 72
> ok 73 - Reference bless( do{\(my $o = "abc")}, 'Local::OL::Stringy' ) fails type constraint StrMatch[(?^i:a[b]c)]
> ok 74 - Reference bless( do{\(my $o = "abc")}, 'Local::OL::Stringy' ) passes type constraint __ANON__
> ok 75 - Value "abc" fails type constraint __ANON__
> ok 76 - Reference bless( do{\(my $o = "abc")}, 'Local::OL::Stringy' ) passes type constraint StrMatch[(?^i:a[b]c)]|__ANON__
> ok 77 - Value "abc" passes type constraint StrMatch[(?^i:a[b]c)]|__ANON__
> ok 78 - Value "1 km" passes type constraint StrMatch[(?^:^(\S+) (\S+)$),Tuple[Num,Enum["mm","cm","m","km"]]]
> ok 79 - Value "-1.6 cm" passes type constraint StrMatch[(?^:^(\S+) (\S+)$),Tuple[Num,Enum["mm","cm","m","km"]]]
> ok 80 - Value "xyz km" fails type constraint StrMatch[(?^:^(\S+) (\S+)$),Tuple[Num,Enum["mm","cm","m","km"]]]
> ok 81 - Value "7 miles" fails type constraint StrMatch[(?^:^(\S+) (\S+)$),Tuple[Num,Enum["mm","cm","m","km"]]]
> ok 82 - Value "7 km " fails type constraint StrMatch[(?^:^(\S+) (\S+)$),Tuple[Num,Enum["mm","cm","m","km"]]]
> ok 83 - Value "1 km" passes type constraint StrMatch[(?^:^(\S+) (\S+)$),__ANON__]
> ok 84 - Value "-1.6 cm" passes type constraint StrMatch[(?^:^(\S+) (\S+)$),__ANON__]
> ok 85 - Value "xyz km" fails type constraint StrMatch[(?^:^(\S+) (\S+)$),__ANON__]
> ok 86 - Value "7 miles" fails type constraint StrMatch[(?^:^(\S+) (\S+)$),__ANON__]
> ok 87 - Value "7 km " fails type constraint StrMatch[(?^:^(\S+) (\S+)$),__ANON__]
> 1..87
> ok
> t/21-types/StrongPassword.t ..................................
> ok 1 - 'StrongPassword' isa 'Type::Tiny'
> ok 2 - StrongPassword has correct name
> ok 3 - StrongPassword has correct display_name
> ok 4 - StrongPassword knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type StrongPassword
> ok 6 - StrongPassword is not deprecated
> ok 7 - StrongPassword is not anonymous
> ok 8 - StrongPassword can be inlined
> ok 9 - Inlining StrongPassword doesn't throw an exception
> ok 10 - StrongPassword doesn't have a coercion
> ok 11 - StrongPassword isn't parameterizable
> ok 12 - StrongPassword has no type_default
> ok 13 - Undef should fail StrongPassword
> ok 14 - False should fail StrongPassword
> ok 15 - True should fail StrongPassword
> ok 16 - Zero should fail StrongPassword
> ok 17 - One should fail StrongPassword
> ok 18 - Negative one should fail StrongPassword
> ok 19 - Non integer should fail StrongPassword
> ok 20 - Empty string should fail StrongPassword
> ok 21 - Whitespace should fail StrongPassword
> ok 22 - Line break should fail StrongPassword
> ok 23 - Random string should fail StrongPassword
> ok 24 - Loaded package name should pass StrongPassword
> ok 25 - Unloaded package name should pass StrongPassword
> ok 26 - A reference to undef should fail StrongPassword
> ok 27 - A reference to false should fail StrongPassword
> ok 28 - A reference to true should fail StrongPassword
> ok 29 - A reference to zero should fail StrongPassword
> ok 30 - A reference to one should fail StrongPassword
> ok 31 - A reference to empty string should fail StrongPassword
> ok 32 - A reference to random string should fail StrongPassword
> ok 33 - Blessed scalarref should fail StrongPassword
> ok 34 - Empty arrayref should fail StrongPassword
> ok 35 - Arrayref with one zero should fail StrongPassword
> ok 36 - Arrayref of integers should fail StrongPassword
> ok 37 - Arrayref of numbers should fail StrongPassword
> ok 38 - Blessed arrayref should fail StrongPassword
> ok 39 - Empty hashref should fail StrongPassword
> ok 40 - Hashref should fail StrongPassword
> ok 41 - Blessed hashref should fail StrongPassword
> ok 42 - Coderef should fail StrongPassword
> ok 43 - Blessed coderef should fail StrongPassword
> ok 44 - Glob should fail StrongPassword
> ok 45 - Globref should fail StrongPassword
> ok 46 - Blessed globref should fail StrongPassword
> ok 47 - Regexp should fail StrongPassword
> ok 48 - Blessed regexp should fail StrongPassword
> ok 49 - Filehandle should fail StrongPassword
> ok 50 - Filehandle object should fail StrongPassword
> ok 51 - Ref to scalarref should fail StrongPassword
> ok 52 - Ref to arrayref should fail StrongPassword
> ok 53 - Ref to hashref should fail StrongPassword
> ok 54 - Ref to coderef should fail StrongPassword
> ok 55 - Ref to blessed hashref should fail StrongPassword
> ok 56 - Object stringifying to "" should fail StrongPassword
> ok 57 - Object stringifying to "1" should fail StrongPassword
> ok 58 - Object numifying to 0 should fail StrongPassword
> ok 59 - Object numifying to 1 should fail StrongPassword
> ok 60 - Object overloading arrayref should fail StrongPassword
> ok 61 - Object overloading hashref should fail StrongPassword
> ok 62 - Object overloading coderef should fail StrongPassword
> ok 63 - Object booling to false should fail StrongPassword
> ok 64 - Object booling to true should fail StrongPassword
> 1..64
> ok
> t/21-types/Tied.t ............................................
> ok 1 - 'Tied' isa 'Type::Tiny'
> ok 2 - Tied has correct name
> ok 3 - Tied has correct display_name
> ok 4 - Tied knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Tied
> ok 6 - Tied is not deprecated
> ok 7 - Tied is not anonymous
> ok 8 - Tied can be inlined
> ok 9 - Inlining Tied doesn't throw an exception
> ok 10 - Tied doesn't have a coercion
> ok 11 - Tied is parameterizable
> ok 12 - Tied has no type_default
> ok 13 - Undef should fail Tied
> ok 14 - False should fail Tied
> ok 15 - True should fail Tied
> ok 16 - Zero should fail Tied
> ok 17 - One should fail Tied
> ok 18 - Negative one should fail Tied
> ok 19 - Non integer should fail Tied
> ok 20 - Empty string should fail Tied
> ok 21 - Whitespace should fail Tied
> ok 22 - Line break should fail Tied
> ok 23 - Random string should fail Tied
> ok 24 - Loaded package name should fail Tied
> ok 25 - Unloaded package name should fail Tied
> ok 26 - A reference to undef should fail Tied
> ok 27 - A reference to false should fail Tied
> ok 28 - A reference to true should fail Tied
> ok 29 - A reference to zero should fail Tied
> ok 30 - A reference to one should fail Tied
> ok 31 - A reference to empty string should fail Tied
> ok 32 - A reference to random string should fail Tied
> ok 33 - Blessed scalarref should fail Tied
> ok 34 - Empty arrayref should fail Tied
> ok 35 - Arrayref with one zero should fail Tied
> ok 36 - Arrayref of integers should fail Tied
> ok 37 - Arrayref of numbers should fail Tied
> ok 38 - Blessed arrayref should fail Tied
> ok 39 - Empty hashref should fail Tied
> ok 40 - Hashref should fail Tied
> ok 41 - Blessed hashref should fail Tied
> ok 42 - Coderef should fail Tied
> ok 43 - Blessed coderef should fail Tied
> ok 44 - Glob should fail Tied
> ok 45 - Globref should fail Tied
> ok 46 - Blessed globref should fail Tied
> ok 47 - Regexp should fail Tied
> ok 48 - Blessed regexp should fail Tied
> ok 49 - Filehandle should fail Tied
> ok 50 - Filehandle object should fail Tied
> ok 51 - Ref to scalarref should fail Tied
> ok 52 - Ref to arrayref should fail Tied
> ok 53 - Ref to hashref should fail Tied
> ok 54 - Ref to coderef should fail Tied
> ok 55 - Ref to blessed hashref should fail Tied
> ok 56 - Object stringifying to "" should fail Tied
> ok 57 - Object stringifying to "1" should fail Tied
> ok 58 - Object numifying to 0 should fail Tied
> ok 59 - Object numifying to 1 should fail Tied
> ok 60 - Object overloading arrayref should fail Tied
> ok 61 - Object overloading hashref should fail Tied
> ok 62 - Object overloading coderef should fail Tied
> ok 63 - Object booling to false should fail Tied
> ok 64 - Object booling to true should fail Tied
> ok 65 - Reference \undef passes type constraint Tied
> ok 66 - Reference \undef passes type constraint Tied["Tie::StdScalar"]
> ok 67 - Reference \undef passes type constraint Tied["Tie::Scalar"]
> ok 68 - Reference \undef fails type constraint Tied["IO::File"]
> ok 69 - Reference bless( do{\(my $o = undef)}, 'Bleh' ) passes type constraint Tied["Tie::Scalar"]
> ok 70 - Reference bless( do{\(my $o = undef)}, 'Bleh' ) fails type constraint Tied["Bleh"]
> ok 71 - $var is tied
> ok 72 - Undef fails type constraint Tied
> ok 73 - Reference [] passes type constraint Tied
> ok 74 - Reference [] passes type constraint Tied["Tie::StdArray"]
> ok 75 - Reference [] passes type constraint Tied["Tie::Array"]
> ok 76 - Reference [] fails type constraint Tied["IO::File"]
> ok 77 - Reference bless( [], 'Bleh' ) passes type constraint Tied["Tie::Array"]
> ok 78 - Reference bless( [], 'Bleh' ) fails type constraint Tied["Bleh"]
> ok 79 - Reference {} passes type constraint Tied
> ok 80 - Reference {} passes type constraint Tied["Tie::StdHash"]
> ok 81 - Reference {} passes type constraint Tied["Tie::Hash"]
> ok 82 - Reference {} fails type constraint Tied["IO::File"]
> ok 83 - Reference bless( {}, 'Bleh' ) passes type constraint Tied["Tie::Hash"]
> ok 84 - Reference bless( {}, 'Bleh' ) fails type constraint Tied["Bleh"]
> 1..84
> ok
> t/21-types/Tuple.t ...........................................
> ok 1 - 'Tuple' isa 'Type::Tiny'
> ok 2 - Tuple has correct name
> ok 3 - Tuple has correct display_name
> ok 4 - Tuple knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Tuple
> ok 6 - Tuple is not deprecated
> ok 7 - Tuple is not anonymous
> ok 8 - Tuple can be inlined
> ok 9 - Inlining Tuple doesn't throw an exception
> ok 10 - Tuple doesn't have a coercion
> ok 11 - Tuple is parameterizable
> ok 12 - Tuple has a type_default
> ok 13 - Tuple type_default is []
> ok 14 - Undef should fail Tuple
> ok 15 - False should fail Tuple
> ok 16 - True should fail Tuple
> ok 17 - Zero should fail Tuple
> ok 18 - One should fail Tuple
> ok 19 - Negative one should fail Tuple
> ok 20 - Non integer should fail Tuple
> ok 21 - Empty string should fail Tuple
> ok 22 - Whitespace should fail Tuple
> ok 23 - Line break should fail Tuple
> ok 24 - Random string should fail Tuple
> ok 25 - Loaded package name should fail Tuple
> ok 26 - Unloaded package name should fail Tuple
> ok 27 - A reference to undef should fail Tuple
> ok 28 - A reference to false should fail Tuple
> ok 29 - A reference to true should fail Tuple
> ok 30 - A reference to zero should fail Tuple
> ok 31 - A reference to one should fail Tuple
> ok 32 - A reference to empty string should fail Tuple
> ok 33 - A reference to random string should fail Tuple
> ok 34 - Blessed scalarref should fail Tuple
> ok 35 - Empty arrayref should pass Tuple
> ok 36 - Arrayref with one zero should pass Tuple
> ok 37 - Arrayref of integers should pass Tuple
> ok 38 - Arrayref of numbers should pass Tuple
> ok 39 - Blessed arrayref should fail Tuple
> ok 40 - Empty hashref should fail Tuple
> ok 41 - Hashref should fail Tuple
> ok 42 - Blessed hashref should fail Tuple
> ok 43 - Coderef should fail Tuple
> ok 44 - Blessed coderef should fail Tuple
> ok 45 - Glob should fail Tuple
> ok 46 - Globref should fail Tuple
> ok 47 - Blessed globref should fail Tuple
> ok 48 - Regexp should fail Tuple
> ok 49 - Blessed regexp should fail Tuple
> ok 50 - Filehandle should fail Tuple
> ok 51 - Filehandle object should fail Tuple
> ok 52 - Ref to scalarref should fail Tuple
> ok 53 - Ref to arrayref should fail Tuple
> ok 54 - Ref to hashref should fail Tuple
> ok 55 - Ref to coderef should fail Tuple
> ok 56 - Ref to blessed hashref should fail Tuple
> ok 57 - Object stringifying to "" should fail Tuple
> ok 58 - Object stringifying to "1" should fail Tuple
> ok 59 - Object numifying to 0 should fail Tuple
> ok 60 - Object numifying to 1 should fail Tuple
> ok 61 - Object overloading arrayref should fail Tuple
> ok 62 - Object overloading hashref should fail Tuple
> ok 63 - Object overloading coderef should fail Tuple
> ok 64 - Object booling to false should fail Tuple
> ok 65 - Object booling to true should fail Tuple
> ok 66 - Reference [42,[1,2,3,4],undef] passes type constraint Tuple[Int,ArrayRef,Undef]
> ok 67 - Reference [{},[1,2,3,4],undef] fails type constraint Tuple[Int,ArrayRef,Undef]
> ok 68 - Reference [42,{},undef] fails type constraint Tuple[Int,ArrayRef,Undef]
> ok 69 - Reference [42,[1,2,3,4],{}] fails type constraint Tuple[Int,ArrayRef,Undef]
> ok 70 - Reference [42,[1,2,3,4],undef,1] fails type constraint Tuple[Int,ArrayRef,Undef]
> ok 71 - Reference [42,[1,2,3,4]] fails type constraint Tuple[Int,ArrayRef,Undef]
> ok 72 - Reference [] fails type constraint Tuple[Int,ArrayRef,Undef]
> ok 73 - Value "42" fails type constraint Tuple[Int,ArrayRef,Undef]
> ok 74 - Reference bless( [42,[1,2,3,4,5,6,7,8,9,10],undef], 'Foo' ) fails type constraint Tuple[Int,ArrayRef,Undef]
> ok 75 - Tuple[Int,ArrayRef,Undef] has no type_default
> ok 76 - Reference [42,[],{},\0] passes type constraint Tuple[Int,ArrayRef,Optional[HashRef],Optional[ScalarRef]]
> ok 77 - Reference [42,[],{}] passes type constraint Tuple[Int,ArrayRef,Optional[HashRef],Optional[ScalarRef]]
> ok 78 - Reference [42,[]] passes type constraint Tuple[Int,ArrayRef,Optional[HashRef],Optional[ScalarRef]]
> ok 79 - Reference [42] fails type constraint Tuple[Int,ArrayRef,Optional[HashRef],Optional[ScalarRef]]
> ok 80 - Reference [] fails type constraint Tuple[Int,ArrayRef,Optional[HashRef],Optional[ScalarRef]]
> ok 81 - Reference [42,[],undef,\0] fails type constraint Tuple[Int,ArrayRef,Optional[HashRef],Optional[ScalarRef]]
> ok 82 - Reference [42,[],{}] fails type constraint Tuple[Int,ArrayRef,Maybe[HashRef],Maybe[ScalarRef]]
> ok 83 - Reference [42,[],{},undef] passes type constraint Tuple[Int,ArrayRef,Maybe[HashRef],Maybe[ScalarRef]]
> ok 84 - Reference [qr//] passes type constraint Tuple[RegexpRef,Slurpy[ArrayRef[Int]]]
> ok 85 - Reference [qr//,1,2,3,4] passes type constraint Tuple[RegexpRef,Slurpy[ArrayRef[Int]]]
> ok 86 - Reference [qr//,1,2,3,4,qr//] fails type constraint Tuple[RegexpRef,Slurpy[ArrayRef[Int]]]
> ok 87 - Reference [qr//,[1,2,3,4]] fails type constraint Tuple[RegexpRef,Slurpy[ArrayRef[Int]]]
> ok 88 - Reference [qr//] passes type constraint Tuple[RegexpRef,Optional[HashRef],Slurpy[ArrayRef[Int]]]
> ok 89 - Reference [qr//,{}] passes type constraint Tuple[RegexpRef,Optional[HashRef],Slurpy[ArrayRef[Int]]]
> ok 90 - Reference [qr//,{},1,2,3,4] passes type constraint Tuple[RegexpRef,Optional[HashRef],Slurpy[ArrayRef[Int]]]
> ok 91 - Reference [qr//,1,2,3,4] fails type constraint Tuple[RegexpRef,Optional[HashRef],Slurpy[ArrayRef[Int]]]
> ok 92 - Reference [qr//] passes type constraint Tuple[RegexpRef,Slurpy[Tuple[Int,Int]]]
> ok 93 - Reference [qr//,1] fails type constraint Tuple[RegexpRef,Slurpy[Tuple[Int,Int]]]
> ok 94 - Reference [qr//,1,2] passes type constraint Tuple[RegexpRef,Slurpy[Tuple[Int,Int]]]
> ok 95 - Reference [qr//,1,2,3] fails type constraint Tuple[RegexpRef,Slurpy[Tuple[Int,Int]]]
> ok 96 - Reference [qr//,1,2,3,4] fails type constraint Tuple[RegexpRef,Slurpy[Tuple[Int,Int]]]
> ok 97 - Reference [qr//,1,2,3,4,5] fails type constraint Tuple[RegexpRef,Slurpy[Tuple[Int,Int]]]
> ok 98 - Reference [qr//] passes type constraint Tuple[RegexpRef,Optional[RegexpRef],Slurpy[Tuple[Int,Int]]]
> ok 99 - Reference [qr//,qr//] passes type constraint Tuple[RegexpRef,Optional[RegexpRef],Slurpy[Tuple[Int,Int]]]
> ok 100 - Reference [qr//,qr//,1] fails type constraint Tuple[RegexpRef,Optional[RegexpRef],Slurpy[Tuple[Int,Int]]]
> ok 101 - Reference [qr//,qr//,1,2] passes type constraint Tuple[RegexpRef,Optional[RegexpRef],Slurpy[Tuple[Int,Int]]]
> ok 102 - Reference [qr//,1,2] fails type constraint Tuple[RegexpRef,Optional[RegexpRef],Slurpy[Tuple[Int,Int]]]
> ok 103 - Reference [qr//,qr//,1,2,3] fails type constraint Tuple[RegexpRef,Optional[RegexpRef],Slurpy[Tuple[Int,Int]]]
> ok 104 - Reference [qr//,qr//,1,2,3,4] fails type constraint Tuple[RegexpRef,Optional[RegexpRef],Slurpy[Tuple[Int,Int]]]
> ok 105 - Reference [qr//,qr//,1,2,3,4,5] fails type constraint Tuple[RegexpRef,Optional[RegexpRef],Slurpy[Tuple[Int,Int]]]
> ok 106 - Reference [qr//] passes type constraint Tuple[RegexpRef,Slurpy[HashRef[Int]]]
> ok 107 - Reference [qr//,"foo",1,"bar",2] passes type constraint Tuple[RegexpRef,Slurpy[HashRef[Int]]]
> ok 108 - Reference [qr//,"foo",1,"bar",2,qr//] fails type constraint Tuple[RegexpRef,Slurpy[HashRef[Int]]]
> ok 109 - Reference [qr//,{"bar" => 2,"foo" => 1}] fails type constraint Tuple[RegexpRef,Slurpy[HashRef[Int]]]
> ok 110 - Reference [qr//,"foo"] fails type constraint Tuple[RegexpRef,Slurpy[HashRef[Int]]]
> ok 111 - Reference [qr//] passes type constraint Tuple[RegexpRef,Optional[ScalarRef],Slurpy[HashRef[Int]]]
> ok 112 - Reference [qr//,\1] passes type constraint Tuple[RegexpRef,Optional[ScalarRef],Slurpy[HashRef[Int]]]
> ok 113 - Reference [qr//,\1,"foo",1,"bar",2] passes type constraint Tuple[RegexpRef,Optional[ScalarRef],Slurpy[HashRef[Int]]]
> ok 114 - Reference [qr//,"foo",1,"bar",2] fails type constraint Tuple[RegexpRef,Optional[ScalarRef],Slurpy[HashRef[Int]]]
> # Subtest: coercion happened as expected
> ok 1
> ok 2
> ok 3
> ok 4
> 1..4
> ok 115 - coercion happened as expected
> ok 116 - Reference [1,\1] passes type constraint Tuple[Int,ScalarRef,Slurpy[HashRef]]
> ok 117 - Reference [1,\1,"foo",3] passes type constraint Tuple[Int,ScalarRef,Slurpy[HashRef]]
> ok 118 - Reference [1,\1,"foo"] fails type constraint Tuple[Int,ScalarRef,Slurpy[HashRef]]
> # Subtest: coercion happened as expected
> ok 1
> ok 2
> ok 3
> ok 4
> 1..4
> ok 119 - coercion happened as expected
> 1..119
> ok
> t/21-types/TypeTiny.t ........................................
> ok 1 - 'TypeTiny' isa 'Type::Tiny'
> ok 2 - TypeTiny has correct name
> ok 3 - TypeTiny has correct display_name
> ok 4 - TypeTiny knows it is in the Types::TypeTiny library
> ok 5 - Types::TypeTiny knows it has type TypeTiny
> ok 6 - TypeTiny is not deprecated
> ok 7 - TypeTiny is not anonymous
> ok 8 - TypeTiny can be inlined
> ok 9 - Inlining TypeTiny doesn't throw an exception
> ok 10 - TypeTiny has a coercion
> ok 11 - TypeTiny isn't parameterizable
> ok 12 - TypeTiny has a type_default
> ok 13 - TypeTiny type_default is Any
> ok 14 - Undef should fail TypeTiny
> ok 15 - False should fail TypeTiny
> ok 16 - True should fail TypeTiny
> ok 17 - Zero should fail TypeTiny
> ok 18 - One should fail TypeTiny
> ok 19 - Negative one should fail TypeTiny
> ok 20 - Non integer should fail TypeTiny
> ok 21 - Empty string should fail TypeTiny
> ok 22 - Whitespace should fail TypeTiny
> ok 23 - Line break should fail TypeTiny
> ok 24 - Random string should fail TypeTiny
> ok 25 - Loaded package name should fail TypeTiny
> ok 26 - Unloaded package name should fail TypeTiny
> ok 27 - A reference to undef should fail TypeTiny
> ok 28 - A reference to false should fail TypeTiny
> ok 29 - A reference to true should fail TypeTiny
> ok 30 - A reference to zero should fail TypeTiny
> ok 31 - A reference to one should fail TypeTiny
> ok 32 - A reference to empty string should fail TypeTiny
> ok 33 - A reference to random string should fail TypeTiny
> ok 34 - Blessed scalarref should fail TypeTiny
> ok 35 - Empty arrayref should fail TypeTiny
> ok 36 - Arrayref with one zero should fail TypeTiny
> ok 37 - Arrayref of integers should fail TypeTiny
> ok 38 - Arrayref of numbers should fail TypeTiny
> ok 39 - Blessed arrayref should fail TypeTiny
> ok 40 - Empty hashref should fail TypeTiny
> ok 41 - Hashref should fail TypeTiny
> ok 42 - Blessed hashref should fail TypeTiny
> ok 43 - Coderef should fail TypeTiny
> ok 44 - Blessed coderef should fail TypeTiny
> ok 45 - Glob should fail TypeTiny
> ok 46 - Globref should fail TypeTiny
> ok 47 - Blessed globref should fail TypeTiny
> ok 48 - Regexp should fail TypeTiny
> ok 49 - Blessed regexp should fail TypeTiny
> ok 50 - Filehandle should fail TypeTiny
> ok 51 - Filehandle object should fail TypeTiny
> ok 52 - Ref to scalarref should fail TypeTiny
> ok 53 - Ref to arrayref should fail TypeTiny
> ok 54 - Ref to hashref should fail TypeTiny
> ok 55 - Ref to coderef should fail TypeTiny
> ok 56 - Ref to blessed hashref should fail TypeTiny
> ok 57 - Object stringifying to "" should fail TypeTiny
> ok 58 - Object stringifying to "1" should fail TypeTiny
> ok 59 - Object numifying to 0 should fail TypeTiny
> ok 60 - Object numifying to 1 should fail TypeTiny
> ok 61 - Object overloading arrayref should fail TypeTiny
> ok 62 - Object overloading hashref should fail TypeTiny
> ok 63 - Object overloading coderef should fail TypeTiny
> ok 64 - Object booling to false should fail TypeTiny
> ok 65 - Object booling to true should fail TypeTiny
> ok 66 - Reference bless( {"_build_coercion" => sub { "DUMMY" },"coercion" => b...) passes type constraint TypeTiny
> # Subtest: Can coerce from coderef to TypeTiny
> ok 1 - Reference bless( {"constraint" => sub { "DUMMY" },"definition_context"...) passes type constraint TypeTiny
> ok 2 - Reference [] passes type constraint __ANON__
> ok 3 - Reference {} fails type constraint __ANON__
> 1..3
> ok 67 - Can coerce from coderef to TypeTiny
> # Subtest: Can coerce from MooseX::Types to TypeTiny
> ok 1 - Reference bless( {"_is_core" => 1,"_overload_coderef" => sub { "DUMMY"...) passes type constraint TypeTiny
> ok 2 - Reference [] passes type constraint ArrayRef
> ok 3 - Reference {} fails type constraint ArrayRef
> ok 4
> ok 5
> 1..5
> ok 68 - Can coerce from MooseX::Types to TypeTiny
> # Subtest: Can coerce from MouseX::Types to TypeTiny
> ok 1 - Reference bless( {"constraint" => sub { "DUMMY" },"constraint_generato...) passes type constraint TypeTiny
> ok 2 - Reference [] passes type constraint ArrayRef
> ok 3 - Reference {} fails type constraint ArrayRef
> ok 4
> 1..4
> ok 69 - Can coerce from MouseX::Types to TypeTiny
> # Subtest: Can coerce from Specio to TypeTiny
> ok 1 - Reference bless( {"constraint" => sub { "DUMMY" },"definition_context"...) passes type constraint TypeTiny
> ok 2 - Reference [] passes type constraint ArrayRef
> ok 3 - Reference {} fails type constraint ArrayRef
> ok 4
> 1..4
> ok 70 - Can coerce from Specio to TypeTiny
> 1..70
> ok
> t/21-types/Undef.t ...........................................
> ok 1 - 'Undef' isa 'Type::Tiny'
> ok 2 - Undef has correct name
> ok 3 - Undef has correct display_name
> ok 4 - Undef knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Undef
> ok 6 - Undef is not deprecated
> ok 7 - Undef is not anonymous
> ok 8 - Undef can be inlined
> ok 9 - Inlining Undef doesn't throw an exception
> ok 10 - Undef doesn't have a coercion
> ok 11 - Undef isn't parameterizable
> ok 12 - Undef has a type_default
> ok 13 - Undef type_default is undef
> ok 14 - Undef should pass Undef
> ok 15 - False should fail Undef
> ok 16 - True should fail Undef
> ok 17 - Zero should fail Undef
> ok 18 - One should fail Undef
> ok 19 - Negative one should fail Undef
> ok 20 - Non integer should fail Undef
> ok 21 - Empty string should fail Undef
> ok 22 - Whitespace should fail Undef
> ok 23 - Line break should fail Undef
> ok 24 - Random string should fail Undef
> ok 25 - Loaded package name should fail Undef
> ok 26 - Unloaded package name should fail Undef
> ok 27 - A reference to undef should fail Undef
> ok 28 - A reference to false should fail Undef
> ok 29 - A reference to true should fail Undef
> ok 30 - A reference to zero should fail Undef
> ok 31 - A reference to one should fail Undef
> ok 32 - A reference to empty string should fail Undef
> ok 33 - A reference to random string should fail Undef
> ok 34 - Blessed scalarref should fail Undef
> ok 35 - Empty arrayref should fail Undef
> ok 36 - Arrayref with one zero should fail Undef
> ok 37 - Arrayref of integers should fail Undef
> ok 38 - Arrayref of numbers should fail Undef
> ok 39 - Blessed arrayref should fail Undef
> ok 40 - Empty hashref should fail Undef
> ok 41 - Hashref should fail Undef
> ok 42 - Blessed hashref should fail Undef
> ok 43 - Coderef should fail Undef
> ok 44 - Blessed coderef should fail Undef
> ok 45 - Glob should fail Undef
> ok 46 - Globref should fail Undef
> ok 47 - Blessed globref should fail Undef
> ok 48 - Regexp should fail Undef
> ok 49 - Blessed regexp should fail Undef
> ok 50 - Filehandle should fail Undef
> ok 51 - Filehandle object should fail Undef
> ok 52 - Ref to scalarref should fail Undef
> ok 53 - Ref to arrayref should fail Undef
> ok 54 - Ref to hashref should fail Undef
> ok 55 - Ref to coderef should fail Undef
> ok 56 - Ref to blessed hashref should fail Undef
> ok 57 - Object stringifying to "" should fail Undef
> ok 58 - Object stringifying to "1" should fail Undef
> ok 59 - Object numifying to 0 should fail Undef
> ok 60 - Object numifying to 1 should fail Undef
> ok 61 - Object overloading arrayref should fail Undef
> ok 62 - Object overloading hashref should fail Undef
> ok 63 - Object overloading coderef should fail Undef
> ok 64 - Object booling to false should fail Undef
> ok 65 - Object booling to true should fail Undef
> ok 66 - The complement of Undef is Defined
> 1..66
> ok
> t/21-types/UpperCaseSimpleStr.t ..............................
> ok 1 - 'UpperCaseSimpleStr' isa 'Type::Tiny'
> ok 2 - UpperCaseSimpleStr has correct name
> ok 3 - UpperCaseSimpleStr has correct display_name
> ok 4 - UpperCaseSimpleStr knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type UpperCaseSimpleStr
> ok 6 - UpperCaseSimpleStr is not deprecated
> ok 7 - UpperCaseSimpleStr is not anonymous
> ok 8 - UpperCaseSimpleStr can be inlined
> ok 9 - Inlining UpperCaseSimpleStr doesn't throw an exception
> ok 10 - UpperCaseSimpleStr has a coercion
> ok 11 - UpperCaseSimpleStr isn't parameterizable
> ok 12 - UpperCaseSimpleStr has no type_default
> ok 13 - Undef should fail UpperCaseSimpleStr
> ok 14 - False should fail UpperCaseSimpleStr
> ok 15 - True should pass UpperCaseSimpleStr
> ok 16 - Zero should pass UpperCaseSimpleStr
> ok 17 - One should pass UpperCaseSimpleStr
> ok 18 - Negative one should pass UpperCaseSimpleStr
> ok 19 - Non integer should pass UpperCaseSimpleStr
> ok 20 - Empty string should fail UpperCaseSimpleStr
> ok 21 - Whitespace should pass UpperCaseSimpleStr
> ok 22 - Line break should fail UpperCaseSimpleStr
> ok 23 - Random string should fail UpperCaseSimpleStr
> ok 24 - Loaded package name should fail UpperCaseSimpleStr
> ok 25 - Unloaded package name should fail UpperCaseSimpleStr
> ok 26 - A reference to undef should fail UpperCaseSimpleStr
> ok 27 - A reference to false should fail UpperCaseSimpleStr
> ok 28 - A reference to true should fail UpperCaseSimpleStr
> ok 29 - A reference to zero should fail UpperCaseSimpleStr
> ok 30 - A reference to one should fail UpperCaseSimpleStr
> ok 31 - A reference to empty string should fail UpperCaseSimpleStr
> ok 32 - A reference to random string should fail UpperCaseSimpleStr
> ok 33 - Blessed scalarref should fail UpperCaseSimpleStr
> ok 34 - Empty arrayref should fail UpperCaseSimpleStr
> ok 35 - Arrayref with one zero should fail UpperCaseSimpleStr
> ok 36 - Arrayref of integers should fail UpperCaseSimpleStr
> ok 37 - Arrayref of numbers should fail UpperCaseSimpleStr
> ok 38 - Blessed arrayref should fail UpperCaseSimpleStr
> ok 39 - Empty hashref should fail UpperCaseSimpleStr
> ok 40 - Hashref should fail UpperCaseSimpleStr
> ok 41 - Blessed hashref should fail UpperCaseSimpleStr
> ok 42 - Coderef should fail UpperCaseSimpleStr
> ok 43 - Blessed coderef should fail UpperCaseSimpleStr
> ok 44 - Glob should fail UpperCaseSimpleStr
> ok 45 - Globref should fail UpperCaseSimpleStr
> ok 46 - Blessed globref should fail UpperCaseSimpleStr
> ok 47 - Regexp should fail UpperCaseSimpleStr
> ok 48 - Blessed regexp should fail UpperCaseSimpleStr
> ok 49 - Filehandle should fail UpperCaseSimpleStr
> ok 50 - Filehandle object should fail UpperCaseSimpleStr
> ok 51 - Ref to scalarref should fail UpperCaseSimpleStr
> ok 52 - Ref to arrayref should fail UpperCaseSimpleStr
> ok 53 - Ref to hashref should fail UpperCaseSimpleStr
> ok 54 - Ref to coderef should fail UpperCaseSimpleStr
> ok 55 - Ref to blessed hashref should fail UpperCaseSimpleStr
> ok 56 - Object stringifying to "" should fail UpperCaseSimpleStr
> ok 57 - Object stringifying to "1" should fail UpperCaseSimpleStr
> ok 58 - Object numifying to 0 should fail UpperCaseSimpleStr
> ok 59 - Object numifying to 1 should fail UpperCaseSimpleStr
> ok 60 - Object overloading arrayref should fail UpperCaseSimpleStr
> ok 61 - Object overloading hashref should fail UpperCaseSimpleStr
> ok 62 - Object overloading coderef should fail UpperCaseSimpleStr
> ok 63 - Object booling to false should fail UpperCaseSimpleStr
> ok 64 - Object booling to true should fail UpperCaseSimpleStr
> ok 65 - Value "\x{436}" fails type constraint UpperCaseSimpleStr
> ok 66 - Value "\x{416}" passes type constraint UpperCaseSimpleStr
> ok 67 - Value "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" passes type constraint UpperCaseSimpleStr
> ok 68 - Value "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" fails type constraint UpperCaseSimpleStr
> ok 69 - Value "\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}" passes type constraint UpperCaseSimpleStr
> ok 70 - Value "\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}\x{416}" fails type constraint UpperCaseSimpleStr
> ok 71 - Value "ABCDEF" passes type constraint UpperCaseSimpleStr
> ok 72 - Value "ABC123" passes type constraint UpperCaseSimpleStr
> ok 73 - Value "abc123" fails type constraint UpperCaseSimpleStr
> ok 74 - Value "abcdef" fails type constraint UpperCaseSimpleStr
> ok 75 - Value "123456" passes type constraint UpperCaseSimpleStr
> ok 76 - Value " " passes type constraint UpperCaseSimpleStr
> ok 77 - Value "" fails type constraint UpperCaseSimpleStr
> ok 78 - coercion success
> ok 79 - does not coerce non-strings
> 1..79
> ok
> t/21-types/UpperCaseStr.t ....................................
> ok 1 - 'UpperCaseStr' isa 'Type::Tiny'
> ok 2 - UpperCaseStr has correct name
> ok 3 - UpperCaseStr has correct display_name
> ok 4 - UpperCaseStr knows it is in the Types::Common::String library
> ok 5 - Types::Common::String knows it has type UpperCaseStr
> ok 6 - UpperCaseStr is not deprecated
> ok 7 - UpperCaseStr is not anonymous
> ok 8 - UpperCaseStr can be inlined
> ok 9 - Inlining UpperCaseStr doesn't throw an exception
> ok 10 - UpperCaseStr has a coercion
> ok 11 - UpperCaseStr isn't parameterizable
> ok 12 - UpperCaseStr has no type_default
> ok 13 - Undef should fail UpperCaseStr
> ok 14 - False should fail UpperCaseStr
> ok 15 - True should pass UpperCaseStr
> ok 16 - Zero should pass UpperCaseStr
> ok 17 - One should pass UpperCaseStr
> ok 18 - Negative one should pass UpperCaseStr
> ok 19 - Non integer should pass UpperCaseStr
> ok 20 - Empty string should fail UpperCaseStr
> ok 21 - Whitespace should pass UpperCaseStr
> ok 22 - Line break should pass UpperCaseStr
> ok 23 - Random string should fail UpperCaseStr
> ok 24 - Loaded package name should fail UpperCaseStr
> ok 25 - Unloaded package name should fail UpperCaseStr
> ok 26 - A reference to undef should fail UpperCaseStr
> ok 27 - A reference to false should fail UpperCaseStr
> ok 28 - A reference to true should fail UpperCaseStr
> ok 29 - A reference to zero should fail UpperCaseStr
> ok 30 - A reference to one should fail UpperCaseStr
> ok 31 - A reference to empty string should fail UpperCaseStr
> ok 32 - A reference to random string should fail UpperCaseStr
> ok 33 - Blessed scalarref should fail UpperCaseStr
> ok 34 - Empty arrayref should fail UpperCaseStr
> ok 35 - Arrayref with one zero should fail UpperCaseStr
> ok 36 - Arrayref of integers should fail UpperCaseStr
> ok 37 - Arrayref of numbers should fail UpperCaseStr
> ok 38 - Blessed arrayref should fail UpperCaseStr
> ok 39 - Empty hashref should fail UpperCaseStr
> ok 40 - Hashref should fail UpperCaseStr
> ok 41 - Blessed hashref should fail UpperCaseStr
> ok 42 - Coderef should fail UpperCaseStr
> ok 43 - Blessed coderef should fail UpperCaseStr
> ok 44 - Glob should fail UpperCaseStr
> ok 45 - Globref should fail UpperCaseStr
> ok 46 - Blessed globref should fail UpperCaseStr
> ok 47 - Regexp should fail UpperCaseStr
> ok 48 - Blessed regexp should fail UpperCaseStr
> ok 49 - Filehandle should fail UpperCaseStr
> ok 50 - Filehandle object should fail UpperCaseStr
> ok 51 - Ref to scalarref should fail UpperCaseStr
> ok 52 - Ref to arrayref should fail UpperCaseStr
> ok 53 - Ref to hashref should fail UpperCaseStr
> ok 54 - Ref to coderef should fail UpperCaseStr
> ok 55 - Ref to blessed hashref should fail UpperCaseStr
> ok 56 - Object stringifying to "" should fail UpperCaseStr
> ok 57 - Object stringifying to "1" should fail UpperCaseStr
> ok 58 - Object numifying to 0 should fail UpperCaseStr
> ok 59 - Object numifying to 1 should fail UpperCaseStr
> ok 60 - Object overloading arrayref should fail UpperCaseStr
> ok 61 - Object overloading hashref should fail UpperCaseStr
> ok 62 - Object overloading coderef should fail UpperCaseStr
> ok 63 - Object booling to false should fail UpperCaseStr
> ok 64 - Object booling to true should fail UpperCaseStr
> ok 65 - Value "\x{436}" fails type constraint UpperCaseStr
> ok 66 - Value "\x{416}" passes type constraint UpperCaseStr
> ok 67 - Value "ABCDEF" passes type constraint UpperCaseStr
> ok 68 - Value "ABC123" passes type constraint UpperCaseStr
> ok 69 - Value "abc123" fails type constraint UpperCaseStr
> ok 70 - Value "abcdef" fails type constraint UpperCaseStr
> ok 71 - Value "123456" passes type constraint UpperCaseStr
> ok 72 - Value " " passes type constraint UpperCaseStr
> ok 73 - Value "" fails type constraint UpperCaseStr
> ok 74 - coercion success
> ok 75 - does not coerce non-strings
> 1..75
> ok
> t/21-types/Value.t ...........................................
> ok 1 - 'Value' isa 'Type::Tiny'
> ok 2 - Value has correct name
> ok 3 - Value has correct display_name
> ok 4 - Value knows it is in the Types::Standard library
> ok 5 - Types::Standard knows it has type Value
> ok 6 - Value is not deprecated
> ok 7 - Value is not anonymous
> ok 8 - Value can be inlined
> ok 9 - Inlining Value doesn't throw an exception
> ok 10 - Value doesn't have a coercion
> ok 11 - Value isn't parameterizable
> ok 12 - Value has no type_default
> ok 13 - Undef should fail Value
> ok 14 - False should pass Value
> ok 15 - True should pass Value
> ok 16 - Zero should pass Value
> ok 17 - One should pass Value
> ok 18 - Negative one should pass Value
> ok 19 - Non integer should pass Value
> ok 20 - Empty string should pass Value
> ok 21 - Whitespace should pass Value
> ok 22 - Line break should pass Value
> ok 23 - Random string should pass Value
> ok 24 - Loaded package name should pass Value
> ok 25 - Unloaded package name should pass Value
> ok 26 - A reference to undef should fail Value
> ok 27 - A reference to false should fail Value
> ok 28 - A reference to true should fail Value
> ok 29 - A reference to zero should fail Value
> ok 30 - A reference to one should fail Value
> ok 31 - A reference to empty string should fail Value
> ok 32 - A reference to random string should fail Value
> ok 33 - Blessed scalarref should fail Value
> ok 34 - Empty arrayref should fail Value
> ok 35 - Arrayref with one zero should fail Value
> ok 36 - Arrayref of integers should fail Value
> ok 37 - Arrayref of numbers should fail Value
> ok 38 - Blessed arrayref should fail Value
> ok 39 - Empty hashref should fail Value
> ok 40 - Hashref should fail Value
> ok 41 - Blessed hashref should fail Value
> ok 42 - Coderef should fail Value
> ok 43 - Blessed coderef should fail Value
> ok 44 - Glob should pass Value
> ok 45 - Globref should fail Value
> ok 46 - Blessed globref should fail Value
> ok 47 - Regexp should fail Value
> ok 48 - Blessed regexp should fail Value
> ok 49 - Filehandle should fail Value
> ok 50 - Filehandle object should fail Value
> ok 51 - Ref to scalarref should fail Value
> ok 52 - Ref to arrayref should fail Value
> ok 53 - Ref to hashref should fail Value
> ok 54 - Ref to coderef should fail Value
> ok 55 - Ref to blessed hashref should fail Value
> ok 56 - Object stringifying to "" should fail Value
> ok 57 - Object stringifying to "1" should fail Value
> ok 58 - Object numifying to 0 should fail Value
> ok 59 - Object numifying to 1 should fail Value
> ok 60 - Object overloading arrayref should fail Value
> ok 61 - Object overloading hashref should fail Value
> ok 62 - Object overloading coderef should fail Value
> ok 63 - Object booling to false should fail Value
> ok 64 - Object booling to true should fail Value
> 1..64
> ok
> t/30-external/Class-InsideOut/basic.t ........................
> ok 1 - Object::HookedTT has/inherited its expected properties
> ok 2 - Creating a Object::HookedTT object
> ok 3 - integer(3.14) dies
> ok 4 - integer(42) lives
> ok 5 - integer() == 42
> ok 6 - word(^^^^) dies
> ok 7 - word(apple) lives
> ok 8 - word() eq 'apple'
> ok 9 - uppercase(banana) lives
> ok 10 - uppercase() eq 'BANANA'
> ok 11 - list(qw(foo bar bam)) lives
> ok 12 - list() gives qw(foo bar bam)
> ok 13 - list( [qw(foo bar bam)] ) lives
> ok 14 - list() gives qw(foo bar bam)
> ok 15 - reverser(qw(foo bar bam)) lives
> ok 16 - reverser() in list context gives qw(bam bar foo)
> ok 17 - reverser() in scalar context gives mabraboof
> ok 18 - write_only lives on write
> ok 19 - write only dies on write (and was caught)
> 1..19
> ok
> t/30-external/Class-Plain/basic.t ............................ skipped: requires Class::Plain
> t/30-external/Class-Plain/multisig.t ......................... skipped: requires Class::Plain
> t/30-external/Data-Constraint/basic.t ........................ skipped: requires Data::Constraint
> t/30-external/Exporter-Tiny/basic.t ..........................
> ok 1 - No exception exporting a legitimate function
> ok 2 - main->can('Any')
> ok 3 - Attempt to export a function which does not exist
> ok 4 - Attempt to export a function which exists but not in @EXPORT_OK
> ok 5 - "-types" shortcut works
> ok 6 - "-coercions" shortcut works
> ok 7 - renaming works
> ok 8 - prefixes work
> ok 9 - suffixes work
> ok 10 - plus notation works for Type::Library
> ok 11 - mkopt_hash
> 1..11
> ok
> t/30-external/Exporter-Tiny/installer.t ...................... skipped: requires Sub::Exporter::Lexical
> t/30-external/Exporter-Tiny/role-conflict.t ..................
> ok 1 - no exception when trying to compose two roles that use type constraints
> # 94541637506128
> # 94541637506128
> 1..1
> ok
> t/30-external/Function-Parameters/basic.t ....................
> ok 1 - foo(4) works
> ok 2 - foo(4.1) throws
> ok 3 - $x->name
> ok 4 - $x->type
> 1..4
> ok
> t/30-external/JSON-PP/basic.t ................................
> ok 1 - Value "0" passes type constraint Bool
> ok 2 - Value "1" passes type constraint Bool
> ok 3 - Value "" passes type constraint Bool
> ok 4 - Undef passes type constraint Bool
> ok 5 - Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) fails type constraint Bool
> ok 6 - Reference bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ) fails type constraint Bool
> ok 7 - Reference \0 fails type constraint Bool
> ok 8 - Reference \1 fails type constraint Bool
> ok 9 - Bool coercion of JSON::PP::true
> ok 10 - Bool coercion of JSON::PP::false
> ok 11 - Value "0" passes type constraint BoolLike
> ok 12 - Value "1" passes type constraint BoolLike
> ok 13 - Value "" passes type constraint BoolLike
> ok 14 - Undef passes type constraint BoolLike
> ok 15 - Reference bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ) passes type constraint BoolLike
> ok 16 - Reference bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ) passes type constraint BoolLike
> ok 17 - Reference \0 fails type constraint Bool
> ok 18 - Reference \1 fails type constraint Bool
> 1..18
> ok
> t/30-external/Kavorka/80returntype.t ......................... skipped: EXTENDED_TESTING
> t/30-external/Kavorka/basic.t ................................ skipped: requires Kavorka
> t/30-external/match-simple/basic.t ...........................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> 1..5
> ok
> t/30-external/Moo/basic.t ....................................
> ok 1 - some values that should pass their type constraint
> ok 2 - direct violation of type constraint
> ok 3 - violation of parent type constraint
> ok 4 - violation of grandparent type constraint
> ok 5 - violation of great-grandparent type constraint
> 1..5
> ok
> t/30-external/Moo/coercion-inlining-avoidance.t ..............
> ok 1 - created a type constraint without a frozen coercion
> ok 2 - ... it reports that it cannot be inlined
> ok 3 - initial use of type in a Moo constructor
> ok 4 - ... and it cannot coerce from an arrayref
> ok 5 - ... and it cannot coerce from an hashref
> ok 6 - can add coercions from ArrayRef and HashRef to the type
> ok 7 - ... it is still not frozen
> ok 8 - ... it reports that it still cannot be inlined
> ok 9 - again use of type in a Moo constructor
> ok 10 - ... but can coerce from ArrayRef
> ok 11 - ... and can coerce from HashRef
> ok 12 - can freeze the coercion
> ok 13 - ... it reports that it is frozen
> ok 14 - ... it reports that it can be inlined
> 1..14
> ok
> t/30-external/Moo/coercion.t .................................
> ok 1 - An object of class 'Type::Tiny' isa 'Type::Tiny'
> ok 2 - no exception on coercion in constructor - mutable class
> ok 3 - 'big' attribute coerces in constructor - mutable class
> ok 4 - 'small' attribute coerces in constructor - mutable class
> ok 5 - 'big' attribute throws when it cannot coerce in constructor - mutable class
> ok 6 - 'small' attribute throws when it cannot coerce in constructor - mutable class
> ok 7 - 'big' attribute coerces in accessor - mutable class
> ok 8 - 'small' attribute coerces in accessor - mutable class
> ok 9 - 'big' attribute throws when it cannot coerce in accessor - mutable class
> ok 10 - 'small' attribute throws when it cannot coerce in accessor - mutable class
> ok 11 - no exception on coercion in constructor - immutable class
> ok 12 - 'big' attribute coerces in constructor - immutable class
> ok 13 - 'small' attribute coerces in constructor - immutable class
> ok 14 - 'big' attribute throws when it cannot coerce in constructor - immutable class
> ok 15 - 'small' attribute throws when it cannot coerce in constructor - immutable class
> ok 16 - 'big' attribute coerces in accessor - immutable class
> ok 17 - 'small' attribute coerces in accessor - immutable class
> ok 18 - 'big' attribute throws when it cannot coerce in accessor - immutable class
> ok 19 - 'small' attribute throws when it cannot coerce in accessor - immutable class
> 1..19
> ok
> t/30-external/Moo/exceptions.t ...............................
> ok 1 - '$e_constructor' isa 'Error::TypeTiny::Assertion'
> ok 2 - $e_constructor->has_attribute_name
> ok 3 - $e_constructor->attribute_name
> ok 4 - $e_constructor->has_attribute_step
> ok 5 - $e_constructor->attribute_step
> ok 6 - $e_constructor->varname
> ok 7 - $e_constructor->value
> ok 8 - $e_constructor->type
> ok 9 - '$e_accessor' isa 'Error::TypeTiny::Assertion'
> ok 10 - $e_accessor->has_attribute_name
> ok 11 - $e_accessor->attribute_name
> ok 12 - $e_accessor->has_attribute_step
> ok 13 - $e_accessor->attribute_step
> ok 14 - $e_accessor->value
> ok 15 - $e_accessor->type
> 1..15
> ok
> t/30-external/Moo/inflation.t ................................
> # {
> # 'Type::Tiny::Class=HASH(0x56041cc4f698)' => sub { "DUMMY" },
> # 'Type::Tiny::Class=HASH(0x56041cc849c8)' => sub { "DUMMY" },
> # 'Type::Tiny::Class=HASH(0x56041cca46c0)' => sub { "DUMMY" },
> # 'Type::Tiny::Duck=HASH(0x56041cca78d8)' => sub { "DUMMY" },
> # 'Type::Tiny::Duck=HASH(0x56041cca85c8)' => sub { "DUMMY" },
> # 'Type::Tiny::Role=HASH(0x56041cc46978)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041c614858)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041c7759c8)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041c88caa8)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041c8ad848)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041c8adbc0)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041c8adce0)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041c8ae0b8)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041c8ae208)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041c996d78)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041c9acad8)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041c9ad228)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041ca11570)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041ca72070)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041ca82d20)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041ca88cc8)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cae4af0)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cae5420)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041caead28)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041caf2c58)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041caf3690)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041caf9230)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb05410)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb05de8)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb0ce80)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb15540)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb1b090)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb1baf8)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb24080)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb2a7f8)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb2b410)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb32aa0)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb3c850)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb44640)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb45288)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb4cd20)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb533d8)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb59148)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb63d38)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb6c7e0)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb6d4a0)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb754b0)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb7e288)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cb82a10)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cba5ec0)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cbaca38)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cbb65d8)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cbc16f8)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cbc23d0)' => sub { "DUMMY" },
> # 'Type::Tiny=HASH(0x56041cc46510)' => sub { "DUMMY" }
> # }
> ok 1 - some values that should pass their type constraint - Moose is not loaded
> ok 2 - direct violation of type constraint - Moose is not loaded
> ok 3 - violation of parent type constraint - Moose is not loaded
> ok 4 - violation of grandparent type constraint - Moose is not loaded
> ok 5 - violation of great-grandparent type constraint - Moose is not loaded
> ok 6 - some values that should pass their type constraint - Moose is loaded
> ok 7 - direct violation of type constraint - Moose is loaded
> ok 8 - violation of parent type constraint - Moose is loaded
> ok 9 - violation of grandparent type constraint - Moose is loaded
> ok 10 - violation of great-grandparent type constraint - Moose is loaded
> ok 11 - type constraint metaobject inflates from Moo to Moose
> 1..11
> ok
> t/30-external/Moo/inflation2.t ...............................
> ok 1
> 1..1
> ok
> t/30-external/Moops/basic.t .................................. skipped: requires Moops
> t/30-external/Moops/library-keyword.t ........................ skipped: requires Moops
> t/30-external/Moose/accept-moose-types.t .....................
> ok 1 - 'Int' isa 'Moose::Meta::TypeConstraint'
> ok 2 - 'Str' isa 'Moose::Meta::TypeConstraint'
> ok 3 - '$PositiveInt' isa 'Type::Tiny'
> ok 4 - '$PositiveInt->parent' isa 'Type::Tiny'
> 1..4
> ok
> t/30-external/Moose/basic.t ..................................
> # The basics
> ok 1 - some values that should pass their type constraint
> ok 2 - direct violation of type constraint
> ok 3 - violation of parent type constraint
> ok 4 - violation of grandparent type constraint
> ok 5 - violation of great-grandparent type constraint
> # Coercion...
> ok 6 - types converted from Moose retain coercions
> ok 7 - ... which work
> ok 8 - ... refaddr matches
> ok 9 - ... coercion refaddr matches
> # Introspection, comparisons, conversions...
> ok 10 - 'Int' isa 'Class::MOP::Object'
> ok 11 - 'ArrayRef' isa 'Moose::Meta::TypeConstraint'
> ok 12 - 'ArrayRef' isa 'Moose::Meta::TypeConstraint::Parameterizable'
> ok 13 - 'ArrayRef[Int]' isa 'Moose::Meta::TypeConstraint'
> ok 14 - 'ArrayRef[Int]' isa 'Moose::Meta::TypeConstraint::Parameterized'
> ok 15 - 'ArrayRef|Int' isa 'Moose::Meta::TypeConstraint'
> ok 16 - 'ArrayRef|Int' isa 'Moose::Meta::TypeConstraint::Union'
> ok 17 - 'MyInt->coercion' isa 'Moose::Meta::TypeCoercion'
> ok 18 - '(ArrayRef|Int)->coercion' isa 'Moose::Meta::TypeCoercion'
> ok 19 - '(ArrayRef|Int)->coercion' isa 'Moose::Meta::TypeCoercion::Union'
> ok 20 - equivalence between Types::Standard types and core Moose types
> ok 21 - '$classtype' isa 'Moose::Meta::TypeConstraint::Class'
> ok 22 - Type::Tiny::Class provides meta information to Moose::Meta::TypeConstraint::Class
> ok 23 - '$classtype->Types::TypeTiny::to_TypeTiny' isa 'Type::Tiny::Class'
> ok 24 - '$roletype' isa 'Moose::Meta::TypeConstraint'
> ok 25 - NB! Type::Tiny::Role does not inflate to Moose::Meta::TypeConstraint::Role because of differing notions as to what constitutes a role.
> ok 26 - '$roletype->Types::TypeTiny::to_TypeTiny' isa 'Type::Tiny::Role'
> ok 27 - '$ducktype' isa 'Moose::Meta::TypeConstraint::DuckType'
> ok 28 - Type::Tiny::Duck provides meta information to Moose::Meta::TypeConstraint::DuckType
> ok 29 - '$ducktype->Types::TypeTiny::to_TypeTiny' isa 'Type::Tiny::Duck'
> ok 30 - '$classtype' isa 'Moose::Meta::TypeConstraint::Enum'
> ok 31 - Type::Tiny::Enum provides meta information to Moose::Meta::TypeConstraint::Enum
> ok 32 - '$enumtype->Types::TypeTiny::to_TypeTiny' isa 'Type::Tiny::Enum'
> ok 33 - '$union' isa 'Moose::Meta::TypeConstraint::Union'
> ok 34 - Type::Tiny::Union provides meta information to Moose::Meta::TypeConstraint::Union
> ok 35 - '$union->Types::TypeTiny::to_TypeTiny' isa 'Type::Tiny::Union'
> ok 36 - $union->type_constraints->[$i]->Types::TypeTiny::to_TypeTiny provides access to underlying Type::Tiny objects
> ok 37 - '$intersect' isa 'Moose::Meta::TypeConstraint'
> ok 38 - '$intersect->Types::TypeTiny::to_TypeTiny' isa 'Type::Tiny::Intersection'
> ok 39 - round-tripping between ->moose_type and ->Types::TypeTiny::to_TypeTiny preserves reference address
> # Method pass-through
> ok 40 - method pass-through
> ok 41 - ... but not non-existant method
> ok 42 - ... and `can` works ok
> ok 43 - method pass-through for coercions
> ok 44 - ... but not non-existant method
> ok 45 - ... and `can` works ok
> 1..45
> ok
> t/30-external/Moose/coercion-more.t ..........................
> ok 1 - An object of class 'Type::Tiny' isa 'Moose::Meta::TypeConstraint'
> ok 2 - no_coercions and friends available on Moose type constraint objects
> 1..2
> ok
> t/30-external/Moose/coercion.t ...............................
> ok 1 - An object of class 'Type::Tiny' isa 'Moose::Meta::TypeConstraint'
> ok 2 - no exception on coercion in constructor - mutable class
> ok 3 - 'big' attribute coerces in constructor - mutable class
> ok 4 - 'small' attribute coerces in constructor - mutable class
> ok 5 - 'big' attribute throws when it cannot coerce in constructor - mutable class
> ok 6 - 'small' attribute throws when it cannot coerce in constructor - mutable class
> ok 7 - 'big' attribute coerces in accessor - mutable class
> ok 8 - 'small' attribute coerces in accessor - mutable class
> ok 9 - 'big' attribute throws when it cannot coerce in accessor - mutable class
> ok 10 - 'small' attribute throws when it cannot coerce in accessor - mutable class
> ok 11 - no exception on coercion in constructor - immutable class
> ok 12 - 'big' attribute coerces in constructor - immutable class
> ok 13 - 'small' attribute coerces in constructor - immutable class
> ok 14 - 'big' attribute throws when it cannot coerce in constructor - immutable class
> ok 15 - 'small' attribute throws when it cannot coerce in constructor - immutable class
> ok 16 - 'big' attribute coerces in accessor - immutable class
> ok 17 - 'small' attribute coerces in accessor - immutable class
> ok 18 - 'big' attribute throws when it cannot coerce in accessor - immutable class
> ok 19 - 'small' attribute throws when it cannot coerce in accessor - immutable class
> 1..19
> ok
> t/30-external/Moose/inflate-then-inline.t ....................
> ok 1 - $type2->inline_check
> ok 2 - $type2->moose_type->_inline_check
> 1..2
> ok
> t/30-external/Moose/native-attribute-traits.t ................
> ok 1
> # IMMUTABLE
> # Subtest: Array trait with type ArrayRef[Object]
> ok 1 - pushing ok value
> ok 2 - pushing not ok value
> 1..2
> ok 2 - Array trait with type ArrayRef[Object]
> # Subtest: Array trait with type ArrayRef[InstanceOf] and coercion
> ok 1 - pushing ok values
> ok 2 - '$things->[0]' isa 'Mini::Milk'
> ok 3 - $things->[0]->i == 0
> ok 4 - '$things->[1]' isa 'Mini::Milk'
> ok 5 - $things->[1]->i == 1
> ok 6 - '$things->[2]' isa 'Mini::Milk'
> ok 7 - $things->[2]->i == 2
> ok 8 - '$things->[3]' isa 'Mini::Milk'
> ok 9 - $things->[3]->i == 3
> 1..9
> ok 3 - Array trait with type ArrayRef[InstanceOf] and coercion
> # Subtest: Array trait with type ArrayRef[InstanceOf] and coercion and subtyping
> ok 1 - pushing ok values
> ok 2 - '$things->[0]' isa 'Mini::Milk'
> ok 3 - $things->[0]->i == 0
> ok 4 - '$things->[1]' isa 'Mini::Milk'
> ok 5 - $things->[1]->i == 1
> ok 6 - '$things->[2]' isa 'Mini::Milk'
> ok 7 - $things->[2]->i == 2
> ok 8 - '$things->[3]' isa 'Mini::Milk'
> ok 9 - $things->[3]->i == 3
> 1..9
> ok 4 - Array trait with type ArrayRef[InstanceOf] and coercion and subtyping
> # Subtest: Hash trait with type HashRef
> ok 1 - default empty hash
> ok 2 - getter
> ok 3 - getter
> ok 4 - setter
> ok 5 - predicate
> ok 6 - predicate
> ok 7 - predicate - negatory
> ok 8 - correct hash
> 1..8
> ok 5 - Hash trait with type HashRef
> # Subtest: Hash trait with type HashRef[Int]
> ok 1 - default empty hash
> ok 2 - getter
> ok 3 - getter
> ok 4 - setter
> ok 5 - predicate
> ok 6 - predicate
> ok 7 - predicate - negatory
> ok 8 - correct hash
> ok 9 - cannot add non-Int value
> 1..9
> ok 6 - Hash trait with type HashRef[Int]
> # Subtest: Hash trait with type Map
> ok 1 - default empty hash
> ok 2 - getter
> ok 3 - getter
> ok 4 - setter
> ok 5 - predicate
> ok 6 - predicate
> ok 7 - predicate - negatory
> ok 8 - correct hash
> 1..8
> ok 7 - Hash trait with type Map
> # Subtest: Hash trait with type Map[Str,Int]
> ok 1 - default empty hash
> ok 2 - getter
> ok 3 - getter
> ok 4 - setter
> ok 5 - predicate
> ok 6 - predicate
> ok 7 - predicate - negatory
> ok 8 - correct hash
> ok 9 - cannot add non-Int value
> 1..9
> ok 8 - Hash trait with type Map[Str,Int]
> # Subtest: Hash trait with types HashRef[InstanceOf] and Map[Int,InstanceOf]; and coercion
> ok 1 - adding ok values to HashRef
> ok 2 - adding ok values to Map
> ok 3 - '$h->{0}' isa 'Mini::Milk'
> ok 4 - $h->{0}->i == .0
> ok 5 - '$h->{1}' isa 'Mini::Milk'
> ok 6 - $h->{1}->i == .1
> ok 7 - '$h->{2}' isa 'Mini::Milk'
> ok 8 - $h->{2}->i == .2
> ok 9 - '$h->{3}' isa 'Mini::Milk'
> ok 10 - $h->{3}->i == .3
> ok 11 - '$m->{4}' isa 'Mini::Milk'
> ok 12 - $m->{4}->i == .4
> ok 13 - '$m->{5}' isa 'Mini::Milk'
> ok 14 - $m->{5}->i == .5
> ok 15 - '$m->{6}' isa 'Mini::Milk'
> ok 16 - $m->{6}->i == .6
> ok 17 - '$m->{7}' isa 'Mini::Milk'
> ok 18 - $m->{7}->i == .7
> 1..18
> ok 9 - Hash trait with types HashRef[InstanceOf] and Map[Int,InstanceOf]; and coercion
> # Subtest: Hash trait with types HashRef[InstanceOf] and Map[Int,InstanceOf]; and coercion and subtyping
> ok 1 - adding ok values to HashRef
> ok 2 - adding ok values to Map
> ok 3 - '$h->{0}' isa 'Mini::Milk'
> ok 4 - $h->{0}->i == .0
> ok 5 - '$h->{1}' isa 'Mini::Milk'
> ok 6 - $h->{1}->i == .1
> ok 7 - '$h->{2}' isa 'Mini::Milk'
> ok 8 - $h->{2}->i == .2
> ok 9 - '$h->{3}' isa 'Mini::Milk'
> ok 10 - $h->{3}->i == .3
> ok 11 - '$m->{4}' isa 'Mini::Milk'
> ok 12 - $m->{4}->i == .4
> ok 13 - '$m->{5}' isa 'Mini::Milk'
> ok 14 - $m->{5}->i == .5
> ok 15 - '$m->{6}' isa 'Mini::Milk'
> ok 16 - $m->{6}->i == .6
> ok 17 - '$m->{7}' isa 'Mini::Milk'
> ok 18 - $m->{7}->i == .7
> 1..18
> ok 10 - Hash trait with types HashRef[InstanceOf] and Map[Int,InstanceOf]; and coercion and subtyping
> # MUTABLE
> # Subtest: Array trait with type ArrayRef[Object]
> ok 1 - pushing ok value
> ok 2 - pushing not ok value
> 1..2
> ok 11 - Array trait with type ArrayRef[Object]
> # Subtest: Array trait with type ArrayRef[InstanceOf] and coercion
> ok 1 - pushing ok values
> ok 2 - '$things->[0]' isa 'Mini::Milk'
> ok 3 - $things->[0]->i == 0
> ok 4 - '$things->[1]' isa 'Mini::Milk'
> ok 5 - $things->[1]->i == 1
> ok 6 - '$things->[2]' isa 'Mini::Milk'
> ok 7 - $things->[2]->i == 2
> ok 8 - '$things->[3]' isa 'Mini::Milk'
> ok 9 - $things->[3]->i == 3
> 1..9
> ok 12 - Array trait with type ArrayRef[InstanceOf] and coercion
> # Subtest: Array trait with type ArrayRef[InstanceOf] and coercion and subtyping
> ok 1 - pushing ok values
> ok 2 - '$things->[0]' isa 'Mini::Milk'
> ok 3 - $things->[0]->i == 0
> ok 4 - '$things->[1]' isa 'Mini::Milk'
> ok 5 - $things->[1]->i == 1
> ok 6 - '$things->[2]' isa 'Mini::Milk'
> ok 7 - $things->[2]->i == 2
> ok 8 - '$things->[3]' isa 'Mini::Milk'
> ok 9 - $things->[3]->i == 3
> 1..9
> ok 13 - Array trait with type ArrayRef[InstanceOf] and coercion and subtyping
> # Subtest: Hash trait with type HashRef
> ok 1 - default empty hash
> ok 2 - getter
> ok 3 - getter
> ok 4 - setter
> ok 5 - predicate
> ok 6 - predicate
> ok 7 - predicate - negatory
> ok 8 - correct hash
> 1..8
> ok 14 - Hash trait with type HashRef
> # Subtest: Hash trait with type HashRef[Int]
> ok 1 - default empty hash
> ok 2 - getter
> ok 3 - getter
> ok 4 - setter
> ok 5 - predicate
> ok 6 - predicate
> ok 7 - predicate - negatory
> ok 8 - correct hash
> ok 9 - cannot add non-Int value
> 1..9
> ok 15 - Hash trait with type HashRef[Int]
> # Subtest: Hash trait with type Map
> ok 1 - default empty hash
> ok 2 - getter
> ok 3 - getter
> ok 4 - setter
> ok 5 - predicate
> ok 6 - predicate
> ok 7 - predicate - negatory
> ok 8 - correct hash
> 1..8
> ok 16 - Hash trait with type Map
> # Subtest: Hash trait with type Map[Str,Int]
> ok 1 - default empty hash
> ok 2 - getter
> ok 3 - getter
> ok 4 - setter
> ok 5 - predicate
> ok 6 - predicate
> ok 7 - predicate - negatory
> ok 8 - correct hash
> ok 9 - cannot add non-Int value
> 1..9
> ok 17 - Hash trait with type Map[Str,Int]
> # Subtest: Hash trait with types HashRef[InstanceOf] and Map[Int,InstanceOf]; and coercion
> ok 1 - adding ok values to HashRef
> ok 2 - adding ok values to Map
> ok 3 - '$h->{0}' isa 'Mini::Milk'
> ok 4 - $h->{0}->i == .0
> ok 5 - '$h->{1}' isa 'Mini::Milk'
> ok 6 - $h->{1}->i == .1
> ok 7 - '$h->{2}' isa 'Mini::Milk'
> ok 8 - $h->{2}->i == .2
> ok 9 - '$h->{3}' isa 'Mini::Milk'
> ok 10 - $h->{3}->i == .3
> ok 11 - '$m->{4}' isa 'Mini::Milk'
> ok 12 - $m->{4}->i == .4
> ok 13 - '$m->{5}' isa 'Mini::Milk'
> ok 14 - $m->{5}->i == .5
> ok 15 - '$m->{6}' isa 'Mini::Milk'
> ok 16 - $m->{6}->i == .6
> ok 17 - '$m->{7}' isa 'Mini::Milk'
> ok 18 - $m->{7}->i == .7
> 1..18
> ok 18 - Hash trait with types HashRef[InstanceOf] and Map[Int,InstanceOf]; and coercion
> # Subtest: Hash trait with types HashRef[InstanceOf] and Map[Int,InstanceOf]; and coercion and subtyping
> ok 1 - adding ok values to HashRef
> ok 2 - adding ok values to Map
> ok 3 - '$h->{0}' isa 'Mini::Milk'
> ok 4 - $h->{0}->i == .0
> ok 5 - '$h->{1}' isa 'Mini::Milk'
> ok 6 - $h->{1}->i == .1
> ok 7 - '$h->{2}' isa 'Mini::Milk'
> ok 8 - $h->{2}->i == .2
> ok 9 - '$h->{3}' isa 'Mini::Milk'
> ok 10 - $h->{3}->i == .3
> ok 11 - '$m->{4}' isa 'Mini::Milk'
> ok 12 - $m->{4}->i == .4
> ok 13 - '$m->{5}' isa 'Mini::Milk'
> ok 14 - $m->{5}->i == .5
> ok 15 - '$m->{6}' isa 'Mini::Milk'
> ok 16 - $m->{6}->i == .6
> ok 17 - '$m->{7}' isa 'Mini::Milk'
> ok 18 - $m->{7}->i == .7
> 1..18
> ok 19 - Hash trait with types HashRef[InstanceOf] and Map[Int,InstanceOf]; and coercion and subtyping
> 1..19
> ok
> t/30-external/Moose/parameterized.t ..........................
> ok 1
> ok 2 - Reference [1,2,3] passes type constraint ArrayRef[Int]
> ok 3 - Reference ["a","b","c"] fails type constraint ArrayRef[Int]
> 1..3
> ok
> t/30-external/MooseX-Getopt/coercion.t .......................
> ok 1 - no exception on coercion in constructor - mutable class
> ok 2 - no exception on coercion in constructor - immutable class
> 1..2
> ok
>
> # Failed test 'An object of class 'Type::Tiny::Union' isa 'Moose::Meta::TypeConstraint''
> # at t/30-external/MooseX-Types/basic.t line 40.
> # The object of class 'Type::Tiny::Union' isn't a 'Moose::Meta::TypeConstraint'
> # Looks like you failed 1 test of 24.
> t/30-external/MooseX-Types/basic.t ...........................
> ok 1 - An object of class 'Moose::Meta::TypeConstraint::Union' isa 'Moose::Meta::TypeConstraint'
> not ok 2 - An object of class 'Type::Tiny::Union' isa 'Moose::Meta::TypeConstraint'
> ok 3 - An object of class 'Type::Tiny::Union' isa 'Type::Tiny'
> ok 4 - Reference [] passes type constraint ArrayRef|Int
> ok 5 - Value "2" passes type constraint ArrayRef|Int
> ok 6 - Reference {} fails type constraint ArrayRef|Int
> ok 7 - Reference [] passes type constraint ArrayRef|Int
> ok 8 - Value "2" passes type constraint ArrayRef|Int
> ok 9 - Reference {} fails type constraint ArrayRef|Int
> ok 10 - Reference [1,2,3] passes type constraint ArrayRef[Int]
> ok 11 - Reference [] passes type constraint ArrayRef[Int]
> ok 12 - Reference {} fails type constraint ArrayRef[Int]
> ok 13 - Reference ["x"] fails type constraint ArrayRef[Int]
> ok 14 - Reference [1,2,3] passes type constraint ArrayRef[Int]
> ok 15 - Reference [] passes type constraint ArrayRef[Int]
> ok 16 - Reference {} fails type constraint ArrayRef[Int]
> ok 17 - Reference ["x"] fails type constraint ArrayRef[Int]
> ok 18 - Reference [] passes type constraint ArrayRef[ArrayRef|Int]
> ok 19 - Reference [1,2,3] passes type constraint ArrayRef[ArrayRef|Int]
> ok 20 - Reference [[],[]] passes type constraint ArrayRef[ArrayRef|Int]
> ok 21 - Reference [11,[]] passes type constraint ArrayRef[ArrayRef|Int]
> ok 22 - Reference [[],11] passes type constraint ArrayRef[ArrayRef|Int]
> ok 23 - Reference ["1.111"] fails type constraint ArrayRef[ArrayRef|Int]
> ok 24 - to_TypeTiny caches results
> 1..24
> Dubious, test returned 1 (wstat 256, 0x100)
> Failed 1/24 subtests
> t/30-external/MooseX-Types/extending.t .......................
> ok 1 - Value "foo" passes type constraint Str
> ok 2 - Value "" passes type constraint Str
> ok 3 - Value "foo" passes type constraint NonEmptyStr
> ok 4 - Value "" fails type constraint NonEmptyStr
> ok 5 - Reference {} passes type constraint HashLike
> ok 6 - Reference [] fails type constraint HashLike
> ok 7 - cannot extend non-type-library
> ok 8 - MooseX::Types coercion works as expected
> ok 9 - Type::Tiny coercion works built from MooseX::Types extension
> 1..9
> ok
>
> # Failed test ''Not' isa 'Moose::Meta::TypeConstraint''
> # at t/30-external/MooseX-Types/more.t line 52.
> # 'Not' isn't a 'Moose::Meta::TypeConstraint'
>
> # Failed test ''~Int' isa 'Moose::Meta::TypeConstraint''
> # at t/30-external/MooseX-Types/more.t line 52.
> # '~Int' isn't a 'Moose::Meta::TypeConstraint'
>
> # Failed test ''Int' isa 'Moose::Meta::TypeConstraint''
> # at t/30-external/MooseX-Types/more.t line 52.
> # 'Int' isn't a 'Moose::Meta::TypeConstraint'
> # Looks like you failed 3 tests of 20.
> t/30-external/MooseX-Types/more.t ............................
> not ok 1 - 'Not' isa 'Moose::Meta::TypeConstraint'
> ok 2 - 'Int' isa 'Moose::Meta::TypeConstraint'
> not ok 3 - '~Int' isa 'Moose::Meta::TypeConstraint'
> not ok 4 - 'Int' isa 'Moose::Meta::TypeConstraint'
> ok 5 - Value "1.1" fails type constraint Int
> ok 6 - Undef fails type constraint Int
> ok 7 - Reference [] fails type constraint Int
> ok 8 - Value "2" passes type constraint Int
> ok 9 - Value "1.1" passes type constraint ~Int
> ok 10 - Undef passes type constraint ~Int
> ok 11 - Reference [] passes type constraint ~Int
> ok 12 - Value "2" fails type constraint ~Int
> ok 13 - Value "1.1" fails type constraint Int
> ok 14 - Undef fails type constraint Int
> ok 15 - Reference [] fails type constraint Int
> ok 16 - Value "2" passes type constraint Int
> ok 17 - Value "1.1" fails type constraint Not
> ok 18 - Undef fails type constraint Not
> ok 19 - Reference [] fails type constraint Not
> ok 20 - Value "2" fails type constraint Not
> 1..20
> Dubious, test returned 3 (wstat 768, 0x300)
> Failed 3/20 subtests
> t/30-external/Mouse/basic.t ..................................
> ok 1 - some values that should pass their type constraint
> ok 2 - direct violation of type constraint
> ok 3 - violation of parent type constraint
> ok 4 - violation of grandparent type constraint
> ok 5 - violation of great-grandparent type constraint
> ok 6 - Mouse::Util::is_a_type_constraint accepts Type::Tiny type constraints
> # Coercion...
> ok 7 - types converted from Mouse retain coercions
> ok 8 - ... which work
> 1..8
> ok
> t/30-external/Mouse/coercion.t ...............................
> ok 1 - An object of class 'Type::Tiny' isa 'Mouse::Meta::TypeConstraint'
> ok 2 - no exception on coercion in constructor - mutable class
> ok 3 - 'big' attribute coerces in constructor - mutable class
> ok 4 - 'small' attribute coerces in constructor - mutable class
> ok 5 - 'big' attribute throws when it cannot coerce in constructor - mutable class
> ok 6 - 'small' attribute throws when it cannot coerce in constructor - mutable class
> ok 7 - 'big' attribute coerces in accessor - mutable class
> ok 8 - 'small' attribute coerces in accessor - mutable class
> ok 9 - 'big' attribute throws when it cannot coerce in accessor - mutable class
> ok 10 - 'small' attribute throws when it cannot coerce in accessor - mutable class
> ok 11 - no exception on coercion in constructor - immutable class
> ok 12 - 'big' attribute coerces in constructor - immutable class
> ok 13 - 'small' attribute coerces in constructor - immutable class
> ok 14 - 'big' attribute throws when it cannot coerce in constructor - immutable class
> ok 15 - 'small' attribute throws when it cannot coerce in constructor - immutable class
> ok 16 - 'big' attribute coerces in accessor - immutable class
> ok 17 - 'small' attribute coerces in accessor - immutable class
> ok 18 - 'big' attribute throws when it cannot coerce in accessor - immutable class
> ok 19 - 'small' attribute throws when it cannot coerce in accessor - immutable class
> 1..19
> ok
> t/30-external/Mouse/parameterized.t ..........................
> ok 1
> ok 2 - Reference [1,2,3] passes type constraint ArrayRef[__ANON__]
> ok 3 - Reference ["a","b","c"] fails type constraint ArrayRef[__ANON__]
> 1..3
> ok
> t/30-external/MouseX-Types/basic.t ...........................
> ok 1 - An object of class 'Mouse::Meta::TypeConstraint' isa 'Mouse::Meta::TypeConstraint'
> ok 2 - An object of class 'Mouse::Meta::TypeConstraint' isa 'Mouse::Meta::TypeConstraint'
> ok 3 - An object of class 'Type::Tiny::Union' isa 'Type::Tiny'
> ok 4 - Reference [] passes type constraint ArrayRef|Int
> ok 5 - Value "2" passes type constraint ArrayRef|Int
> ok 6 - Reference {} fails type constraint ArrayRef|Int
> ok 7 - Reference [] passes type constraint ArrayRef|Int
> ok 8 - Value "2" passes type constraint ArrayRef|Int
> ok 9 - Reference {} fails type constraint ArrayRef|Int
> # bless( {
> # 'compiled_type_constraint' => sub { "DUMMY" },
> # 'constraint' => sub { "DUMMY" },
> # 'definition_context' => {
> # 'file' => 't/30-external/MouseX-Types/basic.t',
> # 'line' => 37,
> # 'package' => 'main'
> # },
> # 'deprecated' => !!0,
> # 'display_name' => 'ArrayRef|Int',
> # 'name' => '__ANON__',
> # 'parent' => undef,
> # 'type_constraints' => [
> # bless( {
> # '_is_core' => 1,
> # '_overload_coderef' => sub { "DUMMY" },
> # '_overrides_assert_return' => !!0,
> # 'coercion' => bless( {
> # '_compiled_type_constraint_check' => sub { "DUMMY" },
> # 'display_name' => 'to_ArrayRef',
> # 'frozen' => 1,
> # 'name' => '__ANON__',
> # 'type_coercion_map' => [],
> # 'type_constraint' => $VAR1->{'type_constraints'}[0]
> # }, 'Type::Coercion' ),
> # 'coercion_generator' => bless( [
> # 'ArrayRef',
> # 'coercion_generator'
> # ], 'Types::Standard::LazyLoad' ),
> # 'compiled_type_constraint' => $VAR1->{'type_constraints'}[0]{'coercion'}{'_compiled_type_constraint_check'},
> # 'constraint' => sub { "DUMMY" },
> # 'constraint_generator' => bless( [
> # 'ArrayRef',
> # 'constraint_generator'
> # ], 'Types::Standard::LazyLoad' ),
> # 'deep_explanation' => bless( [
> # 'ArrayRef',
> # 'deep_explanation'
> # ], 'Types::Standard::LazyLoad' ),
> # 'definition_context' => {
> # 'file' => '/build/reproducible-path/libtype-tiny-perl-2.004000/blib/lib/Types/Standard.pm',
> # 'line' => 513,
> # 'package' => 'Types::Standard'
> # },
> # 'deprecated' => !!0,
> # 'display_name' => 'ArrayRef',
> # 'exception_class' => 'Error::TypeTiny::Assertion',
> # 'inline_generator' => bless( [
> # 'ArrayRef',
> # 'inline_generator'
> # ], 'Types::Standard::LazyLoad' ),
> # 'inlined' => sub { "DUMMY" },
> # 'library' => 'Types::Standard',
> # 'name' => 'ArrayRef',
> # 'parent' => bless( {
> # '_is_core' => 1,
> # '_overload_coderef' => sub { "DUMMY" },
> # '_overrides_assert_return' => !!0,
> # 'coercion' => bless( {
> # '_compiled_type_constraint_check' => sub { "DUMMY" },
> # 'display_name' => 'to_Ref',
> # 'frozen' => 1,
> # 'name' => '__ANON__',
> # 'type_coercion_map' => [],
> # 'type_constraint' => $VAR1->{'type_constraints'}[0]{'parent'}
> # }, 'Type::Coercion' ),
> # 'compiled_type_constraint' => $VAR1->{'type_constraints'}[0]{'parent'}{'coercion'}{'_compiled_type_constraint_check'},
> # 'constraint' => sub { "DUMMY" },
> # 'constraint_generator' => sub { "DUMMY" },
> # 'deep_explanation' => sub { "DUMMY" },
> # 'definition_context' => {
> # 'file' => '/build/reproducible-path/libtype-tiny-perl-2.004000/blib/lib/Types/Standard.pm',
> # 'line' => 428,
> # 'package' => 'Types::Standard'
> # },
> # 'deprecated' => !!0,
> # 'display_name' => 'Ref',
> # 'exception_class' => 'Error::TypeTiny::Assertion',
> # 'inline_generator' => sub { "DUMMY" },
> # 'inlined' => sub { "DUMMY" },
> # 'library' => 'Types::Standard',
> # 'name' => 'Ref',
> # 'parent' => bless( {
> # '_is_core' => 1,
> # '_overload_coderef' => sub { "DUMMY" },
> # '_overrides_assert_return' => !!0,
> # 'coercion' => bless( {
> # '_compiled_type_constraint_check' => sub { "DUMMY" },
> # 'display_name' => 'to_Defined',
> # 'frozen' => 1,
> # 'name' => '__ANON__',
> # 'type_coercion_map' => [],
> # 'type_constraint' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'}
> # }, 'Type::Coercion' ),
> # 'compiled_type_constraint' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'}{'coercion'}{'_compiled_type_constraint_check'},
> # 'complementary_type' => bless( {
> # '_is_core' => 1,
> # '_overload_coderef' => sub { "DUMMY" },
> # '_overrides_assert_return' => !!0,
> # 'coercion' => bless( {
> # '_compiled_type_constraint_check' => sub { "DUMMY" },
> # 'display_name' => 'to_Undef',
> # 'frozen' => 1,
> # 'name' => '__ANON__',
> # 'type_coercion_map' => [],
> # 'type_constraint' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'}{'complementary_type'}
> # }, 'Type::Coercion' ),
> # 'compiled_type_constraint' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'}{'complementary_type'}{'coercion'}{'_compiled_type_constraint_check'},
> # 'complementary_type' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'},
> # 'constraint' => sub { "DUMMY" },
> # 'definition_context' => {
> # 'file' => '/build/reproducible-path/libtype-tiny-perl-2.004000/blib/lib/Types/Standard.pm',
> # 'line' => 245,
> # 'package' => 'Types::Standard'
> # },
> # 'deprecated' => !!0,
> # 'display_name' => 'Undef',
> # 'exception_class' => 'Error::TypeTiny::Assertion',
> # 'inlined' => sub { "DUMMY" },
> # 'library' => 'Types::Standard',
> # 'name' => 'Undef',
> # 'parent' => bless( {
> # '_is_core' => 1,
> # '_overload_coderef' => sub { "DUMMY" },
> # '_overrides_assert_return' => !!0,
> # 'coercion' => bless( {
> # '_compiled_type_constraint_check' => sub { "DUMMY" },
> # 'display_name' => 'to_Item',
> # 'frozen' => 1,
> # 'name' => '__ANON__',
> # 'type_coercion_map' => [],
> # 'type_constraint' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'}{'complementary_type'}{'parent'}
> # }, 'Type::Coercion' ),
> # 'compiled_type_constraint' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'}{'complementary_type'}{'parent'}{'coercion'}{'_compiled_type_constraint_check'},
> # 'constraint' => sub { "DUMMY" },
> # 'definition_context' => {
> # 'file' => '/build/reproducible-path/libtype-tiny-perl-2.004000/blib/lib/Types/Standard.pm',
> # 'line' => 217,
> # 'package' => 'Types::Standard'
> # },
> # 'deprecated' => !!0,
> # 'display_name' => 'Item',
> # 'exception_class' => 'Error::TypeTiny::Assertion',
> # 'inlined' => sub { "DUMMY" },
> # 'library' => 'Types::Standard',
> # 'name' => 'Item',
> # 'parent' => bless( {
> # '_is_core' => 1,
> # '_overload_coderef' => sub { "DUMMY" },
> # '_overrides_assert_return' => !!0,
> # 'coercion' => bless( {
> # '_compiled_type_constraint_check' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'}{'complementary_type'}{'parent'}{'coercion'}{'_compiled_type_constraint_check'},
> # 'display_name' => 'to_Any',
> # 'frozen' => 1,
> # 'name' => '__ANON__',
> # 'type_coercion_map' => [],
> # 'type_constraint' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'}{'complementary_type'}{'parent'}{'parent'}
> # }, 'Type::Coercion' ),
> # 'compiled_type_constraint' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'}{'complementary_type'}{'parent'}{'coercion'}{'_compiled_type_constraint_check'},
> # 'complement_name' => 'None',
> # 'constraint' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'}{'complementary_type'}{'parent'}{'constraint'},
> # 'definition_context' => {
> # 'file' => '/build/reproducible-path/libtype-tiny-perl-2.004000/blib/lib/Types/Standard.pm',
> # 'line' => 211,
> # 'package' => 'Types::Standard'
> # },
> # 'deprecated' => !!0,
> # 'display_name' => 'Any',
> # 'exception_class' => 'Error::TypeTiny::Assertion',
> # 'inlined' => sub { "DUMMY" },
> # 'library' => 'Types::Standard',
> # 'name' => 'Any',
> # 'type_default' => sub { "DUMMY" },
> # 'uniq' => 1
> # }, 'Type::Tiny' ),
> # 'uniq' => 2
> # }, 'Type::Tiny' ),
> # 'type_default' => sub { "DUMMY" },
> # 'uniq' => 6
> # }, 'Type::Tiny' ),
> # 'constraint' => sub { "DUMMY" },
> # 'definition_context' => {
> # 'file' => '/build/reproducible-path/libtype-tiny-perl-2.004000/blib/lib/Types/Standard.pm',
> # 'line' => 253,
> # 'package' => 'Types::Standard'
> # },
> # 'deprecated' => !!0,
> # 'display_name' => 'Defined',
> # 'exception_class' => 'Error::TypeTiny::Assertion',
> # 'inlined' => sub { "DUMMY" },
> # 'library' => 'Types::Standard',
> # 'name' => 'Defined',
> # 'parent' => $VAR1->{'type_constraints'}[0]{'parent'}{'parent'}{'complementary_type'}{'parent'},
> # 'uniq' => 7
> # }, 'Type::Tiny' ),
> # 'uniq' => 16
> # }, 'Type::Tiny' ),
> # 'type_default' => sub { "DUMMY" },
> # 'type_default_generator' => sub { "DUMMY" },
> # 'uniq' => 21
> # }, 'Type::Tiny' ),
> # bless( {
> # 'compiled_type_constraint' => sub { "DUMMY" },
> # 'constraint' => sub { "DUMMY" },
> # 'definition_context' => {
> # 'file' => '/build/reproducible-path/libtype-tiny-perl-2.004000/blib/lib/Types/TypeTiny.pm',
> # 'line' => 772,
> # 'package' => 'Types::TypeTiny'
> # },
> # 'deprecated' => !!0,
> # 'display_name' => 'Int',
> # 'message' => sub { "DUMMY" },
> # 'name' => '__ANON__',
> # 'uniq' => 40
> # }, 'Type::Tiny' )
> # ],
> # 'uniq' => 41
> # }, 'Type::Tiny::Union' )
> ok 10 - Reference [1,2,3] passes type constraint ArrayRef[Int]
> ok 11 - Reference [] passes type constraint ArrayRef[Int]
> ok 12 - Reference {} fails type constraint ArrayRef[Int]
> ok 13 - Reference ["x"] fails type constraint ArrayRef[Int]
> ok 14 - Reference [1,2,3] passes type constraint ArrayRef[Int]
> ok 15 - Reference [] passes type constraint ArrayRef[Int]
> ok 16 - Reference {} fails type constraint ArrayRef[Int]
> ok 17 - Reference ["x"] fails type constraint ArrayRef[Int]
> ok 18 - Reference [] passes type constraint ArrayRef[ArrayRef|Int]
> ok 19 - Reference [1,2,3] passes type constraint ArrayRef[ArrayRef|Int]
> ok 20 - Reference [[],[]] passes type constraint ArrayRef[ArrayRef|Int]
> ok 21 - Reference [11,[]] passes type constraint ArrayRef[ArrayRef|Int]
> ok 22 - Reference [[],11] passes type constraint ArrayRef[ArrayRef|Int]
> ok 23 - Reference ["1.111"] fails type constraint ArrayRef[ArrayRef|Int]
> 1..23
> ok
> t/30-external/MouseX-Types/extending.t .......................
> ok 1 - Value "foo" passes type constraint Str
> ok 2 - Value "" passes type constraint Str
> ok 3 - Value "foo" passes type constraint NonEmptyStr
> ok 4 - Value "" fails type constraint NonEmptyStr
> ok 5 - Reference {} passes type constraint HashLike
> ok 6 - Reference [] fails type constraint HashLike
> ok 7 - cannot extend non-type-library
> 1..7
> ok
> t/30-external/Object-Accessor/basic.t ........................
> ok 1 - write then read on accessor works
> ok 2 - exception thrown for bad value
> 1..2
> ok
> t/30-external/Return-Type/basic.t ............................
> # Subtest: simple return type constraint
> # Subtest: scalar context
> ok 1
> ok 2
> 1..2
> ok 1 - scalar context
> # Subtest: list context
> ok 1
> ok 2
> 1..2
> ok 2 - list context
> 1..2
> ok 1 - simple return type constraint
> # Subtest: more complex return type constraint
> # Subtest: scalar context
> ok 1
> not ok 2 # TODO this seems to fail: error in Return::Type??
> # Failed (TODO) test at t/30-external/Return-Type/basic.t line 116.
> # got: undef
> # expected: anything else
> 1..2
> ok 1 - scalar context
> # Subtest: list context
> ok 1
> ok 2
> 1..2
> ok 2 - list context
> 1..2
> ok 2 - more complex return type constraint
> 1..2
> ok
> t/30-external/Specio/basic.t .................................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> 1..5
> ok
> t/30-external/Specio/library.t ...............................
> ok 1 - Value "1" passes type constraint Int
> ok 2 - Reference [] passes type constraint ArrayRef
> ok 3 - Value "1" fails type constraint ArrayRef
> ok 4 - Reference [] fails type constraint Int
> 1..4
> ok
> t/30-external/Sub-Quote/basic.t ..............................
> ok 1 - Value "41" fails type constraint Type1
> ok 2 - Value "42" passes type constraint Type1
> ok 3 - constraint built using quote_sub and $_[0] can be inlined
> # do { package Type::Tiny; do { local $_ = $value;local @_ = ($value); # BEGIN quote_sub PRELUDE
> # package main;
> # BEGIN {
> # $^H = 2018;
> # ${^WARNING_BITS} = "UUUUUUUUUUUUUUUUUUUU";
> # %^H = (
> # );
> # }
> # # END quote_sub PRELUDE
> # $_[0] eq q(42) } }
> ok 4 - Value "41" fails type constraint Type2
> ok 5 - Value "42" passes type constraint Type2
> ok 6 - constraint built using quote_sub and $_[0] can be inlined
> # do { package Type::Tiny; do { local $_ = $value;local @_ = ($value); # BEGIN quote_sub PRELUDE
> # package main;
> # BEGIN {
> # $^H = 2018;
> # ${^WARNING_BITS} = "UUUUUUUUUUUUUUUUUUUU";
> # %^H = (
> # );
> # }
> # # END quote_sub PRELUDE
> # $_ eq q(42) } }
> ok 7 - Value "41" fails type constraint Type3
> ok 8 - Value "42" passes type constraint Type3
> ok 9 - constraint built using quote_sub and @_ can be inlined
> # do { package Type::Tiny; do { local $_ = $value;# BEGIN quote_sub PRELUDE
> # package main;
> # BEGIN {
> # $^H = 2018;
> # ${^WARNING_BITS} = "UUUUUUUUUUUUUUUUUUUU";
> # %^H = (
> # );
> # }
> # # END quote_sub PRELUDE
> # my ($n) = ($value); $n eq q(42) } }
> ok 10 - Value "41" fails type constraint Type4
> ok 11 - Value "42" passes type constraint Type4
> ok 12 - Value "43" passes type constraint Type4
> ok 13 - Value "44.4" fails type constraint Type4
> ok 14 - constraint built using quote_sub and parent type can be inlined
> # do { package Type::Tiny; (do { my $tmp = $value; defined($tmp) and !ref($tmp) and $tmp =~ /\A-?[0-9]+\z/ }) and do { local $_ = $value;local @_ = ($value); # BEGIN quote_sub PRELUDE
> # package main;
> # BEGIN {
> # $^H = 2018;
> # ${^WARNING_BITS} = "UUUUUUUUUUUUUUUUUUUU";
> # %^H = (
> # );
> # }
> # # END quote_sub PRELUDE
> # $_[0] >= 42 } }
> ok 15 - Value "41" fails type constraint Type5
> ok 16 - Value "42" passes type constraint Type5
> ok 17 - Value "43" passes type constraint Type5
> ok 18 - Value "44.4" fails type constraint Type5
> not ok 19 - constraint built using quote_sub and captures can be inlined # TODO captures not supported yet
> # Failed (TODO) test 'constraint built using quote_sub and captures can be inlined'
> # at t/30-external/Sub-Quote/basic.t line 93.
> ok 20 - Value "41" fails type constraint Type6
> ok 21 - Value "42" passes type constraint Type6
> ok 22 - Value "43" passes type constraint Type6
> ok 23 - Value "44.4" fails type constraint Type6
> ok 24 - constraint built using quote_sub and non-inlinable parent cannot be inlined
> ok 25 - Reference [1,2,3] passes type constraint ArrayRef[Int]&__ANON__
> ok 26 - Reference [1,"2.1",3] fails type constraint ArrayRef[Int]&__ANON__
> ok 27 - Reference [1] fails type constraint ArrayRef[Int]&__ANON__
> ok 28 - Reference [1,2,3,4] fails type constraint ArrayRef[Int]&__ANON__
> ok 29 - constraint built as an intersection of an inlinable type constraint and a quoted sub can be inlined
> # ((Type::Tiny::XS::AUTO::TC1($VAR)) and do { package Type::Tiny; do { local $_ = $VAR;local @_ = ($VAR); !!eval{ # BEGIN quote_sub PRELUDE
> # package main;
> # BEGIN {
> # $^H = 2018;
> # ${^WARNING_BITS} = "UUUUUUUUUUUUUUUUUUUU";
> # %^H = (
> # );
> # }
> # # END quote_sub PRELUDE
> # @$_ > 1 and @$_ < 4 } } })
> 1..29
> ok
> t/30-external/Sub-Quote/delayed-quoting.t ....................
> ok 1 - overload coderef gets cached instead of being rebuilt
> ok 2 - loading Sub::Quote triggers rebuilding overload coderef
> ok 3 - overload coderef gets cached again instead of being rebuilt
> 1..3
> ok
> t/30-external/Sub-Quote/unquote-coercions.t ..................
> ok 1 - Got back code from Sub::Quote
> ok 2 - ... which compiles OK
> ok 3 - ... which passes through values that don't need to be coerced
> ok 4 - ... coerces values that can be coerced
> ok 5 - ... and passes through any values it can't handle
> 1..5
> ok
> t/30-external/Sub-Quote/unquote-constraints.t ................
> ok 1 - Got back code from Sub::Quote
> ok 2 - ... which compiles OK
> ok 3 - ... and seems to work
> ok 4 - ... and throws exceptions properly
> 1..4
> ok
> t/30-external/Switcheroo/basic.t ............................. skipped: requires Switcheroo
> t/30-external/Type-Library-Compiler/basic.t ..................
> ok 1 - An object of class 'Type::Tiny' isa 'Type::Tiny'
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7 - An object of class 'Type::Tiny' isa 'Type::Tiny'
> ok 8
> ok 9
> 1..9
> ok
> t/30-external/Types-ReadOnly/basic.t ......................... skipped: requires Types::ReadOnly
> t/30-external/Validation-Class-Simple/archaic.t ..............
> ok 1 - 'can create a child type constraint from Validation::Class::Simple' isa 'Type::Tiny'
> ok 2 - Value "Hello" fails type constraint __ANON__
> ok 3 - Reference {} fails type constraint __ANON__
> ok 4 - Reference {"email" => "tobyink\@cpan.org","name" => "Toby","pass" => "...} fails type constraint __ANON__
> ok 5 - Reference {"email" => "tobyink\@cpan.org","name" => "Toby","pass" => "...} passes type constraint __ANON__
> ok 6 - Reference {"email" => "tobyink\@cpan.org","name" => "Toby ","pass" => ...} fails type constraint __ANON__
> ok 7 - correct error message (A)
> ok 8 - correct error message (B)
> ok 9 - the type has a coercion
> ok 10 - ... which works
> 1..10
> ok
> t/30-external/Validation-Class-Simple/basic.t ................
> ok 1 - Reference bless( {}, 'Validation::Class::Simple' ) passes type constraint _ForeignTypeConstraint
> ok 2 - Reference bless( {"_validation_class" => bless( {}, 'Validation::Class...) fails type constraint _ForeignTypeConstraint
> ok 3 - 'can create a child type constraint from Validation::Class::Simple' isa 'Type::Tiny'
> ok 4 - Value "Hello" fails type constraint __ANON__
> ok 5 - Reference {} fails type constraint __ANON__
> ok 6 - Reference {"email" => "tobyink\@cpan.org","name" => "Toby","pass" => "...} fails type constraint __ANON__
> ok 7 - Reference {"email" => "tobyink\@cpan.org","name" => "Toby","pass" => "...} passes type constraint __ANON__
> ok 8 - Reference {"email" => "tobyink\@cpan.org","name" => "Toby ","pass" => ...} fails type constraint __ANON__
> ok 9 - correct error message (A)
> ok 10 - correct error message (B)
> ok 11 - the type has a coercion
> ok 12 - ... which works
> 1..12
> ok
> t/40-bugs/73f51e2d.t .........................................
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> ok 11
> ok 12
> ok 13
> ok 14
> ok 15
> ok 16
> ok 17
> ok 18
> ok 19
> ok 20
> ok 21
> ok 22
> ok 23
> ok 24
> ok 25
> ok 26
> ok 27
> ok 28
> ok 29
> ok 30
> ok 31
> ok 32
> ok 33
> ok 34
> ok 35
> ok 36
> ok 37
> ok 38
> ok 39
> ok 40
> ok 41
> ok 42
> ok 43
> ok 44
> ok 45
> ok 46
> ok 47
> ok 48
> ok 49
> ok 50
> ok 51
> ok 52
> ok 53
> ok 54
> ok 55
> ok 56
> ok 57
> ok 58
> ok 59
> ok 60
> ok 61
> ok 62
> ok 63
> ok 64
> ok 65
> ok 66
> ok 67
> ok 68
> ok 69
> ok 70
> ok 71
> ok 72
> ok 73
> ok 74
> ok 75
> ok 76
> ok 77
> ok 78
> ok 79
> ok 80
> ok 81
> ok 82
> ok 83
> ok 84
> ok 85
> ok 86
> ok 87
> ok 88
> ok 89
> ok 90
> ok 91
> ok 92
> ok 93
> ok 94
> ok 95
> ok 96
> ok 97
> ok 98
> ok 99
> ok 100
> 1..100
> ok
> t/40-bugs/gh1.t ..............................................
> ok 1
> ok 2 - Reference bless( {"_e" => bless( [1], 'Math::BigInt::Calc' ),"_es" => ...) passes type constraint __ANON__
> ok 3 - Value "0.5" fails type constraint __ANON__
> 1..3
> ok
> t/40-bugs/gh14.t .............................................
> ok 1
> ok 2
> 1..2
> ok
> t/40-bugs/gh80.t .............................................
> ok 1 - '$@' isa 'Error::TypeTiny'
> ok 2 - $@ is still defined and stringifies properly
> 1..2
> ok
> t/40-bugs/gh96.t .............................................
> ok 1 - don't include linebreaks!
> 1..1
> ok
> t/40-bugs/rt102748.t ......................................... skipped: requires MooseX::Types::DBIx::Class
> t/40-bugs/rt104154.t .........................................
> ok 1
> ok 2
> 1..2
> ok
> t/40-bugs/rt121763.t .........................................
> ok 1
> 1..1
> ok
> t/40-bugs/rt125132.t .........................................
> # Subtest: using temporary variable
> ok 1 - check_int_tt_compile
> ok 2 - check_int_manual
> ok 3 - check_str_tt
> ok 4 - check_int_tt_no_compile
> 1..4
> ok 1 - using temporary variable
> # Subtest: using direct $1
> ok 1 - check_int_tt_compile
> ok 2 - check_int_manual
> ok 3 - check_str_tt
> ok 4 - check_int_tt_no_compile
> 1..4
> ok 2 - using direct $1
> 1..2
> ok
> t/40-bugs/rt125765.t .........................................
> ok 1 - got correct error for Dict
> ok 2 - no warnings
> ok 3 - got correct error for Tuple
> ok 4 - no warnings
> 1..4
> ok
> t/40-bugs/rt129729.t .........................................
> ok 1 - Value "1" passes type constraint Bool|Enum["start-end","end"]
> ok 2 - Value "0" passes type constraint Bool|Enum["start-end","end"]
> ok 3 - Value "2" fails type constraint Bool|Enum["start-end","end"]
> ok 4 - Value "end" passes type constraint Bool|Enum["start-end","end"]
> ok 5 - Value "bend" fails type constraint Bool|Enum["start-end","end"]
> ok 6 - Value "start" fails type constraint Bool|Enum["start-end","end"]
> ok 7 - Value "start-" fails type constraint Bool|Enum["start-end","end"]
> ok 8 - Value "-end" fails type constraint Bool|Enum["start-end","end"]
> ok 9 - Value "start-end" passes type constraint Bool|Enum["start-end","end"]
> 1..9
> ok
> t/40-bugs/rt130823.t .........................................
> ok 1 - Bool has no cycles
> 1..1
> ok
> t/40-bugs/rt131401.t .........................................
> 1..1
> ok 1
> ok
> t/40-bugs/rt131576.t ......................................... skipped: requires MooX::TypeTiny
> t/40-bugs/rt133141.t .........................................
> 1..10
> ok 1 - "a" matches Enum[qw(a b)]
> ok 2 - "c" does not match Enum[qw(a b)]
> ok 3 - "foo bar" matches Enum["foo bar"]
> ok 4 - "baz" does not match Enum["foo bar"]
> ok 5 - "test\"" matches Enum["test\""]
> ok 6 - "baz" does not match Enum["test\""]
> ok 7 - "hello, world" matches Enum["hello, world"]
> ok 8 - "baz" does not match Enum["hello, world"]
> ok 9 - eval_type() evaluates quoted strings
> ok 10 - eval_type() evaluates quoted strings and doesn't pass 'baz'
> ok
> t/40-bugs/rt85911.t ..........................................
> ok 1
> ok 2
> 1..2
> ok
> t/40-bugs/rt86004.t ..........................................
> ok 1 - StrList ArrayRef
> ok 2 - StrList scalar
> ok 3 - StrList ArrayRef
> ok 4 - StrList scalar
> ok 5 - StrList ArrayRef - noninline
> ok 6 - StrList scalar - noninline
> 1..6
> ok
> t/40-bugs/rt86233.t ..........................................
> ok 1
> ok 2
> ok 3
> 1..3
> ok
> t/40-bugs/rt86239.t ..........................................
> # Test 1 ########
> # got: foo
> ok 1
> # Test 2 ########
> # got:
> ok 2
> # Test 3 ########
> ok 3
> # Test 4 ########
> # got: {
> # 'foo' => 'foo'
> # }
> ok 4
> # Test 5 ########
> # got: {}
> ok 5
> # Test 6 ########
> ok 6
> 1..6
> ok
> t/40-bugs/rt90096-2.t ........................................
> ok 1 - check is still code
> ok 2 - slurpy check is still code
> 1..2
> ok
> t/40-bugs/rt90096.t ..........................................
> 1..3
> ok 1
> ok 2
> ok 3
> ok
> t/40-bugs/rt92571-2.t ........................................
> ok 1
> 1..1
> ok
> t/40-bugs/rt92571.t ..........................................
> ok 1
> ok 2
> ok 3
> 1..3
> ok
> t/40-bugs/rt92591.t ..........................................
> ok 1 - Type library, coercion target
> ok 2 - Type library, coercion type map
> ok 3 - Not type library, coercion target
> ok 4 - Not type library, coercion type map
> 1..4
> ok
> t/40-bugs/rt94196.t ..........................................
> ok 1 - slurpy Dict w/ HasMethods
> 1..1
> ok
> t/40-bugs/rt97684.t ..........................................
> ok 1
> 1..1
> ok
> t/40-bugs/rt98113.t ..........................................
> ok 1 - Type::Tiny overload fallback works
> ok 2 - Type::Coercion overload fallback works
> 1..2
> ok
> t/40-bugs/ttxs-gh1.t .........................................
> ok 1 - Test TestDictionary
> 1..1
> ok
> t/98-param-eg-from-docs.t ....................................
> ok 1 - Value "0" passes type constraint MultipleOf[3]
> ok 2 - Value "1" fails type constraint MultipleOf[3]
> ok 3 - Value "2" fails type constraint MultipleOf[3]
> ok 4 - Value "3" passes type constraint MultipleOf[3]
> ok 5 - Value "4" fails type constraint MultipleOf[3]
> ok 6 - Value "5" fails type constraint MultipleOf[3]
> ok 7 - Value "6" passes type constraint MultipleOf[3]
> ok 8 - Value "7" fails type constraint MultipleOf[3]
> ok 9 - Value "-1" fails type constraint MultipleOf[3]
> ok 10 - Value "-3" passes type constraint MultipleOf[3]
> ok 11 - Value "0.1" fails type constraint MultipleOf[3]
> ok 12 - Reference [] fails type constraint MultipleOf[3]
> ok 13 - Undef fails type constraint MultipleOf[3]
> # Subtest: coercion
> ok 1
> ok 2
> ok 3
> ok 4
> ok 5
> ok 6
> ok 7
> ok 8
> ok 9
> ok 10
> 1..10
> ok 14 - coercion
> 1..14
> ok
> t/99-moose-std-types-test.t .................................. skipped: EXTENDED_TESTING
>
> Test Summary Report
> -------------------
> t/30-external/MooseX-Types/basic.t (Wstat: 256 (exited 1) Tests: 24 Failed: 1)
> Failed test: 2
> Non-zero exit status: 1
> t/30-external/MooseX-Types/more.t (Wstat: 768 (exited 3) Tests: 20 Failed: 3)
> Failed tests: 1, 3-4
> Non-zero exit status: 3
> Files=347, Tests=8956, 48 wallclock secs ( 1.45 usr 0.49 sys + 41.41 cusr 6.06 csys = 49.41 CPU)
> Result: FAIL
> Failed 2/347 test programs. 4/8956 subtests failed.
> make[1]: *** [Makefile:1050: test_dynamic] Error 255
> make[1]: Leaving directory '/build/reproducible-path/libtype-tiny-perl-2.004000'
> dh_auto_test: error: make -j8 test TEST_VERBOSE=1 returned exit code 2
The full build log is available from:
http://qa-logs.debian.net/2025/04/29/libtype-tiny-perl_2.004000-1_unstable.log
All bugs filed during this archive rebuild are listed at:
https://bugs.debian.org/cgi-bin/pkgreport.cgi?tag=ftbfs-20250429;users=lucas@debian.org
or:
https://udd.debian.org/bugs/?release=na&merged=ign&fnewerval=7&flastmodval=7&fusertag=only&fusertagtag=ftbfs-20250429&fusertaguser=lucas@debian.org&allbugs=1&cseverity=1&ctags=1&caffected=1#results
A list of current common problems and possible solutions is available at
http://wiki.debian.org/qa.debian.org/FTBFS . You're welcome to contribute!
If you reassign this bug to another package, please mark it as 'affects'-ing
this package. See https://www.debian.org/Bugs/server-control#affects
If you fail to reproduce this, please provide a build log and diff it with mine
so that we can identify if something relevant changed in the meantime.
More information about the pkg-perl-maintainers
mailing list