Free allegheny intermediate unit software for linux

Qalculate! is a multi-purpose desktop calculator for GNU/Linux. Qalculate! project is small and simple to use but with much power and versatility underneath.
Features include customizable functions, units, arbitrary precision, plotting, and a user-friendly interface (KDE or GTK+).
Main features:
- Redesigned GUI with history view in the main window
- Display of as-you-type expression parsing and function hints
- Enhanced completion
- Scaling of result display to vertically fit the window
- Nicer history listing
- Enhanced result display with much nicer parentheses
- Meta modes
- 67 new units: bel (B) and neper (Np), information units such as bit and byte, many convenience units (km/h, deciliter, etc), and more.
- Binary prefixes
- Some new variables and functions
- Fixed help display in new yelp
- Fixed compile with cln-1.1.10
- Fixed regressions in simplification
- Fixed f(x) return type analysis (ex. log(x) represents a real number if x represents a positive). This was by accident unused.
- ...and many more bug fixes and enhancements...

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.

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.

Agora BASIC is a BASIC compiler for POSIX systems. Agora BASIC aims to implement all of Standard Full BASIC (ANSI INCITS 113-1987), with useful but compatible extensions. It does not do that quite yet. What it does is implement a small subset of the language, enough that simple programs can be written in it. A lot of work expanding the support of the language is still required.
Agora BASIC specifically does not aim to be a "modern" BASIC dialect. There are enough of those already, even as free software. The only way for Agora BASIC to acquire classes or other similar things is if the standard is thus updated. Minor extensions, mainly lifting senseless restrictions in the standard and enabling writing useful programs in the Unix environment are possible.
Agora BASIC is a compiler, not an interpreter, and there is no interactive mode. Furthermore, the compiler uses C as an intermediate language and the system C compiler as the backend (note that the intermediate C code is not intended for human consumption or manual editing).
Enhancements:
- This initial release supports enough of the language to write simple programs.

GTestRunner is a Gtk+ based testrunner module for Perl, inspired by JUnit, but with a slightly different user interface and functionality.

If you were not satisfied with the Tk based graphical frontend that ships with Test-Unit, then GTestRunner is probably the tool of choice when you want to do test driven development in Perl.

It also offers some improvements over the other test runner modules that ship with Test-Unit. You can browse through the tree of test suites, and select individual test suites, test cases and even individual tests to run.

You can use this module in two different ways. Most users will just want to run the script "gtestrunner" to run their test suites. If you want to integrate unit testing into your own software, you will probably use the module Test::Unit::GTestRunner.

Some stupid test suites and test cases are included with this package. Try

gtestrunner Suites/TS_TopLevel.pm

or

gtestrunner Suites::TS_TopLevel

to see gtestrunner in action. The test suites fails five times, and you have probably guessed that this is intentionally, so that you can see all features.

GTestRunner is fully internationalized. See the file README-NLS for details. See the file TRANSLATIONS for information about the currently available languages. Feel free to contact the author if you want to contribute a translation for your own native langauge.

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.

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.

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

SYNOPSIS

use Test::Unit::TestSuite;

# more code here ...

sub suite {
my $class = shift;

# create an empty suite
my $suite = Test::Unit::TestSuite->empty_new("A Test Suite");

# get and add an existing suite
$suite->add_test(Test::Unit::TestSuite->new("MyModule::Suite_1"));

# extract suite by way of suite method and add
$suite->add_test(MyModule::Suite_2->suite());

# get and add another existing suite
$suite->add_test(Test::Unit::TestSuite->new("MyModule::TestCase_2"));

# return the suite built
return $suite;
}

This class is normally not used directly, but it can be used for creating your own custom built aggregate suites.

Normally, this class just provides the functionality of auto-building a test suite by extracting methods with a name prefix of test from a given package to the test runners.