Free matches at wrestlemania 25 software for linux

Test::Exception is a Perl module to test exception based code.

SYNOPSIS

use Test::More tests => 5;
use Test::Exception;

# or if you dont need Test::More

use Test::Exception tests => 5;

# then...

# Check that something died
dies_ok { $foo->method1 } expecting to die;

# Check that something did not die
lives_ok { $foo->method2 } expecting to live;

# Check that the stringified exception matches given regex
throws_ok { $foo->method3 } qr/division by zero/, zero caught okay;

# Check an exception of the given class (or subclass) is thrown
throws_ok { $foo->method4 } Error::Simple, simple error thrown;

# all Test::Exceptions subroutines are guaranteed to preserve the state
# of $@ so you can do things like this after throws_ok and dies_ok
like $@, what the stringified exception should look like;

# Check that a test runs without an exception
lives_and { is $foo->method, 42 } method is 42;

# or if you dont like prototyped functions

dies_ok( sub { $foo->method1 }, expecting to die );
lives_ok( sub { $foo->method2 }, expecting to live );
throws_ok( sub { $foo->method3 }, qr/division by zero/,
zero caught okay );
throws_ok( sub { $foo->method4 }, Error::Simple,
simple error thrown );
lives_and( sub { is $foo->method, 42 }, method is 42 );

This is a Gaim plugin that automatically blocks nicknames or messages based on regular expression matches. Right now it only works with yahoo since those are the only chat rooms I visit using gaim.
Installation:
To install, copy autoblock.c and autoblock.h to /path/to/gaim/sources/plugins and type "PLUGIN_LIBS=-lpcre make autoblock.so".
Then copy autoblock.so to your gaim plugins directory (On unices it is ~/.gaim/plugins).
The files ab_nicks.txt and ab_messages.txt are supplied; I spent a little time culling them; and they get most of the bots in the rooms I have been in.
Copy them to your gaim home dir (~/.gaim on unices).
Enhancements:
- Really fixed the problem with blocking IMs even when not chatting.
- Fixed the hang/crash when a non-yahoo IM is recieved.
NOTE - many of the preferences that used to be available are no longer available due to changes in the Gaim API and program flow.

streamripagent is a simple Amarok script that watches the tracks streamed in Amarok. If any of the regexps in ~/.streamripagent matches the current title, streamripper is started and the track is ripped to a specified directory.

Its not exactly an amarok script that you can manage with the amarok script manager, but its related to amarok, so I put it in this category.

Please read the README before installing and running streamripagent!

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.

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.

Gestinanna::Util Perl module contains utility functions.

SYNOPSIS

use Gestinanna::Util qw(:path);

my $regex = path2regex($path)
my $cmp = path_cmp($path_a, $path_b);

use Gestinanna::Util qw(:hash);

my $new_hash = deep_merge_hash(@hashes);

This module provides utility functions that have no better place to be. Sets of utility functions may be imported by specifying their tags.

:path

Imports: path2regex, path_cmp

PATHS

Paths are made up of a sub-set of the XPath language:

/

The slash (/) is the component separator. Alone, it describes the root of the
resource heirarchy.

//

The double slash (//) stands in place of any number of components (zero or more). Alone, it matches any possible path that does not specify attributes or a final component. To match any component with any attributes, use //*|//*@*.

@

The at sign (@) is the attribute separator. A path should only have one. It separates the final component from any attribute. If no attribute follows it, it stands for the general collection of attributes for an object.

|

The pipe symbol (|) separates paths which together specify a union.

&

The ampersand (&) separates paths which together specify an intersection. Intersection has higher precedence to union. For example, the path //a/* & //*@name | //b/* is considered to be (//a/* & //*@name) | //b/*, not //a/* & (//*@name | //b/*). There are no parenthesis for grouping in actual path expressions.

!

An odd number of initial bangs (!) will negate the following clause, up to a pipe (|) or ampersand (&). An even number of initial bangs will have no effect.

Examples:

The following are some examples of paths.

//*

This matches any path. Attaching attributes to this path will apply them to all objects.

//*@name

This matches the name attribute of all objects.

//*/*

This matches any component that is not at the top-level.

!//a//* & //b//*

This matches any path that has a b component and not an a component.

Visual REGEXP project can easily design and debug regular expressions by providing a graphical visualization of the expression and its matches on a sample of your choice.
Version restrictions:
- some regexp can consume a lot of CPU time. This seems to be caused by the use of -all, -inline and -indices flags together.
- when a subexpression is not matched (empty match), the last character of the previous match are coloured. This is due to a problem in Tcl (bug submitted to Scriptics).
Enhancements:
- new version done by Martin Lemburg. Many thanks, Martin.
- it is now a tcl 8.5a4 starpack
- GUI layout changed to be based on a paned window
- GUI code looks different, to be more ergonomic
- the informational labels (replacements & matches) are now sunken
- there are now additional the "first" and "last" navigation buttons
- there is a new option to navigate through matches or matches and submatches
- the displayed count of matches is changed to display the current and the count of matches used for navigation (probably changes, if the new navigation option is changed)
- the replace widget is disabled on startup
- the tcl console is added to the help menu
- the key bindings inside the regexp text widget changed a bit to allow for expanded regexp (-expanded or (?x)) to contain tabs and newlines. Tabs are created with Control-Tab and newlines with Control-Return. Additional with Control-C|V|X (not c|v|x) it is possible to use the clipboard like with Control|Shift-Insert, Shift-Delete.

XSearch project bridges the gap between Beagle (simple interface, large search net) and find/grep (powerful searching, small search net).

What is XSearch?

A fast real-time search engine for displaying all regular expression matches within a file, across multiple directories.

Why XSearch?

Linux currently has two leading search methods:

1.Beagle – simple to use, but shows too many matches.
2.Find/Grep – hard to use, but provides exact matching.

XSearch tales the best features from both.

It provides a simple to use interface, but has the power of find and grep combined. In addition, the end search result is an easy to browse list of matching files, and matching lines.

Who would benefit from XSearch?

Software engineers mainly, but anyone who has a large number of pure text files will benefit.

Searching a large amount of source code, across many directories, is both tedious, and time consuming. Think of this tool as a helper to finding that needle in a haystack!
How many times as a software engineer do you find it essential to search code looking for specific functions, or declarations within the source code? Now with XSearch, you can quickly look-up the code locations, and often get the info without having to open the file in your editor.