package org.junit.tests.experimental.rules;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.experimental.results.PrintableResult.testResult;
import static org.junit.experimental.results.ResultMatchers.hasFailureContaining;
import static org.junit.experimental.results.ResultMatchers.isSuccessful;
import java.util.concurrent.Callable;
import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.results.PrintableResult;
import org.junit.rules.ErrorCollector;
import org.junit.rules.Verifier;
public class VerifierRuleTest {
public static class UsesErrorCollector {
@Rule
public ErrorCollector collector = new ErrorCollector();
@Test
public void example() {
collector.addError(new Throwable("message"));
}
}
@Test
public void usedErrorCollectorShouldFail() {
assertThat(testResult(UsesErrorCollector.class), hasFailureContaining("message"));
}
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"));
}
}
@Test
public void usedErrorCollectorTwiceShouldFail() {
PrintableResult testResult = testResult(UsesErrorCollectorTwice.class);
assertThat(testResult, hasFailureContaining("first thing went wrong"));
assertThat(testResult, hasFailureContaining("second thing went wrong"));
}
public static class UsesErrorCollectorCheckThat {
@Rule
public ErrorCollector collector = new ErrorCollector();
@Test
public void example() {
collector.checkThat(3, is(4));
collector.checkThat(5, is(6));
collector.checkThat("reason 1", 7, is(8));
collector.checkThat("reason 2", 9, is(16));
}
}
@Test
public void usedErrorCollectorCheckThatShouldFail() {
PrintableResult testResult = testResult(UsesErrorCollectorCheckThat.class);
assertThat(testResult, hasFailureContaining("was <3>"));
assertThat(testResult, hasFailureContaining("was <5>"));
assertThat(testResult, hasFailureContaining("reason 1"));
assertThat(testResult, hasFailureContaining("was <7>"));
assertThat(testResult, hasFailureContaining("reason 2"));
assertThat(testResult, hasFailureContaining("was <9>"));
}
public static class UsesErrorCollectorCheckSucceeds {
@Rule
public ErrorCollector collector = new ErrorCollector();
@Test
public void example() {
collector.checkSucceeds(new Callable<Object>() {
public Object call() throws Exception {
throw new RuntimeException("first!");
}
});
collector.checkSucceeds(new Callable<Object>() {
public Object call() throws Exception {
throw new RuntimeException("second!");
}
});
}
}
@Test
public void usedErrorCollectorCheckSucceedsShouldFail() {
PrintableResult testResult = testResult(UsesErrorCollectorCheckSucceeds.class);
assertThat(testResult, hasFailureContaining("first!"));
assertThat(testResult, hasFailureContaining("second!"));
}
public static class UsesErrorCollectorCheckSucceedsPasses {
@Rule
public ErrorCollector collector = new ErrorCollector();
@Test
public void example() {
assertEquals(3, collector.checkSucceeds(new Callable<Object>() {
public Object call() throws Exception {
return 3;
}
}));
}
}
@Test
public void usedErrorCollectorCheckSucceedsShouldPass() {
PrintableResult testResult = testResult(UsesErrorCollectorCheckSucceedsPasses.class);
assertThat(testResult, isSuccessful());
}
private static String sequence;
public static class UsesVerifier {
@Rule
public Verifier collector = new Verifier() {
@Override
protected void verify() {
sequence += "verify ";
}
};
@Test
public void example() {
sequence += "test ";
}
}
@Test
public void verifierRunsAfterTest() {
sequence = "";
assertThat(testResult(UsesVerifier.class), isSuccessful());
assertEquals("test verify ", sequence);
}
}