|
|
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 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
| Test data generator for SQL databases. |
Go To dbMonster
| 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
| 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
| 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
| 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
| Lightweight framework allowing to run EJBs without the application server support for testing purposes. |
Go To MockEJB
| Given the interface or class, it generates source of Mock object for it. |
Go To MockCreator
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| Basher is a lightweight profiling & performance testing framework which hopes to help developers to do early & continuous profiling & performance testing by integrating into normal, Maven build cycle. |
Go To Basher
| JDBHammer is a small database stress tool. It emulates a given number of concurrent users querying the engine and reports timing information for each test.
|
Go To JDBHammer
| 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
| CallbackParams is a JUnit-extension for writing parameterized tests with new innovative patterns that offer elegant solutions to many drawbacks that are traditionally associated with parameterized testing.
CallbackParams separates itself from other parameterization solutions by three characterized features:
- Automated Combining of Parameter-Values
- Parameterized Data Is Accessed through Composite Callbacks
- Seamless Integration with JUnit Add-Ons from 3rd Party (!)
|
Go To CallbackParams
| ContiPerf is a lightweight testing utility that enables the user to easily leverage JUnit 4 test cases as performance tests e.g. for continuous performance testing. It is inspired by JUnit 4's easy test configuration with annotations and by JUnitPerf's idea of wrapping unit tests for performance testing, but more powerful and easier to use. |
Go To ContiPerf
| 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
| Fressia Project is an effort to develop an Open Source framework for Testing Automation. It's intended for users (testers) that want a simple tool which can be used just out of the box. It's does not requires any complicated configuration stuff. |
Go To Fressia
| Persistence testing tool. Easy setup for service/dao. Fancy way to test Criteria and HQL. Full fill the objects tree with dummy values. Generate values according with jsr303/hibernate-validator annotations. Doesn't matter if a previous database row exists (or not). Reduces the necessity of cleaning database (the trash shouldn't scare you). Don't care about auto-increment strategy. Easier than traditional xml database fixtures. |
Go To HibernateMock
| j-Hawk is a Java based open source framework which can be incorporated in any java application for performance testing. The idea is the developer has to define module and its tasks (essentially a java method) inside the application and register the same with j-Hawk. j-Hawk executes the modules and generates a graphical performance report which can be analyzed to find performance bottleneck of your application.
j-Hawk provides it's own scripting language called \"hawk\" whose syntax is similar to C,C++ and UNIX Shell scripting.
Hence the user can implement the performance test case easily with hawk scripting. |
Go To j-hawk
| JUCA stands for \"JUnit Coverage Analyzer\". It is a tool which performs a static analysis of your java class files and determines which methods of your classes are (potentially) called from JUnit testcases. The results are summarized in a HTML report. |
Go To JUCA
| Maveryx is a FREE and OPEN SOURCE Test Automation Framework for functional and regression testing of Java applications.
Maveryx eliminates the GUI Map dependency. Testers don't have to capture (often recapture) and maintain any GUI Map. GUI objects described in the scripts are identified and located directly at runtime during the test scripts execution. Avoiding GUI Maps testers have the possibility of starting automation early in the software lifecycle, long before the application is released for testing.
GUI objects identification is performed by an intelligent Finder powered by a highly configurable set of searching algorithms. Maveryx supports also approximate matching to identify the GUI objects even in case of few or partial information given in the test scripts (this is typical when deriving test scripts from lacking or partial applications specifications or in testing non-mature/early software).
Maveryx is OS independent and works with the most used free and commercial IDE such as Eclipse, NetBeans, JUnit, IBM Rational Functional Tester, etc. |
Go To Maveryx
| SelAid makes it easier to test web applications using Selenium 2.0 WebDriver. Its helper classes provide a richer abstraction layer on top of WebDriver's WebElement class. The SelAid classes represent and operate on groups of inter-related HTML tags, like tables, list boxes, radio buttons and option groups. Typical web testing would make use of both SelAid and WebDriver APIs to keep tests simple, readable and maintainable. |
Go To SelAid
| SWTBot is an open-source Java based functional testing tool for testing SWT and Eclipse based applications.
SWTBot provides APIs that are simple to read and write. The APIs also hide the complexities involved with SWT and Eclipse. This makes it suitable for functional testing by everyone. SWTBot also provides its own set of assertions that are useful for SWT. You can also use your own assertion framework with SWTBot.
SWTBot has a driver and recorder to playback and record tests and integrates with Eclipse, and also provides for ant tasks so that you can run your builds from within CruiseControl or any other CI tool that you use.
SWTBot can run on all platforms that SWT runs on. Very few other testing tools provide such a wide variety of platforms. |
Go To SWTBot
|
|
