Free tests during pregnancy software for linux

Test::Singleton is a test for Singleton classes.

SYNOPSIS

use Test::More tests => 1;
use Test::Singleton;
is_singleton( "Some::Class", "new", "instance" );

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

This is asimple, basic module for checking whether a class is a Singleton. A Singleton describes an object class that can have only one instance in any system. An example of a Singleton might be a print spooler or system registry, or any kind of central dispatcher.

For a description and discussion of the Singleton class, see "Design Patterns", Gamma et al, Addison-Wesley, 1995, ISBN 0-201-63361-2.

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.

STclass is a Contract Based Built-in Testing Framework (CBBT) for Java.
The goal of the STclass project is to diffuse a professional testing framework for the Java language. The Tigris site shoud support the maintenance and the evolution of the tool.
Main features:
- Runtime evaluable contracts definition and evaluation:
OCL like class invariants, pre and postconditions on methods;
contracts defined in javadoc comments (can be extracted by javadoc);
contracts inheritance from parent class and interfaces following the Meyers rules;
- Class level unit testing:
test are organized in TestUnits, TestCases and TestSuites;
Setup and Teardown actions can be associated to TestCase, a testUnit can participate to several TestCases;
tests are contract-based: TestUnits define only scenarii, oracles are evaluated by contracts;
tests are built-in: all the test definition is made in comments of the source code;
tests are inheritable from parent classes and interfaces;
- A preprocessor generates from the source an instrumented code with a main function: running the test is only running the class itself. Options manage the test conditions; it is possible to launch TestUnits individualy in verification mode; with Ant or other scripts, package or system test can be performed.
- Test result are saved in XML format, postprocessing tools produce nice HTML reports; using the JIP profiler, a statisitic and profiling analysis can be made during the test, its resuts are added to the HTML report.
Enhancements:
- Several bugs were fixed.
- Change option management is now based on property files.
- Good integration with Ant was achieved.
- IDEs including NetBeans and Eclipse are now supported.
- A new code_cover command that makes coverage tests with EMMA was added.

Test::ISBN is a Perl module to check international standard book numbers.

SYNOPSIS

use Test::More tests => 1;
use Test::ISBN;

isbn_ok( $isbn );

Functions

isbn_ok( STRING )

Ok is the STRING is a valid ISBN, in any format that Business::ISBN accepts. This function only checks the checksum. The publisher and country codes might be invalid even though the checksum is valid.

isbn_country_ok( STRING, COUNTRY )

Ok is the STRING is a valid ISBN and its country code is the same as COUNTRY.

isbn_publisher_ok( STRING, PUBLISHER )

Ok is the STRING is a valid ISBN and its publisher code is the same as PUBLISHER.

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::WWW::Simple is a Perl module to test Web applications using TAP.

SYNOPSIS

use Test::WWW::Simple;
# This is the default user agent.
user_agent(Windows IE 6);
page_like("http://yahoo.com", qr/.../, "check for expected text");
page_unlike("http://my.yahoo.com", qr/.../, "check for undesirable text");
user_agent(Mac Safari);
...

Test::WWW::Simple is a very basic class for testing Web applications and Web pages. It uses WWW::Mechanize to fetch pages, and Test::Builder to implement TAP (Test Anything Protocol) for the actual testing.

Since we use Test::Builder for the page_like and page_unlike routines, these can be integrated with the other standard Test::Builder-based modules as just more tests.

Test::XML::Simple is an easy testing for XML.

SYNOPSIS

use Test::XML::Simple tests=>5;
xml_valid $xml, "Is valid XML";
xml_node $xml, "/xpath/expression", "specified xpath node is present";
xml_is, $xml, /xpath/expr, "expected value", "specified text present";
xml_like, $xml, /xpath/expr, qr/expected/, "regex text present";
xml_is_deeply, $xml, /xpath/expr, $xml2, "structure and contents match";

# Not yet implemented:
# xml_like_deeply would be nice too...

Test::XML::Simple is a very basic class for testing XML. It uses the XPath syntax to locate nodes within the XML. You can also check all or part of the structure vs. an XML fragment.

Test::STD::PerlSTD is a general Perl Software Test Description (STD).

TITLE PAGE

Gerneral Software Test Description (STD)

for

Perl Program Modules

Revision: -

Date: 2004/05/15

Prepared for: General Public

Prepared by: http://www.SoftwareDiamonds.com support@SoftwareDiamonds.com

Classification: None

1. Scope

This general Software Test Decription (STD) for a Perl Program Module (PM). Together with a detail STD for a Perl Program Module it establishes the tests to verify the requirements of specific Perl Program Module (PM).

In order to avoid duplications (i.e boiler plates), the Perl STD is divided into this general Perl STD and a detail STD for each program module test. This is encourage if not in fact required by 490A 3.1.2