X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=t%2F030_roles%2F009_more_role_edge_cases.t;h=4a4fde0e74ec8f2b9ee42bf374f8d2346da8318f;hb=203e008eb223539d9149bdd74ac79bbd657e32be;hp=0fec31cbcf8aaaffd4b35d72ad1858970e3eaaa0;hpb=e606ae5f848070d889472329819c95f5ba763ca3;p=gitmo%2FMoose.git

diff --git a/t/030_roles/009_more_role_edge_cases.t b/t/030_roles/009_more_role_edge_cases.t
index 0fec31c..4a4fde0 100644
--- a/t/030_roles/009_more_role_edge_cases.t
+++ b/t/030_roles/009_more_role_edge_cases.t
@@ -3,18 +3,17 @@
 use strict;
 use warnings;
 
-use Test::More tests => 74;
+use Test::More;
 use Test::Exception;
 
 
-
 {
     # NOTE:
-    # this tests that repeated role 
-    # composition will not cause 
+    # this tests that repeated role
+    # composition will not cause
     # a conflict between two methods
     # which are actually the same anyway
-    
+
     {
         package RootA;
         use Moose::Role;
@@ -31,8 +30,8 @@ use Test::Exception;
         package SubAB;
         use Moose;
 
-        ::lives_ok { 
-            with "SubAA", "RootA"; 
+        ::lives_ok {
+            with "SubAA", "RootA";
         } '... role was composed as expected';
     }
 
@@ -46,31 +45,31 @@ use Test::Exception;
 
     can_ok( $i, "foo" );
     my $foo_rv;
-    lives_ok { 
-        $foo_rv = $i->foo; 
+    lives_ok {
+        $foo_rv = $i->foo;
     } '... called foo successfully';
     is($foo_rv, "RootA::foo", "... got the right foo rv");
 }
 
 {
     # NOTE:
-    # this edge cases shows the application of 
-    # an after modifier over a method which 
+    # this edge cases shows the application of
+    # an after modifier over a method which
     # was added during role composotion.
     # The way this will work is as follows:
-    #    role SubBA will consume RootB and 
-    #    get a local copy of RootB::foo, it 
+    #    role SubBA will consume RootB and
+    #    get a local copy of RootB::foo, it
     #    will also store a deferred after modifier
-    #    to be applied to whatever class SubBA is 
+    #    to be applied to whatever class SubBA is
     #    composed into.
     #    When class SubBB comsumed role SubBA, the
-    #    RootB::foo method is added to SubBB, then 
-    #    the deferred after modifier from SubBA is 
+    #    RootB::foo method is added to SubBB, then
+    #    the deferred after modifier from SubBA is
     #    applied to it.
-    # It is important to note that the application 
-    # of the after modifier does not happen until 
+    # It is important to note that the application
+    # of the after modifier does not happen until
     # role SubBA is composed into SubAA.
-    
+
     {
         package RootB;
         use Moose::Role;
@@ -95,7 +94,7 @@ use Test::Exception;
         package SubBB;
         use Moose;
 
-        ::lives_ok { 
+        ::lives_ok {
             with "SubBA";
         } '... composed the role successfully';
     }
@@ -106,21 +105,21 @@ use Test::Exception;
     isa_ok( my $i = SubBB->new, "SubBB" );
 
     can_ok( $i, "foo" );
-    
+
     my $foo_rv;
-    lives_ok { 
-        $foo_rv = $i->foo 
+    lives_ok {
+        $foo_rv = $i->foo
     } '... called foo successfully';
     is( $foo_rv, "RootB::foo", "foo rv" );
     is( $i->counter, 1, "after hook called" );
-    
+
     lives_ok { $i->foo } '... called foo successfully (again)';
     is( $i->counter, 2, "after hook called (again)" );
-    
+
     ok(SubBA->meta->has_method('foo'), '... this has the foo method');
     #my $subba_foo_rv;
-    #lives_ok { 
-    #    $subba_foo_rv = SubBA::foo(); 
+    #lives_ok {
+    #    $subba_foo_rv = SubBA::foo();
     #} '... called the sub as a function correctly';
     #is($subba_foo_rv, 'RootB::foo', '... the SubBA->foo is still the RootB version');
 }
@@ -129,9 +128,9 @@ use Test::Exception;
     # NOTE:
     # this checks that an override method
     # does not try to trample over a locally
-    # composed in method. In this case the 
-    # RootC::foo, which is composed into 
-    # SubCA cannot be trampled with an 
+    # composed in method. In this case the
+    # RootC::foo, which is composed into
+    # SubCA cannot be trampled with an
     # override of 'foo'
     {
         package RootC;
@@ -144,15 +143,15 @@ use Test::Exception;
 
         with "RootC";
 
-        ::dies_ok { 
+        ::dies_ok {
             override foo => sub { "overridden" };
         } '... cannot compose an override over a local method';
     }
 }
 
 # NOTE:
-# need to talk to Yuval about the motivation behind 
-# this test, I am not sure we are testing anything 
+# need to talk to Yuval about the motivation behind
+# this test, I am not sure we are testing anything
 # useful here (although more tests cant hurt)
 
 {
@@ -184,10 +183,10 @@ use Test::Exception;
         with "ConcreteA";
 
         # NOTE:
-        # this was originally override, but 
+        # this was originally override, but
         # that wont work (see above set of tests)
         # so I switched it to around.
-        # However, this may not be testing the 
+        # However, this may not be testing the
         # same thing that was originally intended
         around other => sub {
             return ( (shift)->() . " + c" );
@@ -218,12 +217,12 @@ use Test::Exception;
         is( eval { $class->another }, "abstract", "provided by abstract" );
         is( eval { $class->other }, "concrete a", "provided by concrete a" );
         is( eval { $class->method }, "concrete b", "provided by concrete b" );
-    }        
+    }
 
     {
         package ClassWithSome;
         use Moose;
-        
+
         eval { with ::shuffle qw/ConcreteC ConcreteB/ };
         ::ok( !$@, "composition without abstract" ) || ::diag $@;
 
@@ -254,3 +253,5 @@ use Test::Exception;
         is( eval { $class->method }, "concrete b", "provided by concrete b" );
     }
 }
+
+done_testing;