| ActiveTestSuite | A TestSuite for active Tests. |
| After | If you allocate external resources in a |
| AfterClass | If you allocate expensive external resources in a |
| AllDefaultPossibilitiesBuilder | |
| AllMembersSupplier | Supplies Theory parameters based on all public members of the target class. |
| AllTests | Runner for use with JUnit 3.8.x-style AllTests classes
(those that only implement a static suite()
method). |
| AnnotatedBuilder | |
| ArrayComparisonFailure | Thrown when two array elements differ |
| Assert | A set of assert methods. |
| Assert | A set of assertion methods useful for writing tests. |
| AssertionFailedError | Thrown when an assertion failed. |
| Assignments | A potentially incomplete list of value assignments for a method's formal parameters |
| Assume | A set of methods useful for stating assumptions about the conditions in which a test is meaningful. |
| AssumptionViolatedException |
| BaseTestRunner | Base class for all test runners. |
| Before | When writing tests, it is common to find that several tests need similar objects created before they can run. |
| BeforeClass | Sometimes several tests need to share computationally expensive setup (like logging into a database). |
| BlockJUnit4ClassRunner | Implements the JUnit 4 standard test case class model, as defined by the annotations in the org.junit package. |
| Categories | From a given set of test classes, runs only the classes and methods that are annotated with either the category given with the @IncludeCategory annotation, or a subtype of that category. |
| Categories.CategoryFilter | |
| Categories.ExcludeCategory | |
| Categories.IncludeCategory | |
| Category | Marks a test class or test method as belonging to one or more categories of tests. |
| ClassRequest | |
| ClassRoadie |
This class is deprecated.
Included for backwards compatibility with JUnit 4.4. Will be
removed in the next release. Please use
BlockJUnit4ClassRunner in place of JUnit4ClassRunner.
|
| CombinableMatcher<T> | |
| ComparisonCompactor | |
| ComparisonCriteria | Defines criteria for finding two items "equal enough". |
| ComparisonFailure | Thrown when an assert equals for Strings failed. |
| ComparisonFailure | Thrown when an assertEquals(String, String) fails. |
| Computer | Represents a strategy for computing runners and suites. |
| CouldNotReadCoreException | Thrown when Max cannot read the MaxCore serialization |
| DataPoint | |
| DataPoints | |
| Describable | Represents an object that can describe itself |
| Description | A |
| Each | |
| EachTestNotifier | |
| Enclosed | If you put tests in inner classes, Ant, for example, won't find them. |
| ErrorCollector | The ErrorCollector rule allows execution of a test to continue after the
first problem is found (for example, to collect _all_ the incorrect rows in a
table, and report them all at once):
public static class UsesErrorCollectorTwice {
@Rule
public ErrorCollector collector= new ErrorCollector();
@Test
public void example() {
collector.addError(new Throwable("first thing went wrong"));
collector.addError(new Throwable("second thing went wrong"));
collector.checkThat(getResult(), not(containsString("ERROR!")));
// all lines will run, and then a combined failure logged at the end. |
| ErrorReportingRunner | |
| ExactComparisonCriteria | |
| ExpectedException | The ExpectedException Rule allows in-test specification of expected exception
types and messages:
// These tests all pass. |
| ExpectException | |
| ExternalResource | A base class for Rules (like TemporaryFolder) that set up an external
resource before a test (a file, socket, server, database connection, etc.),
and guarantee to tear it down afterward:
public static class UsesExternalResource {
Server myServer= new Server();
@Rule
public ExternalResource resource= new ExternalResource() {
@Override
protected void before() throws Throwable {
myServer.connect();
};
@Override
protected void after() {
myServer.disconnect();
};
};
@Test
public void testFoo() {
new Client().run(myServer);
}
}
|
| Fail | |
| FailOnTimeout | |
| Failure | A Failure holds a description of the failed test and the
exception that was thrown while running it. |
| Filter | The canonical case of filtering is when you want to run a single test method in a class. |
| Filterable | Runners that allow filtering should implement this interface. |
| FilterRequest | A filtered Request. |
| FrameworkField | Represents a field on a test class (currently used only for Rules in
BlockJUnit4ClassRunner, but custom runners can make other uses)
|
| FrameworkMethod | Represents a method on a test class to be invoked at the appropriate point in test execution. |
| Ignore | Sometimes you want to temporarily disable a test or a group of tests. |
| IgnoredBuilder | |
| IgnoredClassRunner | |
| InexactComparisonCriteria | |
| InitializationError | |
| InitializationError | Represents one or more problems encountered while initializing a Runner |
| InvokeMethod | |
| IsCollectionContaining<T> |
| JUnit38ClassRunner | |
| JUnit3Builder | |
| JUnit4 | Aliases the current default JUnit 4 class runner, for future-proofing. |
| JUnit4Builder | |
| JUnit4ClassRunner |
This class is deprecated.
Included for backwards compatibility with JUnit 4.4. Will be
removed in the next release. Please use
BlockJUnit4ClassRunner in place of JUnit4ClassRunner.
This may disappear as soon as 1 April 2009
|
| JUnit4TestAdapter | |
| JUnit4TestAdapterCache | |
| JUnit4TestCaseFacade | |
| JUnitCore | JUnitCore is a facade for running tests. |
| JUnitMatchers | Convenience import class: these are useful matchers for use with the assertThat method, but they are not currently included in the basic CoreMatchers class from hamcrest. |
| JUnitSystem |
| MaxCore | A replacement for JUnitCore, which keeps track of runtime and failure history, and reorders tests to maximize the chances that a failing test occurs early in the test run. |
| MaxHistory | Stores a subset of the history of each test:
|
| MethodRoadie |
This class is deprecated.
Included for backwards compatibility with JUnit 4.4. Will be
removed in the next release. Please use
BlockJUnit4ClassRunner in place of JUnit4ClassRunner.
|
| MethodRule | A MethodRule is an alteration in how a test method is run and reported. |
| MethodValidator |
This class is deprecated.
Included for backwards compatibility with JUnit 4.4. Will be
removed in the next release. Please use
BlockJUnit4ClassRunner in place of JUnit4ClassRunner.
|
| MultipleFailureException |
| NoTestsRemainException | Thrown when a filter removes all tests from a runner. |
| NullBuilder |
| ParallelComputer | |
| Parameterized |
The custom runner |
| Parameterized.Parameters | Annotation for a method which provides parameters to be injected into the
test class constructor by Parameterized
|
| ParameterizedAssertionError | |
| ParameterSignature | |
| ParametersSuppliedBy | |
| ParameterSupplier | |
| ParentRunner<T> | Provides most of the functionality specific to a Runner that implements a
"parent node" in the test tree, with children defined by objects of some data
type T. |
| PotentialAssignment | |
| PotentialAssignment.CouldNotGenerateValueException | |
| PrintableResult | A test result that prints nicely in error messages. |
| Protectable | A Protectable can be run and can throw a Throwable. |
| RealSystem | |
| ReflectiveCallable | When invoked, throws the exception from the reflected method, rather than wrapping it in an InvocationTargetException. |
| RepeatedTest | A Decorator that runs a test repeatedly. |
| Request | A |
| Result | A Result collects and summarizes information from running multiple
tests. |
| ResultMatchers | Matchers on a PrintableResult, to enable JUnit self-tests. |
| ResultPrinter | |
| Rule | Annotates fields that contain rules. |
| RunAfters | |
| RunBefores | |
| RunListener | If you need to respond to the events during a test run, extend |
| Runner | A Runner runs tests and notifies a RunNotifier
of significant events as it does so. |
| RunnerBuilder | A RunnerBuilder is a strategy for constructing runners for classes. |
| RunnerScheduler | Represents a strategy for scheduling when individual test methods should be run (in serial or parallel) WARNING: still experimental, may go away. |
| RunNotifier | If you write custom runners, you may need to notify JUnit of your progress running tests. |
| RunWith | When a class is annotated with @RunWith or extends a class annotated
with @RunWith, JUnit will invoke the class it references to run the
tests in that class instead of the runner built into JUnit. |
| Sortable | Interface for runners that allow sorting of tests. |
| Sorter | A Sorter orders tests. |
| SortingRequest | |
| Statement | Represents one or more actions to be taken at runtime in the course of running a JUnit test suite. |
| StoppedByUserException | Thrown when a user has requested that the test run stop. |
| StringContains | Tests if the argument is a string that contains a substring. |
| SubstringMatcher | |
| Suite | Using Suite as a runner allows you to manually
build a suite containing tests from many classes. |
| Suite.SuiteClasses | The SuiteClasses annotation specifies the classes to be run when a class
annotated with @RunWith(Suite.class) is run. |
| SuiteMethod | Runner for use with JUnit 3.8.x-style AllTests classes
(those that only implement a static suite()
method). |
| SuiteMethodBuilder |
| TemporaryFolder | The TemporaryFolder Rule allows creation of files and folders that are
guaranteed to be deleted when the test method finishes (whether it passes or
fails):
public static class HasTempFolder {
@Rule
public TemporaryFolder folder= new TemporaryFolder();
@Test
public void testUsingTempFolder() throws IOException {
File createdFile= folder.newFile("myfile.txt");
File createdFolder= folder.newFolder("subfolder");
// ... |
| Test | A Test can be run and collect its results. |
| Test | The |
| Test.None | Default empty exception |
| TestCase | A test case defines the fixture to run multiple tests. |
| TestClass |
This class is deprecated.
Included for backwards compatibility with JUnit 4.4. Will be
removed in the next release. Please use
BlockJUnit4ClassRunner in place of JUnit4ClassRunner.
|
| TestClass | Wraps a class to be run, providing method validation and annotation searching |
| TestDecorator | A Decorator for Tests. |
| TestedOn | |
| TestedOnSupplier | |
| TestFailure | A TestFailure collects a failed test together with
the caught exception. |
| TestListener | A Listener for test progress |
| TestMethod |
This class is deprecated.
Included for backwards compatibility with JUnit 4.4. Will be
removed in the next release. Please use
BlockJUnit4ClassRunner in place of JUnit4ClassRunner.
|
| TestName | The TestName Rule makes the current test name available inside test methods:
public class TestNameTest {
@Rule
public TestName name= new TestName();
@Test
public void testA() {
assertEquals("testA", name.getMethodName());
}
@Test
public void testB() {
assertEquals("testB", name.getMethodName());
}
}
|
| TestResult | A TestResult collects the results of executing
a test case. |
| TestRunListener | A listener interface for observing the execution of a test run. |
| TestRunner | A command line based tool to run tests. |
| TestSetup | A Decorator to set up and tear down additional fixture state. |
| TestSuite | A |
| TestWatchman | TestWatchman is a base class for Rules that take note of the testing action, without modifying it. |
| TextListener | |
| Theories | |
| Theories.TheoryAnchor | |
| Theory | |
| Timeout | The Timeout Rule applies the same timeout to all test methods in a class:
public static class HasGlobalTimeout {
public static String log;
@Rule
public MethodRule globalTimeout= new Timeout(20);
@Test
public void testInfiniteLoop1() {
log+= "ran1";
for (;;) {
}
}
@Test
public void testInfiniteLoop2() {
log+= "ran2";
for (;;) {
}
}
}
|
| TypeSafeMatcher<T> | Convenient base class for Matchers that require a non-null value of a specific type. |
| Verifier | Verifier is a base class for Rules like ErrorCollector, which can turn
otherwise passing test methods into failing tests if a verification check is
failed
public static class ErrorLogVerifier() {
private ErrorLog errorLog = new ErrorLog();
@Rule
public MethodRule verifier = new Verifier() {
@Override public void verify() {
assertTrue(errorLog.isEmpty());
}
}
@Test public void testThatMightWriteErrorLog() {
// ... |
| Version | This class defines the current version of JUnit |