Nicolas R. > Test-Parallel > Test::Parallel

Download:
Test-Parallel-0.20.tar.gz

Dependencies

Annotate this POD

View/Report Bugs
Module Version: 0.20   Source  

NAME Test::Parallel - simple object interface to launch unit test in parallel ^

VERSION ^

version 0.20

DESCRIPTION ^

Test::Parallel is a simple object interface used to launch test in parallel. It uses Parallel::ForkManager to launch tests in parallel and get the results.

Alias for basic methods are available

    ok is isnt like unlike cmp_ok is_deeply

Usage ^

Wrap common Test::More methods

It can be used nearly the same way as Test::More

    use Test::More tests => 8;
    use Test::Parallel;
    
    my $p = Test::Parallel->new();
    
    # queue some tests that can be parallelized
    $p->ok( sub { 1 }, "can do ok" );
    $p->is( sub { 42 }, 42, "can do is" );
    $p->isnt( sub { 42 }, 51, "can do isnt" );
    $p->like( sub { "abc" }, qr{ab}, "can do like: match ab");
    $p->unlike( sub { "abc" }, qr{xy}, "can do unlike: match ab");
    $p->cmp_ok( sub { 'abc' }, 'eq', 'abc', "can do cmp ok");
    $p->cmp_ok( sub { '1421' }, '==', 1_421, "can do cmp ok");
    $p->is_deeply( sub { [ 1..15 ] }, [ 1..15 ], "can do is_deeply");

    # run the tests in background
    $p->done();

Implement your own logic

You could also use the results returned by the test function to launch multiple test

    use Test::Parallel;
    use Test::More;

    my $p = Test::Parallel->new();
    $p->add( sub { 
        # will be launched in parallel
        # any code that take time to execute need to go there
        my $time = int( rand(42) );
        sleep( $time );
        return { number => 123, time => $time };
    },
        sub {
            # will be execute from the main thread ( not in parallel )
            my $result = shift;
            is $result->{number} => 123;
            cmp_ok $result->{time}, '<=', 42;                    
        }
     );
    
    $p->done();

METHODS ^

new

Create a new Test::Parallel object. By default it will use the number of cores you have as a maximum limit of parallelized job, but you can control this value with two options : - max_process : set the maximum process to this value - max_process_per_cpu : set the maximum process per cpu, this value will be multiplied by the number of cpu ( core ) avaiable on your server - max_memory : in MB per job. Will use the minimum between #cpu and total memory available / max_memory

    my $p = Test::Parallel->new()
        or Test::Parallel->new( max_process => N )
        or Test::Parallel->new( max_process_per_cpu => P )
        or Test::Parallel->new( max_memory => M )

ok

Same as Test::More::ok but need a code ref in first argument

is

Same as Test::More::is but need a code ref in first argument

isnt

Same as Test::More::isnt but need a code ref in first argument

like

Same as Test::More::like but need a code ref in first argument

unlike

Same as Test::More::unlike but need a code ref in first argument

cmp_ok

Same as Test::More::cmp_ok but need a code ref in first argument

is_deeply

Same as Test::More::is_deeply but need a code ref in first argument

$pm->add($code)

You can manually add some code to be launched in parallel, but if you uses this method you will need to manipulate yourself the final result.

Prefer using one of the following methods :

    ok is isnt like unlike cmp_ok is_deeply

$p->run

will run and wait for all jobs added you do not need to use this method except if you prefer to add jobs yourself and manipulate the results

$p->done

    you need to call this function when you are ready to launch all jobs in bg
    this method will call run and also check results with Test::More

$p->results

    get an array of results, in the same order of jobs

$p->result

    alias to results
syntax highlighting: