Optimize is_deeply for large datastructures

[perl/modules/Test-Leaner.git] / lib / Test / Leaner.pm

diff --git a/lib/Test/Leaner.pm b/lib/Test/Leaner.pm
index 4764511b32ab294f06d7e6878c22fa07ece0022b..8d25ca941f036109d7c39b704badb9cc163f264e 100644 (file)
--- a/lib/Test/Leaner.pm
+++ b/lib/Test/Leaner.pm
@@ -137,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 {
@@ -236,6 +238,8 @@ sub import {
 
 =head2 C<< skip $reason => $count >>
 
+See L<Test::More/skip>.
+
 =cut
 
 sub skip {
@@ -271,6 +275,8 @@ sub skip {
 
 =head2 C<done_testing [ $count ]>
 
+See L<Test::More/done_testing>.
+
 =cut
 
 sub done_testing {
@@ -302,6 +308,8 @@ sub done_testing {
 
 =head2 C<ok $ok [, $desc ]>
 
+See L<Test::More/ok>.
+
 =cut
 
 sub ok ($;$) {
@@ -329,6 +337,8 @@ sub ok ($;$) {
 
 =head2 C<pass [ $desc ]>
 
+See L<Test::More/pass>.
+
 =cut
 
 sub pass (;$) {
@@ -338,6 +348,8 @@ sub pass (;$) {
 
 =head2 C<fail [ $desc ]>
 
+See L<Test::More/fail>.
+
 =cut
 
 sub fail (;$) {
@@ -347,6 +359,8 @@ sub fail (;$) {
 
 =head2 C<is $got, $expected [, $desc ]>
 
+See L<Test::More/is>.
+
 =cut
 
 sub is ($$;$) {
@@ -361,6 +375,8 @@ sub is ($$;$) {
 
 =head2 C<isnt $got, $expected [, $desc ]>
 
+See L<Test::More/isnt>.
+
 =cut
 
 sub isnt ($$;$) {
@@ -446,10 +462,12 @@ IS_BINOP
 
 =head2 C<like $got, $regexp_expected [, $desc ]>
 
-=cut
+See L<Test::More/like>.
 
 =head2 C<unlike $got, $regexp_expected, [, $desc ]>
 
+See L<Test::More/unlike>.
+
 =cut
 
 {
@@ -460,6 +478,8 @@ IS_BINOP
 
 =head2 C<cmp_ok $got, $op, $expected [, $desc ]>
 
+See L<Test::More/cmp_ok>.
+
 =cut
 
 sub cmp_ok ($$$;$) {
@@ -475,20 +495,75 @@ sub cmp_ok ($$$;$) {
 
 =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);
+ 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;
+ 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.
@@ -499,25 +574,9 @@ sub _deep_check {
  # $x eq $y test.
  return 0 unless $ry;
 
- if ($ry eq 'ARRAY') {
-  if ($#$x == $#$y) {
-   # Prevent vivification of deleted elements by fetching the array values.
-   my ($ex, $ey);
-   _deep_check($ex = $x->[$_], $ey = $y->[$_]) or return 0 for 0 .. $#$y;
-   return 1;
-  }
- } elsif ($ry eq 'HASH') {
-  if (keys(%$x) == keys(%$y)) {
-   (exists $x->{$_} and _deep_check($x->{$_}, $y->{$_}))
-                                                       or return 0 for keys %$y;
-   return 1;
-  }
- } elsif ($ry eq 'SCALAR' or $ry eq 'REF') {
-  return _deep_check($$x, $$y);
- }
-
- return 0;
-};
+ # We know that $x and $y are both references of type $ry, without overloading.
+ _deep_ref_check($x, $y, $ry);
+}
 
 sub is_deeply {
  @_ = (
@@ -547,6 +606,8 @@ sub _diag_fh {
 
 =head2 C<diag @text>
 
+See L<Test::More/diag>.
+
 =cut
 
 sub diag {
@@ -556,6 +617,8 @@ sub diag {
 
 =head2 C<note @text>
 
+See L<Test::More/note>.
+
 =cut
 
 sub note {
@@ -565,6 +628,8 @@ sub note {
 
 =head2 C<BAIL_OUT [ $desc ]>
 
+See L<Test::More/BAIL_OUT>.
+
 =cut
 
 sub BAIL_OUT {