|
|
Open Source Testing Tools in Java
|
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. |
Go To JUnit
|
Cactus is a simple test framework for unit testing server-side java code (Servlets, EJBs, Tag Libs, Filters, ...).
The intent of Cactus is to lower the cost of writing tests for server-side code. It uses JUnit and extends it. |
Go To Cactus
|
The Grinder is load-testing framework.
The Grinder makes it easy to orchestrate the activities of a test script in many processes across many machines, using a graphical console application. Test scripts make use of client code embodied in Java plug-ins. Most users of The Grinder do not write plug-ins themselves, instead they use one of the supplied plug-ins. The Grinder comes with a mature plug-in for testing HTTP services, as well as a tool which allows HTTP scripts to be automatically recorded. |
Go To The Grinder
XMLUnit for Java provides two JUnit extension classes, XMLAssert and XMLTestCase, and a set of supporting classes (e.g. Diff, DetailedDiff, Transform, SimpleXpathEngine, Validator, NodeTest) that allow assertions to be made about:
* The differences between two pieces of XML
* The outcome of transforming a piece of XML using XSLT
* The evaluation of an XPath expression on a piece of XML
* The validity of a piece of XML
* Individual nodes in a piece of XML that are exposed by DOM Traversal
XMLUnit for Java can also treat HTML content (even badly-formed HTML) as valid XML to allow these assertions to be made about the content of web pages too. |
Go To XMLUnit
|
StrutsTestCase is an extension of the JUnit TestCase class that allows testing of individual Action objects with or without a running servlet engine. This framework provides both mock servlet objects as well as Cactus support to simulate the environment. |
Go To StrutsTestCase
jMock is a library for testing Java code using mock objects.
The jMock package:
* makes it quick and easy to define mock objects, so you don't break the rhythm of programming.
* lets you define flexible constraints over object interactions, reducing the brittleness of your tests.
* is easy to extend. |
Go To jMock
|
EasyMock provides Mock Objects for interfaces in JUnit tests by generating them on the fly using Java's proxy mechanism. Due to EasyMock's unique style of recording expectations, most refactorings will not affect the Mock Objects. So EasyMock is a perfect fit for Test-Driven Development. |
Go To EasyMock
|
SQLUnit is a regression and unit testing harness for testing database stored procedures. An SQLUnit test suite would be written as an XML file. The SQLUnit harness, which is written in Java, uses the JUnit unit testing framework to convert the XML test specifications to JDBC calls and compare the results generated from the calls with the specified results. |
Go To SQLUnit
|
UISpec4J is an Open Source functional and/or unit testing framework for Swing-based Java applications, built on top of the JUnit test harness. What makes it special is that its APIs are designed to ease the testing process by making the test scripts as close possible to human-readable text. |
Go To UISpec4J
|
soapUI is a desktop application for inspecting, invoking and testing (functional and load) of web services over HTTP. It is mainly aimed at developers/testers providing and/or consuming web services (java, .net, etc). Functional and Load-Testing can be done both interactively in soapUI or within a automated build/integration process using the soapUI command-line tools. |
Go To soapUI
|
The KeY-System is mainly a verification and testing tool for Java with JML/OCL contracts. The tool is being developed since November 1998 by the University of Karlsruhe, Chalmers University of Technology, Gothenburg, and the University of Koblenz. |
Go To KeY
|
Unicorn provides Swing components for interactively invoking methods on JMX MBeans, JavaBeans, and Web Services. It is intended to allow developers to implement simple testing and debugging tools quckly. Unicorn also can be extended to handle other types of objects. All you have to do is implement an ObjectPanelModel. |
Go To Unicorn
|
T2 is a random testing tool. As one, it is fully automatic, but one must keep in mind that the code coverage of random testing is in general very limited. It should be used as a complement to other testing methods.
T2 checks for internal errors, run time exceptions, method specifications, and class invariant. T2 does not check individual methods in isolation; instead T2 generates random executions where methods may interfere with each other, and thus it may discover more subtle errors. Violating executions can be saved for re-test (regression). No special specification language is needed. Specifications are written in plain Java.
The current state is prototype. |
Go To T2
|
Fit is Framework for Integrated Testing.
It is a tool for enhancing communication and collaboration. Fit creates a feedback loop between customers and programmers. Fit allows customers and testers to use tools like Microsoft Office or HTML to specify test cases on a user level -- without the need of being programmers.
Fit automatically checks those examples against the actual program, thus building a simple and powerful bridge between the business and software engineering worlds. |
Go To Fit
|
The Abbot framework is a Java library for GUI unit testing and functional testing. It provides methods to reproduce user actions and examine the state of GUI components. The framework may be invoked directly from Java code or accessed without programming through the use of scripts. |
Go To Abbot
|
JUnitPerf is a collection of JUnit test decorators used to measure the performance and scalability of functionality contained within existing JUnit tests. |
Go To JUnitPerf
|
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. |
Go To Jamelon
|
DbUnit is a JUnit extension (also usable with Ant) targeted for database-driven projects that, among other things, puts your database into a known state between test runs. This is an excellent way to avoid the myriad of problems that can occur when one test case corrupts the database and causes subsequent tests to fail or exacerbate the damage. |
Go To DbUnit
|
Mockrunner is a lightweight framework for unit testing applications in the J2EE environment. It supports Struts actions and forms, servlets, filters and tag classes. Furthermore it includes a JDBC and a JMS test framework. The JDBC test framework can be used standalone or in conjunction with MockEJB to test EJB based applications. |
Go To Mockrunner
|
jfcUnit enables developers to write test cases for Java Swing based applications. It provides support for:
1. Obtaining handles on Windows/Dialogs opened by the Java code.
2. Locating components within a component hierarchy that occur within the containers found above.
3. Raising events on the found components, e.g. clicking a button, typing text in a TextComponent.
4. Handling testing of components in a thread safe manner.
Since version 2.0, jfcUnit provides XML Recording and playback. This allows users to quickly and automatically generate/edit scripts to drive the testing. |
Go To jfcUnit
|
Lightweight framework allowing to run EJBs without the application server support for testing purposes. |
Go To MockEJB
|
Marathon is a testing framework for GUI applications developed using Java/Swing. Marathon composes of recorder, runner and editor. The testscripts are composed of python code.
Marathon focuses on end-user testing. One need not know Java or Swing to record test scripts using Marathon. Marthon is kept intentionally simple. The aim to produce test scripts that are readable by everyone on the project. This includes the developers, testers and the customers. Marathon is flexible and provides facilities to extend the functionality available through python scripts or through writing ones own component resolvers.
Marathon captures the semantic actions on components instead of the mouse & keyboard events. This results in scripts that are simple and at a higher granular level. Marathon suites well for applications that mostly depend on forms-paradigm. |
Go To Marathon
|
TestNG is a testing framework inspired from JUnit and NUnit but introducing some new functionalities that make it more powerful and easier to use, such as:
- JSR 175 Annotations (JDK 1.4 is also supported with JavaDoc annotations).
- Flexible test configuration.
- Default JDK functions for runtime and logging (no dependencies).
- Powerful execution model (no more TestSuite).
- Supports dependent methods. |
Go To TestNG
The Dumbster is a very simple fake SMTP server designed for unit and system testing applications that send email messages. It responds to all standard SMTP commands but does not deliver messages to the user. The messages are stored within the Dumbster for later extraction and verification.
The Dumbster slots itself very easily into your testing strategy. As long as your application talks to an email server using SMTP then the Dumbster can be used to test the application with no code changes.
The Dumbster is useful in the following scenarios:
* System testing an application. It is important at this stage of the development process that all functionality is active and not stubbed out. The Dumbster is able to respond just like a regular SMTP server but delivers no email messages to end users. This is important if you are testing with real world data. In addition it is possible to verify that the correct email messages would have been delivered to the end users by querying the Dumbster.
* Unit testing code that needs to send email. Again the Dumbster can be used as a dumpster to collect all email and ensure nothing is delivered to real users. In addition if the code being tested needs to deliver a specific set of email messages, with specific content then the Dumbster can be queried from within the unit test to verify correct delivery and content.
The Dumbster is written in Java and is open source. It is distributed under the Apache License 2.0. |
Go To Dumbster
Jacareto is a capture & replay tool for programs written in Java. You can capture actions on applications and replay them later on (like macros). Jacareto can be used for many purposes:
* GUI tests
* Creation of animated demonstrations
* Creation of macros
* Qualitative and quantitative analyses of user behavior
There are two front ends included in Jacareto:
* CleverPHL is a GUI front end for Jacareto
* Picorder is a command line front end for Jacareto
Jacareto is subject to the GNU General Public License (GPL). |
Go To Jacareto
|
Jemmy is a JavaTM library that is used to create automated tests for Java GUI applications. It contains methods to reproduce all user actions which can be performed on Swing/AWT components (i.e. button pushing, text typing, tree node expanding, ...). JemmyTest is a program written in Java which uses the Jemmy API to test applications. |
Go To Jemmy
|
DDTUnit is a testing framework based on JUnit that focus on a datadriven approach to testing. It separates testcode from testdata by suppliing an easy to learn xml based data description schema. DDTUnit supports complex object description like collections, maps and value objects out of the box. |
Go To DDTUnit
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.
Features:
* Run a JUnit TestCase method many times, each time with different test data.
* Write tests in Java/JUnit and write data in Excel, using the best tool for each task.
* Handles massive amounts of test data by keeping data separate from code, thus enabling both to be as compact as possible.
* Use standard JavaBean getters/setters to fill your testcase with data. You don't have to write any code to pull in data, all that is handled by the DDSteps framework.
* Tap into the power of property injection which is a complement to dependency injection
found in frameworks like Spring. Property injection does not deal with dependencies, it handles simple data, but lots and lots of it. |
Go To DDSteps
|
JTestCase uses XML file to organize multi-testcase data and asserting conditions (action and expected result), and provides a set of easy-to-use methods to retrieve test cases out from XML, and asserts results against those expected ones in data file. |
Go To JTestCase
|
JTR (Java Test Runner) is a framework meant for fastening the building of both complex and simple test enviroments. It is based on concepts such as Inversion of Control, and is ready for EJB and JMS testing.
The JTR 2.0 framework will give you the chance to code only the testing logic. All the boring middleware-related tasks (connecting to ConnectionFactories, opening connections, sharing connections, opening sessions, handleing exceptions, retrieving administered objects) are carried out by the JTR 2.0 runtime on your behalf according to what you have stated in the jtr.xml configuration file.
Thanks to IoC (Inversion Of Control), the JTR 2.0 runtime is able to inject all these resources into your IRunner concrete implementations. This entails that you are not required to actively retrieve the resources you need: you declaratively tell the JTR 2.0 framework you are going to need them at runtime, and Inversion Of Control will do the work.
The thing same happens with EJBs: all the low-level details are always handled by the JTR framework to let you work only on the pure logic of your tests. |
Go To JTR Java Test Runner
TESTARE is a testing framework that aims to simplify the test development process for distributed enterprise JAVA applications. It tries to achieve this goal by focusing on two main directions:
* provide straightforward and easy to use "in container" testing capabilities
* provide native support for test environment management and introspection techniques such as fixtures, global fixtures, probes and guards
Its initial focus is on "in ejb container" testing but its extensible architecture makes it very easy to develop support for other execution environments such as SERVLETS, JMS listeners, CORBA ORBs or RMI. |
Go To TESTARE
|
A very small library and therefore easy to use to dynamically create a mock object. You can throw exceptions from fake systems that are returned from this library to ensure your system handles faults correctly. It is also a threadsafe mocklibrary unlike most other similar mock object libraries out there. |
Go To MockLib
|
In the same way that JUnit allows us to write unit tests for Java classes, TagUnit allows us to unit test JSP custom tags, inside the container. In essence, TagUnit is a tag library for testing custom tags within JSP pages. |
Go To TagUnit
|
TestGen is a collection of open-source tools that automatically generates unit test cases. The first released component of TestGen is TestGen4J. TestGen4J automatically generates test cases from your own Java class files, or source files. Its primary focus is to exercise boundary value testing of the arguments passed to the method. It uses a rules engine, with a user-configurable XML file, that defines boundary conditions for the data types. The test code is separated from test data with the help of JTestCase.
The test code is generated in a hierarchical manner. A main test suite is generated which invokes test suites of individual classes. The individual class test suite is formed by collection of test methods of that class.
The test data is also organized hierarchically, corresponding to the structure of the test code, in XML format. This XML file actually has data for all unit test cases for each method. JTestCase helps to loop through all the test cases of each method and executing one by one against JUnit. |
Go To TestGen4J
|
Mock is a widely used technology in unit test domain. It shields exteral and unnecessary factors and helps developers focus on the specific function to be tested.
EasyMock is a well known mock tool which can create mock object for given interface at runtime. The mock object's behavior can be fine defined prior the test code in the test case. EasyMock is based on java.lang.reflect.Proxy, which can create dynamic proxy class/object according to the given interfaces. It has the inherent limitation from the Proxy. It can create mock object for given interface only.
Mocquer is a similar mock tool as EasyMock. With the help of Dunamis Project, it extends the function of EasyMock to support mock object creation for both class and interface. |
Go To Mocquer
|
STclass is a unit testing framework comparable to JUnit and its clones, but based on runtime evaluable contracts as defined by B. Meyer in the "Design by Contract"(tm) approach. It implements runtime evaluable contracts and contract based class level unit testing; inheritance of contracts and tests is handled. The framework generates reports in XML, and postprocessing tools produce nice HTML reports; using the JIP profiler, a statisitic and profiling analysis can be made during the test, and its resuts are added to the HTML report. |
Go To STclass
|
p-unit is a framework for performance benchmark and unit test. It records memory consumption and execution time, and generates result in the form of plain text, image and pdf file. p-unit allows users to plugin their own result report. As a tool for unit-test, p-unit supports to run the same tests with a single thread or multi-threads. |
Go To p-unit
|
DepUnit is a data and dependency driven unit test system for Java. DepUnit is ideal for sets of tests that depend on data from previous tests. DepUnit makes it easy to run the same tests over multiple data sets. |
Go To DepUnit
|
Jumble is a Java mutation testing tool that works in conjunction with JUnit. The purpose of mutation testing is to provide a measure of the effectiveness of test cases. A single mutation is performed on the code to be tested, the corresponding test cases are then executed. If the modified code fails the tests, then this increases confidence in the tests. Conversely, if the modified code passes the tests this indicates a testing deficiency.
|
Go To Jumble
|
Test data generator for SQL databases. |
Go To dbMonster
|
Given the interface or class, it generates source of Mock object for it. |
Go To MockCreator
|
Salome-TMF is a test management framework. Salome-TMF offers features for creating and executing tests. Salome-TMF uses the concept of tests defined in the norm ISO9646. Tests can be manual or automatic, tests are organized in campaigns and are executed with different datasets in different environments. For making test execution fully automatic, Salome-TMF has integrated a script language based on Java, as one of several plugins which extend Salome-TMF functionalities.
|
Go To Salome-TMF
|
Surrogate is a complimentary unit testing framework, especially suitable for unit testing of large, complex Java systems.The framework integrates seamlessly with JUnit,MockEJB and various mock object implementations and is based on the AspectJ technology. |
Go To Surrogate Test framework
|
GrandTestAuto is a tool for unit testing applications written in Java.
GrandTestAuto automatically runs all unit tests for an application and at the same time checks that the unit tests provide sufficient coverage. |
Go To GrandTestAuto
|
Ejb3Unit - out of container EJB 3.0 testing. Ejb3Unit is a JUnit extention and can execute automated standalone junit tests for all JEE or Ejb3 projects. The out of container approach leads to short build-test-cycles, no container deployment is needed. |
Go To Ejb3Unit
|
MActor is an extensible tool for system integration testing. It can facilitate tests of any XML-based integration regardless of the type of message transfer protocol used (HTTP, SOAP, file-system and IBM MQ series are currently supplied with the tool) |
Go To MActor
|
SpringUnit is a framework that enables Java developers to create unit tests where test data is separate from tests algorithms. Writing tests this way:
- enables easy addition of test cases that differ only in their inputs and expected outputs
- facilitates reuse of data values across test cases
- reduces Java source code devoted to the creation and retrieval of data values
- promotes and supports a style that removes redundant test algorithmic code |
Go To SpringUnit
|
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. |
Go To Unitils
|
benerator is a framework for creating realistic and valid high-volume test data, used for testing (unit/integration/load) and showcase setup.
Metadata constraints are imported from systems and/or configuration files. Data can imported from and exported to files and systems, anonymized or generated from scratch.
Domain packages provide reusable generators for creating domain-specific data as names and addresses internationalizable in language and region.
benerator is strongly customizable with plugins and configuration options. |
Go To benerator
|
QC4J is an automated, specification-based testing framework, based on QuickCheck for Haskell. It makes it easy to test referentially transparent code, by creating test data automatically through user-defined generators. |
Go To QC4J
|
|
