Free webtest 2.04 software for linux

HTTP::WebTest is a Perl module for testing static and dynamic web content.

SYNOPSIS

use HTTP::WebTest;

my $webtest = new HTTP::WebTest;

# run test from file
$webtest->run_wtscript(script.wt);

# or (to pass test parameters as method arguments)
$webtest->run_tests($tests);

Introduction

This module runs tests on remote URLs containing Perl/JSP/HTML/JavaScript/etc. and generates a detailed test report. This module can be used "as-is" or its functionality can be extended using plugins. Plugins can define test types and provide additional report capabilities. This module comes with a set of default plugins but can be easily extended with third party plugins.

The wt script is provided for running HTTP::WebTest from the command line.
The test specifications can be read from a parameter file in wtscript format or input as method arguments. The test results can be displayed on the terminal, directed to a file, stored in a scalar variable. The test results can also be emailed. The report can be modified and extended using report plugins.

Each URL/web file is tested by fetching it from the web server using a local instance of an HTTP user agent. The basic test is simply whether or not the fetch was successful. You may also test using literal strings or regular expressions that are either required to exist or forbidden to exist in the fetched page. You may also specify tests for the minimum and maximum number of bytes in the returned page. You may also specify tests for the minimum and maximum web server response time.

Data flow for HTTP::WebTest:

-------------- -------------
| | | |
| Input |------------->| WebTest |
| parameters | | |
| | -------------
-------------- | ^
| |
V |
------------- ------------
| | request | |
| Remote || user |
| | response | agent |
------------- | |
------------

Text::Kakasi is a perl frontend to kakasi.

SYNOPSIS

use Text::Kakasi;
# functional
$res = Text::Kakasi::getopt_argv(-JJ, -c, -w);
$str = Text::Kakasi::do_kakasi($japanese_text);
# object-oriented
$obj = Text::Kakasi->new(-JJ, -c, -w);
$str = $obj->get($japanese_text);

This module provides interface to kakasi (kanji kana simple inverter). kakasi is a set of programs and libraries which does what Japanese input methods do in reverse order. You feed Japanese and kakasi converts it to phonetic representation thereof. kakasi can also be used to tokenizing Japanese text. To find more about kakasi, see http://kakasi.namazu.org/ .

Text::Kakasi now features both functional and object-oriented APIs. functional APIs are 100% compatible with ver. 1.05. But to take advantage of "Perl 5.8 Features", you should use OOP APIs instead.

See Text::Kakasi::JP for the Japanese version of this document.

Bumpmap plug-in uses the algorithm described by John Schlag, "Fast Embossing Effects on Raster Image Data in Graphics Gems IV (ISBN 0-12-336155-9).

Bumpmap takes an image to be applied as a bump map to another image, producing a nice embossing effect.

Text::Kakasi::JP is a Japanese Perl extension for Text::Kakasi.

SYNOPSIS

use Text::Kakasi;
# functional
$res = Text::Kakasi::getopt_argv(kakasi, -ieuc, -w);
$str = Text::Kakasi::do_kakasi($japanese_text);
# object-oriented
$obj = Text::Kakasi->new(-ieuc,-w);
$str = $obj->get($japanese_text);

Drumachine is a program which translates a simple drum-pattern description file into a CSOUND score. It is useful in the creation of percussion tracks with csound, ranging from the trivial to the extremely involved and complex. I have compiled and tested the program under Linux only.

Drumachine now supports time-variable volume and tempo changes. Now, the creation of Crescendo/Decrescendo and Ritard/Accelerando is very easy.


Download drumachine2.04.tar.gz (~215k), should you be so inclined. The archive contains a Linux executable of drumachine, and the source code from which it was compiled. There is also a selection of drum samples included in the archive (AIFF), which should enable one to get started on her way to creating gourmet percussion tracks with drumachine.

If you like, you can sneek a peek at the manual, which is really a working drumachine score at the same time. The same score without the manual-devoted portions may also be viewed should one wish to know what it is like to look at a more typical example of a drumachine score-file.

