8 use vars (qw($VERSION @ISA @EXPORT @EXPORT_OK $ntest $TestLevel), #public-ish
9 qw($TESTOUT $TESTERR %Program_Lines $told_about_diff
10 $ONFAIL %todo %history $planned @FAILDETAIL) #private-ish
13 # In case a test is run in a persistent environment.
19 $TestLevel = 0; # how many extra stack frames to skip
27 @EXPORT = qw(&plan &ok &skip);
28 @EXPORT_OK = qw($ntest $TESTOUT $TESTERR);
31 $TESTOUT = *STDOUT{IO};
32 $TESTERR = *STDERR{IO};
34 # Use of this variable is strongly discouraged. It is set mainly to
35 # help test coverage analyzers know which test is running.
36 $ENV{REGRESSION_TEST} = $0;
41 Test - provides a simple framework for writing test scripts
48 # use a BEGIN block so we print our plan before MyModule is loaded
49 BEGIN { plan tests => 14, todo => [3,4] }
54 # Helpful notes. All note-lines must start with a "#".
55 print "# I'm testing MyModule version $MyModule::VERSION\n";
60 ok(0); # ok, expected failure (see todo list, above)
61 ok(1); # surprise success!
63 ok(0,1); # failure: '0' ne '1'
64 ok('broke','fixed'); # failure: 'broke' ne 'fixed'
65 ok('fixed','fixed'); # success: 'fixed' eq 'fixed'
66 ok('fixed',qr/x/); # success: 'fixed' =~ qr/x/
68 ok(sub { 1+1 }, 2); # success: '2' eq '2'
69 ok(sub { 1+1 }, 3); # failure: '2' ne '3'
72 ok @list, 3, "\@list=".join(',',@list); #extra notes
73 ok 'segmentation fault', '/(?i)success/'; #regex match
76 $^O =~ m/MSWin/ ? "Skip if MSWin" : 0, # whether to skip
77 $foo, $bar # arguments just like for ok(...)
80 $^O =~ m/MSWin/ ? 0 : "Skip unless MSWin", # whether to skip
81 $foo, $bar # arguments just like for ok(...)
86 This module simplifies the task of writing test files for Perl modules,
87 such that their output is in the format that
88 L<Test::Harness|Test::Harness> expects to see.
90 =head1 QUICK START GUIDE
92 To write a test for your new (and probably not even done) module, create
93 a new file called F<t/test.t> (in a new F<t> directory). If you have
94 multiple test files, to test the "foo", "bar", and "baz" feature sets,
95 then feel free to call your files F<t/foo.t>, F<t/bar.t>, and
100 This module defines three public functions, C<plan(...)>, C<ok(...)>,
101 and C<skip(...)>. By default, all three are exported by
102 the C<use Test;> statement.
108 BEGIN { plan %theplan; }
110 This should be the first thing you call in your test script. It
111 declares your testing plan, how many there will be, if any of them
112 should be allowed to fail, and so on.
114 Typical usage is just:
117 BEGIN { plan tests => 23 }
119 These are the things that you can put in the parameters to plan:
123 =item C<tests =E<gt> I<number>>
125 The number of tests in your script.
126 This means all ok() and skip() calls.
128 =item C<todo =E<gt> [I<1,5,14>]>
130 A reference to a list of tests which are allowed to fail.
133 =item C<onfail =E<gt> sub { ... }>
135 =item C<onfail =E<gt> \&some_sub>
137 A subroutine reference to be run at the end of the test script, if
138 any of the tests fail. See L</ONFAIL>.
142 You must call C<plan(...)> once and only once. You should call it
143 in a C<BEGIN {...}> block, like so:
145 BEGIN { plan tests => 23 }
150 croak "Test::plan(%args): odd number of arguments" if @_ & 1;
151 croak "Test::plan(): should not be called more than once" if $planned;
153 local($\, $,); # guard against -l and other things that screw with
158 _read_program( (caller)[1] );
162 my ($k,$v) = splice(@_, 0, 2);
163 if ($k =~ /^test(s)?$/) { $max = $v; }
164 elsif ($k eq 'todo' or
165 $k eq 'failok') { for (@$v) { $todo{$_}=1; }; }
166 elsif ($k eq 'onfail') {
167 ref $v eq 'CODE' or croak "Test::plan(onfail => $v): must be CODE";
170 else { carp "Test::plan(): skipping unrecognized directive '$k'" }
172 my @todo = sort { $a <=> $b } keys %todo;
174 print $TESTOUT "1..$max todo ".join(' ', @todo).";\n";
176 print $TESTOUT "1..$max\n";
179 print $TESTOUT "# Running under perl version $] for $^O",
180 (chr(65) eq 'A') ? "\n" : " in a non-ASCII world\n";
182 print $TESTOUT "# Win32::BuildNumber ", &Win32::BuildNumber(), "\n"
183 if defined(&Win32::BuildNumber) and defined &Win32::BuildNumber();
185 print $TESTOUT "# MacPerl version $MacPerl::Version\n"
186 if defined $MacPerl::Version;
189 "# Current time local: %s\n# Current time GMT: %s\n",
190 scalar(localtime($^T)), scalar(gmtime($^T));
192 print $TESTOUT "# Using Test.pm version $VERSION\n";
200 return unless defined $file and length $file
201 and -e $file and -f _ and -r _;
202 open(SOURCEFILE, "<$file") || return;
203 $Program_Lines{$file} = [<SOURCEFILE>];
206 foreach my $x (@{$Program_Lines{$file}})
207 { $x =~ tr/\cm\cj\n\r//d }
209 unshift @{$Program_Lines{$file}}, '';
217 my $value = _to_value($input);
219 Converts an C<ok> parameter to its value. Typically this just means
220 running it, if it's a code reference. You should run all inputted
227 return ref $v eq 'CODE' ? $v->() : $v;
232 return "<UNDEF>" unless defined $str;
236 $str =~ s/[\b]/\\b/g;
242 $str =~ s/([\0-\037])(?!\d)/sprintf('\\%o',ord($1))/eg;
243 $str =~ s/([\0-\037\177-\377])/sprintf('\\x%02X',ord($1))/eg;
244 $str =~ s/([^\0-\176])/sprintf('\\x{%X}',ord($1))/eg;
246 # substr( $str , 218-3 ) = "..."
247 # if length($str) >= 218 and !$ENV{PERL_TEST_NO_TRUNC};
259 ok($have, $expect, $diagnostics);
261 This function is the reason for C<Test>'s existence. It's
262 the basic function that
263 handles printing "C<ok>" or "C<not ok>", along with the
264 current test number. (That's what C<Test::Harness> wants to see.)
266 In its most basic usage, C<ok(...)> simply takes a single scalar
267 expression. If its value is true, the test passes; if false,
268 the test fails. Examples:
270 # Examples of ok(scalar)
272 ok( 1 + 1 == 2 ); # ok if 1 + 1 == 2
273 ok( $foo =~ /bar/ ); # ok if $foo contains 'bar'
274 ok( baz($x + $y) eq 'Armondo' ); # ok if baz($x + $y) returns
276 ok( @a == @b ); # ok if @a and @b are the same length
278 The expression is evaluated in scalar context. So the following will
281 ok( @stuff ); # ok if @stuff has any elements
282 ok( !grep !defined $_, @stuff ); # ok if everything in @stuff is
285 A special case is if the expression is a subroutine reference (in either
286 C<sub {...}> syntax or C<\&foo> syntax). In
287 that case, it is executed and its value (true or false) determines if
288 the test passes or fails. For example,
290 ok( sub { # See whether sleep works at least passably
291 my $start_time = time;
293 time() - $start_time >= 4
296 In its two-argument form, C<ok(I<arg1>, I<arg2>)> compares the two
297 scalar values to see if they match. They match if both are undefined,
298 or if I<arg2> is a regex that matches I<arg1>, or if they compare equal
301 # Example of ok(scalar, scalar)
303 ok( "this", "that" ); # not ok, 'this' ne 'that'
304 ok( "", undef ); # not ok, "" is defined
306 The second argument is considered a regex if it is either a regex
307 object or a string that looks like a regex. Regex objects are
308 constructed with the qr// operator in recent versions of perl. A
309 string is considered to look like a regex if its first and last
310 characters are "/", or if the first character is "m"
311 and its second and last characters are both the
312 same non-alphanumeric non-whitespace character. These regexp
316 ok( 'JaffO', '/Jaff/' ); # ok, 'JaffO' =~ /Jaff/
317 ok( 'JaffO', 'm|Jaff|' ); # ok, 'JaffO' =~ m|Jaff|
318 ok( 'JaffO', qr/Jaff/ ); # ok, 'JaffO' =~ qr/Jaff/;
319 ok( 'JaffO', '/(?i)jaff/ ); # ok, 'JaffO' =~ /jaff/i;
321 If either (or both!) is a subroutine reference, it is run and used
322 as the value for comparing. For example:
325 open(OUT, ">x.dat") || die $!;
326 print OUT "\x{e000}";
328 my $bytecount = -s 'x.dat';
329 unlink 'x.dat' or warn "Can't unlink : $!";
335 The above test passes two values to C<ok(arg1, arg2)> -- the first
336 a coderef, and the second is the number 4. Before C<ok> compares them,
337 it calls the coderef, and uses its return value as the real value of
338 this parameter. Assuming that C<$bytecount> returns 4, C<ok> ends up
339 testing C<4 eq 4>. Since that's true, this test passes.
341 Finally, you can append an optional third argument, in
342 C<ok(I<arg1>,I<arg2>, I<note>)>, where I<note> is a string value that
343 will be printed if the test fails. This should be some useful
344 information about the test, pertaining to why it failed, and/or
345 a description of the test. For example:
347 ok( grep($_ eq 'something unique', @stuff), 1,
348 "Something that should be unique isn't!\n".
349 '@stuff = '.join ', ', @stuff
352 Unfortunately, a note cannot be used with the single argument
353 style of C<ok()>. That is, if you try C<ok(I<arg1>, I<note>)>, then
354 C<Test> will interpret this as C<ok(I<arg1>, I<arg2>)>, and probably
355 end up testing C<I<arg1> eq I<arg2>> -- and that's not what you want!
357 All of the above special cases can occasionally cause some
358 problems. See L</BUGS and CAVEATS>.
362 # A past maintainer of this module said:
363 # <<ok(...)'s special handling of subroutine references is an unfortunate
364 # "feature" that can't be removed due to compatibility.>>
368 croak "ok: plan before you test!" if !$planned;
370 local($\,$,); # guard against -l and other things that screw with
373 my ($pkg,$file,$line) = caller($TestLevel);
374 my $repetition = ++$history{"$file:$line"};
375 my $context = ("$file at line $line".
376 ($repetition > 1 ? " fail \#$repetition" : ''));
378 # Are we comparing two values?
382 my $result = _to_value(shift);
383 my ($expected, $isregex, $regex);
388 $expected = _to_value(shift);
389 if (!defined $expected) {
390 $ok = !defined $result;
391 } elsif (!defined $result) {
393 } elsif (ref($expected) eq 'Regexp') {
394 $ok = $result =~ /$expected/;
396 } elsif (($regex) = ($expected =~ m,^ / (.+) / $,sx) or
397 (undef, $regex) = ($expected =~ m,^ m([^\w\s]) (.+) \1 $,sx)) {
398 $ok = $result =~ /$regex/;
400 $ok = $result eq $expected;
403 my $todo = $todo{$ntest};
405 $context .= ' TODO?!' if $todo;
406 print $TESTOUT "ok $ntest # ($context)\n";
408 # Issuing two seperate prints() causes problems on VMS.
410 print $TESTOUT "not ok $ntest\n";
413 print $TESTOUT "ok $ntest\n";
416 $ok or _complain($result, $expected,
418 'repetition' => $repetition, 'package' => $pkg,
419 'result' => $result, 'todo' => $todo,
420 'file' => $file, 'line' => $line,
421 'context' => $context, 'compare' => $compare,
422 @_ ? ('diagnostic' => _to_value(shift)) : (),
432 my($result, $expected, $detail) = @_;
433 $$detail{expected} = $expected if defined $expected;
435 # Get the user's diagnostic, protecting against multi-line
437 my $diag = $$detail{diagnostic};
438 $diag =~ s/\n/\n#/g if defined $diag;
440 $$detail{context} .= ' *TODO*' if $$detail{todo};
441 if (!$$detail{compare}) {
443 print $TESTERR "# Failed test $ntest in $$detail{context}\n";
445 print $TESTERR "# Failed test $ntest in $$detail{context}: $diag\n";
448 my $prefix = "Test $ntest";
450 print $TESTERR "# $prefix got: " . _quote($result) .
451 " ($$detail{context})\n";
452 $prefix = ' ' x (length($prefix) - 5);
453 my $expected_quoted = (defined $$detail{regex})
454 ? 'qr{'.($$detail{regex}).'}' : _quote($expected);
456 print $TESTERR "# $prefix Expected: $expected_quoted",
457 $diag ? " ($diag)" : (), "\n";
459 _diff_complain( $result, $expected, $detail, $prefix )
460 if defined($expected) and 2 < ($expected =~ tr/\n//);
463 if(defined $Program_Lines{ $$detail{file} }[ $$detail{line} ]) {
465 "# $$detail{file} line $$detail{line} is: $Program_Lines{ $$detail{file} }[ $$detail{line} ]\n"
466 if $Program_Lines{ $$detail{file} }[ $$detail{line} ]
467 =~ m/[^\s\#\(\)\{\}\[\]\;]/; # Otherwise it's uninformative
469 undef $Program_Lines{ $$detail{file} }[ $$detail{line} ];
470 # So we won't repeat it.
473 push @FAILDETAIL, $detail;
480 my($result, $expected, $detail, $prefix) = @_;
481 return _diff_complain_external(@_) if $ENV{PERL_TEST_DIFF};
482 return _diff_complain_algdiff(@_)
483 if eval { require Algorithm::Diff; Algorithm::Diff->VERSION(1.15); 1; };
485 $told_about_diff++ or print $TESTERR <<"EOT";
486 # $prefix (Install the Algorithm::Diff module to have differences in multiline
487 # $prefix output explained. You might also set the PERL_TEST_DIFF environment
488 # $prefix variable to run a diff program on the output.)
496 sub _diff_complain_external {
497 my($result, $expected, $detail, $prefix) = @_;
498 my $diff = $ENV{PERL_TEST_DIFF} || die "WHAAAA?";
501 my($got_fh, $got_filename) = File::Temp::tempfile("test-got-XXXXX");
502 my($exp_fh, $exp_filename) = File::Temp::tempfile("test-exp-XXXXX");
503 unless ($got_fh && $exp_fh) {
504 warn "Can't get tempfiles";
508 print $got_fh $result;
509 print $exp_fh $expected;
510 if (close($got_fh) && close($exp_fh)) {
511 my $diff_cmd = "$diff $exp_filename $got_filename";
512 print $TESTERR "#\n# $prefix $diff_cmd\n";
513 if (open(DIFF, "$diff_cmd |")) {
516 print $TESTERR "# $prefix $_";
521 warn "Can't run diff: $!";
524 warn "Can't write to tempfiles: $!";
526 unlink($got_filename);
527 unlink($exp_filename);
533 sub _diff_complain_algdiff {
534 my($result, $expected, $detail, $prefix) = @_;
536 my @got = split(/^/, $result);
537 my @exp = split(/^/, $expected);
542 my $diff_flush = sub {
543 return unless $diff_kind;
545 my $count_lines = @diff_lines;
546 my $s = $count_lines == 1 ? "" : "s";
547 my $first_line = $diff_lines[0][0] + 1;
549 print $TESTERR "# $prefix ";
550 if ($diff_kind eq "GOT") {
551 print $TESTERR "Got $count_lines extra line$s at line $first_line:\n";
552 for my $i (@diff_lines) {
553 print $TESTERR "# $prefix + " . _quote($got[$i->[0]]) . "\n";
555 } elsif ($diff_kind eq "EXP") {
556 if ($count_lines > 1) {
557 my $last_line = $diff_lines[-1][0] + 1;
558 print $TESTERR "Lines $first_line-$last_line are";
561 print $TESTERR "Line $first_line is";
563 print $TESTERR " missing:\n";
564 for my $i (@diff_lines) {
565 print $TESTERR "# $prefix - " . _quote($exp[$i->[1]]) . "\n";
567 } elsif ($diff_kind eq "CH") {
568 if ($count_lines > 1) {
569 my $last_line = $diff_lines[-1][0] + 1;
570 print $TESTERR "Lines $first_line-$last_line are";
573 print $TESTERR "Line $first_line is";
575 print $TESTERR " changed:\n";
576 for my $i (@diff_lines) {
577 print $TESTERR "# $prefix - " . _quote($exp[$i->[1]]) . "\n";
578 print $TESTERR "# $prefix + " . _quote($got[$i->[0]]) . "\n";
587 my $diff_collect = sub {
589 &$diff_flush() if $diff_kind && $diff_kind ne $kind;
591 push(@diff_lines, [@_]);
595 Algorithm::Diff::traverse_balanced(
598 DISCARD_A => sub { &$diff_collect("GOT", @_) },
599 DISCARD_B => sub { &$diff_collect("EXP", @_) },
600 CHANGE => sub { &$diff_collect("CH", @_) },
601 MATCH => sub { &$diff_flush() },
612 #~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~`~
615 =item C<skip(I<skip_if_true>, I<args...>)>
617 This is used for tests that under some conditions can be skipped. It's
618 basically equivalent to:
620 if( $skip_if_true ) {
626 ...except that the C<ok(1)> emits not just "C<ok I<testnum>>" but
627 actually "C<ok I<testnum> # I<skip_if_true_value>>".
629 The arguments after the I<skip_if_true> are what is fed to C<ok(...)> if
630 this test isn't skipped.
635 $^O =~ m/MSWin/ ? 'Skip if under MSWin' : '';
637 # A test to be skipped if under MSWin (i.e., run except under MSWin)
638 skip($if_MSWin, thing($foo), thing($bar) );
640 Or, going the other way:
643 $^O =~ m/MSWin/ ? '' : 'Skip unless under MSWin';
645 # A test to be skipped unless under MSWin (i.e., run only under MSWin)
646 skip($unless_MSWin, thing($foo), thing($bar) );
648 The tricky thing to remember is that the first parameter is true if
649 you want to I<skip> the test, not I<run> it; and it also doubles as a
650 note about why it's being skipped. So in the first codeblock above, read
651 the code as "skip if MSWin -- (otherwise) test whether C<thing($foo)> is
652 C<thing($bar)>" or for the second case, "skip unless MSWin...".
654 Also, when your I<skip_if_reason> string is true, it really should (for
655 backwards compatibility with older Test.pm versions) start with the
656 string "Skip", as shown in the above examples.
658 Note that in the above cases, C<thing($foo)> and C<thing($bar)>
659 I<are> evaluated -- but as long as the C<skip_if_true> is true,
660 then we C<skip(...)> just tosses out their value (i.e., not
661 bothering to treat them like values to C<ok(...)>. But if
662 you need to I<not> eval the arguments when skipping the
668 # This code returns true if the test passes.
669 # (But it doesn't even get called if the test is skipped.)
670 thing($foo) eq thing($bar)
674 or even this, which is basically equivalent:
677 sub { thing($foo) }, sub { thing($bar) }
680 That is, both are like this:
682 if( $unless_MSWin ) {
683 ok(1); # but it actually appends "# $unless_MSWin"
684 # so that Test::Harness can tell it's a skip
686 # Not skipping, so actually call and evaluate...
687 ok( sub { thing($foo) }, sub { thing($bar) } );
693 local($\, $,); # guard against -l and other things that screw with
696 my $whyskip = _to_value(shift);
697 if (!@_ or $whyskip) {
698 $whyskip = '' if $whyskip =~ m/^\d+$/;
699 $whyskip =~ s/^[Ss]kip(?:\s+|$)//; # backwards compatibility, old
700 # versions required the reason
701 # to start with 'skip'
702 # We print in one shot for VMSy reasons.
703 my $ok = "ok $ntest # skip";
704 $ok .= " $whyskip" if length $whyskip;
710 # backwards compatibility (I think). skip() used to be
711 # called like ok(), which is weird. I haven't decided what to do with
713 # warn <<WARN if $^W;
714 #This looks like a skip() using the very old interface. Please upgrade to
715 #the documented interface as this has been deprecated.
718 local($TestLevel) = $TestLevel+1; #to ignore this stack frame
728 $ONFAIL->(\@FAILDETAIL) if @FAILDETAIL && $ONFAIL;
740 These tests are expected to succeed. Usually, most or all of your tests
741 are in this category. If a normal test doesn't succeed, then that
742 means that something is I<wrong>.
744 =item * SKIPPED TESTS
746 The C<skip(...)> function is for tests that might or might not be
747 possible to run, depending
748 on the availability of platform-specific features. The first argument
749 should evaluate to true (think "yes, please skip") if the required
750 feature is I<not> available. After the first argument, C<skip(...)> works
751 exactly the same way as C<ok(...)> does.
755 TODO tests are designed for maintaining an B<executable TODO list>.
756 These tests are I<expected to fail.> If a TODO test does succeed,
757 then the feature in question shouldn't be on the TODO list, now
760 Packages should NOT be released with succeeding TODO tests. As soon
761 as a TODO test starts working, it should be promoted to a normal test,
762 and the newly working feature should be documented in the release
763 notes or in the change log.
769 BEGIN { plan test => 4, onfail => sub { warn "CALL 911!" } }
771 Although test failures should be enough, extra diagnostics can be
772 triggered at the end of a test run. C<onfail> is passed an array ref
773 of hash refs that describe each test failure. Each hash will contain
774 at least the following fields: C<package>, C<repetition>, and
775 C<result>. (You shouldn't rely on any other fields being present.) If the test
776 had an expected value or a diagnostic (or "note") string, these will also be
779 The I<optional> C<onfail> hook might be used simply to print out the
780 version of your package and/or how to report problems. It might also
781 be used to generate extremely sophisticated diagnostics for a
782 particularly bizarre test failure. However it's not a panacea. Core
783 dumps or other unrecoverable errors prevent the C<onfail> hook from
784 running. (It is run inside an C<END> block.) Besides, C<onfail> is
785 probably over-kill in most cases. (Your test code should be simpler
786 than the code it is testing, yes?)
789 =head1 BUGS and CAVEATS
795 C<ok(...)>'s special handing of strings which look like they might be
796 regexes can also cause unexpected behavior. An innocent:
798 ok( $fileglob, '/path/to/some/*stuff/' );
800 will fail, since Test.pm considers the second argument to be a regex!
801 The best bet is to use the one-argument form:
803 ok( $fileglob eq '/path/to/some/*stuff/' );
807 C<ok(...)>'s use of string C<eq> can sometimes cause odd problems
809 numbers, especially if you're casting a string to a number:
812 ok( $foo, 1 ); # not ok, "1.0" ne 1
814 Your best bet is to use the single argument form:
816 ok( $foo == 1 ); # ok "1.0" == 1
820 As you may have inferred from the above documentation and examples,
821 C<ok>'s prototype is C<($;$$)> (and, incidentally, C<skip>'s is
822 C<($;$$$)>). This means, for example, that you can do C<ok @foo, @bar>
823 to compare the I<size> of the two arrays. But don't be fooled into
824 thinking that C<ok @foo, @bar> means a comparison of the contents of two
825 arrays -- you're comparing I<just> the number of elements of each. It's
826 so easy to make that mistake in reading C<ok @foo, @bar> that you might
827 want to be very explicit about it, and instead write C<ok scalar(@foo),
832 This almost definitely doesn't do what you expect:
834 ok $thingy->can('some_method');
836 Why? Because C<can> returns a coderef to mean "yes it can (and the
837 method is this...)", and then C<ok> sees a coderef and thinks you're
838 passing a function that you want it to call and consider the truth of
839 the result of! I.e., just like:
841 ok $thingy->can('some_method')->();
843 What you probably want instead is this:
845 ok $thingy->can('some_method') && 1;
847 If the C<can> returns false, then that is passed to C<ok>. If it
848 returns true, then the larger expression S<< C<<
849 $thingy->can('some_method') && 1 >> >> returns 1, which C<ok> sees as
850 a simple signal of success, as you would expect.
855 The syntax for C<skip> is about the only way it can be, but it's still
856 quite confusing. Just start with the above examples and you'll
859 Moreover, users may expect this:
861 skip $unless_mswin, foo($bar), baz($quux);
863 to not evaluate C<foo($bar)> and C<baz($quux)> when the test is being
864 skipped. But in reality, they I<are> evaluated, but C<skip> just won't
865 bother comparing them if C<$unless_mswin> is true.
869 skip $unless_mswin, sub{foo($bar)}, sub{baz($quux)};
871 But that's not terribly pretty. You may find it simpler or clearer in
872 the long run to just do things like this:
874 if( $^O =~ m/MSWin/ ) {
875 print "# Yay, we're under $^O\n";
876 ok foo($bar), baz($quux);
877 ok thing($whatever), baz($stuff);
878 ok blorp($quux, $whatever);
879 ok foo($barzbarz), thang($quux);
881 print "# Feh, we're under $^O. Watch me skip some tests...\n";
882 for(1 .. 4) { skip "Skip unless under MSWin" }
885 But be quite sure that C<ok> is called exactly as many times in the
886 first block as C<skip> is called in the second block.
893 If C<PERL_TEST_DIFF> environment variable is set, it will be used as a
894 command for comparing unexpected multiline results. If you have GNU
895 diff installed, you might want to set C<PERL_TEST_DIFF> to C<diff -u>.
896 If you don't have a suitable program, you might install the
897 C<Text::Diff> module and then set C<PERL_TEST_DIFF> to be C<perl
898 -MText::Diff -e 'print diff(@ARGV)'>. If C<PERL_TEST_DIFF> isn't set
899 but the C<Algorithm::Diff> module is available, then it will be used
900 to show the differences in multiline results.
903 If C<PERL_TEST_NO_TRUNC> is set, then the initial "Got 'something' but
904 expected 'something_else'" readings for long multiline output values aren't
905 truncated at about the 230th column, as they normally could be in some
906 cases. Normally you won't need to use this, unless you were carefully
907 parsing the output of your test programs.
912 A past developer of this module once said that it was no longer being
913 actively developed. However, rumors of its demise were greatly
914 exaggerated. Feedback and suggestions are quite welcome.
916 Be aware that the main value of this module is its simplicity. Note
917 that there are already more ambitious modules out there, such as
918 L<Test::More> and L<Test::Unit>.
920 Some earlier versions of this module had docs with some confusing
921 typos in the description of C<skip(...)>.
928 L<Test::Simple>, L<Test::More>, L<Devel::Cover>
930 L<Test::Builder> for building your own testing library.
932 L<Test::Unit> is an interesting XUnit-style testing library.
934 L<Test::Inline> and L<SelfTest> let you embed tests in code.
939 Copyright (c) 1998-2000 Joshua Nathaniel Pritikin.
941 Copyright (c) 2001-2002 Michael G. Schwern.
943 Copyright (c) 2002-2004 Sean M. Burke.
945 Current maintainer: Jesse Vincent. E<lt>jesse@bestpractical.comE<gt>
947 This package is free software and is provided "as is" without express
948 or implied warranty. It may be used, redistributed and/or modified
949 under the same terms as Perl itself.
953 # "Your mistake was a hidden intention."
954 # -- /Oblique Strategies/, Brian Eno and Peter Schmidt