[gitmo/MooseX-Types-Structured.git] / t / 06-api.t

BEGIN {
	use strict;
	use warnings;
	use Test::More tests=>83;
}

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 ( 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");
}
Commit	Line	Data
a4a88fef	1	BEGIN {
	2	use strict;
	3	use warnings;
179af711	4	use Test::More tests=>83;
a4a88fef	5	}
a4a88fef	6
e327145a	7	use Moose::Util::TypeConstraints;
16aea7bf	8	use MooseX::Types::Structured qw(Dict Tuple);
179af711	9	use MooseX::Types::Moose qw(Int Str Item Object ArrayRef HashRef);
16aea7bf	10	use MooseX::Types -declare => [qw(
179af711	11	MyDict1 MyDict2 MyDict3 MyDict4 subMyDict3 subMyDict1
16aea7bf	12	MyTuple1 MyTuple2 MyTuple3 subMyTuple3
	13	)];
	14
	15	## Create some sample Dicts
	16
	17	subtype MyDict1,
	18	as Dict[name=>Str, age=>Int];
	19
	20	subtype subMyDict1,
	21	as MyDict1;
	22
	23	subtype MyDict2,
	24	as Dict[name=>Str, age=>Int];
	25
	26	subtype MyDict3,
	27	as Dict[key=>Int, anotherkey=>Str];
	28
	29	subtype subMyDict3,
	30	as MyDict3;
	31
179af711	32	subtype MyDict4,
	33	as Dict[name=>Str, age=>Item];
	34
16aea7bf	35	## Create some sample Tuples
	36
	37	subtype MyTuple1,
	38	as Tuple[Int,Int,Str];
	39
	40	subtype MyTuple2,
	41	as Tuple[Int,Int,Str];
	42
	43	subtype MyTuple3,
	44	as Tuple[Object, HashRef];
	45
	46	subtype subMyTuple3,
	47	as MyTuple3;
a4a88fef	48
	49	## Test equals
	50
16aea7bf	51	ok ( MyDict1->equals(MyDict2), 'MyDict1 == MyDict2');
	52	ok ( MyDict2->equals(MyDict1), 'MyDict2 == MyDict1');
	53	ok (!MyDict1->equals(MyDict3), 'MyDict1 == MyDict3');
	54	ok (!MyDict2->equals(MyDict3), 'MyDict2 == MyDict3');
	55	ok (!MyDict3->equals(MyDict2), 'MyDict3 == MyDict2');
	56	ok (!MyDict3->equals(MyDict1), 'MyDict3 == MyDict1');
a4a88fef	57
16aea7bf	58	ok ( MyTuple1->equals(MyTuple2), 'MyTuple1 == MyTuple2');
	59	ok ( MyTuple2->equals(MyTuple1), 'MyTuple2 == MyTuple1');
	60	ok (!MyTuple1->equals(MyTuple3), 'MyTuple1 == MyTuple3');
	61	ok (!MyTuple2->equals(MyTuple3), 'MyTuple2 == MyTuple3');
	62	ok (!MyTuple3->equals(MyTuple2), 'MyTuple3 == MyTuple2');
	63	ok (!MyTuple3->equals(MyTuple1), 'MyTuple3 == MyTuple1');
a4a88fef	64
fe1fd33c	65	ok ( MyDict1->equals(MyDict2), 'MyDict1 == MyDict2');
	66	ok ( MyDict2->equals(MyDict1), 'MyDict2 == MyDict1');
	67	ok (!MyDict1->equals(MyDict3), 'MyDict1 == MyDict3');
179af711	68	ok (!MyDict1->equals(MyDict4), 'MyDict1 == MyDict3');
fe1fd33c	69	ok (!MyDict2->equals(MyDict3), 'MyDict2 == MyDict3');
179af711	70	ok (!MyDict2->equals(MyDict4), 'MyDict2 == MyDict3');
fe1fd33c	71	ok (!MyDict3->equals(MyDict2), 'MyDict3 == MyDict2');
179af711	72	ok (!MyDict3->equals(MyDict4), 'MyDict3 == MyDict2');
fe1fd33c	73	ok (!MyDict3->equals(MyDict1), 'MyDict3 == MyDict1');
179af711	74	ok (!MyDict4->equals(MyDict1), 'MyDict3 == MyDict1');
	75	ok (!MyDict4->equals(MyDict2), 'MyDict3 == MyDict1');
	76	ok (!MyDict4->equals(MyDict3), 'MyDict3 == MyDict1');
