X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=t%2F001_mouse%2F043-parameterized-type.t;h=531febbcbb8ad91109e660fbfda6d24bc25f4045;hb=85b15d5f1644327a51646d5081fa366caae7ac44;hp=6eaedddc864720894321bedba581fa5c0c398819;hpb=920139b3efca66d2caeeef306c97fa0da62c6b73;p=gitmo%2FMouse.git

diff --git a/t/001_mouse/043-parameterized-type.t b/t/001_mouse/043-parameterized-type.t
index 6eaeddd..531febb 100644
--- a/t/001_mouse/043-parameterized-type.t
+++ b/t/001_mouse/043-parameterized-type.t
@@ -1,9 +1,12 @@
-#!/usr/bin/env perl
+#!perl
 use strict;
 use warnings;
-use Test::More tests => 46;
+use Test::More;
 use Test::Exception;
 
+use Tie::Hash;
+use Tie::Array;
+
 {
     {
         package My::Role;
@@ -67,30 +70,30 @@ use Test::Exception;
     # check bad args
     throws_ok {
         Foo->new( foo => { a => 'b' });
-    } qr/Attribute \(foo\) does not pass the type constraint because: Validation failed for 'HashRef\[Int\]' failed with value/, "Bad args for hash throws an exception";
+    } qr/Attribute \(foo\) does not pass the type constraint because: Validation failed for 'HashRef\[Int\]' with value/, "Bad args for hash throws an exception";
 
     throws_ok {
         Foo->new( bar => [ a => 'b' ]);
-    } qr/Attribute \(bar\) does not pass the type constraint because: Validation failed for 'ArrayRef\[Int\]' failed with value/, "Bad args for array throws an exception";
+    } qr/Attribute \(bar\) does not pass the type constraint because: Validation failed for 'ArrayRef\[Int\]' with value/, "Bad args for array throws an exception";
 
     throws_ok {
         Foo->new( complex => [ { a => 1, b => 1 }, { c => "d", e => "f" } ] )
-    } qr/Attribute \(complex\) does not pass the type constraint because: Validation failed for 'ArrayRef\[HashRef\[Int\]\]' failed with value/, "Bad args for complex types throws an exception";
+    } qr/Attribute \(complex\) does not pass the type constraint because: Validation failed for 'ArrayRef\[HashRef\[Int\]\]' with value/, "Bad args for complex types throws an exception";
 
     throws_ok {
         Foo->new( my_class => [ 10 ] );
-    } qr/Attribute \(my_class\) does not pass the type constraint because: Validation failed for 'ArrayRef\[My::Class\]' failed with value/;
+    } qr/Attribute \(my_class\) does not pass the type constraint because: Validation failed for 'ArrayRef\[My::Class\]' with value/;
     throws_ok {
         Foo->new( my_class => [ {foo => 'bar'} ] );
-    } qr/Attribute \(my_class\) does not pass the type constraint because: Validation failed for 'ArrayRef\[My::Class\]' failed with value/;
+    } qr/Attribute \(my_class\) does not pass the type constraint because: Validation failed for 'ArrayRef\[My::Class\]' with value/;
 
 
     throws_ok {
         Foo->new( my_role => [ 20 ] );
-    } qr/Attribute \(my_role\) does not pass the type constraint because: Validation failed for 'ArrayRef\[My::Role\]' failed with value/;
+    } qr/Attribute \(my_role\) does not pass the type constraint because: Validation failed for 'ArrayRef\[My::Role\]' with value/;
     throws_ok {
         Foo->new( my_role => [ {foo => 'bar'} ] );
-    } qr/Attribute \(my_role\) does not pass the type constraint because: Validation failed for 'ArrayRef\[My::Role\]' failed with value/;
+    } qr/Attribute \(my_role\) does not pass the type constraint because: Validation failed for 'ArrayRef\[My::Role\]' with value/;
 }
 
 {
@@ -120,11 +123,12 @@ use Test::Exception;
         my $bar = Bar->new(list => [ qw(a b c) ]);
 
         is_deeply( $bar->list, \@list, "list is as expected");
-    } "coercion works";
+    } "coercion works"
+        or diag( Mouse::Util::TypeConstraints::find_type_constraint("Bar::List")->dump );
 
     throws_ok {
         Bar->new(list => [ { 1 => 2 }, 2, 3 ]);
-    } qr/Attribute \(list\) does not pass the type constraint because: Validation failed for 'Bar::List' failed with value/, "Bad coercion parameter throws an error";
+    } qr/Attribute \(list\) does not pass the type constraint because: Validation failed for 'Bar::List' with value/, "Bad coercion parameter throws an error";
 }
 
 use Mouse::Util::TypeConstraints;
@@ -183,4 +187,75 @@ ok $x->check([[10, undef]]);
 ok!$x->check([[10, 3.14]]);
 ok!$x->check({});
 
+$x = tie my @ta, 'Tie::StdArray';
+
+my $array_of_int = Mouse::Util::TypeConstraints::find_or_parse_type_constraint('ArrayRef[Int]');
+
+@$x = (1, 2, 3);
+ok $array_of_int->check(\@ta), 'magical array';
+
+@$x = (1, 2, 3.14);
+ok !$array_of_int->check(\@ta);
+
+$x = tie my %th, 'Tie::StdHash';
+
+my $hash_of_int = Mouse::Util::TypeConstraints::find_or_parse_type_constraint('HashRef[Int]');
+
+%$x = (foo => 1, bar => 3, baz => 5);
+ok $hash_of_int->check(\%th), 'magical hash';
+
+$x->{foo} = 3.14;
+ok!$hash_of_int->check(\%th);
+
+my %th_clone;
+while(my($k, $v) = each %th){
+    $th_clone{$k} = $v;
+}
+
+is( $hash_of_int->type_parameter, 'Int' );
+
+if('Mouse' eq ('Mo' . 'use')){ # under Mouse
+    ok $hash_of_int->__is_parameterized();
+    ok!$hash_of_int->type_parameter->__is_parameterized();
+}
+else{ # under Moose
+    ok $hash_of_int->can('type_parameter');
+    ok!$hash_of_int->type_parameter->can('type_parameter');
+}
+
+is_deeply \%th_clone, \%th, 'the hash iterator is initialized';
+
+
+for my $i(1 .. 2) {
+    diag "derived from parameterized types #$i";
+
+    my $myhashref = subtype 'MyHashRef',
+        as 'HashRef[Value]',
+        where { keys %$_ > 1 };
+
+    ok  $myhashref->is_a_type_of('HashRef'), "$myhashref";
+    ok  $myhashref->check({ a => 43, b => 100 });
+    ok  $myhashref->check({ a => 43, b => 3.14 });
+    ok !$myhashref->check({});
+    ok !$myhashref->check({ a => 42, b => [] });
+
+    is $myhashref->type_parameter, 'Value';
+
+    $myhashref = subtype 'H', as 'MyHashRef[Int]';
+
+    ok  $myhashref->is_a_type_of('HashRef'), "$myhashref";
+    ok  $myhashref->check({ a => 43, b => 100 });
+    ok  $myhashref->check({ a => 43, b => 100, c => 0 });
+    ok !$myhashref->check({}), 'empty hash';
+    ok !$myhashref->check({ foo => 42 });
+    ok !$myhashref->check({ a => 43, b => "foo" });
+    ok !$myhashref->check({ a => 42, b => [] });
+    ok !$myhashref->check({ a => 42, b => undef });
+    ok !$myhashref->check([42]);
+    ok !$myhashref->check("foo");
+
+    is $myhashref->type_parameter, 'Int';
+}
+
+done_testing;