testdriven.com Wrangling quality out of chaos

The JMUnit is a Java ME (or J2ME) application used by developers to test code. It’s an implementation of the popular xUnit framework.

JMUnit 1.1 has been released. It allows test failures and errors to be viewed on real devices (not just the emulator console). An Ant task for JMUnit has been added that generates XML reports that can be rendered by the <junitreport> Ant task.

JMUnit 1.2 is included in the Eclipse MTJ 0.9.1 plugin and in Netbeans 6.5. JMUnit 1.2 adds additional support for Ant and classes for performance monitoring.

link

TestUtil is a Java open source low-effort automated method testing strategy and tool for verifying all matching accessor methods on mutable objects with a single line of unit test code. It is compatible with both in-container and outside-the-container strategies extending JUnit.

Version 2.4 includes support for Enums.

link

Bumblebee generates human-readable documentation from your JUnit test-structure. By adding comments powered with wiki-syntax and an extensible Ruby context for including snippets, runtime data and other content, you can create and maintain your system documentation with a minimum of effort.
link

T2 is a fully automatic, trace-based random testing tool, featuring in-code specifications and reflexive testing.

T2 checks for internal errors, run time exceptions, method specifications, and class invariant. Unlike other testing tools, T2 reads specifications written in plain java! They are placed in the class we want to specify. Though not as fancy as Z or JML, in-code specifications are declarative, formal, and powerful. Maintenance effort is also minimum.

Unlike other testing tools T2 does not check individual methods in isolation. Nor does it generate Junit test scripts, though we could add this feature. T2 actually performs the test directly or on the fly. So it responds faster, perhaps even giving the feel that it is interactive. Internally it generates tests in the form of traces (sequences) of method calls; each will be checked. This has the effect that methods are basically checking each other. This is called reflexive testing. The benefit is that it still works well even if the specifications provided are very partial, whereas other testing tools typically rely complete specifications.

It is a unit testing tool; with classes as the units. Violating traces are reported, and can be saved, and reloaded for re-testing or regression.

(Still in prototype stage)
link

Unitils is an open source library aimed at making unit testing easy and maintainable. Unitils builds further on existing libraries like DBUnit and EasyMock and integrates with JUnit and TestNG.

Unitils provides general asserion utilities, support for database testing, support for testing with mock objects and offers integration with Spring and Hibernate. It has been designed to offer these services to unit tests in a very configurable and loosely coupled way. As a result, services can be added and extended very easily.
link

MoMEUnit is an instance of the xUnit architecture for unit testing of J2ME applications. It is derived from well known JUnit framework.

CLDC 1.1 compliance only.
link

Ultra lightweight Java Developer Tools. Offers universal testing and mock object frameworks. Currently developing the tools needed to make a 100% Java OS. All products are community-oriented (see web site for details) with full source code accessible by everyone.
link

JDave is a BDD framework for Java. It is inspired by rspec and integrates JMock as mocking framework. It currently uses JUnit adapter to launch JDave specifications. This way it is possible to have IDE and build tool support from day one.
link

The Ejb3Unit project will automate Entity and Session bean testing outside the container for the EJB 3.0 specification. Ejb3Unit can execute automated standalone JUnit test for all EJB 3.0 conform J2EE projects. EJb3Unit is using an in memory database by default but also can be configured for a user defined target database if necessary. Testdata can be provided by in various ways, for instance comma seperated file, data generators or constants.
link

actiWATE R1.0 (Actimind Web Application Testing Environment) is a free software platform intended to simplify the test automation process.

The major component of actiWATE is a Java-based Framework that emulates Internet browser functionality and provides a convenient and intuitive action-based API for test script development. Action-based tests are easier to write and comprehend, and therefore easier to maintain through the regression testing process.

Automated tests in actiWATE consist of Java code using the actiWATE API. Therefore these tests can be executed by means of different tools (for example, the JUnit test runner).

actiWATE collects testing information to log files and generates test failure reports to simplify problem allocation and correction.

actiWATE can now be used for testing web applications written in AJAX.
link

JUnit Factory is an experimental test-generation service from Agitar Software. You send us code. We send you tests.
link

RIFE is a full-stack web application framework with tools and APIs to implement most common web features. Each of its toolkits is usable by itself and together they offer powerful integrated features that boost your productivity. RIFE ensures that every declaration and definition is handled in one place in the code. This simplifies the developer’s task by reducing code replication, enforcing consistency, and easing maintenance.
link

EclEmma is a free Java code coverage tool for Eclipse, available under the Eclipse Public License. Internally it is based on the great EMMA Java code coverage tool, trying to adopt EMMA’s philosophy for the Eclipse workbench:

* Fast develop/test cycle: Launches from within the workbench like JUnit test runs can directly be analyzed for code coverage.
* Rich coverage analysis: Coverage results are immediately summarized and highlighted in the Java source code editors.
* Non-invasive: EclEmma does not require modifying your projects or performing any other setup.

The Eclipse integration has its focus on supporting the individual developer in an highly interactive way.
link

JUseCase is an open source Java framework supporting recording and simulation of user interaction in Java Swing GUIs. The interactions are recorded to plain-text use case scripts, which then may be used to simulate the interaction you just recorded. JUseCase currently supports most of the standard events, such as selecting items in a list, toggling radio buttons/checkboxes, flipping tabs, selecting/editing table cells etc., but the framework can easily be extended to support custom components/events.
link

