Free tests for diabetes software for linux

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::Parser is a collection of parsers for different test output file formats. These parse the data into a general purpose data structure that can then be used to create reports, do post-processing analysis, etc.

Test-Parser can also export tests in SpikeSources TRPI test description XML language.

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::Parser is a collection of parsers for different test output file formats.
These parse the data into a general purpose data structure that can then be used to create reports, do post-processing analysis, etc.
Test::Parser can also export tests in SpikeSources TRPI test description XML language.
Installation:
To install the script and man pages in the standard areas, give the sequence of commands
$ perl Makefile.PL
$ make
$ make test
$ make install # you probably need to do this step as superuser
If you want to install the script in your own private space, use
$ perl Makefile.PL PREFIX=/home/joeuser
INSTALLMAN1DIR=/home/joeuser/man/man1
INSTALLMAN3DIR=/home/joeuser/man/man3
$ make
$ make test
$ make install # can do this step as joeuser
Note that `make test` does nothing interesting.
Enhancements:
- This release improves the LTP parser and adds a parse_ltp script that prints a tabular summary of the PASS/FAILs of test cases.

Test::C2FIT is a direct Perl port of Ward Cunninghams FIT acceptance test framework for Java.

SYNOPSIS

FileRunner.pl input_containing_fit_tests.html test_results.html

perl -MTest::C2FIT -e file_runner input_containing_fit_tests.html test_results.html

perl -MTest::C2FIT -e fit_shell

Great software requires collaboration and communication. Fit is a tool for enhancing collaboration in software development. Its an invaluable way to collaborate on complicated problems - and get them right - early in development.

Fit allows customers, testers, and programmers to learn what their software should do and what it does do. It automatically compares customers expectations to actual results.

This port of FIT has a featureset equivalent to v1.1 of FIT. Dave W. Smiths original port was based on fit-b021021j and Ive updated most of the core to match the 1.1 version.

This port passes the current FIT spec and also implements a all of the examples.

The following functions are provided (and exported) by this module:
file_runner($infile,$outfile)

Process a FIT-document contained in $infile and writes the result to $outfile.
wiki_runer($infile,$outfile)

Same as file_runner, except that not < table >, < tr > and < td > but < wiki >, < table >, < tr > and < td > is searched for in the input document.

fit_shell

Creates an interactive shell from which you can easily run tests. Start it and enter "help" for more information.

Suppose, your tests-related files reside in a directory with three subdirectories: input - where the files come from, output - where the results will be written to and lib - where your fixtures reside, all you need to do is just to enter "runall"

Logging

The file_runner and wiki_runner support filtering of warn messages, similar to javas common logging. To change the log level, use the -L parameter, e.g.:

perl -MTest::C2FIT -e file_runner -- -L 1 input_containing_fit_tests.html test_results.html

There are following log levels defined: 0 - trace, 1 - debug, 2 - info, 3 - warn, 4 - error, 5 - fatal.

In your code, simply use warn "message" if it should be printed out unconditionally or warn 1, " message" if it should be printed out, when log level is either TRACE or DEBUG.

Naming, Namespace(s)

In your FIT-documents, please use the java-style dot-notation for qualifying package names. E.g. if you want the package Domain::Object::Simple to be used, specify it by entering Domain.Object.Simple into your fit document.
Package names should be fully qualified, case is importat. Special care is taken on the fit.* packages, these can be specified either by fit.Name as well as Test.C2FIT.Name.

Test::XML::Order is a Perl module to compare the order of XML tags in perl tests.

SYNOPSIS

use Test::XML::Order tests => 3;
is_xml_in_order( , ); # PASS
is_xml_in_order( , ); # FAIL
isnt_xml_in_order( , ); # PASS

This module contains generic XML testing tools. See below for a list of other modules with functions relating to specific XML modules.

FUNCTIONS

is_xml_in_order ( GOT, EXPECTED [, TESTNAME ] )

This function compares GOT and EXPECTED, both of which are strings of XML. The comparison works only on the order of the tags, attributes are ignored.

Returns true or false, depending upon test success.

isnt_xml_in_order( GOT, MUST_NOT_BE [, TESTNAME ] )

This function is similar to is_xml_in_order(), except that it will fail if GOT and MUST_NOT_BE have elements in the same order.

NOTES

Please note the following about Test::XML::Order.

The package does not check that the input is well formed XML. You should use Test::XML or a similar package if you want to make sure the XML is well formed.
Only the order of tags are checked, so

is_xml_in_order(< a a="b"/ >x< b >< /b >, < a/ >< b a="c" >asdf< /b >);

passes as the inputs have the same order: < a/ >< b/ >.

The tree structure is tested so the the test below passes.

isnt_xml_in_order(< a >< b/ >< /a >, < a/ >< b/ >);

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.