=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> 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.
+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 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>).
+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 *
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.
-=item *
-
-L<Test::Leaner> depends on L<Scalar::Util>, while L<Test::More> does not.
-
=back
=cut
-use Exporter ();
-use Scalar::Util ();
+use Exporter ();
+
+my $main_process;
BEGIN {
+ $main_process = $$;
+
if ($] >= 5.008 and $INC{'threads.pm'}) {
my $use_ithreads = do {
require Config;
=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 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).
+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.
my $leaner_stash = \%Test::Leaner::;
my $more_stash = \%Test::More::;
- my %valid_imports;
+ my %stubbed;
for (@EXPORT) {
my $replacement = exists $more_stash->{$_} ? *{$more_stash->{$_}}{CODE}
: undef;
- if (defined $replacement) {
- $valid_imports{$_} = 1;
- } else {
+ unless (defined $replacement) {
+ $stubbed{$_}++;
$replacement = sub {
@_ = ("$_ is not implemented in this version of Test::More");
goto &croak;
}
my $import = sub {
- shift;
+ my $class = shift;
+
my @imports = &_handle_import_args;
- @imports = @EXPORT unless @imports;
+ 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 ($valid_imports{$_}) {
- push @test_more_imports, $_;
- } else {
+ 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',
@_,
lock $plan if THREADSAFE;
push @_, 'no_diag' if $no_diag;
}
+
goto $test_more_import;
};
++$test;
my $test_str = "ok $test";
- unless ($ok) {
+ $ok or do {
$test_str = "not $test_str";
++$failed;
- }
+ };
if (defined $desc) {
_sanitize_comment($desc);
$test_str .= " - $desc" if length $desc;
=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) = @_;
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;
+ $ry = _reftype($ey);
+ return 0 if _reftype($ex) ne $ry;
return 0 unless $ry and _deep_ref_check($ex, $ey, $ry);
}
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;
+ $ry = _reftype($ey);
+ return 0 if _reftype($ex) ne $ry;
return 0 unless $ry and _deep_ref_check($ex, $ey, $ry);
}
# 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;
+ 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.
}
END {
- unless ($?) {
+ if ($main_process == $$ and not $?) {
lock $plan if THREADSAFE;
if (defined $plan) {
L<perl> 5.6.
-L<Exporter>, L<Scalar::Util>, 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