org.junit.rules.MethodRule |
Known Indirect Subclasses
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. |
ExpectedException |
The ExpectedException Rule allows in-test specification of expected exception
types and messages:
// These tests all pass. |
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);
}
}
|
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");
// ... |
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());
}
}
|
TestWatchman |
TestWatchman is a base class for Rules that take note of the testing
action, without modifying it. |
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 (;;) {
}
}
}
|
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() {
// ... |
|
Class Overview
A MethodRule is an alteration in how a test method is run and reported.
Multiple MethodRule
s can be applied to a test method. The
Statement
that executes the method is passed to each annotated
Rule
in turn, and each may return a substitute or modified
Statement
, which is passed to the next Rule
, if any. For
examples of how this can be useful, see these provided MethodRules,
or write your own:
Public Methods
Modifies the method-running Statement
to implement an additional
test-running rule.
Parameters
base
| The Statement to be modified |
method
| The method to be run |
target
| The object on with the method will be run. |
Returns
- a new statement, which may be the same as
base
,
a wrapper around base
, or a completely new Statement.