VerifierRuleTest.java

package org.junit.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.hasSingleFailureMatching;
import static org.junit.experimental.results.ResultMatchers.isSuccessful;

import java.util.concurrent.Callable;

import org.hamcrest.CoreMatchers;
import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.results.PrintableResult;
import org.junit.function.ThrowingRunnable;
import org.junit.internal.AssumptionViolatedException;

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 PassesAssumptionViolatedExceptionToErrorCollector {
        @Rule
        public ErrorCollector collector = new ErrorCollector();

        @Test
        public void example() {
            collector.addError(new AssumptionViolatedException("message"));
        }
    }

    @Test
    public void passingAssumptionViolatedExceptionShouldResultInFailure() {
        assertThat(testResult(PassesAssumptionViolatedExceptionToErrorCollector.class), hasSingleFailureMatching(
                CoreMatchers.<Throwable>instanceOf(AssertionError.class)));
    }

    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<Integer>() {
                public Integer call() throws Exception {
                    throw new RuntimeException("second!");
                }
            });
            Integer result = collector.checkSucceeds(new Callable<Integer>() {
                public Integer call() throws Exception {
                    return 1;
                }
            });
            assertEquals(Integer.valueOf(1), result);
        }
    }

    @Test
    public void usedErrorCollectorCheckSucceedsShouldFail() {
        PrintableResult testResult = testResult(UsesErrorCollectorCheckSucceeds.class);
        assertThat(testResult, hasFailureContaining("first!"));
        assertThat(testResult, hasFailureContaining("second!"));
    }

    public static class UsesErrorCollectorCheckSucceedsWithAssumptionViolatedException {
        @Rule
        public ErrorCollector collector = new ErrorCollector();

        @Test
        public void example() {
            collector.checkSucceeds(new Callable<Object>() {
                public Object call() throws Exception {
                    throw new AssumptionViolatedException("message");
                }
            });
        }
    }

    @Test
    public void usedErrorCollectorCheckSucceedsWithAssumptionViolatedExceptionShouldFail() {
        PrintableResult testResult = testResult(UsesErrorCollectorCheckSucceedsWithAssumptionViolatedException.class);
        assertThat(testResult, hasSingleFailureMatching(CoreMatchers.<Throwable>instanceOf(AssertionError.class)));
        assertThat(testResult, hasFailureContaining("Callable threw AssumptionViolatedException"));
    }

    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());
    }

    public static class UsesErrorCollectorCheckThrowsMatchingClass {
        @Rule
        public ErrorCollector collector = new ErrorCollector();

        @Test
        public void example() {
            collector.checkThrows(IllegalArgumentException.class, new ThrowingRunnable() {
                public void run() throws Throwable {
                    throw new IllegalArgumentException();
                }
            });
        }
    }

    @Test
    public void usedErrorCollectorCheckThrowsMatchingClassShouldPass() {
        PrintableResult testResult = testResult(UsesErrorCollectorCheckThrowsMatchingClass.class);
        assertThat(testResult, isSuccessful());
    }

    public static class UsesErrorCollectorCheckThrowsClassMismatch {
        @Rule
        public ErrorCollector collector = new ErrorCollector();

        @Test
        public void example() {
            collector.checkThrows(IllegalArgumentException.class, new ThrowingRunnable() {
                public void run() throws Throwable {
                    throw new NullPointerException();
                }
            });
        }
    }

    @Test
    public void usedErrorCollectorCheckThrowsClassMismatchShouldFail() {
        PrintableResult testResult = testResult(UsesErrorCollectorCheckThrowsClassMismatch.class);
        assertThat(testResult, hasFailureContaining(
            "expected:<java.lang.IllegalArgumentException> but was:<java.lang.NullPointerException>"));
    }

    public static class UsesErrorCollectorCheckThrowsNothingThrown {
        @Rule
        public ErrorCollector collector = new ErrorCollector();

        @Test
        public void example() {
            collector.checkThrows(IllegalArgumentException.class, new ThrowingRunnable() {
                public void run() throws Throwable {
                }
            });
        }
    }

    @Test
    public void usedErrorCollectorCheckThrowsNothingThrownShouldFail() {
        PrintableResult testResult = testResult(UsesErrorCollectorCheckThrowsNothingThrown.class);
        assertThat(testResult, hasFailureContaining("but nothing was thrown"));
    }

    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);
    }
}