Free stupid tests software for linux

This is the second pseudo-release of Bloody Stupid Linux, which of course has nothing to do with the first release. The first BSL was a 50Mb ISO Live run CD based on DamnSmall Linux.

I had a lot of fun hacking around DamnSmall, and apparently it drew a little attention. John, the lord master of DamnSmall, even was kind enough to link to me off of the DSL relatives page. I got a few mails, most about the image to the right, about a hundred downloads or so, and some of those were even people I didnt know.

This whole project started because I needed to cramb a kernel and a root filesytem onto a floppy. Not having enough room in the kernel for disk or filesystem support, I figured why not wget the modules, with the inevitable conclusion, why not wget a bigger root filesystem next?

Why go to all this trouble? The BSL kernel is basically a life support system for ram and network cards, since it wgets support for everything else on the machine the kernel is very small. The initial aim was to fit it on a single floppy, then PXE booting became attractive, and really, since the kernel doesnt need to support whatever it just booted from in order to have its root filesystem, its very flexible. Yeah, I know an initrd can do the same thing, but its more fun this way. As it stands, BSL makes for an excellent repair system, the framework for a bulk installer, a neat toy, and an alright thin client ( as long as youve got a gob of RAM handy.)

Most of all, this whole thing is incredibly hackable. If you wanted to use a different slackware image, just tar one up, name it image.tar.gz and stick it in the /bsl directory of your image web server. If you need that image to unpack to larger than 170Mb, hack up the init script in the cpio archive, rebuild the archive, then recompile the kernel... sounds like a lot, but it really isnt. Want to replace the whole image with Debian/SuSe/Fedora/Arch/DSL/Gentoo? Go to it!"

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",
);

Test::Unit::tests::AllTests is a unit testing framework self tests.

SYNOPSIS

# command line style use

perl TestRunner.pl Test::Unit::tests::AllTests

# GUI style use

perl TkTestRunner.pl Test::Unit::tests::AllTests

This class is used by the unit testing framework to encapsulate all the self tests of the framework.

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::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::Class is a Perl module that allows you to easily create test classes in an xUnit/JUnit style.

SYNOPSIS

package Example::Test;
use base qw(Test::Class);
use Test::More;

# setup methods are run before every test method.
sub make_fixture : Test(setup) {
my $array = [1, 2];
shift->{test_array} = $array;
};

# a test method that runs 1 test
sub test_push : Test {
my $array = shift->{test_array};
push @$array, 3;
is_deeply($array, [1, 2, 3], push worked);
};

# a test method that runs 4 tests
sub test_pop : Test(4) {
my $array = shift->{test_array};
is(pop @$array, 2, pop = 2);
is(pop @$array, 1, pop = 1);
is_deeply($array, [], array empty);
is(pop @$array, undef, pop = undef);
};

# teardown methods are run after every test method.
sub teardown : Test(teardown) {
my $array = shift->{test_array};
diag("array = (@$array) after test(s)");
};
later in a nearby .t file
#! /usr/bin/perl
use Example::Test;

# run all the test methods in Example::Test
Test::Class->runtests;

Outputs:

1..5
ok 1 - pop = 2
ok 2 - pop = 1
ok 3 - array empty
ok 4 - pop = undef
# array = () after test(s)
ok 5 - push worked
# array = (1 2 3) after test(s)

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.