Open Source Testing Tools in Java

Lightweight framework for unit testing J2EE applications: Struts actions/forms, servlets, filters, tags, plus JDBC, JMS, and JCA test frameworks; no application server required. Maintained on GitHub with Maven modules.

Fake SMTP server for unit and system testing of email-sending applications. Responds to standard SMTP commands; stores messages for later extraction and verification. No code changes required when the app uses SMTP.

Dynamic mock-object generator for JUnit: creates mocks for interfaces on the fly via Java proxies. Record-and-replay style keeps mocks stable across refactorings; well-suited to test-driven development.

Test runner framework for Java. Runs all unit tests for an application and checks that tests provide sufficient coverage. Built with Apache Ant.

Swing/AWT UI test automation library. Operator-based API to simulate user actions (clicks, typing, menu navigation). Used for automated GUI testing; originated in NetBeans, now maintained in OpenJDK.

Library for test-driven development with mock objects. Defines mocks quickly, specifies object interactions precisely to reduce brittle tests, and plugs into common test frameworks and IDEs.

Testing framework for Java and the JVM. Provides JUnit Platform, Jupiter (JUnit 5), and Vintage (JUnit 4). De facto standard for unit and developer-side testing.

PIT is a state of the art mutation testing system, providing gold standard test coverage for Java and the jvm. It's fast, scalable and integrates with modern test and build tooling.

Open-source Java UI testing tool for SWT and Eclipse applications; simple APIs, recorder, Ant/Maven support, and cross-platform coverage.

Testing framework inspired by JUnit and NUnit; annotations, flexible configuration, data-driven tests (@DataProvider), parallel execution, dependent methods, and IDE/Maven integration.

Open-source functional and unit testing framework for Swing-based Java applications on top of JUnit; APIs designed for readable test scripts.

Library for testing XML: diff engine, schema validation, XPath assertions, XSLT outcome checks; supports HTML as XML; Java and . NET.

JUnit extension (and Ant support) for database-driven projects. Puts the database into a known state between test runs; prepares, verifies, and restores tables to avoid test pollution and cascading failures.

Integrated environment for GUI test script creation and execution. Supports Java Swing, JavaFX, and Web; JRuby script model, recording and playback, Allure reports, modules, breakpoints, and Selenium commands.

Java load-testing framework; distributed tests via a graphical console; scripts in Jython or Clojure; mature HTTP support with record/replay, SSL, and connection throttling.

Deductive verification and symbolic debugging for Java. Specify behavior in JML; KeY proves correctness or finds bugs. Symbolic Execution Debugger integrates with Eclipse.

Desktop and CLI tool for inspecting, invoking, and testing REST, SOAP, and GraphQL APIs; supports functional and load testing and integration in automated builds.

Open-source test automation framework for out-of-the-box use. Built on TestNG, HttpUnit, and Selenium; includes a DSL, script interpreter, and report generator for functional, integration, and acceptance testing.

Framework for Integrated Testing: customers and testers specify test cases in Office or HTML without programming. Fit runs those examples against the application and reports results, bridging business and development.

Lightweight JUnit 4 add-on for performance and continuous performance testing. Annotations define execution settings and requirements; generates HTML reports with latency distribution. Ramp-up, warm-up, and concurrent execution supported.

Collection of JUnit test decorators for performance and scalability testing. Wraps existing JUnit tests to measure timing and load without changing test logic.

Framework for unit and functional testing of Java GUIs (AWT, Swing, SWT). Reproduces user actions and inspects component state; usable from Java code or via scripts with recording and playback.

Lightweight profiling and performance-testing framework for Java POJOs. Integrates into the Maven build cycle for thread testing, profiling, and reproducible performance scenarios.

JUnit extension for parameterized tests with composite callbacks, automated combination of parameter values, and seamless integration with third-party JUnit runners.

Test data generator for SQL databases.

JUnit extension for data-driven tests: external data (Excel, XML) injected via JavaBeans properties; one run per row. Integrates with JWebUnit, DbUnit, and Spring for function and end-to-end testing.

JUnit-based data-driven testing: XML schema describes test data; program flow stays in Java. Supports collections, maps, and value objects; combines multiple test cases with coded test methods.

JUnit extension for out-of-container EJB 3. 0 testing. Runs automated standalone tests for JEE/EJB3 projects without container deployment; supports entity and session beans, in-memory or custom database.

