X-Git-Url: http://git.vpit.fr/?a=blobdiff_plain;f=lib%2FTest%2FLeaner.pm;h=8d25ca941f036109d7c39b704badb9cc163f264e;hb=9c79bce8bb6da45e4a032fe8354d5bfc73a648bb;hp=92f386f6402913e7bfd40a71d3e8a2ac5870c507;hpb=da6dd0b8533e32433851119428d3bc4e1959599c;p=perl%2Fmodules%2FTest-Leaner.git

diff --git a/lib/Test/Leaner.pm b/lib/Test/Leaner.pm
index 92f386f..8d25ca9 100644
--- a/lib/Test/Leaner.pm
+++ b/lib/Test/Leaner.pm
@@ -30,10 +30,52 @@ our $VERSION = '0.01';
 When profiling some L<Test::More>-based test script that contained about 10 000 unit tests, I realized that 60% of the time was spent in L<Test::Builder> itself, even though every single test actually involved a costly C<eval STRING>.
 
 This module aims to be a partial replacement to L<Test::More> in those situations where you want to run a large number of simple tests.
+Its functions behave the same as their L<Test::More> counterparts, except for the following differences :
+
+=over 4
+
+=item *
+
+Stringification isn't forced on the test operands.
+However, L</ok> honors C<'bool'> overloading, L</is> and L</is_deeply> honor C<'eq'> overloading (and just that one) and L</cmp_ok> honors whichever overloading category corresponds to the specified operator.
+
+=item *
+
+L</pass>, L</fail>, L</ok>, L</is>, L</isnt>, L</like>, L</unlike> and L</cmp_ok> are all guaranteed to return the truth value of the test.
+
+=item *
+
+L</like> and L</unlike> don't special case regular expressions that are passed as C<'/.../'> strings.
+A string regexp argument is always treated as a the source of the regexp, making C<like $text, $rx> and C<like $text, qr[$rx]> equivalent to each other and to C<cmp_ok $text, '=~', $rx> (and likewise for C<unlike>).
+
+=item *
+
+L</cmp_ok> throws an exception if the given operator isn't a valid Perl binary operator (except C<'='> and variants).
+It also tests in scalar context, so C<'..'> will be treated as the flip-flop operator and not the range operator.
+
+=item *
+
+L</is_deeply> doesn't guard for memory cycles.
+If the two first arguments present parallel memory cycles, the test may result in an infinite loop.
+
+=item *
+
+The tests don't output any kind of default diagnostic in case of failure ; the rationale being that if you have a large number of tests and a lot of them are failing, then you don't want to be flooded by diagnostics.
+
+=item *
+
+C<use_ok>, C<require_ok>, C<can_ok>, C<isa_ok>, C<new_ok>, C<subtest>, C<explain>, C<TODO> blocks and C<todo_skip> are not implemented.
+
+=item *
+
+L<Test::Leaner> depends on L<Scalar::Util>, while L<Test::More> does not.
+
+=back
 
 =cut
 
