There are cases when you will not know beforehand how many tests your script is going to run. In this case, you can declare your tests at the end. use Test::More; ... run your tests ... done_testing( $number_of_tests_run ); Sometimes you really don't know how many tests were run, or it's too difficult to calculate. In which case you can leave off $number_of_tests_run.

So would it be any harm just leave off the number of tests until you are done writing all the tests? I guess I'm just not entirely clear on why keeping this number accurate is important, then. I guess so Test::More will know if all test ran successfully so it can give an accurate final report as to whether all tests were completed successfully?

$PM = "Perl Monk's";
$MCF = "Most Clueless Friar Abbot Bishop Pontiff Deacon Curate";
$nysus = $PM . ' ' . $MCF;
Click here if you love Perl Monks

You can comment some test off when working on a feature, but the number of tests will tell you when you forget to uncomment them. Also, if you run a test in a loop (some theories say you should never do that), the number of tests checks the number of iterations.

Also, we use Test::Spec at work. If you place a test to a wrong part of the code (outside of an it/they ), it could never run. Having the number of tests specified means you know the test didn't run.

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

Perhaps I'm reading too far into this... is this all you are looking for?

use warnings;
use strict;

use Test::More;

{ # 5 tests

    is 5, 5, "five ok";
    is 25/5, 5, "25 by 5 ok";
}

{ # 6 tests

    is 6, 6, "six ok";
    is 6**6/6**2, 1296, "odd division ok"
}

{ # unexpected test
 
    my $ok;
    
    $ok = eval { die "another test!?!\n"; 1; };
    is $ok, undef, "we died expectedly";
    like $@, qr/^another test/, "...err msg ok";
}

done_testing();
[download]

G'day nysus,

I often use the plan() function of Test::More like this:

use Test::More;

my @tests = (
    [ @test_input_args_1, $expected_output_1 ],
    ...
    [ @test_input_args_N, $expected_output_N ],
);

plan tests => scalar @tests;

# run tests here
[download]

Here's three examples from posts I've made in recent weeks:

• Re: Recognizing 3 and 4 digit number
• Re: Win32 ->Replacement->{Text} more than 255 characters
• Re: OCR matching regex

The Test::More doco gives this example:

plan tests => keys %Stuff * 3;
[download]

I bundle stuff up to make individual count idiosyncrasies easier to track and I leave them all as done_testing() without a count until I am done writing them and then I enter the counts. The counts RFC:SHOULD be there. There are cases where the tests will fail or skip and without the count, they might appear to pass. Simplistic example of my prefered approach–

Update: Added an idiom I use and like.

use strictures;
use Test::More;

subtest "This stuff with namespace and test count isolation" => sub {
    my @whatever = 1 .. 3;
    ok $_, "$_ is okay" for @whatever;
    return done_testing(scalar @whatever) if $ENV{FULL_MOON};
    ok "one more", "One more is okay";
    done_testing(1+@whatever);
};

subtest "That stuff" => sub {
    my %whatever = ( 1 => "One", 2 => "Two" );
    ok $_, "$whatever{$_} is okay" for keys %whatever;
    done_testing(scalar keys %whatever);
};

done_testing(2);
[download]