testdriven.com Wrangling quality out of chaos

Artima SuiteRunner is a free open source testing toolkit for Java released under the Open Software License. You can use this tool with JUnit to run existing JUnit test suites, or standalone to create unit and conformance tests for Java APIs.

The three main advantages Artima SuiteRunner offers to JUnit users are reporters, runpaths, and recipe files. Existing JUnit users can use SuiteRunner to run their JUnit tests, which allows them to gain the benefits of reporters, runpaths, and recipe files while continuing to use their JUnit test cases.
link

CruiseControl is a framework for a continuous build process. It includes, but is not limited to, plugins for email notification, Ant, and various source control tools. A web interface is provided to view the details of the current and previous builds.
link

Cricket Cage automatically creates JUnit TestCases for repeatable bugs and test scenarios. It uses AspectJ to insert code into your classes to generate the code for the test case.
link

Haste (High-level Automated System Test Environment) represents an approach to system testing that is philosophically consistent with standard XP unit testing practices. Test code runs in the same address space as the application under test, allowing for ready examination of application state. The fundamental Haste abstractions of Story, Step, and StoryBook provide a framework to implement system tests.

Haste has been used for system testing of Web applications and Java Swing applications.

White paper: http://atomicobject.com/media/files/Haste.pdf
link

Clover is a Java code coverage analysis tool. It discovers sections of code that are not being adequately exercised by your unit tests. Clover reports its findings in multiple formats for easy use by the whole team at the project level down to each line of source code.
link

Jameleon is an acceptance-level automated testing tool that separates applications into features and allows those features to be tied together independently, creating test cases. These test cases can then be data-driven and executed against different environments. Even though it would be possible to write unit tests using Jameleon, Jameleon was designed with integration and acceptance-level testing in mind.
link

‘Test everything that could possibly break’ is the motto. But how good are the tests you’ve written? Are they missing any part of your code? Are you testing too much? Is something being tested only via 5 or 6 nested calls?

NoUnit answers these questions by giving you a simple picture of your code. Like a Graph, NoUnit shows you a picture of your code, and reveals how complete your JUnit tests are.
link

Creating and maintaining a test structure can be cumbersome. JUnitDoclet lowers the step toward JUnit, by generating skeletons of TestCases based on your application’s source code. It supports test reorganization during refactoring.
link

Jester finds code that is not covered by tests. Jester makes some change to your Java code, runs your tests, and if the tests pass Jester displays a message saying what it changed. Jester includes a script for generating web pages that show the changes made that did not cause the tests to fail.

Pester (for Python/PyUnit) appears on the same page.
link

Hansel is an extension to JUnit that adds code coverage testing to the testing framework. Much of the source code is taken from Gretel a "Residual Test Coverage Monitoring"-Tool developed at the University of Oregon.
link

The Daedalos JUnit Extensions aka djux allow you to define and use test resources easily within your test code. Unit tests are speeded up by using test resources, because time-consuming initializations are only done once and remain active over a series of tests. As an example, a database connection is opened before executing the first unit test and can be accessed during the whole testing circle. It isn’t necessary to re-open the database connection before an unit test is executed. Furthermore, additional extensions are included that improve unit testing.
link

GroboUtils aims to expand the testing possibilities of Java. It contains many sub-projects which experiment with one aspect of testing through Java. Some projects are present to add shared functionality between the testing sub-projects, while others are remnants from the old purpose of GroboUtils (a collection of useful libraries).
link

Passing or failing: these are the usual states of JUnit tests. But discover a third state that many use but only few acknowledge, and how you can elegantly manage these tests with JUnit-addons Runner: the Excluded test case.
link

TestDox creates simple documentation from the method names in JUnit test cases.

For Example, a test class like:

public class FooTest extends TestCase {
public void testIsASingleton() {}
public void testAReallyLongNameIsAGoodThing() {}
}

would generate the following :

Foo
- is a singleton
- a really long name is a good thing
link

The Jusc tool is a Java unit test selection tool based on residual structural coverage. Much of the code is taken from Hansel, an extension to JUnit that adds residual structural coverage testing to the testing framework. Some code related to instrumentation and command line options is taken from a method tracing tool. Jusc uses BCEL to perform on-the-fly instrumentation at class loading time.

Running Jusc on a test class containing a list of test methods, you can get a list of selected tests, each of which cover at least one new structural entity (method or branch in particular) from the class under test.

See also:
Tool-Assisted Unit Test Selection Based on Operational Violations [PDF]
Jov (Java Unit Test Selection Tool Based on Operational Violations)
link

Jov is a Java unit test selection tool based on operational violations. The current implementation integrates ParaSoft Jtest (a commercial Java unit test generation tool) and Daikon (an invariant detection tool).

See also:
Tool-Assisted Unit Test Selection Based on Operational Violations [PDF]
Jusc (Java Unit Test Selection Tool Based on Residual Structural Coverage)
link

Junit-addons Runner is a Junit runner that is especially targeted at integration tests, where external resources are too expensive to acquire before each test. Some of JUnit-addons Runner features include:

- custom listeners;
- resources (like a connection to a database) shared by tests;
- properties split for the runner and tests;
- custom monitor (to manage the execution of the tests).

This runner is very flexible (IMO) and was designed especially for
integration tests.

Programmer: Vladimir R. Bossicard (site)
See also: JUnit-addons documentation
link

JUnit is a regression testing framework written by Erich Gamma and Kent Beck. It is used by the developer who implements unit tests in Java. Most famous of XUnits, JUnit is Open Source Software.
link