fe1fd33c	77
	78	ok ( MyTuple1->equals(MyTuple2), 'MyTuple1 == MyTuple2');
	79	ok ( MyTuple2->equals(MyTuple1), 'MyTuple2 == MyTuple1');
	80	ok (!MyTuple1->equals(MyTuple3), 'MyTuple1 == MyTuple3');
	81	ok (!MyTuple2->equals(MyTuple3), 'MyTuple2 == MyTuple3');
	82	ok (!MyTuple3->equals(MyTuple2), 'MyTuple3 == MyTuple2');
	83	ok (!MyTuple3->equals(MyTuple1), 'MyTuple3 == MyTuple1');
af1d00c9	84
a4a88fef	85	## Test is_a_type_of
a4a88fef	86
179af711	87	ok ( MyDict1->is_a_type_of(HashRef), 'MyDict1 is_a_type_of HashRef');
16aea7bf	88	ok ( MyDict1->is_a_type_of(Dict), 'MyDict1 is_a_type_of Dict');
	89	ok (!MyDict1->is_a_type_of(Tuple), 'MyDict1 NOT is_a_type_of Tuple');
	90	ok ( MyDict1->is_a_type_of(MyDict2), 'MyDict1 is_a_type_of MyDict2');
	91	ok ( MyDict2->is_a_type_of(MyDict1), 'MyDict2 is_a_type_of MyDict1');
	92	ok (!MyDict1->is_a_type_of(MyDict3), 'MyDict1 NOT is_a_type_of MyDict3');
	93	ok (!MyDict2->is_a_type_of(MyDict3), 'MyDict2 NOT is_a_type_of MyDict3');
	94	ok ( subMyDict1->is_a_type_of(Dict), 'subMyDict1 type of Dict');
	95	ok ( subMyDict1->is_a_type_of(MyDict1), 'subMyDict1 type of MyDict1');
	96	ok ( subMyDict1->is_a_type_of(subMyDict1), 'subMyDict1 type of subMyDict1');
	97	ok ( subMyDict1->is_a_type_of(MyDict2), 'subMyDict1 type of MyDict2');
179af711	98	ok ( MyDict4->is_a_type_of(HashRef), 'MyDict4 is_a_type_of HashRef');
	99	ok ( MyDict4->is_a_type_of(Dict), 'MyDict4 is_a_type_of Dict');
	100	ok (!MyDict4->is_a_type_of(Tuple), 'MyDict4 NOT is_a_type_of Tuple');
	101	ok (!MyDict4->is_a_type_of(MyDict2), 'MyDict4 NOT is_a_type_of MyDict2');
	102	ok ( MyDict2->is_a_type_of(MyDict4), 'MyDict2 is_a_type_of MyDict4');
	103	ok (!MyDict4->is_a_type_of(MyDict3), 'MyDict4 NOT is_a_type_of MyDict3');
	104
16aea7bf	105
	106	ok ( MyTuple1->is_a_type_of(Tuple), 'MyTuple1 is_a_type_of Tuple');
	107	ok (!MyTuple1->is_a_type_of(Dict), 'MyTuple1 NOT is_a_type_of Dict');
	108	ok ( MyTuple1->is_a_type_of(MyTuple2), 'MyTuple1 is_a_type_of MyTuple2');
	109	ok ( MyTuple2->is_a_type_of(MyTuple1), 'MyTuple2 is_a_type_of MyTuple1');
	110	ok (!MyTuple1->is_a_type_of(MyTuple3), 'MyTuple1 NOT is_a_type_of MyTuple3');
	111	ok (!MyTuple2->is_a_type_of(MyTuple3), 'MyTuple2 NOT is_a_type_of MyTuple3');
	112
a4a88fef	113	## is_subtype_of
a4a88fef	114
179af711	115	ok ( MyDict1->is_subtype_of(HashRef), 'MyDict1 is_subtype_of HashRef');
16aea7bf	116	ok ( MyDict1->is_subtype_of(Dict), 'MyDict1 is_subtype_of Dict');
179af711	117	ok ( MyDict1->is_subtype_of(MyDict4), 'MyDict1 is_subtype_of MyDict4');
16aea7bf	118	ok (!MyDict1->is_subtype_of(Tuple), 'MyDict1 NOT is_subtype_of Tuple');
179af711	119	ok (!MyDict1->is_subtype_of(MyDict2), 'MyDict1 NOT is_subtype_of MyDict2');
179af711	120	ok (!MyDict2->is_subtype_of(MyDict1), 'MyDict2 NOT is_subtype_of MyDict1');
16aea7bf	121	ok (!MyDict1->is_subtype_of(MyDict3), 'MyDict1 NOT is_subtype_of MyDict3');
	122	ok (!MyDict2->is_subtype_of(MyDict3), 'MyDict2 NOT is_subtype_of MyDict3');
	123	ok ( subMyDict1->is_subtype_of(Dict), 'subMyDict1 is_subtype_of Dict');
	124	ok ( subMyDict1->is_subtype_of(MyDict1), 'subMyDict1 is_subtype_of MyDict1');
179af711	125	ok (!subMyDict1->is_subtype_of(subMyDict1), 'subMyDict1 NOT is_subtype_of subMyDict1');
16aea7bf	126	ok ( subMyDict1->is_subtype_of(MyDict2), 'subMyDict1 is_subtype_of MyDict2');
	127
	128	ok ( MyTuple1->is_subtype_of(Tuple), 'MyTuple1 is_subtype_of Tuple');
	129	ok (!MyTuple1->is_subtype_of(Dict), 'MyTuple1 NOT is_subtype_of Dict');
	130	ok (!MyTuple1->is_subtype_of(MyTuple2), 'MyTuple1 is_subtype_of MyTuple2');
	131	ok (!MyTuple2->is_subtype_of(MyTuple1), 'MyTuple2 is_subtype_of MyTuple1');
	132	ok (!MyTuple1->is_subtype_of(MyTuple3), 'MyTuple1 NOT is_subtype_of MyTuple3');
	133	ok (!MyTuple2->is_subtype_of(MyTuple3), 'MyTuple2 NOT is_subtype_of MyTuple3');
a4a88fef	134
e327145a	135	## Test manual parameterizing
	136
	137	PARAMETERIZE: {
	138
	139	ok (my $int = Moose::Util::TypeConstraints::find_or_parse_type_constraint('Int'), 'Got Int');
	140	ok (my $str = Moose::Util::TypeConstraints::find_or_parse_type_constraint('Str'), 'Got Str');
	141	ok (my $hashref = Moose::Util::TypeConstraints::find_or_parse_type_constraint('HashRef[Int]'), 'Got HashRef');
	142
	143	## Test Dict->parameterize
	144	ok (my $test_dict = Dict(), 'Created Test Dict');
	145	ok (my $person = $test_dict->parameterize(name=>$str, age=>$int), 'Parameterized It');
	146	ok ($person->check({name=>'John', age=>21}), 'Passed');
	147	ok ($person->check({age=>25, name=>'User'}), 'Passed');
	148
	149	## Test Tuple->parameterize
	150	ok (my $test_tuple = Tuple(), 'Created Test Tuple');
	151	ok (my $int_and_hashref = $test_tuple->parameterize($int, $hashref), 'Parameterized It');
	152	ok ($int_and_hashref->check([1, {key=>2, key2=>3}]), "Passed");
	153	ok (!$int_and_hashref->check(['a', {key=>2, key2=>3}]), "Not Passed");
	154	ok (!$int_and_hashref->check([1, {key=>'a', key2=>3}]), "Not Passed");
	155	}