Fitnesse, a wiki encapsulating the Framework for Integration Tests (aka FIT), enables customers to write sentence-like tests which can be mapped to the underlying system. Selenium drives a browser without all of the fragile mouse coordinate testing you get from a lot of testing tools (ala WinRunner).

In order for customers to harness the power of Selenium in the acceptance tests they are writing, this tool uses the DoFixture and the Selenium Remote Control Java API to produce a custom Fitnesse fixture which reads surprisingly well.
link

LiFT is a framework for Literate Functional Testing. LiFT allows writing automated tests in a style that makes them very readable, even for non-programmers. Using the LiFT API, we can write tests that read almost like natural language, allowing business requirements to be expressed very clearly. This aids communication amongst developers and customers, helping give all stakeholders confidence that the right things are being tested.
link

Javadoc-Junit is an Ant task which extends the optional JUnit Task and includes some Javadoc informations in the resulting JUnit test report.

The javadoc information is not directly retrieved from the test class source files, because the sources doesn’t need to exist during running the tests and generating the test reports.

To achieve this design goal, the needed javadoc informations are retrieved during a separate javadoc task with a special doclet. The javadoc informations are then serialized to files and stored with the class files themself. In this way only the class files with the serialized javadocs are needed to generate the javadoc-junit test reports.
link

junit-objects is different from Junit in that it allows you to assert the state of objects and design patterns rather than the result of method calls. It should be seen as a replacement for previous unit testing frameworks.

* junit-objects focuses on testing objects: their structure, state and behavior.
* An object’s state is asserted with testing protocols.
* JO greatly reduces the amount of code in a unit-test in this manner; allowing you to "bolt on" (and reuse) assertion sequences anywhere, with no change to your test methods.
* When an object changes state (its properties and behavior), you can assert that the change is deterministic and well-behaved.
* JO profiles let you assert design patterns and anti-patterns to keep your objects consistent and well-behaved.
* Also use JO profiling to root out design entropy (let JO suggest where objects may benefit from using a particular design pattern).
link

You want to write tests, but hesitate because it will all be a bunch of hardly interpretable logprints in the end anyway? The Test Harness is developed to make it easier for us who like full control over testing, but want to be able to give the test environment to someone else to run from time to time. This is achieved by providing a very simple Java-based framework for writing the tests, while still providing a intuitive GUI to present results and manage what tests to run.

The test-cases are bundled in test-case folders and loaded into the GUI point-n-click style. And even though the test-cases are written in Java, the multitude of libraries available for that language makes it very easy to write tests to test anything from actual Java-code to SQL-databases or embedded systems. Pretty much every system than can communicate via a Java-compatible interface e.g. sockets, serial etc. can be tested with this harness.
link

DDSteps is a JUnit extension for building data driven test cases. In a nutshell, DDSteps lets you parameterize your test cases, and run them more than once using different data.

Since DDSteps is 100% JUnit compatible, you can run your new data driven test cases just like any old JUnit test case. No IDE plugins or new Ant tasks are required – just add the DDSteps jars to your classpath and you are ready to go!

DDSteps uses external test data (in Excel) which is injected into your test case using standard JavaBeans properties. Your test case is run once for each row of data, so adding new tests is just a matter of adding a row of data in Excel.

DDSteps integrates best-of-breed toolkits for web and database testing, such as JWebUnit, DbUnit and Spring Framework. By making these toolkits data driven, you can do powerful function testing. Automated end-to-end testing of your website is not only possible – it is easy.
link

Testar is a tool designed to reduce the time spent running Java unit tests. It runs on top of JUnit and automatically selects individual tests to run based on what tests previously succeeded and what changes you have made to your code since then.

Additionally, Testar allows you to find out which methods a given test covers, and vice versa.
link

GTT is a visual tool for developing and executing test scripts for Java swing-based applications. It applies Jemmy events as its event model, and performs an abstraction of events during capturing. GTT offers both view-assertion and model-assertion mechanisms to automatically verify the correctness of the application under test.

GTT can be applied in a test-first programming style, which is not possible for other CR-based tools.
link

Contracts for Java (C4J) is a Design By Contract framework for Java 1.5 and later.

Adding class invariants, pre conditions, and post conditions to your regular Java objects is easy with C4J. Contracts for a class (the target) are implemented in a separate class (the contract). The contract is linked to the target at compile time using an annotation, and the actual contract verification code is tied to the target using instrumentation during class loading at run time.
link

JUnit PDF Report generates a PDF report from JUnit test results. It uses Apache Ant to execute the generation, and Apache FOP to render the PDF document.
link

The Testing Tools Project is a project in the Eclipse TPTP Top-Level Project, it addresses the testing phase of the application lifecycle. The Testing Tools Project provides frameworks for building testing tools by extending the TPTP Platform. The framework contains testing editors, deployment and execution of tests, execution environments and associated execution history analysis and reporting. The project also includes exemplary tools for JUnit based component testing tool, Web application performance testing tool, and a manual testing tool.

See also: [url=http://www-128.ibm.com/developerworks/views/opensource/libraryview.jsp?search_by=eclipse+test+performance+tools+platform]Ongoing series of articles on TPTP[/url]
link