Free assert software for linux

JsTester allows validation of JavaScript code inside Java.

JsTester provides a group of assert methods like JUnits Assert, and it supports validation by Douglas Crockfords Remedial JavaScript. You can also use your own validations.

Class::Contract - Design-by-Contract OO in Perl.

SYNOPSIS

package ClassName
use Class::Contract;

contract {
inherits BaseClass;

invar { ... };

attr data1;
attr data2 => HASH;

class attr shared => SCALAR;

ctor new;

method methodname;
pre { ... };
failmsg Error message;

post { ... };
failmsg Error message;

impl { ... };

method nextmethod;
impl { ... };

class method sharedmeth;
impl { ... };

# etc.
};

Background

Design-by-contract is a software engineering technique in which each module of a software system specifies explicitly what input (or data or arguments) it requires, and what output (or information or results) it guarantees to produce in response.

These specifications form the "clauses" of a contract between a module and the client software that uses it. If the client software abides by the input requirements, the module guarantees to produce the correct output. Hence by verifying these clauses at each interaction with a module, the overall behaviour of the system can be confidently predicted.
Design-by-contract reinforces the benefits of modular design techniques by inserting explicit compile-time or run-time checks on a contract. These checks are most often found in object-oriented languages and are typically implemented as pre-conditions and post-conditions on methods, and invariants on classes.

Note that these features differ from simple verification statements such as the C assert statement. Conditions and invariants are properties of a class, and are inherited by derived classes.

An additional capacity that is often provided in design-by-contract systems is the ability to selectively disable checking in production code. This allows the contractual testing to be carried out during implementation, without impinging on the performance of the final system.

Adding design-by-contract to Perl

The Class::Contract module provides a framework for specifying methods and attributes for a class (much like the existing class definition modules Class::Struct, Class::MethodMaker, and Class::Generate). Class::Contract allows both per-object and per-class methods and attributes to be defined. Attributes may be scalar-, array-, hash-, or object-based.

Class::Contract differs from other class-specification modules (except Class::Generate) in that it also provides the ability to specify invariant conditions on classes, and pre- and post-conditions on methods and attributes. All of these clauses are fully inheritable, and may be selectively disabled. It differs from all other modules in that it has a cleaner, simpler specification syntax, and -- more importantly -- it enforces encapsulation of object attributes, thereby ensuring that the class contract cannot be subverted.

Defining classes

Class::Contract provides an explicit syntax for defining the attributes, methods, and constructors of a class. The class itself is defined using the contract subroutine. contract takes a single argument -- a subroutine reference or a block. That block is executed once and the results used to construct and install the various components of the class in the current package:

package Queue;
contract {
# specification of class Queue attributes and methods here
};

Solex is a free open source Web application testing tool built as a plug-in for the Eclipse IDE. Solex project provides functions to record a client session, adjust it according to various parameters and replay it later typically in order to ensure non regression of the applications behaviour (with stress testing capabilities being added at a later stage).
By recording, we mean that Solex acts as an HTTP proxy and records all HTTP requests and responses going through the wire between a Web client (eg. a Web browser) and a Web server. The task of replaying a scenario consists in sending the previously recorded and eventually customized HTTP requests to the server and asserting each response.
Solex started as an internal project because we were unable to find an open source testing tool fully suitable to our needs and in particular capable of dynamically altering requests. Furthermore, the tool was expected to be fully integrated with our internal development environment based on the Eclipse platform.
For some web applications, a request depends on a previous servers response. To address such a requirement, Solex introduces the concept of extraction and replacement rules. An extraction rule tied to an HTTP message content will bind an extracted value with a variable. A replacement rule will replace any part of an HTTP message with a variable content.
Solex therefore provides an easy way to extract URL parameters, Header values or any part of a request or a response, bind their values with variables and then replace URL parameters, Header values or any part of a request with the variable content.
Example:
Lets imagine the next two requests recorded from a Web browser:
GET http://www.myServer/myWebApp?action=connect HTTP/1.1
GET http://www.myServer/myWebApp?action=list&dynamic_id=12345 HTTP/1.1
Replaying these two requests without any modification may fail because dynamic_id must be different each time. This value may come from the first response body content. By using Solex, it is possible to add an extraction rule to the first response (e.g. obtaining the value 12345) and a replacement rule to the second request (e.g. populating the dynamic_id parameter with the value extracted).
Moreover, Solex provides the user with the capability to add assertions for each response. Once a response has been received, all assertions of this response will be called to ensure that it is valid. If not, the playback process is stopped.
Solex provides several kinds of rules and assertions, the most complicated ones support regular expressions and XPath.
Solex 0.5.0 works with Eclipse Release 2.1.2, Build id: 200311030802 and Solex 0.5.3 works with Eclipse Release 3.1.1, Build id: M20050929-0840. You will also need a JRE 1.4.x or later.
Enhancements:
- This version contains several enhancements and bugfixes such as compliance with Eclipse 3.1.1, use of Jakarta HTTPClient 3.0 final, SSL support during playback, use of the Commons Logging library, improved Javadoc, and more.

apt is the Debian package manager.

To compile this you need a couple things:

- A working POSIX system with working POSIX gcc, g++, make (GNU), ar, sh, awk and sed in the path
- GNU Make 3.74 or so, -- normal UNIX make will NOT work
* Note 3.77 is broken.
- A working ANSI C++ compiler, this is not g++ 2.7.* g++ 2.8 works OK and newer egcs work well also. Nobody has tried it on other compilers :< You will need a properly working STL as well.
- A C library with the usual POSIX functions and a BSD socket layer. If you OS conforms to the Single Unix Spec then you are fine:
http://www.opengroup.org/onlinepubs/7908799/index.html
- Refer to the Build-Depends information in debian/control for additional requirements (some of which are Debian-specific)