The release notes detail new features and bug-fixes from rev to rev. Reading it can help one decide whether to download a new version.

Math::MagicSquare is a Magic Square Checker and Designer.

SYNOPSIS

use Math::MagicSquare;

$a= Math::MagicSquare -> new ([num,...,num],
...,
[num,...,num]);
$a->print("string");
$a->printhtml();
$a->printimage();
$a->check();
$a->rotation();
$a->reflection();

The following methods are available:

new

Constructor arguments are a list of references to arrays of the same length.

$a = Math::MagicSquare -> new ([num,...,num],
...,
[num,...,num]);

check

This function can return 4 value

0: the Square is not Magic
1: the Square is a Semimagic Square (the sum of the rows and the columns is equal)
2: the Square is a Magic Square (the sum of the rows, the columns and the diagonals is equal)
3: the Square ia Panmagic Square (the sum of the rows, the columns, the diagonals and the broken diagonals is equal)

print

Prints the Square on STDOUT. If the method has additional parameters, these are printed before the Magic Square is printed.

printhtml

Prints the Square on STDOUT in an HTML format (exactly a inside a TABLE)

printimage

Prints the Square on STDOUT in png format.

rotation

Rotates the Magic Square of 90 degree clockwise

reflection

Reflect the Magic Square

Pod::Man is a Perl module to convert POD data to formatted *roff input.

SYNOPSIS

use Pod::Man;
my $parser = Pod::Man->new (release => $VERSION, section => 8);

# Read POD from STDIN and write to STDOUT.
$parser->parse_file (*STDIN);

# Read POD from file.pod and write to file.1.
$parser->parse_from_file (file.pod, file.1);

Pod::Man is a module to convert documentation in the POD format (the preferred language for documenting Perl) into *roff input using the man macro set. The resulting *roff code is suitable for display on a terminal using nroff(1), normally via man(1), or printing using troff(1). It is conventionally invoked using the driver script pod2man, but it can also be used directly.
As a derived class from Pod::Simple, Pod::Man supports the same methods and interfaces. See Pod::Simple for all the details.

new() can take options, in the form of key/value pairs that control the behavior of the parser. See below for details.

If no options are given, Pod::Man uses the name of the input file with any trailing .pod, .pm, or .pl stripped as the man page title, to section 1 unless the file ended in .pm in which case it defaults to section 3, to a centered title of "User Contributed Perl Documentation", to a centered footer of the Perl version it is run with, and to a left-hand footer of the modification date of its input (or the current date if given STDIN for input).

Pod::Man assumes that your *roff formatters have a fixed-width font named CW. If yours is called something else (like CR), use the fixed option to specify it. This generally only matters for troff output for printing. Similarly, you can set the fonts used for bold, italic, and bold italic fixed-width output.

Besides the obvious pod conversions, Pod::Man also takes care of formatting func(), func(3), and simple variable references like $foo or @bar so you dont have to use code escapes for them; complex expressions like $fred{stuff} will still need to be escaped, though. It also translates dashes that arent used as hyphens into en dashes, makes long dashes--like this--into proper em dashes, fixes "paired quotes," makes C++ look right, puts a little space between double underbars, makes ALLCAPS a teeny bit smaller in troff, and escapes stuff that *roff treats as special so that you dont have to.

Chatbot::Alpha::Syntax is a Perl module for syntax checking of Chatbot::Alpha replies.

SYNOPSIS

use Chatbot::Alpha::Syntax;

my $syntax = new Chatbot::Alpha::Syntax;

# Set strict syntax.
$syntax->syntax (strict);

# Changed my mind, use loose
$syntax->syntax (loose);

# Only allow SOME commands.
$syntax->deny_type (allow_some);

# Allow only +s and -s.
$syntax->allow (+, -);

# Syntax-check this file.
$syntax->check ("replies.cba");

Chatbot::Alpha::Syntax provides syntax checking for Alpha documents. All syntax errors result in a die so dont expect to run your syntax checking halfway through a large applications process. Doing it in initialization is always fine though.