All Classes

Class	Description
After	If you allocate external resources in a Before method you need to release them after the test runs.
AfterClass	If you allocate expensive external resources in a BeforeClass method you need to release them after all the tests in the class have run.
AllTests	Runner for use with JUnit 3.8.x-style AllTests classes (those that only implement a static suite() method).
Assert	A set of assertion methods useful for writing tests.
Assume	A set of methods useful for stating assumptions about the conditions in which a test is meaningful.
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.
ClassRule	Annotates static fields that reference rules or methods that return them.
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 Description describes a test which is to be run or has been run.
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):
ExpectedException	The ExpectedException rule allows in-test specification of expected exception types and messages:
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:
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.
FixMethodOrder	This class allows the user to choose the order of execution of the methods within a test class.
FrameworkField	Represents a field on a test class (currently used only for Rules in BlockJUnit4ClassRunner, but custom runners can make other uses)
FrameworkMember<T extends FrameworkMember<T>>	Parent class for FrameworkField and FrameworkMethod
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.
InitializationError	Represents one or more problems encountered while initializing a Runner
JUnit4	Aliases the current default JUnit 4 class runner, for future-proofing.
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.
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: Last failure timestamp Duration of last execution
MethodRule	A MethodRule is an alteration in how a test method is run and reported.
MethodSorters	Sort the methods into a specified execution order.
MultipleFailureException	Collects multiple Throwables into one exception.
NoTestsRemainException	Thrown when a filter removes all tests from a runner.
ParallelComputer
Parameterized	The custom runner Parameterized implements parameterized tests.
Parameterized.Parameter	Annotation for fields of the test class which will be initialized by the method annotated by Parameters By using directly this annotation, the test class constructor isn't needed. Index range must start at 0.
Parameterized.Parameters	Annotation for a method which provides parameters to be injected into the test class constructor by Parameterized
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.
Request	A Request is an abstract description of tests to be run.
Result	A Result collects and summarizes information from running multiple tests.
ResultMatchers	Matchers on a PrintableResult, to enable JUnit self-tests.
Rule	Annotates fields that reference rules or methods that return a rule.
RuleChain	The RuleChain rule allows ordering of TestRules.
RunListener	If you need to respond to the events during a test run, extend RunListener and override the appropriate methods.
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.
RunRules	Runs a collection of rules on a statement.
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.
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.
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.
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):
Test	The Test annotation tells JUnit that the public void method to which it is attached can be run as a test case.
Test.None	Default empty exception
TestClass	Wraps a class to be run, providing method validation and annotation searching
TestedOn
TestedOnSupplier
TestName	The TestName Rule makes the current test name available inside test methods:
TestRule	A TestRule is an alteration in how a test method, or set of test methods, is run and reported.
TestWatcher	TestWatcher is a base class for Rules that take note of the testing action, without modifying it.
TestWatchman	Deprecated. Use TestWatcher (which implements TestRule) instead.
Theories
Theories.TheoryAnchor
Theory
Timeout	The Timeout Rule applies the same timeout to all test methods in a class:
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