Free state of flprida ged predictive test software for linux

State Threads project is a small library for designing scalable Internet applications.
The State Threads is a small application library which provides a foundation for writing fast and highly scalable Internet applications (such as Web servers, proxy servers, mail transfer agents, etc.) on UNIX-like platforms.
It offers a threading API for structuring a network application as an event-driven state machine.
The State Threads library is a derivative of the Netscape Portable Runtime library (NSPR) and therefore is distributed under the Mozilla Public License (MPL) version 1.1 or the GNU General Public License (GPL) version 2 or later.
Enhancements:
- Added support for kqueue and epoll on platforms that support them.
- Added ability to choose the event notification system at program startup.
- Long-overdue public definitions of ST_UTIME_NO_TIMEOUT (-1ULL) and ST_UTIME_NO_WAIT (0) [bug 1514436].
- Documentation patch for st_utime() [bug 1514484].
- Documentation patch for st_timecache_set() [bug 1514486].
- Documentation patch for st_netfd_serialize_accept() [bug 1514494].
- Added st_writev_resid() [rfe 1538344].
- Added st_readv_resid() [rfe 1538768] and, for symmetry, st_readv().

Ragel State Machine Compiler compiles finite state machines from regular languages into executable C/C++/Objective-C code. Ragel state machines can not only recognize byte sequences as regular expression machines do, but can also execute code at arbitrary points in the recognition of a regular language.
Ragel can also be thought of as a finite state transducer compiler where output symbols represent blocks of code that get executed instead of written to the output stream.
When you wish to write down a regular language you start with some simple regular language and build a bigger one using the regular language operators union, concatenation, kleene star, intersection and subtraction.
This is precisely the way you describe to Ragel how to compile your finite state machines. Ragel also understands operators that embed actions into machines and operators that control any non-determinism in machines.
Ragel FSMs are closed under all of Ragels regular language, action specification and priority assignment operators. This property allows arbitrary regular languages to be described. Complexity is limited only by available processing resources.
For example, you can make one machine that picks out specially formatted comments in C code, another machine that builds a list all function declarations and a third that identifies string constants then "or" them all together to make a single machine that performs all of these tasks concurrently and independently on one pass of the input.
Main features:
- Describe arbitrary state machines using regular language operators and/or state tables.
- NFA to DFA conversion.
- Hopcrofts state minimization.
- Embed any number of actions into machines at arbitrary places.
- Control non-determinism using priorities on transitions.
- Visualize output with Graphviz.
- Use byte, double byte or word sized alphabets.
- Generate C/C++/Objective-C code with no dependencies.
- Choose from table or control flow driven output.
Enhancements:
- The documentation and the Ruby code generator were improved.

WWW::Search::Test contains utilities to aid in testing WWW::Search backends.

SYNOPSIS

$oTest = new WWW::Search::Test(HotBot,Yahoo,Excite);
$oTest->test(HotBot, Kingpin, one, $sQuery, $TEST_RANGE, 1, 10);

See file test.pl in the WWW-Search-HotBot distribution for a detailed "real-world" example.

METHODS AND FUNCTIONS

new

Create a new WWW::Search::Test object. All arguments are strings, names of backends that this object will be able to test. If no arguments are given, will be able to test all backends.

mode

Set / get the test mode of this object. If an argument is given, sets the mode to that value. Returns the current (or newly set) value.
There are three test modes available. They are:

$MODE_INTERNAL: parse URLs out of saved pages (as a sanity check or regression test);
$MODE_EXTERNAL: send the query to the search engine "live", parse the results, and compare them to the previously saved results;
and
$MODE_UPDATE: send the query to the search engine "live", parse the results, and save them for future testing.

relevant_test

Given the name of a backend, returns true if this Test object is able to test that backend.

eval_test

Given the name of a backend, grabs the $TEST_CASES variable from that backend and evaluates it.

test

Run test(s) for a backend. Arguments are, in order: name of a backend to test (string, required); name of backend maintainer (string, if undef $backend::MAINTAINER will be used); filename for results storage/comparison (string, required); query to be sent to backend (string, required); test method (required, one of the following).

Several test methods are possible:

$TEST_EXACTLY: list of URLs must match exactly (line for line, in order);
$TEST_BY_COUNTING: test passes if number of resulting URLs is equal;
$TEST_GREATER_THAN: test passes if we get more than N result URLs;
and
$TEST_RANGE: like $TEST_GREATER_THAN but constrained on both ends.

no_test

Prints a message stating that this backend does not have a test suite. Takes two arguments, the backend name and the name of the maintainer.

not_working

Prints a message stating that this backend is known to be broken. Takes two arguments, the backend name and the name of the maintainer.

not_working_with_tests

Prints a message stating that this backend is known to be broken even though it has a test suite. Takes two arguments, the backend name and the name of the maintainer.

not_working_and_abandoned

Prints a message stating that this backend is known to be broken and is not being actively maintained. Takes two arguments, the backend name and the name of the maintainer.

reset_error_count

Reset the counter of errors to zero. You probably want to call this before each call to test() or eval_test().

wc_l (private, not a method)

Given a filename, count the number of lines of text contained within the file. (I.e. simulate running UNIX command wc -l on a file)

diff (private, not a method)

