All Classes and Interfaces

Class
Description
An abstract IEvent.
 
A dummy interface to indicate listener types for ANT.
An event dispatched after all slaves have completed their jobs.
Aggregated result from a suite or test.
An event dispatched before any slave starts.
 
 
A single test's execution information.
Aggregates atomic events from JUnitCore to higher-level events that contain a full summary of a given test's execution.
Base class for TestMethodProviders based on annotations.
A report listener that produces XML files compatible with those produced by ANT's default junit task.
 
 
A generator emitting simple ASCII alphanumeric letters and numbers from the set (newlines not counted):
Deprecated.
A generator emitting simple ASCII characters from the set (newlines not counted):
A random with a delegate, preventing Random.setSeed(long) and locked to be used by a single thread.
A nested list of SuiteBalancers.
RunListener decorator that does something before and after a given method call.
Utility classes for selecting numbers at random, but not necessarily in an uniform way.
Initial message sent from the slave to the master (if forked locally).
 
 
A filter for Description.getClassName().
Class model for a test suite.
 
 
 
 
 
Allocation information (Thread, allocation stack) for tracking disposable resources.
A string generator from a predefined set of codepoints or characters.
Some useful constants.
Event deserializer.
 
 
Duplicate nested resources N times.
 
An OutputStream delegate.
Events (messages) passed between the slave and the master.
A test suite balancer based on past execution times saved using ExecutionTimesReport.
 
A report listener that emits per-suite execution times information useful for load balancing tests across JVMs.
Generic serialized failure event.
A type-safe mirror of Failure.
 
Test group conditions filter parser.
 
 
Static slave information.
Formatting utilities for consistency across code.
A filter that matches something using globbing (*) pattern.
Evaluates enabled/ disabled state for a given test group.
 
High level heartbeat event issued to report listeners when a forked JVM does not repond for a longer while.
Display help information on junit4-maven-plugin.
Call mvn junit4:help -Ddetail=true -Dgoal=<goal-name> to display parameter details.
An identity hash set implemented using open addressing.
An event that carries a Description.
Marker that the slave is idle and awaiting more suite names.
An event/ message passed between the forked JVM and the master.
Provide a test instance.
We have our own "custom" assumption class because of JUnit's internal closed-up architecture.
 
 
 
Reads a JSON (RFC 4627) encoded value as a stream of tokens.
A report listener that produces a single JSON file for all suites and tests.
 
Lexical scoping elements within a JSON reader or writer.
A structure, name or value type in a JSON-encoded string.
Writes a JSON (RFC 4627) encoded value to a stream, one token at a time.
Method provider selecting tests that follow a name pattern of test(.*).
An ANT task to run JUnit4 tests.
A PropertySet with an additional attribute specifying whether or not empty values should be propagated or ignored.
A Environment.Variable with an additional attribute specifying whether or not empty values should be propagated or ignored.
What to do on JVM output?
What to do when there were no executed tests (all ignored or none at all?).
Method provider selecting Test annotated public instance parameterless methods.
Run tests using a delegation to Randomized Testing's JUnit4 ANT task.
 
An event emitted when there was any unexpected JVM output from the forked JVM.
Lifecycle stages for tracking resources.
 
Annotate your suite class with this annotation to automatically add hooks to the RunNotifier used for executing tests inside RandomizedRunner.
 
Establish event passing with a subprocess and pump events to the bus.
 
Heartbeat for reporting long running tests.
Thrown when a reader encounters malformed JSON.
 
An adapter to maven logging system from ANT BuildListener.
Merge execution hints emitted by ExecutionTimeBalancer to one file.
A filter for Description.getMethodName().
A SeedDecorator to be used with SeedDecorators annotation to modify the master Randomness with a hash off the suite's class name.
Hash routines for primitive types.
Hash routines for primitive types.
Used to annotate constructor parameters for parameterized tests.
An annotation indicating a given test case (or suite) should run only during nightly tests.
Don't allow BeforeClass and AfterClass hook shadowing as it is most likely a user error.
RunListener decorator that does something before and after a given method call.
Don't allow Before and After hook overrides as it is most likely a user error and will result in superclass methods not being called (requires manual chaining).
 
Discovers shadowing or override relationships among methods annotated with any of the provided annotations.
Local markup to indicate which elements are extensions and where.
 
 
 
Used to annotate methods providing parameters for parameterized tests.
Partial output emitted from a given slave.
An ANT task to pick and fix the random seed in advance (for selecting other derivative values, for example).
Nested value element.
An ANT task to pick and fix the random seed in advance (for selecting other derivative values, for example).
 
Prefixes every new line with a given byte [], synchronizing multiple streams to emit consistent lines.
 
