=head1 VERSION
-Version 0.01
+Version 0.03
=cut
-our $VERSION = '0.01';
+our $VERSION = '0.03';
=head1 SYNOPSIS
=item *
Stringification isn't forced on the test operands.
-However, L</ok> honors C<'bool'> overloading, L</is> honors C<'eq'> overloading and L</cmp_ok> honors whichever overloading category corresponds to the specified operator.
+However, L</ok> honors C<'bool'> overloading, L</is> and L</is_deeply> honor C<'eq'> overloading (and just that one), L</isnt> honors C<'ne'> overloading, 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.
+L</pass>, L</fail>, L</ok>, L</is>, L</isnt>, L</like>, L</unlike>, L</cmp_ok> and L</is_deeply> are all guaranteed to return the truth value of the test.
+
+=item *
+
+C<isn't> (the sub C<t> in package C<isn>) is not aliased to L</isnt>.
+
+=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 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 *
=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.
+Moreover, this allows a much faster variant of L</is_deeply>.
+
+=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.
=back
use Exporter ();
+my $main_process;
+
BEGIN {
+ $main_process = $$;
+
if ($] >= 5.008 and $INC{'threads.pm'}) {
my $use_ithreads = do {
require Config;
my ($plan, $test, $failed, $no_diag, $done_testing);
+our @EXPORT = qw<
+ plan
+ skip
+ done_testing
+ pass
+ fail
+ ok
+ is
+ isnt
+ like
+ unlike
+ cmp_ok
+ is_deeply
+ diag
+ note
+ BAIL_OUT
+>;
+
+=head1 ENVIRONMENT
+
+=head2 C<PERL_TEST_LEANER_USES_TEST_MORE>
+
+If this environment variable is set, L<Test::Leaner> will replace its functions by those from L<Test::More>.
+Moreover, the symbols that are imported when you C<use Test::Leaner> will be those from L<Test::More>, but you can still only import the symbols originally defined in L<Test::Leaner> (hence the functions from L<Test::More> that are not implemented in L<Test::Leaner> will not be imported).
+If your version of L<Test::More> is too old and doesn't have some symbols (like L</note> or L</done_testing>), they will be replaced in L<Test::Leaner> by croaking stubs.
+
+This may be useful if your L<Test::Leaner>-based test script fails and you want extra diagnostics.
+
+=cut
+
+sub _handle_import_args {
+ my @imports;
+
+ my $i = 0;
+ while ($i <= $#_) {
+ my $item = $_[$i];
+ my $splice;
+ if (defined $item) {
+ if ($item eq 'import') {
+ push @imports, @{ $_[$i+1] };
+ $splice = 2;
+ } elsif ($item eq 'no_diag') {
+ lock $plan if THREADSAFE;
+ $no_diag = 1;
+ $splice = 1;
+ }
+ }
+ if ($splice) {
+ splice @_, $i, $splice;
+ } else {
+ ++$i;
+ }
+ }
+
+ return @imports;
+}
+
+if ($ENV{PERL_TEST_LEANER_USES_TEST_MORE}) {
+ require Test::More;
+
+ my $leaner_stash = \%Test::Leaner::;
+ my $more_stash = \%Test::More::;
+
+ my %stubbed;
+
+ for (@EXPORT) {
+ my $replacement = exists $more_stash->{$_} ? *{$more_stash->{$_}}{CODE}
+ : undef;
+ unless (defined $replacement) {
+ $stubbed{$_}++;
+ $replacement = sub {
+ @_ = ("$_ is not implemented in this version of Test::More");
+ goto &croak;
+ };
+ }
+ no warnings 'redefine';
+ $leaner_stash->{$_} = $replacement;
+ }
+
+ my $import = sub {
+ my $class = shift;
+
+ my @imports = &_handle_import_args;
+ if (@imports == grep /^!/, @imports) {
+ # All imports are negated, or @imports is empty
+ my %negated;
+ /^!(.*)/ and ++$negated{$1} for @imports;
+ push @imports, grep !$negated{$_}, @EXPORT;
+ }
+
+ my @test_more_imports;
+ for (@imports) {
+ if ($stubbed{$_}) {
+ my $pkg = caller;
+ no strict 'refs';
+ *{$pkg."::$_"} = $leaner_stash->{$_};
+ } elsif (/^!/ or !exists $more_stash->{$_} or exists $leaner_stash->{$_}) {
+ push @test_more_imports, $_;
+ } else {
+ # Croak for symbols in Test::More but not in Test::Leaner
+ Exporter::import($class, $_);
+ }
+ }
+
+ my $test_more_import = 'Test::More'->can('import');
+ return unless $test_more_import;
+
+ @_ = (
+ 'Test::More',
+ @_,
+ import => \@test_more_imports,
+ );
+ {
+ lock $plan if THREADSAFE;
+ push @_, 'no_diag' if $no_diag;
+ }
+
+ goto $test_more_import;
+ };
+
+ no warnings 'redefine';
+ *import = $import;
+
+ return 1;
+}
+
sub NO_PLAN () { -1 }
sub SKIP_ALL () { -2 }
sub carp {
my $level = 1 + ($Test::Builder::Level || 0);
- my ($file, $line) = (caller $level)[1, 2];
+ my @caller;
+ do {
+ @caller = caller $level--;
+ } while (!@caller and $level >= 0);
+ my ($file, $line) = @caller[1, 2];
warn @_, " at $file line $line.\n";
}
sub croak {
my $level = 1 + ($Test::Builder::Level || 0);
- my ($file, $line) = (caller $level)[1, 2];
+ my @caller;
+ do {
+ @caller = caller $level--;
+ } while (!@caller and $level >= 0);
+ my ($file, $line) = @caller[1, 2];
die @_, " at $file line $line.\n";
}
-sub sanitize_comment {
+sub _sanitize_comment {
$_[0] =~ s/\n+\z//;
$_[0] =~ s/#/\\#/g;
$_[0] =~ s/\n/\n# /g;
=head2 C<< plan [ tests => $count | 'no_plan' | skip_all => $reason ] >>
+See L<Test::More/plan>.
+
=cut
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 {
return 1;
}
-our @EXPORT = qw<
- plan
- skip
- done_testing
- pass
- fail
- ok
- is
- isnt
- cmp_ok
- like
- unlike
- diag
- note
- BAIL_OUT
->;
-
sub import {
my $class = shift;
- my @imports;
- my $i = 0;
- while ($i <= $#_) {
- my $item = $_[$i];
- my $splice;
- if (defined $item) {
- if ($item eq 'import') {
- push @imports, @{ $_[$i+1] };
- $splice = 2;
- } elsif ($item eq 'no_diag') {
- lock $plan if THREADSAFE;
- $no_diag = 1;
- $splice = 1;
- }
- }
- if ($splice) {
- splice @_, $i, $splice;
- } else {
- ++$i;
- }
- }
+ my @imports = &_handle_import_args;
if (@_) {
local $Test::Builder::Level = ($Test::Builder::Level || 0) + 1;
=head2 C<< skip $reason => $count >>
+See L<Test::More/skip>.
+
=cut
sub skip {
my $skip_str = "ok $test # skip";
if (defined $reason) {
- sanitize_comment($reason);
+ _sanitize_comment($reason);
$skip_str .= " $reason" if length $reason;
}
=head2 C<done_testing [ $count ]>
+See L<Test::More/done_testing>.
+
=cut
sub done_testing {
=head2 C<ok $ok [, $desc ]>
+See L<Test::More/ok>.
+
=cut
sub ok ($;$) {
++$test;
my $test_str = "ok $test";
- unless ($ok) {
+ $ok or do {
$test_str = "not $test_str";
++$failed;
- }
+ };
if (defined $desc) {
- sanitize_comment($desc);
+ _sanitize_comment($desc);
$test_str .= " - $desc" if length $desc;
}
=head2 C<pass [ $desc ]>
+See L<Test::More/pass>.
+
=cut
sub pass (;$) {
=head2 C<fail [ $desc ]>
+See L<Test::More/fail>.
+
=cut
sub fail (;$) {
=head2 C<is $got, $expected [, $desc ]>
+See L<Test::More/is>.
+
=cut
sub is ($$;$) {
=head2 C<isnt $got, $expected [, $desc ]>
+See L<Test::More/isnt>.
+
=cut
sub isnt ($$;$) {
=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
{
=head2 C<cmp_ok $got, $op, $expected [, $desc ]>
+See L<Test::More/cmp_ok>.
+
=cut
sub cmp_ok ($$$;$) {
goto $handler;
}
+=head2 C<is_deeply $got, $expected [, $desc ]>
+
+See L<Test::More/is_deeply>.
+
+=cut
+
+BEGIN {
+ local $@;
+ if (eval { require Scalar::Util; 1 }) {
+ *_reftype = \&Scalar::Util::reftype;
+ } else {
+ # Stolen from Scalar::Util::PP
+ require B;
+ my %tmap = qw<
+ B::NULL SCALAR
+
+ B::HV HASH
+ B::AV ARRAY
+ B::CV CODE
+ B::IO IO
+ B::GV GLOB
+ B::REGEXP REGEXP
+ >;
+ *_reftype = sub ($) {
+ my $r = shift;
+
+ return undef unless length ref $r;
+
+ my $t = ref B::svref_2object($r);
+
+ return exists $tmap{$t} ? $tmap{$t}
+ : length ref $$r ? 'REF'
+ : 'SCALAR'
+ }
+ }
+}
+
+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 = _reftype($ey);
+ return 0 if _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 = _reftype($ey);
+ return 0 if _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 = _reftype($y);
+ return 0 if _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;
return if $no_diag;
my $msg = join '', map { defined($_) ? $_ : 'undef' } @_;
- sanitize_comment($msg);
+ _sanitize_comment($msg);
return unless length $msg;
local $\;
=head2 C<diag @text>
+See L<Test::More/diag>.
+
=cut
sub diag {
=head2 C<note @text>
+See L<Test::More/note>.
+
=cut
sub note {
=head2 C<BAIL_OUT [ $desc ]>
+See L<Test::More/BAIL_OUT>.
+
=cut
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
}
}
END {
- unless ($?) {
+ if ($main_process == $$ and not $?) {
lock $plan if THREADSAFE;
if (defined $plan) {
$? = $failed <= 254 ? $failed : 254;
} elsif ($plan >= 0) {
$? = $test == $plan ? 0 : 255;
- } elsif ($plan == NO_PLAN) {
+ }
+ if ($plan == NO_PLAN) {
local $\;
print $TAP_STREAM "1..$test\n";
}
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<Test::More>.
=head1 AUTHOR
=head1 COPYRIGHT & LICENSE
-Copyright 2010 Vincent Pit, all rights reserved.
+Copyright 2010,2011 Vincent Pit, all rights reserved.
+
+This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
+
+Except for the fallback implementation of the internal C<_reftype> function, which has been taken from L<Scalar::Util> and is
+
+Copyright 1997-2007 Graham Barr, all rights reserved.
This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
projects / perl / modules / Test-Leaner.git / blobdiff