Given two files, returns TRUE if contents are line-by-line different, or FALSE if contents are line-by-line same. (I.e. like the UNIX command diff, but just reports true or false)

Shortcuts for running backend tests

WWW::Search::Test keeps its own count of test numbers, so if you want to mix-and-match these functions with your own tests, use the $WWW::Search::Test::iTest counter.

new_engine

One argument: the name of a backend suitable to be passed to WWW::Search::new(). Prints ok or not ok and the test number. Creates a WWW::Search object internally, to be used for all subsequent calls to run_test and run_gui_test (see below).

tm_new_engine

Same as new_engine(), but uses Test::More instead of just printing ok.

run_test

Three arguments: a query string, NOT escaped; a minimum number of expected results; and a maximum number of expected results. Optional fourth argument: integer value to be used as the search_debug.

If the minimum is undef, assumes zero. If the maximum is undef, does not check.
Prints ok or not ok and the test number.

run_gui_test

Same as run_test(), but calls gui_query() instead of native_query().

tm_run_test

Same as run_test(), but uses Test::More rather than just printing ok.
Note: If you use this function inside a TODO block, you must set global variable $TODO rather than a local $TODO, and you must set the global $TODO back to empty-string (or undef) at the end of your TODO block. For example:

TODO:
{
$TODO = I have not fixed this yet;
ok(...);
$TODO = ;
} # end of TODO block

tm_run_test_no_approx

Same as tm_run_test, but does NOT check the approximate_result_count.

count_results

Run a query, and return the actual (not approximate) number of hits.

skip_test

You can call this function instead of run_test() or run_gui_test() if the current test must be skipped for any reason.

Final Fantasy VI Save State Editor project is an editor for Final Fantasy VI characters.

Final Fantasy VI Save State Editor is a tool for editing characters in Final Fantasy VI (or III in the USA) saved games. It makes it possible to increase skills, learn spells, gain weapons, and more using an easy to use GUI.

This
program does not edit battery based saved games, but complete game save states
generated by Snes9x and zsnes.

USAGE:

Open the program and select File->Open. Select a game save on your filesystem,
and then edit away! Use File->Save when done. Enjoy!

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.

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:
- Minor bugfixes in hop count validation.

The Bioinformatics Benchmark System is an attempt to build a reasonable testing framework, tests, and data, to enable end users and vendors to probe the performance of their systems.

What we are trying to do is to create a framework for testing, and a core set of tests that all may download and use to probe specific elements of systems performance.

Moreover, the source to these tests are available under GPL, and are hosted on Bioinformatics.org and Scalable Informatics LLC The idea is to enable end users, consumers, systems developers, and others to easily build and use meaningful tests for measurement and tuning reasons.

Joe Landman from Scalable Informatics LLC conceived the idea and wrote the original codes. We are looking for additional benchmark code suggestions, tests, data sets, etc.

Current baseline tests are several NCBI BLAST runs, several HMMer runs, and a variety of others. We plan to include ClustalW, X!Tandem, various chemistry, dynamics, and related tests, as well as several others.

Tests such as LINPACK or HPL simply do not provide meaningful performance indicators or predictive models for high performance informatics. Unfortunately, nor do a number of more recent and focused tests.

This is a problem as LINPACK and HPL specifically test the performance on various matrix operations, where you have effectively regular memory access patterns, and specific mathematical operations.

These codes are most useful for comparison to codes with heavy floating point operations, and interleaved memory traffic. These codes were not designed for comprehensive systems benchmarking, where disk I/O, memory latency, and other factors all contribute to the performance issues.

The best tests are the ones that are most similar to the codes you will run on the machine. The tests themselves should be reasonable approximations to a real execution of your code, using real data. You may need to pare it back in order to get realistic run times.

You should have a reasonable subset of data sizes. A single test does not tell you how your system scales, and one of the reasons for the existance of this test is specifically to allow you to test the performance while you increase various aspects of the workload.

You rarely get a quiescent system in a cluster, so we would recommend that you try to run in as realistic an operating environment as possible. A baseline in a quiescent system is fine, but it may set your expectations unreasonably.
top

Gedcom is a Perl module to manipulate Gedcom genealogy files.

SYNOPSIS

use Gedcom;

my $ged = Gedcom->new;
my $ged = Gedcom->new($gedcom_file);
my $ged = Gedcom->new(grammar_version => 5.5,
gedcom_file => $gedcom_file,
read_only => 1,
callback => $cb);
my $ged = Gedcom->new(grammar_file => "gedcom-5.5.grammar",
gedcom_file => $gedcom_file);

return unless $ged->validate;
my $xref = $self->resolve_xref($value);
$ged->resolve_xrefs;
$ged->unresolve_xrefs;
$ged->normalise_dates;
my %xrefs = $ged->renumber;
$ged->order;
$ged->write($new_gedcom_file, $flush);
$ged->write_xml($new_xml_file);
my @individuals = $ged->individuals;
my @families = $ged->families;
my $me = $ged->get_individual("Paul Johnson");
my $xref = $ged->next_xref("I");
my $record = $ged->add_header;
add_submitter
add_individual
add_family
add_note
add_repository
add_source
add_trailer
my $source = $ged->get_source("S1");