Free tests de amor software for linux

Test::Glade is a simple way to test Gtk2::GladeXML-based apps.

SYNOPSIS

use Test::Glade tests => 2;

my $glade_xml = interface.glade;
has_widget( $glade_xml, {
name => main_window,
type => GtkWindow,
properties => {
title => Test Application,
type => GTK_WINDOW_TOPLEVEL,
resizable => 1,
},
} );

has_widget( $glade_xml, {
type => GtkButton,
properties => {label => Press me!},
signals => {clicked => button_pressed_handler},
} );

GUIs are notoriously difficult to test. Historically this was well deserved as the available perl GUI toolkits did not encourage separation of the view and controller layers. The introduction of the Glade GUI designer and Gtk2::GladeXML changed that by segregating user interface and logical components (into GladeXML and Perl files respectively).

Users who avoid creating GUI elements from within their application logic can now test each layer separately with appropriate tools. The Perl logic can be verified with standard unit tests and this module provides a way to inspect and verify the GladeXML UI specification. You can confirm that a given widget exists, that it has the correct label and other attributes, that it will be correctly placed in the interface and that it will respond to signals as expected.

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.

Test::use::ok is an alternative to Test::More::use_ok.

SYNOPSIS

use ok( Some::Module );

According to the Test::More documentation, it is recommended to run use_ok() inside a BEGIN block, so functions are exported at compile-time and prototypes are properly honored.

That is, instead of writing this:

use_ok( Some::Module );
use_ok( Other::Module );

One should write this:

BEGIN { use_ok( Some::Module ); }
BEGIN { use_ok( Other::Module ); }

However, people often either forget to add BEGIN, or mistakenly group use_ok with other tests in a single BEGIN block, which can create subtle differences in execution order.

With this module, simply change all use_ok in test scripts to use ok, and they will be executed at BEGIN time. The explicit space after use makes it clear that this is a single compile-time action.

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

Test::MultiFork is a test suite that has support for multi-process programs.

SYNOPSIS

use Test::MultiFork;

($name, $letter, $number) = procname([new name])
lockcommon()
@oldvalues = getcommon()
setcommon(@newvalues)
unlockcommon()

use Test::MultiFork qw(groupwait setgroup dofork stderr bail_on_bad_plan)

groupwait([$tag])
$oldgroup = setgroup([$newgroup])
dofork(fork_specification)

This test module is to support creating test suites for programs and modules that run as multiple processes and do mostly blocking I/O.

Test::MultiFork handles the forking so that it can set up each child to coordinate the output. The output from each child fork is redirected to the parent. Each fork produces normal test output -- possibly using normal test modules like Test::Simple. The output is collected and rewritten by the parent process.

Each child fork has a letter and number designation. The forks are created by dofork(). Dofork takes a specifiction on the form: ([a-z](d*))+. That is to say, one or more lower-case letters, each optionally followd by a number. The number says how many children to fork for that letter (default one). The specifier ab2c3 means have one a child (numbered 1); two b children (numbered 1, 2); and three c children (numbered 1, 2, 3).

To aid in writing tests, Test::MultiFork will pass data between the child processes. The data is test-writer defined.

Tagesschau.de RSS-Reader is a RSS Reader of the German tagesschau.de News. Actually, it is not more than a little modified Version of the BBC Newsreader from http://www.kde-look.org/content/show.php?content=35922

Thanks to the author of this, and the author of the one, where he copied it, and so on...

Ive also not modified anything in the Script, I just put in the right URLs and made the header.

Hint: If you install it, and you only see a blank applet, refresh it with a right-click and Refresh Theme.

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::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.