Free tests software for linux

The goal of RUMT is to check the memory of a computer over a long period of time and almost-real load conditions without having to interrupt the services.

RUMT exploits the possibility of some Unix kernels to selectivly disable some memory areas while still accessing them through the /dev/mem device. The principle of RUMT is to write pseudo-random data in these disabled memory areas, and later check them. This principle and the original code for the deterministic pseudo-random generator are from David Madore.

This distribution contains another variant on the same theme: URUMT allocates a large chunk of memory, locks it in memory using the mlock(2) system call, and scans /dev/mem to find where in physical memory the allocated area is. Then it continuously runs the same tests in that memory.

URUMT can not be used to test a particular area of memory: the kernel will give it whatever physical memory it feels like. But URUMT can be restarted now and then, hopefully getting different physical memory each time.

This is perfect if you suspect you have bad bits, but do not know at all where they are. Once you have sighted the bad bits, you can use a plain RUMT to test more extensively the neighborhood.

TAHI Test Suite 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:
- This release extends the tests in the specification and code.
- There are assorted minor bugfixes.

Test Environment Toolkit in short TET, is a multi-platform uniform test scaffold, into which non-distributed and distributed test suites can be incorporated.
TET supports tests written in C, C++, Perl, Tcl, Shell (sh, bash, and POSIX shell), Python, Ruby, and Korn Shell.
Installation:
Typical installation is as follows:
Install a .profile for the test suite user
Example:
TET_ROOT=/home/tet
PATH=$PATH:$TET_ROOT/bin
export TET_ROOT PATH
To configure TET3
cd $TET_ROOT
sh configure -t lite # for TETware lite
cd src
make install
(the final command below is not necessary)
make compat # for backwards compatibility for include directories
If the build fails check the makefiles in src/defines
Note: some Make utilities may have trouble with the include directive, this is a known problem on BSDI systems. In this case use GNU Make (gmake). Version 3.75 and higher is known to work.
Enhancements:
- This is a full source release. It features both non-distributed (TET3-Lite) and distributed (Distributed TET3) functionality.
- This includes a bundled contrib distribution in the "contrib" directory.
- New API support includes the Java API, Ruby, Python, PHP-CLI, Tcl, and a POSIX 1003.1-2001 shell API.
- A new report writer (grw) is also included.

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::Chunks is a Data Driven Testing Framework.

NOTE - This module has been deprecated and replaced by Test::Base. This is basically just a renaming of the module. Test::Chunks was not the best name for this module. Please discontinue using Test::Chunks and switch to Test::Base.
Helpful Hint: change all occurences of chunk to block in your test code, and everything should work exactly the same.

SYNOPSIS

use Test::Chunks;
use Pod::Simple;

delimiters qw(=== +++);
plan tests => 1 * chunks;

for my $chunk (chunks) {
# Note that this code is conceptual only. Pod::Simple is not so
# simple as to provide a simple pod_to_html function.
is(
Pod::Simple::pod_to_html($chunk->pod),
$chunk->text,
$chunk->name,
);
}

__END__

=== Header 1 Test

This is an optional description
of this particular test.

+++ pod
=head1 The Main Event
+++ html
< h1 >The Main Event< /h1 >


=== List Test
+++ pod
=over
=item * one
=item * two
=back

+++ html
< ul >
< li >one< /li >
< li >two< /li >
< /ul >

There are many testing situations where you have a set of inputs and a set of expected outputs and you want to make sure your process turns each input chunk into the corresponding output chunk. Test::Chunks allows you do this with a minimal amount of code.

PSA::Test::Builder is a backend for building test libraries.

SYNOPSIS

package My::Test::Module;
use PSA::Test::Builder;
require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(ok);

my $Test = Test::Builder->new;
$Test->output(my_logfile);

sub import {
my($self) = shift;
my $pack = caller;

$Test->exported_to($pack);
$Test->plan(@_);

$self->export_to_level(1, $self, ok);
}

sub ok {
my($test, $name) = @_;

$Test->ok($test, $name);
}

END {
$Test->_ending();
}

Test::Simple and Test::More have proven to be popular testing modules, but theyre not always flexible enough. Test::Builder provides the a building block upon which to write your own test libraries which can work together.

And the block was found to be rotten, and so PSA::Test::Builder was constructed.

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.

OpenGuides::Test are methods to help test OpenGuides applications.

Provides methods to help when writing tests for OpenGuides. Distributed and installed as part of the OpenGuides project, not intended for independent installation. This documentation is probably only useful to OpenGuides developers.

SYNOPSIS

use OpenGuides;
use OpenGuides::Test;

my $config = OpenGuides::Test->make_basic_config;
$config->default_language( "nl" );

my $guide = OpenGuides->new( config => $config );

OpenGuides::Test->write_data(
guide => $guide,
node => "Crabtree Tavern",
os_x => 523465,
os_y => 177490,
categories => "Pubs",
);