9944e257a4b6d31ba7e1aa88b395e7e0d1a1d38a
[perl/modules/indirect.git] / t / lib / Test / Leaner.pm
1 package Test::Leaner;
2
3 use 5.006;
4 use strict;
5 use warnings;
6
7 =head1 NAME
8
9 Test::Leaner - A slimmer Test::More for when you favor performance over completeness.
10
11 =head1 VERSION
12
13 Version 0.05
14
15 =cut
16
17 our $VERSION = '0.05';
18
19 =head1 SYNOPSIS
20
21     use Test::Leaner tests => 10_000;
22     for (1 .. 10_000) {
23      ...
24      is $one, 1, "checking situation $_";
25     }
26
27
28 =head1 DESCRIPTION
29
30 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>.
31
32 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.
33 Its functions behave the same as their L<Test::More> counterparts, except for the following differences :
34
35 =over 4
36
37 =item *
38
39 Stringification isn't forced on the test operands.
40 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.
41
42 =item *
43
44 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.
45
46 =item *
47
48 C<isn't> (the sub C<t> in package C<isn>) is not aliased to L</isnt>.
49
50 =item *
51
52 L</like> and L</unlike> don't special case regular expressions that are passed as C<'/.../'> strings.
53 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>).
54
55 =item *
56
57 L</cmp_ok> throws an exception if the given operator isn't a valid Perl binary operator (except C<'='> and variants).
58 It also tests in scalar context, so C<'..'> will be treated as the flip-flop operator and not the range operator.
59
60 =item *
61
62 L</is_deeply> doesn't guard for memory cycles.
63 If the two first arguments present parallel memory cycles, the test may result in an infinite loop.
64
65 =item *
66
67 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.
68 Moreover, this allows a much faster variant of L</is_deeply>.
69
70 =item *
71
72 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.
73
74 =back
75
76 =cut
77
78 use Exporter ();
79
80 my $main_process;
81
82 BEGIN {
83  $main_process = $$;
84
85  if ("$]" >= 5.008 and $INC{'threads.pm'}) {
86   my $use_ithreads = do {
87    require Config;
88    no warnings 'once';
89    $Config::Config{useithreads};
90   };
91   if ($use_ithreads) {
92    require threads::shared;
93    *THREADSAFE = sub () { 1 };
94   }
95  }
96  unless (defined &Test::Leaner::THREADSAFE) {
97   *THREADSAFE = sub () { 0 }
98  }
99 }
100
101 my ($TAP_STREAM, $DIAG_STREAM);
102
103 my ($plan, $test, $failed, $no_diag, $done_testing);
104
105 our @EXPORT = qw<
106  plan
107  skip
108  done_testing
109  pass
110  fail
111  ok
112  is
113  isnt
114  like
115  unlike
116  cmp_ok
117  is_deeply
118  diag
119  note
120  BAIL_OUT
121 >;
122
123 =head1 ENVIRONMENT
124
125 =head2 C<PERL_TEST_LEANER_USES_TEST_MORE>
126
127 If this environment variable is set, L<Test::Leaner> will replace its functions by those from L<Test::More>.
128 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).
129 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.
130
131 This may be useful if your L<Test::Leaner>-based test script fails and you want extra diagnostics.
132
133 =cut
134
135 sub _handle_import_args {
136  my @imports;
137
138  my $i = 0;
139  while ($i <= $#_) {
140   my $item = $_[$i];
141   my $splice;
142   if (defined $item) {
143    if ($item eq 'import') {
144     push @imports, @{ $_[$i+1] };
145     $splice  = 2;
146    } elsif ($item eq 'no_diag') {
147     lock $plan if THREADSAFE;
148     $no_diag = 1;
149     $splice  = 1;
150    }
151   }
152   if ($splice) {
153    splice @_, $i, $splice;
154   } else {
155    ++$i;
156   }
157  }
158
159  return @imports;
160 }
161
162 if ($ENV{PERL_TEST_LEANER_USES_TEST_MORE}) {
163  require Test::More;
164
165  my $leaner_stash = \%Test::Leaner::;
166  my $more_stash   = \%Test::More::;
167
168  my %stubbed;
169
170  for (@EXPORT) {
171   my $replacement = exists $more_stash->{$_} ? *{$more_stash->{$_}}{CODE}
172                                              : undef;
173   unless (defined $replacement) {
174    $stubbed{$_}++;
175    $replacement = sub {
176     @_ = ("$_ is not implemented in this version of Test::More");
177     goto &croak;
178    };
179   }
180   no warnings 'redefine';
181   $leaner_stash->{$_} = $replacement;
182  }
183
184  my $import = sub {
185   my $class = shift;
186
187   my @imports = &_handle_import_args;
188   if (@imports == grep /^!/, @imports) {
189    # All imports are negated, or @imports is empty
190    my %negated;
191    /^!(.*)/ and ++$negated{$1} for @imports;
192    push @imports, grep !$negated{$_}, @EXPORT;
193   }
194
195   my @test_more_imports;
196   for (@imports) {
197    if ($stubbed{$_}) {
198     my $pkg = caller;
199     no strict 'refs';
200     *{$pkg."::$_"} = $leaner_stash->{$_};
201    } elsif (/^!/ or !exists $more_stash->{$_} or exists $leaner_stash->{$_}) {
202     push @test_more_imports, $_;
203    } else {
204     # Croak for symbols in Test::More but not in Test::Leaner
205     Exporter::import($class, $_);
206    }
207   }
208
209   my $test_more_import = 'Test::More'->can('import');
210   return unless $test_more_import;
211
212   @_ = (
213    'Test::More',
214    @_,
215    import => \@test_more_imports,
216   );
217   {
218    lock $plan if THREADSAFE;
219    push @_, 'no_diag' if $no_diag;
220   }
221
222   goto $test_more_import;
223  };
224
225  no warnings 'redefine';
226  *import = $import;
227
228  return 1;
229 }
230
231 sub NO_PLAN  () { -1 }
232 sub SKIP_ALL () { -2 }
233
234 BEGIN {
235  if (THREADSAFE) {
236   threads::shared::share($_) for $plan, $test, $failed, $no_diag, $done_testing;
237  }
238
239  lock $plan if THREADSAFE;
240
241  $plan   = undef;
242  $test   = 0;
243  $failed = 0;
244 }
245
246 sub carp {
247  my $level = 1 + ($Test::Builder::Level || 0);
248  my @caller;
249  do {
250   @caller = caller $level--;
251  } while (!@caller and $level >= 0);
252  my ($file, $line) = @caller[1, 2];
253  warn @_, " at $file line $line.\n";
254 }
255
256 sub croak {
257  my $level = 1 + ($Test::Builder::Level || 0);
258  my @caller;
259  do {
260   @caller = caller $level--;
261  } while (!@caller and $level >= 0);
262  my ($file, $line) = @caller[1, 2];
263  die @_, " at $file line $line.\n";
264 }
265
266 sub _sanitize_comment {
267  $_[0] =~ s/\n+\z//;
268  $_[0] =~ s/#/\\#/g;
269  $_[0] =~ s/\n/\n# /g;
270 }
271
272 =head1 FUNCTIONS
273
274 The following functions from L<Test::More> are implemented and exported by default.
275
276 =head2 C<plan>
277
278     plan tests => $count;
279     plan 'no_plan';
280     plan skip_all => $reason;
281
282 See L<Test::More/plan>.
283
284 =cut
285
286 sub plan {
287  my ($key, $value) = @_;
288
289  return unless $key;
290
291  lock $plan if THREADSAFE;
292
293  croak("You tried to plan twice") if defined $plan;
294
295  my $plan_str;
296
297  if ($key eq 'no_plan') {
298   croak("no_plan takes no arguments") if $value;
299   $plan       = NO_PLAN;
300  } elsif ($key eq 'tests') {
301   croak("Got an undefined number of tests") unless defined $value;
302   croak("You said to run 0 tests")          unless $value;
303   croak("Number of tests must be a positive integer.  You gave it '$value'")
304                                             unless $value =~ /^\+?[0-9]+$/;
305   $plan       = $value;
306   $plan_str   = "1..$value";
307  } elsif ($key eq 'skip_all') {
308   $plan       = SKIP_ALL;
309   $plan_str   = '1..0 # SKIP';
310   if (defined $value) {
311    _sanitize_comment($value);
312    $plan_str .= " $value" if length $value;
313   }
314  } else {
315   my @args = grep defined, $key, $value;
316   croak("plan() doesn't understand @args");
317  }
318
319  if (defined $plan_str) {
320   local $\;
321   print $TAP_STREAM "$plan_str\n";
322  }
323
324  exit 0 if $plan == SKIP_ALL;
325
326  return 1;
327 }
328
329 sub import {
330  my $class = shift;
331
332  my @imports = &_handle_import_args;
333
334  if (@_) {
335   local $Test::Builder::Level = ($Test::Builder::Level || 0) + 1;
336   &plan;
337  }
338
339  @_ = ($class, @imports);
340  goto &Exporter::import;
341 }
342
343 =head2 C<skip>
344
345     skip $reason => $count;
346
347 See L<Test::More/skip>.
348
349 =cut
350
351 sub skip {
352  my ($reason, $count) = @_;
353
354  lock $plan if THREADSAFE;
355
356  if (not defined $count) {
357   carp("skip() needs to know \$how_many tests are in the block")
358                                       unless defined $plan and $plan == NO_PLAN;
359   $count = 1;
360  } elsif ($count =~ /[^0-9]/) {
361   carp('skip() was passed a non-numeric number of tests.  Did you get the arguments backwards?');
362   $count = 1;
363  }
364
365  for (1 .. $count) {
366   ++$test;
367
368   my $skip_str = "ok $test # skip";
369   if (defined $reason) {
370    _sanitize_comment($reason);
371    $skip_str  .= " $reason" if length $reason;
372   }
373
374   local $\;
375   print $TAP_STREAM "$skip_str\n";
376  }
377
378  no warnings 'exiting';
379  last SKIP;
380 }
381
382 =head2 C<done_testing>
383
384     done_testing;
385     done_testing $count;
386
387 See L<Test::More/done_testing>.
388
389 =cut
390
391 sub done_testing {
392  my ($count) = @_;
393
394  lock $plan if THREADSAFE;
395
396  $count = $test unless defined $count;
397  croak("Number of tests must be a positive integer.  You gave it '$count'")
398                                                  unless $count =~ /^\+?[0-9]+$/;
399
400  if (not defined $plan or $plan == NO_PLAN) {
401   $plan         = $count; # $plan can't be NO_PLAN anymore
402   $done_testing = 1;
403   local $\;
404   print $TAP_STREAM "1..$plan\n";
405  } else {
406   if ($done_testing) {
407    @_ = ('done_testing() was already called');
408    goto &fail;
409   } elsif ($plan != $count) {
410    @_ = ("planned to run $plan tests but done_testing() expects $count");
411    goto &fail;
412   }
413  }
414
415  return 1;
416 }
417
418 =head2 C<ok>
419
420     ok $ok;
421     ok $ok, $desc;
422
423 See L<Test::More/ok>.
424
425 =cut
426
427 sub ok ($;$) {
428  my ($ok, $desc) = @_;
429
430  lock $plan if THREADSAFE;
431
432  ++$test;
433
434  my $test_str = "ok $test";
435  $ok or do {
436   $test_str   = "not $test_str";
437   ++$failed;
438  };
439  if (defined $desc) {
440   _sanitize_comment($desc);
441   $test_str .= " - $desc" if length $desc;
442  }
443
444  local $\;
445  print $TAP_STREAM "$test_str\n";
446
447  return $ok;
448 }
449
450 =head2 C<pass>
451
452     pass;
453     pass $desc;
454
455 See L<Test::More/pass>.
456
457 =cut
458
459 sub pass (;$) {
460  unshift @_, 1;
461  goto &ok;
462 }
463
464 =head2 C<fail>
465
466     fail;
467     fail $desc;
468
469 See L<Test::More/fail>.
470
471 =cut
472
473 sub fail (;$) {
474  unshift @_, 0;
475  goto &ok;
476 }
477
478 =head2 C<is>
479
480     is $got, $expected;
481     is $got, $expected, $desc;
482
483 See L<Test::More/is>.
484
485 =cut
486
487 sub is ($$;$) {
488  my ($got, $expected, $desc) = @_;
489  no warnings 'uninitialized';
490  @_ = (
491   (not(defined $got xor defined $expected) and $got eq $expected),
492   $desc,
493  );
494  goto &ok;
495 }
496
497 =head2 C<isnt>
498
499     isnt $got, $expected;
500     isnt $got, $expected, $desc;
501
502 See L<Test::More/isnt>.
503
504 =cut
505
506 sub isnt ($$;$) {
507  my ($got, $expected, $desc) = @_;
508  no warnings 'uninitialized';
509  @_ = (
510   ((defined $got xor defined $expected) or $got ne $expected),
511   $desc,
512  );
513  goto &ok;
514 }
515
516 my %binops = (
517  'or'  => 'or',
518  'xor' => 'xor',
519  'and' => 'and',
520
521  '||'  => 'hor',
522  ('//' => 'dor') x ("$]" >= 5.010),
523  '&&'  => 'hand',
524
525  '|'   => 'bor',
526  '^'   => 'bxor',
527  '&'   => 'band',
528
529  'lt'  => 'lt',
530  'le'  => 'le',
531  'gt'  => 'gt',
532  'ge'  => 'ge',
533  'eq'  => 'eq',
534  'ne'  => 'ne',
535  'cmp' => 'cmp',
536
537  '<'   => 'nlt',
538  '<='  => 'nle',
539  '>'   => 'ngt',
540  '>='  => 'nge',
541  '=='  => 'neq',
542  '!='  => 'nne',
543  '<=>' => 'ncmp',
544
545  '=~'  => 'like',
546  '!~'  => 'unlike',
547  ('~~' => 'smartmatch') x ("$]" >= 5.010),
548
549  '+'   => 'add',
550  '-'   => 'substract',
551  '*'   => 'multiply',
552  '/'   => 'divide',
553  '%'   => 'modulo',
554  '<<'  => 'lshift',
555  '>>'  => 'rshift',
556
557  '.'   => 'concat',
558  '..'  => 'flipflop',
559  '...' => 'altflipflop',
560  ','   => 'comma',
561  '=>'  => 'fatcomma',
562 );
563
564 my %binop_handlers;
565
566 sub _create_binop_handler {
567  my ($op) = @_;
568  my $name = $binops{$op};
569  croak("Operator $op not supported") unless defined $name;
570  {
571   local $@;
572   eval <<"IS_BINOP";
573 sub is_$name (\$\$;\$) {
574  my (\$got, \$expected, \$desc) = \@_;
575  \@_ = (scalar(\$got $op \$expected), \$desc);
576  goto &ok;
577 }
578 IS_BINOP
579   die $@ if $@;
580  }
581  $binop_handlers{$op} = do {
582   no strict 'refs';
583   \&{__PACKAGE__."::is_$name"};
584  }
585 }
586
587 =head2 C<like>
588
589     like $got, $regexp_expected;
590     like $got, $regexp_expected, $desc;
591
592 See L<Test::More/like>.
593
594 =head2 C<unlike>
595
596     unlike $got, $regexp_expected;
597     unlike $got, $regexp_expected, $desc;
598
599 See L<Test::More/unlike>.
600
601 =cut
602
603 {
604  no warnings 'once';
605  *like   = _create_binop_handler('=~');
606  *unlike = _create_binop_handler('!~');
607 }
608
609 =head2 C<cmp_ok>
610
611     cmp_ok $got, $op, $expected;
612     cmp_ok $got, $op, $expected, $desc;
613
614 See L<Test::More/cmp_ok>.
615
616 =cut
617
618 sub cmp_ok ($$$;$) {
619  my ($got, $op, $expected, $desc) = @_;
620  my $handler = $binop_handlers{$op};
621  unless ($handler) {
622   local $Test::More::Level = ($Test::More::Level || 0) + 1;
623   $handler = _create_binop_handler($op);
624  }
625  @_ = ($got, $expected, $desc);
626  goto $handler;
627 }
628
629 =head2 C<is_deeply>
630
631     is_deeply $got, $expected;
632     is_deeply $got, $expected, $desc;
633
634 See L<Test::More/is_deeply>.
635
636 =cut
637
638 BEGIN {
639  local $@;
640  if (eval { require Scalar::Util; 1 }) {
641   *_reftype = \&Scalar::Util::reftype;
642  } else {
643   # Stolen from Scalar::Util::PP
644   require B;
645   my %tmap = qw<
646    B::NULL   SCALAR
647
648    B::HV     HASH
649    B::AV     ARRAY
650    B::CV     CODE
651    B::IO     IO
652    B::GV     GLOB
653    B::REGEXP REGEXP
654   >;
655   *_reftype = sub ($) {
656    my $r = shift;
657
658    return undef unless length ref $r;
659
660    my $t = ref B::svref_2object($r);
661
662    return exists $tmap{$t} ? $tmap{$t}
663                            : length ref $$r ? 'REF'
664                                             : 'SCALAR'
665   }
666  }
667 }
668
669 sub _deep_ref_check {
670  my ($x, $y, $ry) = @_;
671
672  no warnings qw<numeric uninitialized>;
673
674  if ($ry eq 'ARRAY') {
675   return 0 unless $#$x == $#$y;
676
677   my ($ex, $ey);
678   for (0 .. $#$y) {
679    $ex = $x->[$_];
680    $ey = $y->[$_];
681
682    # Inline the beginning of _deep_check
683    return 0 if defined $ex xor defined $ey;
684
685    next if not(ref $ex xor ref $ey) and $ex eq $ey;
686
687    $ry = _reftype($ey);
688    return 0 if _reftype($ex) ne $ry;
689
690    return 0 unless $ry and _deep_ref_check($ex, $ey, $ry);
691   }
692
693   return 1;
694  } elsif ($ry eq 'HASH') {
695   return 0 unless keys(%$x) == keys(%$y);
696
697   my ($ex, $ey);
698   for (keys %$y) {
699    return 0 unless exists $x->{$_};
700    $ex = $x->{$_};
701    $ey = $y->{$_};
702
703    # Inline the beginning of _deep_check
704    return 0 if defined $ex xor defined $ey;
705
706    next if not(ref $ex xor ref $ey) and $ex eq $ey;
707
708    $ry = _reftype($ey);
709    return 0 if _reftype($ex) ne $ry;
710
711    return 0 unless $ry and _deep_ref_check($ex, $ey, $ry);
712   }
713
714   return 1;
715  } elsif ($ry eq 'SCALAR' or $ry eq 'REF') {
716   return _deep_check($$x, $$y);
717  }
718
719  return 0;
720 }
721
722 sub _deep_check {
723  my ($x, $y) = @_;
724
725  no warnings qw<numeric uninitialized>;
726
727  return 0 if defined $x xor defined $y;
728
729  # Try object identity/eq overloading first. It also covers the case where
730  # $x and $y are both undefined.
731  # If either $x or $y is overloaded but none has eq overloading, the test will
732  # break at that point.
733  return 1 if not(ref $x xor ref $y) and $x eq $y;
734
735  # Test::More::is_deeply happily breaks encapsulation if the objects aren't
736  # overloaded.
737  my $ry = _reftype($y);
738  return 0 if _reftype($x) ne $ry;
739
740  # Shortcut if $x and $y are both not references and failed the previous
741  # $x eq $y test.
742  return 0 unless $ry;
743
744  # We know that $x and $y are both references of type $ry, without overloading.
745  _deep_ref_check($x, $y, $ry);
746 }
747
748 sub is_deeply {
749  @_ = (
750   &_deep_check,
751   $_[2],
752  );
753  goto &ok;
754 }
755
756 sub _diag_fh {
757  my $fh = shift;
758
759  return unless @_;
760
761  lock $plan if THREADSAFE;
762  return if $no_diag;
763
764  my $msg = join '', map { defined($_) ? $_ : 'undef' } @_;
765  _sanitize_comment($msg);
766  return unless length $msg;
767
768  local $\;
769  print $fh "# $msg\n";
770
771  return 0;
772 };
773
774 =head2 C<diag>
775
776     diag @lines;
777
778 See L<Test::More/diag>.
779
780 =cut
781
782 sub diag {
783  unshift @_, $DIAG_STREAM;
784  goto &_diag_fh;
785 }
786
787 =head2 C<note>
788
789     note @lines;
790
791 See L<Test::More/note>.
792
793 =cut
794
795 sub note {
796  unshift @_, $TAP_STREAM;
797  goto &_diag_fh;
798 }
799
800 =head2 C<BAIL_OUT>
801
802     BAIL_OUT;
803     BAIL_OUT $desc;
804
805 See L<Test::More/BAIL_OUT>.
806
807 =cut
808
809 sub BAIL_OUT {
810  my ($desc) = @_;
811
812  lock $plan if THREADSAFE;
813
814  my $bail_out_str = 'Bail out!';
815  if (defined $desc) {
816   _sanitize_comment($desc);
817   $bail_out_str  .= "  $desc" if length $desc; # Two spaces
818  }
819
820  local $\;
821  print $TAP_STREAM "$bail_out_str\n";
822
823  exit 255;
824 }
825
826 END {
827  if ($main_process == $$ and not $?) {
828   lock $plan if THREADSAFE;
829
830   if (defined $plan) {
831    if ($failed) {
832     $? = $failed <= 254 ? $failed : 254;
833    } elsif ($plan >= 0) {
834     $? = $test == $plan ? 0 : 255;
835    }
836    if ($plan == NO_PLAN) {
837     local $\;
838     print $TAP_STREAM "1..$test\n";
839    }
840   }
841  }
842 }
843
844 =pod
845
846 L<Test::Leaner> also provides some functions of its own, which are never exported.
847
848 =head2 C<tap_stream>
849
850     my $tap_fh = tap_stream;
851     tap_stream $fh;
852
853 Read/write accessor for the filehandle to which the tests are outputted.
854 On write, it also turns autoflush on onto C<$fh>.
855
856 Note that it can only be used as a write accessor before you start any thread, as L<threads::shared> cannot reliably share filehandles.
857
858 Defaults to C<STDOUT>.
859
860 =cut
861
862 sub tap_stream (;*) {
863  if (@_) {
864   $TAP_STREAM = $_[0];
865
866   my $fh = select $TAP_STREAM;
867   $|++;
868   select $fh;
869  }
870
871  return $TAP_STREAM;
872 }
873
874 tap_stream *STDOUT;
875
876 =head2 C<diag_stream>
877
878     my $diag_fh = diag_stream;
879     diag_stream $fh;
880
881 Read/write accessor for the filehandle to which the diagnostics are printed.
882 On write, it also turns autoflush on onto C<$fh>.
883
884 Just like L</tap_stream>, it can only be used as a write accessor before you start any thread, as L<threads::shared> cannot reliably share filehandles.
885
886 Defaults to C<STDERR>.
887
888 =cut
889
890 sub diag_stream (;*) {
891  if (@_) {
892   $DIAG_STREAM = $_[0];
893
894   my $fh = select $DIAG_STREAM;
895   $|++;
896   select $fh;
897  }
898
899  return $DIAG_STREAM;
900 }
901
902 diag_stream *STDERR;
903
904 =head2 C<THREADSAFE>
905
906 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>.
907 In that case, it also needs a working L<threads::shared>.
908
909 =head1 DEPENDENCIES
910
911 L<perl> 5.6.
912
913 L<Exporter>, L<Test::More>.
914
915 =head1 AUTHOR
916
917 Vincent Pit, C<< <perl at profvince.com> >>, L<http://www.profvince.com>.
918
919 You can contact me by mail or on C<irc.perl.org> (vincent).
920
921 =head1 BUGS
922
923 Please report any bugs or feature requests to C<bug-test-leaner at rt.cpan.org>, or through the web interface at L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Test-Leaner>.
924 I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.
925
926 =head1 SUPPORT
927
928 You can find documentation for this module with the perldoc command.
929
930     perldoc Test::Leaner
931
932 =head1 COPYRIGHT & LICENSE
933
934 Copyright 2010,2011,2013 Vincent Pit, all rights reserved.
935
936 This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
937
938 Except for the fallback implementation of the internal C<_reftype> function, which has been taken from L<Scalar::Util> and is
939
940 Copyright 1997-2007 Graham Barr, all rights reserved.
941
942 This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
943
944 =cut
945
946 1; # End of Test::Leaner