Free matches trick software for linux

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.

Hattrick Broadcasting Bot is an eggdrop module which displays matches of the online game Hattrick live in IRC channels.
Enhancements:
- Support for multiple cookies (now needed to log in), compression of the communication with the server, matchflags to hide certain events, and some smaller fixes.

check_ssl_cert project is a Nagios plugin to check X.509 certificates.

It checks if the server is running and delivers a valid certificate.

It also checks if the CA matches a given pattern, and checks the validity.

Regexp::MatchContext is Perl module to replace (and improve) $MATCH, $PREMATCH, and $POSTMATCH

SYNOPSIS

use Regexp::MatchContext -vars;

$str = m/(?p) d+ /;

print "Before: $PREMATCHn";
print "Matched: $MATCHn";
print "After: $POSTMATCHn";

$MATCH = 2 * $MATCH; # substitute into original $str

The English.pm module provides named aliases for Perls built-in $`, $& and $ variables: $PREMATCH, $MATCH, and $POSTMATCH. Unfortunately, those aliases suffer the same problems as their originals: they degrade the performance of every single regex in your program, even if youre only using them to get information about a single match.

This module also provides $PREMATCH, $MATCH, and $POSTMATCH, but in a way that only impacts the performance of matches that you specify. That is, these three variables are only set if the most recently matched regex contained the special (non-standard) meta- flag: (?p).

That is:

use Regexp::MatchContext -vars;

$str = foobarbaz;

$str =~ /(?p) foo /x;

# $PREMATCH contains foo
# $MATCH contains bar
# $POSTMATCH contains baz

$str =~ / foo /x;

# $PREMATCH, $MATCH, and $POSTMATCH all undef

The (?p) marker can be placed anywhere within the regex and, except for setting the three context variables on a successful match, is otherwise totally ignored.

Chroniton::Config it manages config file for Chroniton.

SYNOPSIS

my $config = Chroniton::Config->new;

METHODS

new

Creates an instance. Takes no arguments.

destination

Returns the directory where the backup should be placed.

locations

Returns a list of directories to be backed up.

config_file

Returns the path to the config file.

archive_after

Returns the number of days between archiving operations.

exclude

Returns a list of compiled regular expressions. If a path matches one of these, dont back it up.

Chroniton::Config->_create

Creates an empty config file.

List::Search is a Perl module for fast searching of sorted lists.

SYNOPSIS

use List::Search qw( list_search nlist_search custom_list_search );

# Create a list to search
my @list = sort qw( bravo charlie delta );

# Search for a value, returns the index of first match
print list_search( alpha, @list ); # 0
print list_search( charlie, @list ); # 1
print list_search( zebra, @list ); # -1

# Search numerically
my @numbers = sort { $a $b } ( 10, 20, 100, 200, );
print nlist_search( 20, @numbers ); # 2

# Search using some other comparison
my $cmp_code = sub { lc( $_[0] ) cmp lc( $_[1] ) };
my @custom_list = sort { $cmp_code->( $a, $b ) } qw( FOO bar BAZ bundy );
print list_search_generic( $cmp_code, foo, @custom_list );

This module lets you quickly search a sorted list. It will return the index of the first entry that matches, or if there is no exact matches then the first entry that is greater than the search key.

For example in the list my @list = qw( bob dave fred ); searching for dave will return 1 as $list[1] eq dave. Searching for charles will also return 1 as dave is the first entry that is greater than charles.

If there are none of the entries match then -1 is returned. You can either check for this or use it as an index to get the last values in the list. Whichever approach you choose will depend on what you are trying to do.

The actual searching is done using a binary search which is very fast.

The TagMogrifier library for PHPs goal is to let you perform fast and easy-to-program transformations on XML documents. Instead of having to write your own parser, or directly using the PHP DOM parser, and having to write your own tree walker and such, you only need to instantiate a class, add a few match expressions, and assign a function to process every XML element that matches, DOM-style.

Do you work with PHP and XML often? If you do, you’ve probably noticed it’s very tedious to manipulate XML from PHP. Be it regular expressions, tree walking of DOM nodes, or SAX, all of these alternatives are hard work.

The purpose of this library is to let you perform fast and easy-to-program transformations on XML documents. Instead of having to write your own parser, or directly using the PHP DOM parser, and having to write your own tree walker and such, you only need to instantiate a class, add a few match expressions, and assign a function to process every XML element that matches, DOM-style.