Download

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:

Using Java annotations for defining test execution characterisitics and performance requirements
You can mark a test to run a certain number of times or to be repeatedly executed for a certain amount of time
Performance requirements can be maximum, average, medium or any percentile exectution time
Perfect control and readability of performance requirements
You can run tests in two different modes, using them as simple unit tests or performance tests
Easy integration with Eclipse and Maven
Export of execution summary to a CSV file
Small library without external dependencies (only JUnit)
Easy extension with custom statistics evaluation and tracking mechanisms

Defining an attribute of type ContiPerfRule with the annotation @Rule activates ContiPerf. You can then choose from a different settings for specifying test execution (@PerfTest) and performance requirements (@Required). In the example the test is configured to be executed 1000 times with 20 concurrent threads, so each thread does 50 invocations. A maximum execution time of 1.2 seconds and and an average below or equals 250 milliseconds are tolerated.

As small but important detail is, that ContiPerf makes a difference to the behavior, you might expect from JUnit: ContiPerf creates a new test class instance and setup for each test method, but not for each test invocation! ContiPerf's purpose ist to do performance testing of your code, not of JUnit and the garbage collector! So, the behavior is as follows:

For each test method, a new instance of the test class is created and all further invocations of this method will happen on one and the same Java object!

First the @Before method is called. Then the test method is invoked 1,000 times subsequently and finally the @After method(s). ContiPerf 2 supports this behaviour for all JUnit 4 versions since version 4.7.

An example: Assuming you have a test class with two test methods, test1() and test2() which are executed two times each, a @Before method called before() and an @After method called after(), the invocation sequence is

constructor()
before()
test1()
test1()
after()

constructor()
before()
test2()
test2()
after()