Final message sent from the slave.
Estimates the size (memory representation) of Java objects.
Cached information about a given class.
 
 
JVM diagnostic features.
Random byte sequence generators.
Context variables for an execution of a test suite (hooks and tests) running under a RandomizedRunner.
Per thread assigned resources.
A Runner implementation for running randomized test cases with predictable and repeatable randomness.
 
Queue uncaught exceptions.
 
Helper tuple (Method, instance params).
 
Common scaffolding for subclassing randomized tests.
Per-thread, per-lifecycle state randomness defined as an initial seed and the current Random instance.
Utility classes for selecting random numbers from within a range or the numeric domain for a given type.
Random selections of objects.
A facade to various implementations of StringGenerator interface.
 
Rants about blocker limitations of JUnit...
 
A string generator that emits valid unicodeGenerator codepoints.
 
Repeats randomized test case a given number of times.
Replicates the test class on each concurrent forked JVM.
A builder for constructing "reproduce with" message.
A RunListener that emits to System.err a string with command line parameters allowing quick test re-run under ANT command line.
Require assertions TestRule.
Thrown when a resource could not be released.
Rethrowing checked exceptions as unchecked ones.
Classy puzzler to rethrow any checked exception as an unchecked one.
A round-robin suite balancer (default for non-assigned suites).
Serialize test execution events.
What kind of container are we in? Unfortunately we need to adjust to some "assumptions" containers make about runners.
A ThreadGroup under which all tests (and hooks) are executed.
Defines the starting seed for a given test or the entire suite.
This is an advanced feature.
Allows modifying the master seed (before the suite is started).
Defines a list of starting seeds for a given test.
Utilities for parsing random seeds.
Event serializer.
An event published when a slave is idle and waits for new suite classes.
A slave process running the actual tests on the target JVM.
Base for redirected streams.
 
Stack trace filtering.
This is never thrown.
An abstract Statement that guarantees the execution of StatementAdapter.afterAlways(java.util.List<java.lang.Throwable>) even if an exception has been thrown from delegate Statement.
A TestRule that ensures static, reference fields of the suite class (and optionally its superclasses) are cleaned up after a suite is completed.
 
Iterates over lines from standard input.
Flushes System.out and System.err before passing the event to the delegate.
A StringGenerator generates random strings composed of characters.
A test balancer schedules test suites to be executed on a given JVM.
 
Serialized failure.
Serialized failure.
A suite with the cost hint.
Serialized failure.
Suppresses forbidden-API checks.
Global names for system properties controlling the behavior of JUnit4 ANT task and RandomizedRunner.
A TestRule that ensures system properties remain unmodified by the nested Statement.
A TestRule which restores system properties from before the nested Statement.
An input stream that tails from a random access file as new input appears there.
Custom teeing stream that ensures both streams receive the output and no exceptions are quietly suppressed.
A temporary path resource will be deleted at the end of a given lifecycle phase.
Determines how instances of the test suite class are created for each test case.
 
 
Test case ordering.
Alphabetic, increasing order by method name.
 
A supplier of Random instances for the RandomizedContext.
 
 
A test group applied to an annotation indicates that a given annotation can be used on individual tests as "labels".
Utilities to deal with annotations annotated with TestGroup.
 
 
A single test case entry composed of the test method and the arguments eventually passed to the test class's constructor.
Responsible for providing individual test instances and their descriptions.
Test case method provider.
An abstract TestRule that guarantees the execution of TestRuleAdapter.afterAlways(java.util.List<java.lang.Throwable>) even if an exception has been thrown from delegate Statement.
A collection of test suites and extracted annotation information.
Summary of tests execution.
Create a summary of tests execution.
 
 
Suite model of ANT-JUnit XML.
A listener that will subscribe to test execution and dump informational info about the progress to the console or a text file.
Display mode for output streams.
 
 
 
Everything corresponding to thread leak control.
A dummy class serving as the source of defaults for annotations.
 
Runs a Statement and keeps any exception and completion flag.
 
Timeout parsing code and logic.
A thread went wild.
 
 
 
 
 
 
 
 
 
Maximum execution time for a single test method.
Maximum execution time for an entire suite (including all hooks and tests).
Display the slowest test suites based on hints files.
 
Utilities for dealing with throwables, stacks, etc.
This is thrown on uncaught exceptions during suite or test execution.
A string generator that emits valid unicodeGenerator codepoints.
Validation utilities.
 
 
OutputStream implementation that transforms a byte stream to a character stream using a specified charset encoding and writes the resulting stream to a Writer.
Write a plexus configuration to a stream
 
Implements Xoroshiro128PlusRandom.