Free smtp test software for linux

libsmtp allows programs to send mail directly through SMTP (no sendmail needed). lib smtp is designed to be simple and memory efficient, and has slightly untested support for MIME multipart body parts.

Acme::Tests is a Perl module to see how much do you know.

SYNOPSIS

perl Makefile.PL
make test

This module is a "test software", it has tests in the software rather then software tests. Upon installation, you are reqruied to answered several question, and the installation would be only successful if all you pass them all.

classes::Test are functions to help with classes pragma testing.

SYNOPSIS

can_new
can_set_get
has_decl
has_class_const
has_mixins
has_mixins_hash

is_classes MyClass;
is_classes main;

is_throwable X::Mine;
is_classes_exc X::Mine;

Generic tests based on Test::Builder designed to help write unit tests for code that uses the classes pragma.

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-Run is an improved test harness for scripts that emit TAP (Test Anything Protocol). It was forked from Test::Harness, and it uses TAP::Parser.

The project is used to analyze the output of the scripts and present it to the user in a summarized form. Test-Run features separation of the test-running backend and the command line frontend, a "runprove" utility for running tests from the command line, a plugin-system, and colors for the summary line.

Test::Data is a Perl module to test functions for particular variable types.

SYNOPSIS

use Test::Data qw(Scalar Array Hash Function);

Test::Data provides utility functions to check properties and values of data and variables.

Functions

Plug-in modules define functions for each data type. See the appropriate module.

How it works

The Test::Data module simply emports functions from Test::Data::* modules. Each module defines a self-contained function, and puts that function name into @EXPORT. Test::Data defines its own import function, but that does not matter to the plug-in modules.

If you want to write a plug-in module, follow the example of one that already exists. Name the module Test::Data::Foo, where you replace Foo with the right name. Test::Data should automatically find it.

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.