X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=t%2F06-api.t;h=cbfb6873e36b90137934ac7e194787599a8eea53;hb=179af711f82dd08536a45a6d915978e6bd59d433;hp=00c7686f7d64a39aca7d18850839a77697380ae0;hpb=a4a88fefad0246cc6b5eea44874bcfb2ff34253d;p=gitmo%2FMooseX-Types-Structured.git diff --git a/t/06-api.t b/t/06-api.t index 00c7686..cbfb687 100644 --- a/t/06-api.t +++ b/t/06-api.t @@ -1,69 +1,155 @@ BEGIN { use strict; use warnings; - use Test::More tests=>12; - use Test::Exception; + use Test::More tests=>83; } -{ - ## Tests for the Moose::Meta::TypeConstraints API stuff (equals, etc) - package Test::MooseX::Meta::TypeConstraint::Structured::API; - - use Moose; - use MooseX::Types::Structured qw(Dict Tuple); - use MooseX::Types::Moose qw(Int Str Object ArrayRef HashRef); - use MooseX::Types -declare => [qw( - MyDict1 MyDict2 MyDict3 subMyDict3 - MyTuple1 MyTuple2 MyTuple3 subMyTuple3 - )]; - - ## Create some sample Dicts - - my $MyDict1 = subtype MyDict1, - as Dict[name=>Str, age=>Int]; - - my $MyDict2 = subtype MyDict2, - as Dict[name=>Str, age=>Int]; - - my $MyDict3 = subtype MyDict3, - as Dict[key=>Int, anotherkey=>Str]; - - my $subMyDict3 = subtype subMyDict3, - as MyDict3; - - ## Create some sample Tuples - - my $MyTuple1 = subtype MyTuple1, - as Tuple[Int,Int,Str]; - - my $MyTuple2 = subtype MyTuple2, - as Tuple[Int,Int,Str]; - - my $MyTuple3 = subtype MyTuple3, - as Tuple[Object, HashRef]; - - my $subMyTuple3 = subtype subMyTuple3, - as MyTuple3; -} +use Moose::Util::TypeConstraints; +use MooseX::Types::Structured qw(Dict Tuple); +use MooseX::Types::Moose qw(Int Str Item Object ArrayRef HashRef); +use MooseX::Types -declare => [qw( + MyDict1 MyDict2 MyDict3 MyDict4 subMyDict3 subMyDict1 + MyTuple1 MyTuple2 MyTuple3 subMyTuple3 +)]; + +## Create some sample Dicts + +subtype MyDict1, + as Dict[name=>Str, age=>Int]; + +subtype subMyDict1, + as MyDict1; + +subtype MyDict2, + as Dict[name=>Str, age=>Int]; + +subtype MyDict3, + as Dict[key=>Int, anotherkey=>Str]; + +subtype subMyDict3, + as MyDict3; + +subtype MyDict4, + as Dict[name=>Str, age=>Item]; + +## Create some sample Tuples + +subtype MyTuple1, + as Tuple[Int,Int,Str]; + +subtype MyTuple2, + as Tuple[Int,Int,Str]; + +subtype MyTuple3, + as Tuple[Object, HashRef]; + +subtype subMyTuple3, + as MyTuple3; ## Test equals -ok $MyDict1->equals($MyDict2), '$MyDict1 == $MyDict2'; -ok $MyDict2->equals($MyDict1), '$MyDict2 == $MyDict1'; -ok ! $MyDict1->equals($MyDict3), '$MyDict1 == $MyDict3'; -ok ! $MyDict2->equals($MyDict3), '$MyDict2 == $MyDict3'; -ok ! $MyDict3->equals($MyDict2), '$MyDict3 == $MyDict2'; -ok ! $MyDict3->equals($MyDict1), '$MyDict3 == $MyDict1'; +ok ( MyDict1->equals(MyDict2), 'MyDict1 == MyDict2'); +ok ( MyDict2->equals(MyDict1), 'MyDict2 == MyDict1'); +ok (!MyDict1->equals(MyDict3), 'MyDict1 == MyDict3'); +ok (!MyDict2->equals(MyDict3), 'MyDict2 == MyDict3'); +ok (!MyDict3->equals(MyDict2), 'MyDict3 == MyDict2'); +ok (!MyDict3->equals(MyDict1), 'MyDict3 == MyDict1'); -ok $MyTuple1->equals($MyTuple2), '$MyTuple1 == $MyTuple2'; -ok $MyTuple2->equals($MyTuple1), '$MyTuple2 == $MyTuple1'; -ok ! $MyTuple1->equals($MyTuple3), '$MyTuple1 == $MyTuple3'; -ok ! $MyTuple2->equals($MyTuple3), '$MyTuple2 == $MyTuple3'; -ok ! $MyTuple3->equals($MyTuple2), '$MyTuple3 == $MyTuple2'; -ok ! $MyTuple3->equals($MyTuple1), '$MyTuple3 == $MyTuple1'; +ok ( MyTuple1->equals(MyTuple2), 'MyTuple1 == MyTuple2'); +ok ( MyTuple2->equals(MyTuple1), 'MyTuple2 == MyTuple1'); +ok (!MyTuple1->equals(MyTuple3), 'MyTuple1 == MyTuple3'); +ok (!MyTuple2->equals(MyTuple3), 'MyTuple2 == MyTuple3'); +ok (!MyTuple3->equals(MyTuple2), 'MyTuple3 == MyTuple2'); +ok (!MyTuple3->equals(MyTuple1), 'MyTuple3 == MyTuple1'); + +ok ( MyDict1->equals(MyDict2), 'MyDict1 == MyDict2'); +ok ( MyDict2->equals(MyDict1), 'MyDict2 == MyDict1'); +ok (!MyDict1->equals(MyDict3), 'MyDict1 == MyDict3'); +ok (!MyDict1->equals(MyDict4), 'MyDict1 == MyDict3'); +ok (!MyDict2->equals(MyDict3), 'MyDict2 == MyDict3'); +ok (!MyDict2->equals(MyDict4), 'MyDict2 == MyDict3'); +ok (!MyDict3->equals(MyDict2), 'MyDict3 == MyDict2'); +ok (!MyDict3->equals(MyDict4), 'MyDict3 == MyDict2'); +ok (!MyDict3->equals(MyDict1), 'MyDict3 == MyDict1'); +ok (!MyDict4->equals(MyDict1), 'MyDict3 == MyDict1'); +ok (!MyDict4->equals(MyDict2), 'MyDict3 == MyDict1'); +ok (!MyDict4->equals(MyDict3), 'MyDict3 == MyDict1'); + +ok ( MyTuple1->equals(MyTuple2), 'MyTuple1 == MyTuple2'); +ok ( MyTuple2->equals(MyTuple1), 'MyTuple2 == MyTuple1'); +ok (!MyTuple1->equals(MyTuple3), 'MyTuple1 == MyTuple3'); +ok (!MyTuple2->equals(MyTuple3), 'MyTuple2 == MyTuple3'); +ok (!MyTuple3->equals(MyTuple2), 'MyTuple3 == MyTuple2'); +ok (!MyTuple3->equals(MyTuple1), 'MyTuple3 == MyTuple1'); ## Test is_a_type_of +ok ( MyDict1->is_a_type_of(HashRef), 'MyDict1 is_a_type_of HashRef'); +ok ( MyDict1->is_a_type_of(Dict), 'MyDict1 is_a_type_of Dict'); +ok (!MyDict1->is_a_type_of(Tuple), 'MyDict1 NOT is_a_type_of Tuple'); +ok ( MyDict1->is_a_type_of(MyDict2), 'MyDict1 is_a_type_of MyDict2'); +ok ( MyDict2->is_a_type_of(MyDict1), 'MyDict2 is_a_type_of MyDict1'); +ok (!MyDict1->is_a_type_of(MyDict3), 'MyDict1 NOT is_a_type_of MyDict3'); +ok (!MyDict2->is_a_type_of(MyDict3), 'MyDict2 NOT is_a_type_of MyDict3'); +ok ( subMyDict1->is_a_type_of(Dict), 'subMyDict1 type of Dict'); +ok ( subMyDict1->is_a_type_of(MyDict1), 'subMyDict1 type of MyDict1'); +ok ( subMyDict1->is_a_type_of(subMyDict1), 'subMyDict1 type of subMyDict1'); +ok ( subMyDict1->is_a_type_of(MyDict2), 'subMyDict1 type of MyDict2'); +ok ( MyDict4->is_a_type_of(HashRef), 'MyDict4 is_a_type_of HashRef'); +ok ( MyDict4->is_a_type_of(Dict), 'MyDict4 is_a_type_of Dict'); +ok (!MyDict4->is_a_type_of(Tuple), 'MyDict4 NOT is_a_type_of Tuple'); +ok (!MyDict4->is_a_type_of(MyDict2), 'MyDict4 NOT is_a_type_of MyDict2'); +ok ( MyDict2->is_a_type_of(MyDict4), 'MyDict2 is_a_type_of MyDict4'); +ok (!MyDict4->is_a_type_of(MyDict3), 'MyDict4 NOT is_a_type_of MyDict3'); + + +ok ( MyTuple1->is_a_type_of(Tuple), 'MyTuple1 is_a_type_of Tuple'); +ok (!MyTuple1->is_a_type_of(Dict), 'MyTuple1 NOT is_a_type_of Dict'); +ok ( MyTuple1->is_a_type_of(MyTuple2), 'MyTuple1 is_a_type_of MyTuple2'); +ok ( MyTuple2->is_a_type_of(MyTuple1), 'MyTuple2 is_a_type_of MyTuple1'); +ok (!MyTuple1->is_a_type_of(MyTuple3), 'MyTuple1 NOT is_a_type_of MyTuple3'); +ok (!MyTuple2->is_a_type_of(MyTuple3), 'MyTuple2 NOT is_a_type_of MyTuple3'); + ## is_subtype_of +ok ( MyDict1->is_subtype_of(HashRef), 'MyDict1 is_subtype_of HashRef'); +ok ( MyDict1->is_subtype_of(Dict), 'MyDict1 is_subtype_of Dict'); +ok ( MyDict1->is_subtype_of(MyDict4), 'MyDict1 is_subtype_of MyDict4'); +ok (!MyDict1->is_subtype_of(Tuple), 'MyDict1 NOT is_subtype_of Tuple'); +ok (!MyDict1->is_subtype_of(MyDict2), 'MyDict1 NOT is_subtype_of MyDict2'); +ok (!MyDict2->is_subtype_of(MyDict1), 'MyDict2 NOT is_subtype_of MyDict1'); +ok (!MyDict1->is_subtype_of(MyDict3), 'MyDict1 NOT is_subtype_of MyDict3'); +ok (!MyDict2->is_subtype_of(MyDict3), 'MyDict2 NOT is_subtype_of MyDict3'); +ok ( subMyDict1->is_subtype_of(Dict), 'subMyDict1 is_subtype_of Dict'); +ok ( subMyDict1->is_subtype_of(MyDict1), 'subMyDict1 is_subtype_of MyDict1'); +ok (!subMyDict1->is_subtype_of(subMyDict1), 'subMyDict1 NOT is_subtype_of subMyDict1'); +ok ( subMyDict1->is_subtype_of(MyDict2), 'subMyDict1 is_subtype_of MyDict2'); + +ok ( MyTuple1->is_subtype_of(Tuple), 'MyTuple1 is_subtype_of Tuple'); +ok (!MyTuple1->is_subtype_of(Dict), 'MyTuple1 NOT is_subtype_of Dict'); +ok (!MyTuple1->is_subtype_of(MyTuple2), 'MyTuple1 is_subtype_of MyTuple2'); +ok (!MyTuple2->is_subtype_of(MyTuple1), 'MyTuple2 is_subtype_of MyTuple1'); +ok (!MyTuple1->is_subtype_of(MyTuple3), 'MyTuple1 NOT is_subtype_of MyTuple3'); +ok (!MyTuple2->is_subtype_of(MyTuple3), 'MyTuple2 NOT is_subtype_of MyTuple3'); +## Test manual parameterizing + +PARAMETERIZE: { + + ok (my $int = Moose::Util::TypeConstraints::find_or_parse_type_constraint('Int'), 'Got Int'); + ok (my $str = Moose::Util::TypeConstraints::find_or_parse_type_constraint('Str'), 'Got Str'); + ok (my $hashref = Moose::Util::TypeConstraints::find_or_parse_type_constraint('HashRef[Int]'), 'Got HashRef'); + + ## Test Dict->parameterize + ok (my $test_dict = Dict(), 'Created Test Dict'); + ok (my $person = $test_dict->parameterize(name=>$str, age=>$int), 'Parameterized It'); + ok ($person->check({name=>'John', age=>21}), 'Passed'); + ok ($person->check({age=>25, name=>'User'}), 'Passed'); + + ## Test Tuple->parameterize + ok (my $test_tuple = Tuple(), 'Created Test Tuple'); + ok (my $int_and_hashref = $test_tuple->parameterize($int, $hashref), 'Parameterized It'); + ok ($int_and_hashref->check([1, {key=>2, key2=>3}]), "Passed"); + ok (!$int_and_hashref->check(['a', {key=>2, key2=>3}]), "Not Passed"); + ok (!$int_and_hashref->check([1, {key=>'a', key2=>3}]), "Not Passed"); +}