Java framework for in-application performance testing. Register modules and tasks (methods); j-Hawk runs them and produces graphical performance reports. Includes Hawk scripting language (C/shell-like syntax) for flexible test scenarios.

Capture and replay tool for Java applications: record actions and replay as macros. Used for GUI testing, demos, and user-behavior analysis. Includes CleverPHL (GUI) and Picorder (CLI) front ends.

Acceptance-level automated testing (Jameleon): applications split into features scripted in Java and composed in XML. Data-driven test cases run against multiple environments; plugins for jWebUnit, HttpUnit, Selenium, HtmlUnit, and others.

Small Java database stress tool. Emulates concurrent users querying the engine and reports per-test timing. Currently supports MySQL.

Framework for testing Java Swing applications: obtain handles on windows/dialogs, locate components in the hierarchy, raise events (clicks, typing), and run tests in a thread-safe way. XML recording and playback since 2. 0.

Pure Java microframework to separate test data from test code. XML format defines test cases; API retrieves data and asserts against expected results. Integrates with Jice for dependency injection.

Framework for building test environments using Inversion of Control. Supports JSE, EJB, JMS, and WS testing; jtr. xml config drives middleware setup so tests focus on logic.

Class-level mutation testing for Java with JUnit. Mutates bytecode (via BCEL), runs tests per mutation; score indicates test effectiveness. Eclipse plugin and CLI available.

Extensible tool for functional integration testing of XML-based systems. Supports JMS, HTTP, SOAP, TIBCO Rv, IBM MQ, file-shares; test spec language, CLI and GUI runner, tabular test data.

Code generator that produces mock object source from a given interface or class for unit testing.

Lightweight framework for running EJBs without an application server; implements javax. ejb APIs with dynamic proxies and supports unit testing outside the container.

Small library to dynamically create mock objects; supports throwing exceptions from fakes and is thread-safe.

Framework for performance benchmark and unit test; records memory and execution time, outputs plain text, image, or PDF; supports single- and multi-threaded runs and pluggable reporters.

Framework for unit tests with test data separated from test logic; promotes reuse of data, fewer boilerplate values, and less redundant test code.

Regression and unit testing harness for database stored procedures; test suites are XML; Java harness uses JUnit to run JDBC calls and compare results.

JUnit extension for testing Struts actions with or without a servlet engine; provides mock servlet objects and Cactus in-container support.

Unit testing framework for large Java systems; integrates with JUnit, MockEJB, and mocks; based on AspectJ, supports mocking without refactoring production code.

Tag library for unit testing JSP custom tags inside the container; analogous to JUnit for Java classes.

Automatic JUnit test generator from Java class or source files; focuses on boundary-value testing via a rules engine and XML config; test data separated with JTestCase.

Library to simplify unit and integration testing; reflection assertions, DBUnit-style database testing, mocking, and integration with JUnit, TestNG, Spring, and Hibernate.

Test framework for in-container unit testing of server-side Java code (Servlets, EJBs, tag libs, filters). Extends JUnit; runs tests inside the container.

Data- and dependency-driven unit test system for Java. Suited for test sets where later tests depend on data from earlier ones; supports running the same tests over multiple data sets.

Persistence testing tool for Hibernate: easy setup for service/DAO layers, test Criteria and HQL, fill object trees with dummy data. Generates values from JSR-303 and Hibernate Validator annotations; reduces need for DB cleanup and fixtures.

JUnit Coverage Analyzer: static analysis of Java class files to determine which methods are (potentially) called from JUnit tests. Results summarized in an HTML report.

Automated, specification-based testing framework ported from QuickCheck (Haskell); generates test data via user-defined generators for referentially transparent code.

Open test management framework for automatic test execution, document production, and defects/requirements management; supports manual and automatic tests, campaigns, and Java-based script plugins (ISO9646-style).

Unit testing framework based on Design by Contract (Meyer): runtime contracts, class-level tests, contract inheritance; XML reports and JIP profiling.

Automatic random testing tool for Java; checks internal errors, exceptions, specifications, and invariants; specifications in plain Java; prototype stage.

Swing components for interactively invoking methods on JMX MBeans, JavaBeans, and Web Services; for building testing and debugging tools; extensible via ObjectPanelModel.

Mock tool similar to EasyMock that extends it via Dunamis to create mock objects for both classes and interfaces (not only interfaces as with Proxy-based EasyMock).