ConcurrentUnit alternatives and similar libraries
Based on the "Testing" category.
Alternatively, view ConcurrentUnit alternatives based on common mentions on social networks and blogs.
-
Apache JMeter
Apache JMeter open-source load testing tool for analyzing and measuring the performance of a variety of services -
TestContainers
Testcontainers is a Java library that supports JUnit tests, providing lightweight, throwaway instances of common databases, Selenium web browsers, or anything else that can run in a Docker container. -
MockServer
MockServer enables easy mocking of any system you integrate with via HTTP or HTTPS with clients written in Java, JavaScript and Ruby. MockServer also includes a proxy that introspects all proxied traffic including encrypted SSL traffic and supports Port Forwarding, Web Proxying (i.e. HTTP proxy), HTTPS Tunneling Proxying (using HTTP CONNECT) and SOCKS Proxying (i.e. dynamic port forwarding). -
PowerMock
PowerMock is a Java framework that allows you to unit test code normally regarded as untestable. -
Pact JVM
JVM version of Pact. Enables consumer driven contract testing, providing a mock service and DSL for the consumer project, and interaction playback and verification for the service provider project. -
Scott Test Reporter
Never debug a test again: Detailed failure reports and hassle free assertions for Java tests - Power Asserts for Java -
pojo-tester
Java testing framework for testing pojo methods. It tests equals, hashCode, toString, getters, setters, constructors and whatever you report in issues ;)
CodeRabbit: AI Code Reviews for Developers

* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of ConcurrentUnit or a related project?
README
ConcurrentUnit
A simple, zero-dependency toolkit for testing multi-threaded code. Supports Java 1.6+.
Introduction
ConcurrentUnit was created to help developers test multi-threaded or asynchronous code. It allows you to perform assertions and wait for operations in any thread, with failures being properly reported back to the main test thread. If an assertion fails, your test fails, regardless of which thread the assertion came from.
Usage
- Create a
Waiter
- Use
Waiter.await
to block the main test thread. - Use the
Waiter.assert
calls from any thread to perform assertions. - Once expected assertions are completed, use
Waiter.resume
call to unblock theawait
ing thread.
When your test runs, assertion failures will result in the main thread being interrupted and the failure thrown. If an await
call times out before all expected resume
calls occur, the test will fail with a TimeoutException
.
Examples
Consider a test for a message bus that delivers messages asynchronously:
@Test
public void shouldDeliverMessage() throws Throwable {
final Waiter waiter = new Waiter();
messageBus.registerHandler(message -> {
// Called on separate thread
waiter.assertEquals(message, "foo");
waiter.resume();
};
messageBus.send("foo");
// Wait for resume() to be called
waiter.await(1000);
}
We can also handle wait for multiple resume
calls:
@Test
public void shouldDeliverMessages() throws Throwable {
final Waiter waiter = new Waiter();
messageBus.registerHandler(message -> {
waiter.assertEquals(message, "foo");
waiter.resume();
};
messageBus.send("foo");
messageBus.send("foo");
messageBus.send("foo");
// Wait for resume() to be called 3 times
waiter.await(1000, 3);
}
If an assertion fails in any thread, the test will fail as expected:
@Test(expected = AssertionError.class)
public void shouldFail() throws Throwable {
final Waiter waiter = new Waiter();
new Thread(() -> {
waiter.assertTrue(false);
}).start();
waiter.await();
}
TimeoutException is thrown if resume
is not called before the await
time is exceeded:
@Test(expected = TimeoutException.class)
public void shouldTimeout() throws Throwable {
new Waiter().await(1);
}
Alternatively
As a more concise alternative to using the Waiter
class, you can extend the ConcurrentTestCase
:
class SomeTest extends ConcurrentTestCase {
@Test
public void shouldSucceed() throws Throwable {
new Thread(() -> {
doSomeWork();
threadAssertTrue(true);
resume();
}).start();
await(1000);
}
}
Assertions
ConcurrentUnit's Waiter
supports the standard assertions along with Hamcrest Matcher assertions:
waiter.assertEquals(expected, result);
waiter.assertThat(result, is(equalTo(expected)));
Since Hamcrest is an optional dependency, users need to explicitly add it to their classpath (via Maven/Gradle/etc).
Other Examples
More example usages can be found in the WaiterTest or in the following projects:
Additional Notes
On await
/ resume
Timing
Since it is not always possible to ensure that resume
is called after await
in multi-threaded tests, ConcurrentUnit allows them to be called in either order. If resume
is called before await
, the resume calls are recorded and await
will return immediately if the expected number of resumes have already occurred. This ability comes with a caveat though: it is not possible to detect when additional unexpected resume
calls are made since ConcurrentUnit allows an await
call to follow.
Additional Resources
- Javadocs
- An article describing the motivation for ConcurrentUnit
License
Copyright 2011-2021 Jonathan Halterman - Released under the Apache 2.0 license.
*Note that all licence references and agreements mentioned in the ConcurrentUnit README section above
are relevant to that project's source code only.