** NOTICE **

The C++ global constructors do not link correctly when using non-shared libaries. This is probably the correct behavior of the linker, but I have not yet had time to devise a work around for it. The correct thing to do is add a reference to debSystem in apt-pkg/init.cc, assert(&debSystem == 0) would be fine for instance.

RCUNIT is a robust C unit testing framework. Requiring only an ANSI compliant C compiler, It is a highly portable testing tool.
Main features:
- Uniform interfaces for managing test cases
- Optional setup and tear down functions for each test case (test function) to isolate a particular test.
- Optional setup and tear down functions for each test suite (test module).
- Multiple test registries and test suites for structuring test cases. Also provides a default test suite and default test registry.
- Output redirection mechanism to redirect log and test run report when a file I/O facility is not available in the test platform.
- Log handler mechanism for redirecting logs.
- Allows optional test run callback function (test run hook).
- Alternative mechanism to ANSI Cs assert() function (non-test run assertions). Also allows assertion callback function (assertion hook)
- A runtime memory leak check facility
- An extensible exception handling mechanism
Enhancements:
- This is is the pre-release version of 1.0.
- There were no major changes from version 0.1, and it is fairly stable.

RDFStore::Parser::SiRPAC is a Perl module that implements a streaming RDF Parser as a direct implementation of XML::Parser::Expat.

SYNOPSIS

use RDFStore::Parser::SiRPAC;
use RDFStore::NodeFactory;
my $p=new RDFStore::Parser::SiRPAC(
ErrorContext => 2,
Handlers => {
Init => sub { print "INITn"; },
Final => sub { print "FINALn"; },
Assert => sub { print "STATEMENT - @_n"; }
},
NodeFactory => new RDFStore::NodeFactory() );

$p->parsefile(http://www.gils.net/bsr-gils.rdfs);
$p->parsefile(http://www.gils.net/rdf/bsr-gils.rdfs);
$p->parsefile(/some/where/my.rdf);
$p->parsefile(file:/some/where/my.rdf);
$p->parse(*STDIN); #parse stream but with *blocking* Expat (see below example for n-blocking parsing using XML::Parse::ExpatNB)

use RDFStore::Parser::SiRPAC;
use RDFStore::NodeFactory;
my $pstore=new RDFStore::Parser::SiRPAC(
ErrorContext => 2,
Style => RDFStore::Parser::Styles::RDFStore::Model,
NodeFactory => new RDFStore::NodeFactory(),
store => {
persistent => 1,
seevalues => 1,
options => { Name => /tmp/test }
}
);
my $rdfstore_model = $pstore->parsefile(http://www.gils.net/bsr-gils.rdfs);

#using the expat no-blocking feature (generally for large XML streams) - see XML::Parse::Expat(3)
my $rdfstore_stream_model = $pstore->parsestream(*STDIN);

This module implements a Resource Description Framework (RDF) streaming parser completely in Perl using the XML::Parser::Expat(3) module. The actual RDF parsing happens using an instance of XML::Parser::Expat with Namespaces option enabled and start/stop and char handlers set. The RDF specific code is based on the modified version of SiRPAC of Sergey Melnik in Java; a lot of changes and adaptations have been done to actually run it under Perl. Expat options may be provided when the RDFStore::Parser::SiRPAC object is created. These options are then passed on to the Expat object on each parse call.

Exactly like XML::Parser(3) the behavior of the parser is controlled either by the Style entry elsewhere in this document and/or the Handlers entry elsewhere in this document options, or by the setHandlers entry elsewhere in this document method. These all provide mechanisms for RDFStore::Parser::SiRPAC to set the handlers needed by Expat. If neither Style nor Handlers are specified, then parsing just checks the RDF document syntax against the W3C RDF Raccomandation . When underlying handlers get called, they receive as their first parameter the Expat object, not the Parser object.

To see some examples about how to use it look at the sections below and in the samples and utils directory coming with this software distribution.
E.g. With RDFStore::Parser::SiRPAC you can easily write an rdfingest.pl script to do something like this:

fetch -o - -q http://dmoz.org/rdf/content.rdf.u8.gz |
gunzip - |
sed -f dmoz.content.sed | rdfingest.pl -

EZMorph is simple Java library for transforming an Object to another Object.
It supports transformations for primitives, Objects, and multidimensional arrays, compatibility with JDK 1.3.1, and small memory footprint (~60K).
EZMorph began life as the converter package in Json-lib but became a project on its own.
- Supports transformations for primitives and Objects
- Supports transformations for multidimensional arrays
- JDK 1.3.1 compatible
- Small memory footprint (~60K)
EZMorph comes with another feature: ArrayAssertions . JUnit 3.x does not have an assertEquals() method for asserting array equality, and JUnit 4.x has a limited one (it only supports Object[] not primitive arrays).
With ArrayAssertions is possible to compare a boolean[] with a boolean[] or even a Boolean[], an those arrays can be multidimensional too. EZMorph began life as the converter package on Json-lib but seeing that the features provided were more generic than JSON parsing, it became a project on its own.
Enhancements:
- This release can override existing morphers for a type when registering a new one, and clear all morphers for a type.
- The Javadocs have been updated.