Free test version software for linux

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::Exception is a Perl module to test exception based code.

SYNOPSIS

use Test::More tests => 5;
use Test::Exception;

# or if you dont need Test::More

use Test::Exception tests => 5;

# then...

# Check that something died
dies_ok { $foo->method1 } expecting to die;

# Check that something did not die
lives_ok { $foo->method2 } expecting to live;

# Check that the stringified exception matches given regex
throws_ok { $foo->method3 } qr/division by zero/, zero caught okay;

# Check an exception of the given class (or subclass) is thrown
throws_ok { $foo->method4 } Error::Simple, simple error thrown;

# all Test::Exceptions subroutines are guaranteed to preserve the state
# of $@ so you can do things like this after throws_ok and dies_ok
like $@, what the stringified exception should look like;

# Check that a test runs without an exception
lives_and { is $foo->method, 42 } method is 42;

# or if you dont like prototyped functions

dies_ok( sub { $foo->method1 }, expecting to die );
lives_ok( sub { $foo->method2 }, expecting to live );
throws_ok( sub { $foo->method3 }, qr/division by zero/,
zero caught okay );
throws_ok( sub { $foo->method4 }, Error::Simple,
simple error thrown );
lives_and( sub { is $foo->method, 42 }, method is 42 );

Test-Run is an improved test harness for scripts that emit TAP (Test Anything Protocol). It was forked from Test::Harness, and it uses TAP::Parser.

The project is used to analyze the output of the scripts and present it to the user in a summarized form. Test-Run features separation of the test-running backend and the command line frontend, a "runprove" utility for running tests from the command line, a plugin-system, and colors for the summary line.

Test::Signature is a Perl module to automate SIGNATURE testing.

SYNOPSIS

# This is actually the t/00signature.t
# file from this distribution.
use Test::More tests => 1;
use Test::Signature;

signature_ok();

ABSTRACT

Test::Signature verifies that the Module::Signature generated signature of a module is correct.

Module::Signature allows you to verify that a distribution has not been tampered with. Test::Signature lets that be tested as part of the distributions test suite.
By default, if Module::Signature is not installed then it will just say so and not fail the test. That can be overridden though.

IMPORTANT: This is not a substitute for the users verifying the distribution themselves. By the time this module is run, the users will have already run your Makefile.PL or Build.PL scripts which could have been compromised.
This module is more for ensuring youve updated your signature appropriately before distributing, and for preventing accidental errors during transmission or packaging.

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::Simple is a Perl module with basic utilities for writing tests.

SYNOPSIS

use Test::Simple tests => 1;

ok( $foo eq $bar, foo is bar );

** If you are unfamiliar with testing read Test::Tutorial first! **

This is an extremely simple, extremely basic module for writing tests suitable for CPAN modules and other pursuits. If you wish to do more complicated testing, use the Test::More module (a drop-in replacement for this one).
The basic unit of Perl testing is the ok. For each thing you want to test your program will print out an "ok" or "not ok" to indicate pass or fail. You do this with the ok() function (see below).

The only other constraint is you must pre-declare how many tests you plan to run. This is in case something goes horribly wrong during the test and your test program aborts, or skips a test or whatever. You do this like so:

use Test::Simple tests => 23;

You must have a plan.

ok
ok( $foo eq $bar, $name );
ok( $foo eq $bar );

ok() is given an expression (in this case $foo eq $bar). If its true, the test passed. If its false, it didnt. Thats about it.

ok() prints out either "ok" or "not ok" along with a test number (it keeps track of that for you).

# This produces "ok 1 - Hell not yet frozen over" (or not ok)
ok( get_temperature($hell) > 0, Hell not yet frozen over );

If you provide a $name, that will be printed along with the "ok/not ok" to make it easier to find your test when if fails (just search for the name). It also makes it easier for the next guy to understand what your test is for. Its highly recommended you use test names.

All tests are run in scalar context. So this:

ok( @stuff, I have some stuff );
will do what you mean (fail if stuff is empty)

Test::Simple will start by printing number of tests run in the form "1..M" (so "1..5" means youre going to run 5 tests). This strange format lets Test::Harness know how many tests you plan on running in case something goes horribly wrong.
If all your tests passed, Test::Simple will exit with zero (which is normal). If anything failed it will exit with how many failed. If you run less (or more) tests than you planned, the missing (or extras) will be considered failures. If no tests were ever run Test::Simple will throw a warning and exit with 255. If the test died, even after having successfully completed all its tests, it will still be considered a failure and will exit with 255.

So the exit codes are...
0 all tests successful
255 test died or all passed but wrong # of tests run
any other number how many failed (including missing or extras)

If you fail more than 254 tests, it will be reported as 254.

This module is by no means trying to be a complete testing system. Its just to get you started. Once youre off the ground its recommended you look at Test::More.

TAHI Test Suite project provides a mechanism for validating an IPv6 implementation against a standardized test for conformance to the IPv6 specification, extensions and directly related protocols.
TAHI Project is the joint effort formed with the objective of developing and providing the verification technology for IPv6.
The growth process of IPv4 was the history of encountering various kinds of obstacles and conquering such obstacles. However, once the position as infrastructure was established, it is not allowed to repeat the same history. This is a reason why the verification technology is essential for IPv6 deployment.
We research and develop conformance tests and interoperability tests for IPv6.
We closely work with the KAME project and USAGI project. We help activities of them in the quality side by offering the verification technology we develop in the TAHI project and improve the development efficiency.
We open the results and fruits of the project to the public for FREE. Any developer concerned with IPv6 can utilize the results and fruits of TAHI project freely. A free software plays an important role in progress of the Internet. We believe that providing the verification technology for FREE contributes to advances of IPv6. Besides the programs, the specifications and criteria of verification will be included in the Package.
Enhancements:
- A potential memory leak has been fixed.