-use Exporter ();
+use Exporter     ();
+use Scalar::Util ();
 
 BEGIN {
  if ($] >= 5.008 and $INC{'threads.pm'}) {
@@ -83,7 +125,7 @@ sub croak {
  die @_, " at $file line $line.\n";
 }
 
-sub sanitize_comment {
+sub _sanitize_comment {
  $_[0] =~ s/\n+\z//;
  $_[0] =~ s/#/\\#/g;
  $_[0] =~ s/\n/\n# /g;
@@ -95,6 +137,8 @@ The following functions from L<Test::More> are implemented and exported by defau
 
 =head2 C<< plan [ tests => $count | 'no_plan' | skip_all => $reason ] >>
 
+See L<Test::More/plan>.
+
 =cut
 
 sub plan {
@@ -122,7 +166,7 @@ sub plan {
   $plan       = SKIP_ALL;
   $plan_str   = '1..0 # SKIP';
   if (defined $value) {
-   sanitize_comment($value);
+   _sanitize_comment($value);
    $plan_str .= " $value" if length $value;
   }
  } else {
@@ -142,7 +186,6 @@ sub plan {
 
 our @EXPORT = qw<
  plan
- skip_all
  skip
  done_testing
  pass
@@ -150,9 +193,10 @@ our @EXPORT = qw<
  ok
  is
  isnt
- cmp_ok
  like
  unlike
+ cmp_ok
+ is_deeply
  diag
  note
  BAIL_OUT
@@ -192,17 +236,10 @@ sub import {
  goto &Exporter::import;
 }
 
-=head2 C<skip_all $reason>
-
-=cut
-
-sub skip_all {
- @_ = (skip_all => $_[0]);
- goto &plan;
-}
-
 =head2 C<< skip $reason => $count >>
 
+See L<Test::More/skip>.
+
 =cut
 
 sub skip {
@@ -224,7 +261,7 @@ sub skip {
 
   my $skip_str = "ok $test # skip";
   if (defined $reason) {
-   sanitize_comment($reason);
+   _sanitize_comment($reason);
    $skip_str  .= " $reason" if length $reason;
   }
 
@@ -238,6 +275,8 @@ sub skip {
 
 =head2 C<done_testing [ $count ]>
 
+See L<Test::More/done_testing>.
+
 =cut
 
 sub done_testing {
@@ -269,6 +308,8 @@ sub done_testing {
 
 =head2 C<ok $ok [, $desc ]>
 
+See L<Test::More/ok>.
+
 =cut
 
 sub ok ($;$) {
@@ -284,7 +325,7 @@ sub ok ($;$) {
   ++$failed;
  }
  if (defined $desc) {
-  sanitize_comment($desc);
+  _sanitize_comment($desc);
   $test_str .= " - $desc" if length $desc;
  }
 
@@ -296,6 +337,8 @@ sub ok ($;$) {
 
 =head2 C<pass [ $desc ]>
 
+See L<Test::More/pass>.
+
 =cut
 
 sub pass (;$) {
@@ -305,6 +348,8 @@ sub pass (;$) {
 
 =head2 C<fail [ $desc ]>
 
+See L<Test::More/fail>.
+
 =cut
 
 sub fail (;$) {
@@ -314,6 +359,8 @@ sub fail (;$) {
 
 =head2 C<is $got, $expected [, $desc ]>
 
+See L<Test::More/is>.
+
 =cut
 
 sub is ($$;$) {
@@ -328,6 +375,8 @@ sub is ($$;$) {
 
 =head2 C<isnt $got, $expected [, $desc ]>
 
+See L<Test::More/isnt>.
+
 =cut
 
 sub isnt ($$;$) {
@@ -342,12 +391,17 @@ sub isnt ($$;$) {
 
 my %binops = (
  'or'  => 'or',
- 'and' => 'and',
  'xor' => 'xor',
+ 'and' => 'and',
 
  '||'  => 'hor',
+ ('//' => 'dor') x ($] >= 5.010),
  '&&'  => 'hand',
 
+ '|'   => 'bor',
+ '^'   => 'bxor',
+ '&'   => 'band',
+
  'lt'  => 'lt',
  'le'  => 'le',
  'gt'  => 'gt',
@@ -366,7 +420,21 @@ my %binops = (
 
  '=~'  => 'like',
  '!~'  => 'unlike',
- '~~'  => 'smartmatch',
+ ('~~' => 'smartmatch') x ($] >= 5.010),
+
+ '+'   => 'add',
+ '-'   => 'substract',
+ '*'   => 'multiply',
+ '/'   => 'divide',
+ '%'   => 'modulo',
+ '<<'  => 'lshift',
+ '>>'  => 'rshift',
+
+ '.'   => 'concat',
+ '..'  => 'flipflop',
+ '...' => 'altflipflop',
+ ','   => 'comma',
+ '=>'  => 'fatcomma',
 );
 
 my %binop_handlers;
@@ -380,7 +448,7 @@ sub _create_binop_handler {
   eval <<"IS_BINOP";
 sub is_$name (\$\$;\$) {
  my (\$got, \$expected, \$desc) = \@_;
- \@_ = ((\$got $op \$expected), \$desc);
+ \@_ = (scalar(\$got $op \$expected), \$desc);
  goto &ok;
 }
 IS_BINOP
@@ -394,8 +462,12 @@ IS_BINOP
 
 =head2 C<like $got, $regexp_expected [, $desc ]>
 
+See L<Test::More/like>.
+
 =head2 C<unlike $got, $regexp_expected, [, $desc ]>
 
+See L<Test::More/unlike>.
+
 =cut
 
 {
@@ -406,6 +478,8 @@ IS_BINOP
 
 =head2 C<cmp_ok $got, $op, $expected [, $desc ]>
 
+See L<Test::More/cmp_ok>.
+
 =cut
 
 sub cmp_ok ($$$;$) {
@@ -419,6 +493,99 @@ sub cmp_ok ($$$;$) {
  goto $handler;
 }
 
+=head2 C<is_deeply $got, $expected [, $desc ]>
+
+See L<Test::More/is_deeply>.
+
+=cut
+
+sub _deep_ref_check {
+ my ($x, $y, $ry) = @_;
+
+ no warnings qw<numeric uninitialized>;
+
+ if ($ry eq 'ARRAY') {
+  return 0 unless $#$x == $#$y;
+
+  my ($ex, $ey);
+  for (0 .. $#$y) {
+   $ex = $x->[$_];
+   $ey = $y->[$_];
+
+   # Inline the beginning of _deep_check
+   return 0 if defined $ex xor defined $ey;
+
+   next if not(ref $ex xor ref $ey) and $ex eq $ey;
+
+   $ry = Scalar::Util::reftype($ey);
+   return 0 if Scalar::Util::reftype($ex) ne $ry;
+
+   return 0 unless $ry and _deep_ref_check($ex, $ey, $ry);
+  }
+
+  return 1;
+ } elsif ($ry eq 'HASH') {
+  return 0 unless keys(%$x) == keys(%$y);
+
+  my ($ex, $ey);
+  for (keys %$y) {
+   return 0 unless exists $x->{$_};
+   $ex = $x->{$_};
+   $ey = $y->{$_};
+
+   # Inline the beginning of _deep_check
+   return 0 if defined $ex xor defined $ey;
+
+   next if not(ref $ex xor ref $ey) and $ex eq $ey;
+
+   $ry = Scalar::Util::reftype($ey);
+   return 0 if Scalar::Util::reftype($ex) ne $ry;
+
+   return 0 unless $ry and _deep_ref_check($ex, $ey, $ry);
+  }
+
+  return 1;
+ } elsif ($ry eq 'SCALAR' or $ry eq 'REF') {
+  return _deep_check($$x, $$y);
+ }
+
+ return 0;
+}
+
+sub _deep_check {
+ my ($x, $y) = @_;
+
+ no warnings qw<numeric uninitialized>;
+
+ return 0 if defined $x xor defined $y;
+
+ # Try object identity/eq overloading first. It also covers the case where
+ # $x and $y are both undefined.
+ # If either $x or $y is overloaded but none has eq overloading, the test will
+ # break at that point.
+ return 1 if not(ref $x xor ref $y) and $x eq $y;
+
+ # Test::More::is_deeply happily breaks encapsulation if the objects aren't
+ # overloaded.
+ my $ry = Scalar::Util::reftype($y);
+ return 0 if Scalar::Util::reftype($x) ne $ry;
+
+ # Shortcut if $x and $y are both not references and failed the previous
+ # $x eq $y test.
+ return 0 unless $ry;
+
+ # We know that $x and $y are both references of type $ry, without overloading.
+ _deep_ref_check($x, $y, $ry);
+}
+
+sub is_deeply {
+ @_ = (
+  &_deep_check,
+  $_[2],
+ );
+ goto &ok;
+}
+
 sub _diag_fh {
  my $fh = shift;
 
@@ -428,7 +595,7 @@ sub _diag_fh {
  return if $no_diag;
 
  my $msg = join '', map { defined($_) ? $_ : 'undef' } @_;
- sanitize_comment($msg);
+ _sanitize_comment($msg);
  return unless length $msg;
 
  local $\;
@@ -439,6 +606,8 @@ sub _diag_fh {
 
 =head2 C<diag @text>
 
+See L<Test::More/diag>.
+
 =cut
 
 sub diag {
@@ -448,6 +617,8 @@ sub diag {
 
 =head2 C<note @text>
 
+See L<Test::More/note>.
+
 =cut
 
 sub note {
@@ -457,6 +628,8 @@ sub note {
 
 =head2 C<BAIL_OUT [ $desc ]>
 
+See L<Test::More/BAIL_OUT>.
+
 =cut
 
 sub BAIL_OUT {
@@ -466,7 +639,7 @@ sub BAIL_OUT {
 
  my $bail_out_str = 'Bail out!';
  if (defined $desc) {
-  sanitize_comment($desc);
+  _sanitize_comment($desc);
   $bail_out_str  .= "  $desc" if length $desc; # Two spaces
  }
 
@@ -495,9 +668,6 @@ END {
 
 =pod
 
-L</pass>, L</fail>, L</ok>, L</is>, L</isnt>, L</like>, L</unlike> and L</cmp_ok> are all guaranteed to return the truth value of the test.
-Their L<Test::More> counterparts behave the same, but it is not documented anywhere.
-
 L<Test::Leaner> also provides some functions of its own, which are never exported.
 
 =head2 C<tap_stream [ $fh ]>
@@ -550,11 +720,16 @@ sub diag_stream (;*) {
 
 diag_stream *STDERR;
 
+=head2 C<THREADSAFE>
+
+This constant evaluates to true if and only if L<Test::Leaner> is thread-safe, i.e. when this version of C<perl> is at least 5.8, has been compiled with C<useithreads> defined, and L<threads> has been loaded B<before> L<Test::Leaner>.
+In that case, it also needs a working L<threads::shared>.
+
 =head1 DEPENDENCIES
 
 L<perl> 5.6.
 
-L<Exporter>, L<Test::More>
+L<Exporter>, L<Scalar::Util>, L<Test::More>.
 
 =head1 AUTHOR