Free tests software for linux

Test::Resub is a lexically scoped subroutine replacement for testing.

SYNOPSIS

#!/usr/bin/perl

use Test::More tests => 4;
use Test::Resub qw(resub);

{
package Somewhere;
sub show {
my ($class, $message) = @_;
return "$class, $message";
}
}

# sanity
is( Somewhere->show(beyond the sea), Somewhere, beyond the sea );

# scoped replacement of subroutine with argument capturing
{
my $rs = resub Somewhere::show, sub { hi }, capture => 1;
is( Somewhere->show(over the rainbow), hi );
is_deeply( $rs->method_args, [[over the rainbow]] );
}

# scope ends, resub goes away, original code returns
is( Somewhere->show(waiting for me), Somewhere, waiting for me );

This module allows you to temporarily replace a subroutine/method with arbitrary code. Later, you can tell how many times was it called and with what arguments each time. You can also specify that the subroutine/method must get called, must not get called, or may be optionally called.

Test soon project is a testing framework trying to enable you to write tests quickly, organize them easily and still being flexible.

The goal is to utilize the strengths of C++ while minimizing the impact of its weaknesses.

Test::Unit::tests::AllTests is a unit testing framework self tests.

SYNOPSIS

# command line style use

perl TestRunner.pl Test::Unit::tests::AllTests

# GUI style use

perl TkTestRunner.pl Test::Unit::tests::AllTests

This class is used by the unit testing framework to encapsulate all the self tests of the framework.

Test::Unit::TestRunner is a unit testing framework helper class.

SYNOPSIS

use Test::Unit::TestRunner;

my $testrunner = Test::Unit::TestRunner->new();
$testrunner->start($my_testcase_class);

This class is the test runner for the command line style use of the testing framework.

It is used by simple command line tools like the TestRunner.pl script provided.
The class needs one argument, which is the name of the class encapsulating the tests to be run.

OPTIONS

-wait
wait for user confirmation between tests

-v
version info

Test::Class is a Perl module that allows you to easily create test classes in an xUnit/JUnit style.

SYNOPSIS

package Example::Test;
use base qw(Test::Class);
use Test::More;

# setup methods are run before every test method.
sub make_fixture : Test(setup) {
my $array = [1, 2];
shift->{test_array} = $array;
};

# a test method that runs 1 test
sub test_push : Test {
my $array = shift->{test_array};
push @$array, 3;
is_deeply($array, [1, 2, 3], push worked);
};

# a test method that runs 4 tests
sub test_pop : Test(4) {
my $array = shift->{test_array};
is(pop @$array, 2, pop = 2);
is(pop @$array, 1, pop = 1);
is_deeply($array, [], array empty);
is(pop @$array, undef, pop = undef);
};

# teardown methods are run after every test method.
sub teardown : Test(teardown) {
my $array = shift->{test_array};
diag("array = (@$array) after test(s)");
};
later in a nearby .t file
#! /usr/bin/perl
use Example::Test;

# run all the test methods in Example::Test
Test::Class->runtests;

Outputs:

1..5
ok 1 - pop = 2
ok 2 - pop = 1
ok 3 - array empty
ok 4 - pop = undef
# array = () after test(s)
ok 5 - push worked
# array = (1 2 3) after test(s)

Test::Unit::Runner::XML is a Perl module that can generate XML reports from unit test results.

SYNOPSIS

use Test::Unit::Runner::XML;

mkdir("test_reports");
my $runner = Test::Unit::Runner::XML->new("test-reports");
$runner->start($test);
exit(!$runner->all_tests_passed());

Test::Unit::Runner::XML generates XML reports from unit test results. The reports are in the same format as those produced by Ants JUnit task, allowing them to be used with Java continuous integration and reporting tools.

CONSTRUCTOR

Test::Unit::Runner::XML->new($directory)
Construct a new runner that will write XML reports into $directory

METHODS

start

$runner->start($test);

Run the Test::Unit::Test $test and generate XML reports from the results.

all_tests_passed

exit(!$runner->all_tests_passed());

Return true if all tests executed by $runner since it was constructed passed.

Test::Unit::Procedural Perl module contains a procedural style unit testing interface.

SYNOPSIS

use Test::Unit::Procedural;

# your code to be tested goes here

sub foo { return 23 };
sub bar { return 42 };

# define tests

sub test_foo { assert(foo() == 23, "Your message here"); }
sub test_bar { assert(bar() == 42, "I will be printed if this fails"); }

# set_up and tear_down are used to
# prepare and release resources need for testing

sub set_up { print "hello worldn"; }
sub tear_down { print "leaving world againn"; }

# run your test

create_suite();
run_suite();

Test::Unit::Procedural is the procedural style interface to a sophisticated unit testing framework for Perl that is derived from the JUnit testing framework for Java by Kent Beck and Erich Gamma. While this framework is originally intended to support unit testing in an object-oriented development paradigm (with support for inheritance of tests etc.), Test::Unit::Procedural is intended to provide a simpler interface to the framework that is more suitable for use in a scripting style environment. Therefore, Test::Unit::Procedural does not provide much support for an object-oriented approach to unit testing - if you want that, please have a look at Test::Unit::TestCase.

You test a given unit (a script, a module, whatever) by using Test::Unit::Procedural, which exports the following routines into your namespace:

assert()

used to assert that a boolean condition is true

create_suite()

used to create a test suite consisting of all methods with a name prefix of test

run_suite()

runs the test suite (text output)

add_suite()

used to add test suites to each other

For convenience, create_suite() will automatically build a test suite for a given package. This will build a test case for each subroutine in the package given that has a name starting with test and pack them all together into one TestSuite object for easy testing. If you dont give a package name to create_suite(), the current package is taken as default.

Test output is one status line (a "." for every successful test run, or an "F" for any failed test run, to indicate progress), one result line ("OK" or "!!!FAILURES!!!"), and possibly many lines reporting detailed error messages for any failed tests.
Please remember, Test::Unit::Procedural is intended to be a simple and convenient interface. If you need more functionality, take the object-oriented approach outlined in Test::Unit::TestCase.