t/06-api.t

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