X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FTest%2FMore.pm;h=be7e9fcf05d0cc67a997211e52561d7ca3e57d13;hb=0295a53a2a0d7b08c078ea9d195ec919c7df2a35;hp=aa02808516c27c5fc9c5e5de80611668a7676a6b;hpb=0257f296204adb69c838f5fbb883eb20cd264593;p=p5sagit%2Fp5-mst-13.2.git diff --git a/lib/Test/More.pm b/lib/Test/More.pm index aa02808..be7e9fc 100644 --- a/lib/Test/More.pm +++ b/lib/Test/More.pm @@ -3,7 +3,6 @@ package Test::More; use 5.004; use strict; -use Test::Builder; # Can't use Carp because it might cause use_ok() to accidentally succeed @@ -16,12 +15,12 @@ sub _carp { -require Exporter; use vars qw($VERSION @ISA @EXPORT %EXPORT_TAGS $TODO); -$VERSION = '0.54'; +$VERSION = '0.63'; $VERSION = eval $VERSION; # make the alpha version come out as a number -@ISA = qw(Exporter); +use Test::Builder::Module; +@ISA = qw(Test::Builder::Module); @EXPORT = qw(ok use_ok require_ok is isnt like unlike is_deeply cmp_ok @@ -32,22 +31,9 @@ $VERSION = eval $VERSION; # make the alpha version come out as a number plan can_ok isa_ok diag + BAIL_OUT ); -my $Test = Test::Builder->new; -my $Show_Diag = 1; - - -# 5.004's Exporter doesn't have export_to_level. -sub _export_to_level -{ - my $pkg = shift; - my $level = shift; - (undef) = shift; # redundant arg - my $callpkg = caller($level); - $pkg->export($callpkg, @_); -} - =head1 NAME @@ -100,17 +86,11 @@ Test::More - yet another framework for writing test scripts pass($test_name); fail($test_name); - # Utility comparison functions. - eq_array(\@this, \@that); - eq_hash(\%this, \%that); - eq_set(\@this, \@that); + BAIL_OUT($why); # UNIMPLEMENTED!!! my @status = Test::More::status; - # UNIMPLEMENTED!!! - BAIL_OUT($why); - =head1 DESCRIPTION @@ -142,7 +122,7 @@ have no plan. (Try to avoid using this as it weakens your test.) use Test::More qw(no_plan); B: using no_plan requires a Test::Harness upgrade else it will -think everything has failed. See L) +think everything has failed. See L). In some cases, you'll want to completely skip an entire testing script. @@ -177,53 +157,34 @@ or for deciding between running the tests at all: =cut sub plan { - my(@plan) = @_; + my $tb = Test::More->builder; - my $idx = 0; - my @cleaned_plan; - while( $idx <= $#plan ) { - my $item = $plan[$idx]; - - if( $item eq 'no_diag' ) { - $Show_Diag = 0; - } - else { - push @cleaned_plan, $item; - } - - $idx++; - } - - $Test->plan(@cleaned_plan); + $tb->plan(@_); } -sub import { - my($class) = shift; - - my $caller = caller; - $Test->exported_to($caller); +# This implements "use Test::More 'no_diag'" but the behavior is +# deprecated. +sub import_extra { + my $class = shift; + my $list = shift; + my @other = (); my $idx = 0; - my @plan; - my @imports; - while( $idx <= $#_ ) { - my $item = $_[$idx]; - - if( $item eq 'import' ) { - push @imports, @{$_[$idx+1]}; - $idx++; + while( $idx <= $#{$list} ) { + my $item = $list->[$idx]; + + if( defined $item and $item eq 'no_diag' ) { + $class->builder->no_diag(1); } else { - push @plan, $item; + push @other, $item; } $idx++; } - plan(@plan); - - __PACKAGE__->_export_to_level(1, __PACKAGE__, @imports); + @$list = @other; } @@ -288,7 +249,8 @@ but we B strongly encourage its use. Should an ok() fail, it will produce some diagnostics: not ok 18 - sufficient mucus - # Failed test 18 (foo.t at line 42) + # Failed test 'sufficient mucus' + # in foo.t at line 42. This is actually Test::Simple's ok() routine. @@ -296,7 +258,9 @@ This is actually Test::Simple's ok() routine. sub ok ($;$) { my($test, $name) = @_; - $Test->ok($test, $name); + my $tb = Test::More->builder; + + $tb->ok($test, $name); } =item B @@ -334,7 +298,8 @@ test: Will produce something like this: not ok 17 - Is foo the same as bar? - # Failed test (foo.t at line 139) + # Failed test 'Is foo the same as bar?' + # in foo.t at line 139. # got: 'waffle' # expected: 'yarblokos' @@ -359,11 +324,15 @@ function which is an alias of isnt(). =cut sub is ($$;$) { - $Test->is_eq(@_); + my $tb = Test::More->builder; + + $tb->is_eq(@_); } sub isnt ($$;$) { - $Test->isnt_eq(@_); + my $tb = Test::More->builder; + + $tb->isnt_eq(@_); } *isn't = \&isnt; @@ -400,7 +369,9 @@ diagnostics on failure. =cut sub like ($$;$) { - $Test->like(@_); + my $tb = Test::More->builder; + + $tb->like(@_); } @@ -414,7 +385,9 @@ given pattern. =cut sub unlike ($$;$) { - $Test->unlike(@_); + my $tb = Test::More->builder; + + $tb->unlike(@_); } @@ -439,7 +412,7 @@ Its advantage over ok() is when the test fails you'll know what $this and $that were: not ok 1 - # Failed test (foo.t at line 12) + # Failed test in foo.t at line 12. # '23' # && # undef @@ -452,7 +425,9 @@ is()'s use of C will interfere: =cut sub cmp_ok($$$;$) { - $Test->cmp_ok(@_); + my $tb = Test::More->builder; + + $tb->cmp_ok(@_); } @@ -488,10 +463,17 @@ as one test. If you desire otherwise, use: sub can_ok ($@) { my($proto, @methods) = @_; my $class = ref $proto || $proto; + my $tb = Test::More->builder; + + unless( $class ) { + my $ok = $tb->ok( 0, "->can(...)" ); + $tb->diag(' can_ok() called with empty class or reference'); + return $ok; + } unless( @methods ) { - my $ok = $Test->ok( 0, "$class->can(...)" ); - $Test->diag(' can_ok() called with no methods'); + my $ok = $tb->ok( 0, "$class->can(...)" ); + $tb->diag(' can_ok() called with no methods'); return $ok; } @@ -506,9 +488,9 @@ sub can_ok ($@) { $name = @methods == 1 ? "$class->can('$methods[0]')" : "$class->can(...)"; - my $ok = $Test->ok( !@nok, $name ); + my $ok = $tb->ok( !@nok, $name ); - $Test->diag(map " $class->can('$_') failed\n", @nok); + $tb->diag(map " $class->can('$_') failed\n", @nok); return $ok; } @@ -544,6 +526,7 @@ you'd like them to be more specific, you can supply an $object_name sub isa_ok ($$;$) { my($object, $class, $obj_name) = @_; + my $tb = Test::More->builder; my $diag; $obj_name = 'The object' unless defined $obj_name; @@ -583,11 +566,11 @@ WHOA my $ok; if( $diag ) { - $ok = $Test->ok( 0, $name ); - $Test->diag(" $diag\n"); + $ok = $tb->ok( 0, $name ); + $tb->diag(" $diag\n"); } else { - $ok = $Test->ok( 1, $name ); + $ok = $tb->ok( 1, $name ); } return $ok; @@ -612,65 +595,17 @@ Use these very, very, very sparingly. =cut sub pass (;$) { - $Test->ok(1, @_); + my $tb = Test::More->builder; + $tb->ok(1, @_); } sub fail (;$) { - $Test->ok(0, @_); + my $tb = Test::More->builder; + $tb->ok(0, @_); } =back -=head2 Diagnostics - -If you pick the right test function, you'll usually get a good idea of -what went wrong when it failed. But sometimes it doesn't work out -that way. So here we have ways for you to write your own diagnostic -messages which are safer than just C. - -=over 4 - -=item B - - diag(@diagnostic_message); - -Prints a diagnostic message which is guaranteed not to interfere with -test output. Like C @diagnostic_message is simply concatinated -together. - -Handy for this sort of thing: - - ok( grep(/foo/, @users), "There's a foo user" ) or - diag("Since there's no foo, check that /etc/bar is set up right"); - -which would produce: - - not ok 42 - There's a foo user - # Failed test (foo.t at line 52) - # Since there's no foo, check that /etc/bar is set up right. - -You might remember C with the mnemonic C. - -All diag()s can be made silent by passing the "no_diag" option to -Test::More. C 1, 'no_diag'>. This is useful -if you have diagnostics for personal testing but then wish to make -them silent for release without commenting out each individual -statement. - -B The exact formatting of the diagnostic output is still -changing, but it is guaranteed that whatever you throw at it it won't -interfere with the test. - -=cut - -sub diag { - return unless $Show_Diag; - $Test->diag(@_); -} - - -=back =head2 Module tests @@ -723,6 +658,7 @@ because the notion of "compile-time" is relative. Instead, you want: sub use_ok ($;@) { my($module, @imports) = @_; @imports = () unless @imports; + my $tb = Test::More->builder; my($pack,$filename,$line) = caller; @@ -743,13 +679,13 @@ use $module \@imports; USE } - my $ok = $Test->ok( !$@, "use $module;" ); + my $ok = $tb->ok( !$@, "use $module;" ); unless( $ok ) { chomp $@; $@ =~ s{^BEGIN failed--compilation aborted at .*$} {BEGIN failed--compilation aborted at $filename line $line.}m; - $Test->diag(<diag(<builder; my $pack = caller; @@ -783,11 +720,11 @@ package $pack; require $module; REQUIRE - my $ok = $Test->ok( !$@, "require $module;" ); + my $ok = $tb->ok( !$@, "require $module;" ); unless( $ok ) { chomp $@; - $Test->diag(<diag(< I'm not quite sure what will happen with filehandles. + +=over 4 + +=item B + + is_deeply( $this, $that, $test_name ); + +Similar to is(), except that if $this and $that are references, it +does a deep comparison walking each data structure to see if they are +equivalent. If the two structures are different, it will display the +place where they start differing. + +is_deeply() compares the dereferenced values of references, the +references themselves (except for their type) are ignored. This means +aspects such as blessing and ties are not considered "different". + +is_deeply() current has very limited handling of function reference +and globs. It merely checks if they have the same referent. This may +improve in the future. + +Test::Differences and Test::Deep provide more in-depth functionality +along these lines. + +=cut + +use vars qw(@Data_Stack %Refs_Seen); +my $DNE = bless [], 'Does::Not::Exist'; +sub is_deeply { + my $tb = Test::More->builder; + + unless( @_ == 2 or @_ == 3 ) { + my $msg = <ok(0); + } + + my($this, $that, $name) = @_; + + $tb->_unoverload_str(\$that, \$this); + + my $ok; + if( !ref $this and !ref $that ) { # neither is a reference + $ok = $tb->is_eq($this, $that, $name); + } + elsif( !ref $this xor !ref $that ) { # one's a reference, one isn't + $ok = $tb->ok(0, $name); + $tb->diag( _format_stack({ vals => [ $this, $that ] }) ); + } + else { # both references + local @Data_Stack = (); + if( _deep_check($this, $that) ) { + $ok = $tb->ok(1, $name); + } + else { + $ok = $tb->ok(0, $name); + $tb->diag(_format_stack(@Data_Stack)); + } + } + + return $ok; +} + +sub _format_stack { + my(@Stack) = @_; + + my $var = '$FOO'; + my $did_arrow = 0; + foreach my $entry (@Stack) { + my $type = $entry->{type} || ''; + my $idx = $entry->{'idx'}; + if( $type eq 'HASH' ) { + $var .= "->" unless $did_arrow++; + $var .= "{$idx}"; + } + elsif( $type eq 'ARRAY' ) { + $var .= "->" unless $did_arrow++; + $var .= "[$idx]"; + } + elsif( $type eq 'REF' ) { + $var = "\${$var}"; + } + } + + my @vals = @{$Stack[-1]{vals}}[0,1]; + my @vars = (); + ($vars[0] = $var) =~ s/\$FOO/ \$got/; + ($vars[1] = $var) =~ s/\$FOO/\$expected/; + + my $out = "Structures begin differing at:\n"; + foreach my $idx (0..$#vals) { + my $val = $vals[$idx]; + $vals[$idx] = !defined $val ? 'undef' : + $val eq $DNE ? "Does not exist" : + ref $val ? "$val" : + "'$val'"; + } + + $out .= "$vars[0] = $vals[0]\n"; + $out .= "$vars[1] = $vals[1]\n"; + + $out =~ s/^/ /msg; + return $out; +} + + +sub _type { + my $thing = shift; + + return '' if !ref $thing; + + for my $type (qw(ARRAY HASH REF SCALAR GLOB CODE Regexp)) { + return $type if UNIVERSAL::isa($thing, $type); + } + + return ''; +} + +=back + + +=head2 Diagnostics + +If you pick the right test function, you'll usually get a good idea of +what went wrong when it failed. But sometimes it doesn't work out +that way. So here we have ways for you to write your own diagnostic +messages which are safer than just C. + +=over 4 + +=item B + + diag(@diagnostic_message); + +Prints a diagnostic message which is guaranteed not to interfere with +test output. Like C @diagnostic_message is simply concatenated +together. + +Handy for this sort of thing: + + ok( grep(/foo/, @users), "There's a foo user" ) or + diag("Since there's no foo, check that /etc/bar is set up right"); + +which would produce: + + not ok 42 - There's a foo user + # Failed test 'There's a foo user' + # in foo.t at line 52. + # Since there's no foo, check that /etc/bar is set up right. + +You might remember C with the mnemonic C. + +B The exact formatting of the diagnostic output is still +changing, but it is guaranteed that whatever you throw at it it won't +interfere with the test. + +=cut + +sub diag { + my $tb = Test::More->builder; + + $tb->diag(@_); +} + + +=back + + =head2 Conditional tests Sometimes running a test under certain conditions will cause the @@ -872,16 +992,17 @@ use TODO. Read on. #'# sub skip { my($why, $how_many) = @_; + my $tb = Test::More->builder; unless( defined $how_many ) { # $how_many can only be avoided when no_plan is in use. _carp "skip() needs to know \$how_many tests are in the block" - unless $Test->has_plan eq 'no_plan'; + unless $tb->has_plan eq 'no_plan'; $how_many = 1; } for( 1..$how_many ) { - $Test->skip($why); + $tb->skip($why); } local $^W = 0; @@ -927,7 +1048,7 @@ Once a todo test starts succeeding, simply move it outside the block. When the block is empty, delete it. B: TODO tests require a Test::Harness upgrade else it will -treat it as a normal failure. See L) +treat it as a normal failure. See L). =item B @@ -952,16 +1073,17 @@ interpret them as passing. sub todo_skip { my($why, $how_many) = @_; + my $tb = Test::More->builder; unless( defined $how_many ) { # $how_many can only be avoided when no_plan is in use. _carp "todo_skip() needs to know \$how_many tests are in the block" - unless $Test->has_plan eq 'no_plan'; + unless $tb->has_plan eq 'no_plan'; $how_many = 1; } for( 1..$how_many ) { - $Test->todo_skip($why); + $tb->todo_skip($why); } local $^W = 0; @@ -982,126 +1104,59 @@ but want to put tests in your testing script (always a good idea). =back -=head2 Comparison functions -Not everything is a simple eq check or regex. There are times you -need to see if two arrays are equivalent, for instance. For these -instances, Test::More provides a handful of useful functions. - -B I'm not quite sure what will happen with filehandles. +=head2 Test control =over 4 -=item B +=item B - is_deeply( $this, $that, $test_name ); + BAIL_OUT($reason); -Similar to is(), except that if $this and $that are hash or array -references, it does a deep comparison walking each data structure to -see if they are equivalent. If the two structures are different, it -will display the place where they start differing. +Indicates to the harness that things are going so badly all testing +should terminate. This includes the running any additional test scripts. -Test::Differences and Test::Deep provide more in-depth functionality -along these lines. +This is typically used when testing cannot continue such as a critical +module failing to compile or a necessary external utility not being +available such as a database connection failing. -=cut +The test will exit with 255. -use vars qw(@Data_Stack %Refs_Seen); -my $DNE = bless [], 'Does::Not::Exist'; -sub is_deeply { - unless( @_ == 2 or @_ == 3 ) { - my $msg = <builder; - my $ok; - if( !ref $this xor !ref $that ) { # one's a reference, one isn't - $ok = 0; - } - if( !ref $this and !ref $that ) { - $ok = $Test->is_eq($this, $that, $name); - } - else { - local @Data_Stack = (); - local %Refs_Seen = (); - if( _deep_check($this, $that) ) { - $ok = $Test->ok(1, $name); - } - else { - $ok = $Test->ok(0, $name); - $ok = $Test->diag(_format_stack(@Data_Stack)); - } - } - - return $ok; + $tb->BAIL_OUT($reason); } -sub _format_stack { - my(@Stack) = @_; +=back - my $var = '$FOO'; - my $did_arrow = 0; - foreach my $entry (@Stack) { - my $type = $entry->{type} || ''; - my $idx = $entry->{'idx'}; - if( $type eq 'HASH' ) { - $var .= "->" unless $did_arrow++; - $var .= "{$idx}"; - } - elsif( $type eq 'ARRAY' ) { - $var .= "->" unless $did_arrow++; - $var .= "[$idx]"; - } - elsif( $type eq 'REF' ) { - $var = "\${$var}"; - } - } - my @vals = @{$Stack[-1]{vals}}[0,1]; - my @vars = (); - ($vars[0] = $var) =~ s/\$FOO/ \$got/; - ($vars[1] = $var) =~ s/\$FOO/\$expected/; +=head2 Discouraged comparison functions - my $out = "Structures begin differing at:\n"; - foreach my $idx (0..$#vals) { - my $val = $vals[$idx]; - $vals[$idx] = !defined $val ? 'undef' : - $val eq $DNE ? "Does not exist" - : "'$val'"; - } +The use of the following functions is discouraged as they are not +actually testing functions and produce no diagnostics to help figure +out what went wrong. They were written before is_deeply() existed +because I couldn't figure out how to display a useful diff of two +arbitrary data structures. - $out .= "$vars[0] = $vals[0]\n"; - $out .= "$vars[1] = $vals[1]\n"; +These functions are usually used inside an ok(). - $out =~ s/^/ /msg; - return $out; -} + ok( eq_array(\@this, \@that) ); +C can do that better and with diagnostics. -sub _type { - my $thing = shift; - - return '' if !ref $thing; - - for my $type (qw(ARRAY HASH REF SCALAR GLOB Regexp)) { - return $type if UNIVERSAL::isa($thing, $type); - } + is_deeply( \@this, \@that ); - return ''; -} +They may be deprecated in future versions. +=over 4 =item B - eq_array(\@this, \@that); + my $is_eq = eq_array(\@this, \@that); Checks if two arrays are equivalent. This is a deep check, so multi-level structures are handled correctly. @@ -1111,8 +1166,7 @@ multi-level structures are handled correctly. #'# sub eq_array { local @Data_Stack; - local %Refs_Seen; - _eq_array(@_); + _deep_check(@_); } sub _eq_array { @@ -1125,13 +1179,6 @@ sub _eq_array { return 1 if $a1 eq $a2; - if($Refs_Seen{$a1}) { - return $Refs_Seen{$a1} eq $a2; - } - else { - $Refs_Seen{$a1} = "$a2"; - } - my $ok = 1; my $max = $#$a1 > $#$a2 ? $#$a1 : $#$a2; for (0..$max) { @@ -1150,16 +1197,24 @@ sub _eq_array { sub _deep_check { my($e1, $e2) = @_; + my $tb = Test::More->builder; + my $ok = 0; + # Effectively turn %Refs_Seen into a stack. This avoids picking up + # the same referenced used twice (such as [\$a, \$a]) to be considered + # circular. + local %Refs_Seen = %Refs_Seen; + { # Quiet uninitialized value warnings when comparing undefs. local $^W = 0; - $Test->_unoverload(\$e1, \$e2); + $tb->_unoverload_str(\$e1, \$e2); # Either they're both references or both not. my $same_ref = !(!ref $e1 xor !ref $e2); + my $not_ref = (!ref $e1 and !ref $e2); if( defined $e1 xor defined $e2 ) { $ok = 0; @@ -1170,12 +1225,23 @@ sub _deep_check { elsif ( $same_ref and ($e1 eq $e2) ) { $ok = 1; } + elsif ( $not_ref ) { + push @Data_Stack, { type => '', vals => [$e1, $e2] }; + $ok = 0; + } else { + if( $Refs_Seen{$e1} ) { + return $Refs_Seen{$e1} eq $e2; + } + else { + $Refs_Seen{$e1} = "$e2"; + } + my $type = _type($e1); - $type = '' unless _type($e2) eq $type; + $type = 'DIFFERENT' unless _type($e2) eq $type; - if( !$type ) { - push @Data_Stack, { vals => [$e1, $e2] }; + if( $type eq 'DIFFERENT' ) { + push @Data_Stack, { type => $type, vals => [$e1, $e2] }; $ok = 0; } elsif( $type eq 'ARRAY' ) { @@ -1185,7 +1251,7 @@ sub _deep_check { $ok = _eq_hash($e1, $e2); } elsif( $type eq 'REF' ) { - push @Data_Stack, { type => 'REF', vals => [$e1, $e2] }; + push @Data_Stack, { type => $type, vals => [$e1, $e2] }; $ok = _deep_check($$e1, $$e2); pop @Data_Stack if $ok; } @@ -1194,6 +1260,13 @@ sub _deep_check { $ok = _deep_check($$e1, $$e2); pop @Data_Stack if $ok; } + elsif( $type ) { + push @Data_Stack, { type => $type, vals => [$e1, $e2] }; + $ok = 0; + } + else { + _whoa(1, "No type in _deep_check"); + } } } @@ -1201,9 +1274,20 @@ sub _deep_check { } +sub _whoa { + my($check, $desc) = @_; + if( $check ) { + die < - eq_hash(\%this, \%that); + my $is_eq = eq_hash(\%this, \%that); Determines if the two hashes contain the same keys and values. This is a deep check. @@ -1212,8 +1296,7 @@ is a deep check. sub eq_hash { local @Data_Stack; - local %Refs_Seen; - return _eq_hash(@_); + return _deep_check(@_); } sub _eq_hash { @@ -1226,13 +1309,6 @@ sub _eq_hash { return 1 if $a1 eq $a2; - if( $Refs_Seen{$a1} ) { - return $Refs_Seen{$a1} eq $a2; - } - else { - $Refs_Seen{$a1} = "$a2"; - } - my $ok = 1; my $bigger = keys %$a1 > keys %$a2 ? $a1 : $a2; foreach my $k (keys %$bigger) { @@ -1251,15 +1327,28 @@ sub _eq_hash { =item B - eq_set(\@this, \@that); + my $is_eq = eq_set(\@this, \@that); Similar to eq_array(), except the order of the elements is B important. This is a deep check, but the irrelevancy of order only applies to the top level. -B By historical accident, this is not a true set comparision. + ok( eq_set(\@this, \@that) ); + +Is better written: + + is_deeply( [sort @this], [sort @that] ); + +B By historical accident, this is not a true set comparison. While the order of elements does not matter, duplicate elements do. +B eq_set() does not know how to deal with references at the top +level. The following is an example of a comparison which might not work: + + eq_set([\1, \2], [\2, \1]); + +Test::Deep contains much better set comparison functions. + =cut sub eq_set { @@ -1269,14 +1358,20 @@ sub eq_set { # There's faster ways to do this, but this is easiest. local $^W = 0; - # We must make sure that references are treated neutrally. It really - # doesn't matter how we sort them, as long as both arrays are sorted - # with the same algorithm. + # It really doesn't matter how we sort them, as long as both arrays are + # sorted with the same algorithm. + # + # Ensure that references are not accidentally treated the same as a + # string containing the reference. + # # Have to inline the sort routine due to a threading/sort bug. # See [rt.cpan.org 6782] + # + # I don't know how references would be sorted so we just don't sort + # them. This means eq_set doesn't really work with refs. return eq_array( - [sort { ref $a ? -1 : ref $b ? 1 : $a cmp $b } @$a1], - [sort { ref $a ? -1 : ref $b ? 1 : $a cmp $b } @$a2] + [grep(ref, @$a1), sort( grep(!ref, @$a1) )], + [grep(ref, @$a2), sort( grep(!ref, @$a2) )], ); } @@ -1303,11 +1398,6 @@ you can access the underlying Test::Builder object like so: Returns the Test::Builder object underlying Test::More for you to play with. -=cut - -sub builder { - return Test::Builder->new; -} =back @@ -1325,11 +1415,13 @@ considered a failure and will exit with 255. So the exit codes are... 0 all tests successful - 255 test died + 255 test died or all passed but wrong # of tests run any other number how many failed (including missing or extras) If you fail more than 254 tests, it will be reported as 254. +B This behavior may go away in future versions. + =head1 CAVEATS and NOTES @@ -1342,10 +1434,12 @@ Test::More works with Perls as old as 5.004_05. =item Overloaded objects -String overloaded objects are compared B. This prevents -Test::More from piercing an object's interface allowing better blackbox -testing. So if a function starts returning overloaded objects instead of -bare strings your tests won't notice the difference. This is good. +String overloaded objects are compared B (or in cmp_ok()'s +case, strings or numbers as appropriate to the comparison op). This +prevents Test::More from piercing an object's interface allowing +better blackbox testing. So if a function starts returning overloaded +objects instead of bare strings your tests won't notice the +difference. This is good. However, it does mean that functions like is_deeply() cannot be used to test the internals of string overloaded objects. In this case I would