X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=t%2F06-api.t;h=38b5ce3b826e017090e5d65bd1353865acaa2191;hb=fe1fd33cceed6665ece5705e5ce0642a23659752;hp=00c7686f7d64a39aca7d18850839a77697380ae0;hpb=a4a88fefad0246cc6b5eea44874bcfb2ff34253d;p=gitmo%2FMooseX-Types-Structured.git

diff --git a/t/06-api.t b/t/06-api.t
index 00c7686..38b5ce3 100644
--- a/t/06-api.t
+++ b/t/06-api.t
@@ -1,69 +1,114 @@
 BEGIN {
 	use strict;
 	use warnings;
-	use Test::More tests=>12;
-	use Test::Exception;
+	use Test::More tests=>56;
 }
 
-{
-	## 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 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 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;
+
+## 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 ( 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');
 
 ## Test is_a_type_of
 
+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 ( 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(Dict), 'MyDict1 is_subtype_of Dict');
+ok (!MyDict1->is_subtype_of(Tuple), 'MyDict1 NOT is_subtype_of Tuple');
+ok (!MyDict1->is_subtype_of(MyDict2), 'MyDict1 is_subtype_of MyDict2');
+ok (!MyDict2->is_subtype_of(MyDict1), 'MyDict2 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 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');