Free tests and quizzes software for linux

Tinyquizz project is a deliberately simplistic tool to produce self-assessment quizzes. Quizzes consist of a single entirely self-contained XHTML file. There is no need for a web server, PHP, database server, or e-learning platform to run them. A simple web browser is enough. It even fully works offline.
Quizzes produces by Tinyquizz can only be used for self-assessment because the answers are contained in the quizz file.
How does Tinyquizz work ?
Quizzes are written in XML, that is raw text with tags to delimit sections. For instance here is a question (tags are in bold):
< question>
< statement>You can cross when the light is < /statement>
< answer correct="no">Red< /answer>
< answer correct="yes">Green< /answer>
< /question>
Once you wrote the quizz you transform it with an XSLT processor or using the online transformer which does not require any installation.
Any basic text editor is ok to write Tinyquizz quizzes. However you may prefer to use a dedicated XML text editor such as Jaxe which can additionally ensure that the syntax is correct. Indeed you need to use the right tag at the right place
Enhancements:
- Input widgets are now locked once the result is displayed.
- A new reset button has been added.
- A new optional < justification > tag can now be added after each answer to provide the user with individualized feedback.
- Disc bullets are used for answers when there is no correct answer.
- New reference documentation is now available on the Web site as well as in the distribution.

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.

Syllogism Quizzer is an educational game that systematically quizzes you so you learn all 256 syllogism forms.

Test::STDmaker::STD is a Perl module that generates a STD POD from a test description short hand.

The Test::STDmaker::STD package is an internal driver package to the Test::STDmaker package that supports the Test::STDmaker::tmake() method. Any changes to the internal drive interface and this package will not even consider backward compatibility. Thus, this POD serves as a Software Design Folder documentation the current internal design of the Test::STDmaker and its driver packages.

The Test::STDmaker::STD package inherits the methods of the Test::STDmaker package. The Test::STDmaker build generate and methods directs the Test::STDmaker::STD to perform its work by calling its methods.

The Test::STDmaker::STD package methods use the Tie::Form methods to encode a STD POD and STD form database from the internal database checked by the Test::STDmaker::STD package methods. The Test::STDmaker package takes this data from the Test::STDmaker::STD package methods and generates a STD program module with a fresh POD and a checked __DATA__ form database with correctly counted ok fields.

The Test::STDmaker::STD package useful product is tables that trace requirements to tests and test headers that may be used to link (cite) tests in the tracebility matrices and other PODs.

During the course of the processing the Test::STDmaker::STD package maintains the following in the $self object data hash:

$demo_only

flags that the test description is for demo only

$fields

cumulative fields for the __DATA__ form section

@requirements

list of requirements for a test

$test

short hand test descriptions for a test

$Test_Descriptions

cumulative test descriptions POD

%trace_req

cumulative requirements to test hash

%trace_test

cumulative test to requirements hash

The Test::STDmaker::STD package processes following options that are passed as part of the $self hash from Test::STDmaker methods:

fspec_out

The file specification for the files in the __DATA__ form database.

Test::Cmd is a Perl module for portable testing of commands and scripts.

SYNOPSIS

use Test::Cmd;

$test = Test::Cmd->new(prog => program_or_script_to_test,
interpreter => script_interpreter,
string => identifier_string,
workdir => ,
subdir => dir,
match_sub => $code_ref,
verbose => 1);

$test->verbose(1);

$test->prog(program_or_script_to_test);

$test->basename(@suffixlist);

$test->interpreter(script_interpreter);

$test->string(identifier string);

$test->workdir(prefix);

$test->workpath(subdir, file);

$test->subdir(subdir, ...);
$test->subdir([sub, dir], ...);

$test->write(file, read($contents, [subdir, file]);
$test->read(@lines, [subdir, file]);

$test->writable(dir);
$test->writable(dir, $rwflag);
$test->writable(dir, $rwflag, %errors);

$test->preserve(condition, ...);

$test->cleanup(condition);

$test->run(prog => program_or_script_to_test,
interpreter => script_interpreter,
chdir => dir, args => arguments, stdin => pass(condition, &func);

$test->fail(condition);
$test->fail(condition, &func);
$test->fail(condition, &func, $caller);

$test->no_result(condition);
$test->no_result(condition, &func);
$test->no_result(condition, &func, $caller);

$test->stdout;
$test->stdout($run_number);

$test->stderr;
$test->stderr($run_number);

$test->match(@lines, @matches);
$test->match($lines, $matches);

$test->match_exact(@lines, @matches);
$test->match_exact($lines, $matches);

$test->match_regex(@lines, @regexes);
$test->match_regex($lines, $regexes);

$test->diff_exact(@lines, @matches, @output);
$test->diff_exact($lines, $matches, @output);

$test->diff_regex(@lines, @regexes, @output);
$test->diff_regex($lines, $regexes, @output);

sub func {
my ($self, $lines, $matches) = @_;
# code to match $lines and $matches
}
$test->match_sub(&func);
$test->match_sub(sub { code to match $_[1] and $_[2] });

$test->here;

The Test::Cmd module provides a low-level framework for portable automated testing of executable commands and scripts (in any language, not just Perl), especially commands and scripts that interact with the file system.

The Test::Cmd module makes no assumptions about what constitutes a successful or failed test. Attempting to read a file that doesnt exist, for example, may or may not be an error, depending on the software being tested.

Consequently, no Test::Cmd methods (including the new() method) exit, die or throw any other sorts of exceptions (but they all do return useful error indications). Exceptions or other error status should be handled by a higher layer: a subclass of Test::Cmd, or another testing framework such as the Test or Test::Simple Perl modules, or by the test itself.
(That said, see the Test::Cmd::Common module if you want a similar module that provides exception handling, either to use directly in your own tests, or as an example of how to use Test::Cmd.)

In addition to running tests and evaluating conditions, the Test::Cmd module manages and cleans up one or more temporary workspace directories, and provides methods for creating files and directories in those workspace directories from in-line data (that is, here-documents), allowing tests to be completely self-contained. When used in conjunction with another testing framework, the Test::Cmd module can function as a fixture (common startup code for multiple tests) for simple management of command execution and temporary workspaces.

The Test::Cmd module inherits File::Spec methods (file_name_is_absolute(), catfile(), etc.) to support writing tests portably across a variety of operating and file systems.

A Test::Cmd environment object is created via the usual invocation:

$test = Test::Cmd->new();

Arguments to the Test::Cmd::new method are keyword-value pairs that may be used to initialize the object, typically by invoking the same-named method as the keyword.

Test::Singleton is a test for Singleton classes.

SYNOPSIS

use Test::More tests => 1;
use Test::Singleton;
is_singleton( "Some::Class", "new", "instance" );

** If you are unfamiliar with testing read Test::Tutorial first! **

This is asimple, basic module for checking whether a class is a Singleton. A Singleton describes an object class that can have only one instance in any system. An example of a Singleton might be a print spooler or system registry, or any kind of central dispatcher.

For a description and discussion of the Singleton class, see "Design Patterns", Gamma et al, Addison-Wesley, 1995, ISBN 0-201-63361-2.

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.