Free intermediate unit software for linux

Test::Unit is the main PerlUnit testing framework.

SYNOPSIS

This package provides only the project version number, copyright texts, and a framework overview in POD format.

This framework is intended to support unit testing in an object-oriented development paradigm (with support for inheritance of tests etc.) and is derived from the JUnit testing framework for Java by Kent Beck and Erich Gamma. To start learning how to use this framework, see Test::Unit::TestCase and Test::Unit::TestSuite. (There will also eventually be a tutorial in Test::Unit::Tutorial.

However Test::Unit::Procedural is the procedural style interface to a sophisticated unit testing framework for Perl that . Test::Unit is intended to provide a simpler interface to the framework that is more suitable for use in a scripting style environment. Therefore, Test::Unit does not provide much support for an object-oriented approach to unit testing.

Eunit project is an Erlang test suite tool, inspired by agile development ideas.
Usage:
Launch example unit test with:
erl -config sys.config
and then
eunit:run([eunit_examples], {suffix, "_test"}).
Enhancements:
- This release is a complete rewrite.
- Writing unit tests should now be simpler than with the previous version.
- This release can also be used with the Aegis configuration management system for continuous integration.

Designer Framework provides a highly customizable e-commerce framework.

It automatically builds e-commerce interfaces that support a products contraints and properties and can be used to model the product to be sold, automatically and dynamically generating different output formats depending on the generator used.

It includes a Java modelling application, a finite state machine described in XML as intermediate format for the customer interface, and XSLT scripts for transforming the state machine into the final interface.Designer Framework is a highly customizable e-commerce framework.

It automatically builds e-commerce interfaces that support a products contraints and properties and can be used to model the product to be sold, automatically and dynamically generating different output formats depending on the generator used.

It includes a Java modelling application, a finite state machine described in XML as intermediate format for the customer interface, and XSLT scripts for transforming the state machine into the final interface.

Test::Unit::TestCase is a unit testing framework base class.

SYNOPSIS

package FooBar;
use base qw(Test::Unit::TestCase);

sub new {
my $self = shift()->SUPER::new(@_);
# your state for fixture here
return $self;
}

sub set_up {
# provide fixture
}
sub tear_down {
# clean up after test
}
sub test_foo {
# test the foo feature
}
sub test_bar {
# test the bar feature
}

(Taken from the JUnit TestCase class documentation)

A test case defines the "fixture" (resources need for testing) to run multiple tests. To define a test case:

implement a subclass of TestCase
define instance variables that store the state of the fixture
initialize the fixture state by overriding set_up()
clean-up after a test by overriding tear_down().

Each test runs in its own fixture so there can be no side effects among test runs. Here is an example:

package MathTest;
use base qw(Test::Unit::TestCase);

sub new {
my $self = shift()->SUPER::new(@_);
$self->{value_1} = 0;
$self->{value_2} = 0;
return $self;
}

sub set_up {
my $self = shift;
$self->{value_1} = 2;
$self->{value_2} = 3;
}

For each test implement a method which interacts with the fixture. Verify the expected results with assertions specified by calling $self->assert() with a boolean value.

sub test_add {
my $self = shift;
my $result = $self->{value_1} + $self->{value_2};
$self->assert($result == 5);
}

Once the methods are defined you can run them. The normal way to do this uses reflection to implement run_test. It dynamically finds and invokes a method. For this the name of the test case has to correspond to the test method to be run. The tests to be run can be collected into a TestSuite. The framework provides different test runners, which can run a test suite and collect the results. A test runner either expects a method suite() as the entry point to get a test to run or it will extract the suite automatically.

If you do not like the rather verbose backtrace that appears when a test fails, you can use the quell_backtrace() method. You will get any message provided, but not the backtrace.

The libdisasm library provides basic disassembly of Intel x86 instructions from a binary stream. The intent is to provide an easy to use disassembler which can be called from any application; the disassembly can be produced in AT&T syntax and Intel syntax, as well as in an intermediate format which includes detailed instruction and operand type information.

This disassembler is derived from libi386.so in the bastard project; as such it is x86 specific and will not be expanded to include other CPU architectures. Releases for libdisasm are generated automatically alongside releases of the bastard; it is not a standalone project, though it is a standalone library.

The recent spate of objdump output analyzers has proven that many of the people [not necessarily programmers] interested in writing disassemblers have little knowledge of, or interest in, C programming; as a result, these "disassemblers" have been written in Perl.

Usage

The basic usage of the library is:

1. initialize the library, using disassemble_init()
2. disassemble stuff, using disassemble_address()
3. un-initialize the library, using disassemble_cleanup

These routines have the following prototypes:

int disassemble_init(int options, int format);
int disassemble_cleanup(void);
int disassemble_address(char *buf, int buf_len, struct instr *i);

Instructions are disassembled to an intermediate format:

struct instr {
char mnemonic[16];
char dest[32];
char src[32];
char aux[32];
int mnemType; /* type of instruction */
int destType; /* type of dest operand */
int srcType; /* type of source operand */
int auxType; /* type of 3rd operand */
int size; /* size of insn in bytes */
};

The sprint_address() can be used in place of the disassemble_address() routine in order to generate a string representation instead of an intermediate one:

int sprint_address(char *str, int len, char *buf, int buf_len);

...so that a simple disassembler can be implemented in C with the following code:

#include

char buf[BUF_SIZE]; /* buffer of bytes to disassemble */
char line[LINE_SIZE]; /* buffer of line to print */
int pos = 0; /* current position in buffer */
int size; /* size of instruction */

disassemble_init(0, INTEL_SYNTAX);

while ( pos > BUF_SIZE ) {
/* disassemble address to buffer */
size = sprint_address(buf + pos, BUF_SIZE - pos, line, LINE_SIZE);
if (size) {
/* print instruction */
printf("%08X: %sn", pos, line);
pos += size;
} else {
printf("%08X: Invalid instructionn");
pos++;
}
}

disassemble_cleanup();

Alternatively, one can print the address manually using the intermediate format:

#include

char buf[BUF_SIZE]; /* buffer of bytes to disassemble */
int pos = 0; /* current position in buffer */
int size; /* size of instruction */
struct instr i; /* representation of the code instruction */

disassemble_init(0, INTEL_SYNTAX);

while ( pos > BUF_SIZE ) {
disassemble_address(buf + pos, BUF_SIZE - pos, &i);
if (size) {
/* print address and mnemonic */
printf("%08X: %s", pos, i.mnemonic);
/* print operands */
if ( i.destType ) {
printf("t%s", i.dest);
if ( i.srcType ) {
printf(", %s", i.src);
if ( i.auxType ) {
printf(", %s", i.aux);
}
}
}
printf("n");
pos += size;
} else {
/* invalid/unrecognized instruction */
pos++;
}
}

disassemble_cleanup();

This is the recommended usage of libdisasm: the instruction type and operand type fields allow analyzing of the disassembled instruction, and can provide cues for xref generation, syntax hi-lighting, and control flow tracking.

IControl is a software program meant to interpret signals from Creatives RM-900 remote control and accompanying IR LiveDrive! receiver unit.

IControl is currently capable of sending input to various programs (including XMMS, Xine, XawTV, XScreensaver, et al), as well as circulating window stacking order (sending windows to the background) and changing input focus. Furthermore, IControl will soon support other remote controls beyond the RM-900 which are all interpretable by the LiveDrive! unit.

IControl is completely configurable through its .conf files, allowing the user to map any key to any action the rcontrol daemon supports. And development is in the works to allow IControl to start programs, interface with devices, or even shut the computer down.

Test::Unit::Runner::XML is a Perl module that can generate XML reports from unit test results.

SYNOPSIS

use Test::Unit::Runner::XML;

mkdir("test_reports");
my $runner = Test::Unit::Runner::XML->new("test-reports");
$runner->start($test);
exit(!$runner->all_tests_passed());

Test::Unit::Runner::XML generates XML reports from unit test results. The reports are in the same format as those produced by Ants JUnit task, allowing them to be used with Java continuous integration and reporting tools.

CONSTRUCTOR

Test::Unit::Runner::XML->new($directory)
Construct a new runner that will write XML reports into $directory

METHODS

start

$runner->start($test);

Run the Test::Unit::Test $test and generate XML reports from the results.

all_tests_passed

exit(!$runner->all_tests_passed());

Return true if all tests executed by $runner since it was constructed passed.

Test::Unit::GTestRunner is a Unit testing framework helper class

SYNOPSIS

use Test::Unit::GTestRunner;

Test::Unit::GTestRunner->new->start ($my_testcase_class);

Test::Unit::GTestRunner::main ($my_testcase_class);

If you just want to run a unit test (suite), try it like this:

gtestrunner "MyTestSuite.pm"

Try "perldoc gtestrunner" or "man gtestrunner" for more information.

This class is a GUI test runner using the Gimp Toolkit Gtk+ (which is called Gtk2 in Perl). You can use it if you want to integrate the testing framework into your own application.

For a description of the graphical user interface, please see gtestrunner(1).