| package org.junit.rules; |
| |
| import static java.util.Arrays.asList; |
| import static org.hamcrest.MatcherAssert.assertThat; |
| import static org.junit.Assert.*; |
| import static org.junit.Assume.assumeTrue; |
| import static org.junit.experimental.results.PrintableResult.testResult; |
| import static org.junit.experimental.results.ResultMatchers.failureCountIs; |
| import static org.junit.experimental.results.ResultMatchers.hasFailureContaining; |
| import static org.junit.rules.ExpectedException.none; |
| |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.experimental.results.PrintableResult; |
| import org.junit.experimental.runners.Enclosed; |
| import org.junit.internal.AssumptionViolatedException; |
| import org.junit.runner.Description; |
| import org.junit.runner.JUnitCore; |
| import org.junit.runner.Result; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.Parameterized; |
| import org.junit.runners.Parameterized.Parameter; |
| import org.junit.runners.Parameterized.Parameters; |
| import org.junit.runners.model.Statement; |
| |
| import java.util.List; |
| |
| @RunWith(Enclosed.class) |
| public class TestWatcherTest { |
| |
| @RunWith(Parameterized.class) |
| public static class Callbacks { |
| |
| @Parameters(name = "{0}") |
| public static Object[][] parameters() { |
| return new Object[][] { |
| { |
| FailingTest.class, |
| "starting failed finished ", |
| asList("starting failed", "test failed", "failed failed", "finished failed") }, |
| { |
| InternalViolatedAssumptionTest.class, |
| "starting deprecated skipped finished ", |
| asList("starting failed", "don't run", "deprecated skipped failed", "finished failed") }, |
| { |
| SuccessfulTest.class, |
| "starting succeeded finished ", |
| asList("starting failed", "succeeded failed", "finished failed") }, |
| { |
| ViolatedAssumptionTest.class, |
| "starting skipped finished ", |
| asList("starting failed", "Test could not be skipped due to other failures", "skipped failed", "finished failed") } |
| }; |
| } |
| |
| @Parameter(0) |
| public Class<?> testClass; |
| |
| @Parameter(1) |
| public String expectedCallbacks; |
| |
| @Parameter(2) |
| public List<String> expectedFailures; |
| |
| private static TestRule selectedRule; //for injecting rule into test classes |
| |
| @Test |
| public void correctCallbacksCalled() { |
| StringBuilder log = new StringBuilder(); |
| selectedRule = new LoggingTestWatcher(log); |
| JUnitCore.runClasses(testClass); |
| assertEquals(expectedCallbacks, log.toString()); |
| } |
| |
| @Test |
| public void resultHasAllFailuresThrownByCallbacks() { |
| selectedRule = new ErroneousTestWatcher(); |
| PrintableResult result = testResult(testClass); |
| assertThat(result, failureCountIs(expectedFailures.size())); |
| for (String expectedFailure: expectedFailures) { |
| assertThat(result, hasFailureContaining(expectedFailure)); |
| } |
| } |
| |
| @Test |
| public void testWatcherDoesNotModifyResult() { |
| selectedRule = new NoOpRule(); |
| Result resultNoOpRule = JUnitCore.runClasses(testClass); |
| selectedRule = new LoggingTestWatcher(new StringBuilder()); |
| Result resultTestWatcher = JUnitCore.runClasses(testClass); |
| assertEquals( |
| "was successful", |
| resultNoOpRule.wasSuccessful(), |
| resultTestWatcher.wasSuccessful()); |
| assertEquals( |
| "failure count", |
| resultNoOpRule.getFailureCount(), |
| resultTestWatcher.getFailureCount()); |
| assertEquals( |
| "ignore count", |
| resultNoOpRule.getIgnoreCount(), |
| resultTestWatcher.getIgnoreCount()); |
| assertEquals( |
| "run count", |
| resultNoOpRule.getRunCount(), |
| resultTestWatcher.getRunCount()); |
| } |
| |
| private static class NoOpRule implements TestRule { |
| public Statement apply(Statement base, Description description) { |
| return base; |
| } |
| } |
| |
| private static class ErroneousTestWatcher extends TestWatcher { |
| @Override |
| protected void succeeded(Description description) { |
| throw new RuntimeException("succeeded failed"); |
| } |
| |
| @Override |
| protected void failed(Throwable e, Description description) { |
| throw new RuntimeException("failed failed"); |
| } |
| |
| @Override |
| protected void skipped(org.junit.AssumptionViolatedException e, Description description) { |
| throw new RuntimeException("skipped failed"); |
| } |
| |
| @Override |
| @SuppressWarnings("deprecation") |
| protected void skipped(AssumptionViolatedException e, Description description) { |
| throw new RuntimeException("deprecated skipped failed"); |
| } |
| |
| @Override |
| protected void starting(Description description) { |
| throw new RuntimeException("starting failed"); |
| } |
| |
| @Override |
| protected void finished(Description description) { |
| throw new RuntimeException("finished failed"); |
| } |
| } |
| |
| public static class FailingTest { |
| @Rule |
| public TestRule rule = selectedRule; |
| |
| @Test |
| public void test() { |
| fail("test failed"); |
| } |
| } |
| |
| public static class InternalViolatedAssumptionTest { |
| @Rule |
| public TestRule watcher = selectedRule; |
| |
| @SuppressWarnings("deprecation") |
| @Test |
| public void test() { |
| throw new AssumptionViolatedException("don't run"); |
| } |
| } |
| |
| public static class SuccessfulTest { |
| @Rule |
| public TestRule watcher = selectedRule; |
| |
| @Test |
| public void test() { |
| } |
| } |
| |
| public static class ViolatedAssumptionTest { |
| @Rule |
| public TestRule watcher = selectedRule; |
| |
| @Test |
| public void test() { |
| assumeTrue(false); |
| } |
| } |
| } |
| |
| public static class CallbackArguments { |
| |
| public static class Succeeded { |
| private static Description catchedDescription; |
| |
| @Rule |
| public final TestRule watcher = new TestWatcher() { |
| @Override |
| protected void succeeded(Description description) { |
| catchedDescription = description; |
| } |
| }; |
| |
| @Test |
| public void test() { |
| } |
| } |
| |
| @Test |
| public void succeeded() { |
| JUnitCore.runClasses(Succeeded.class); |
| assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$Succeeded)", |
| Succeeded.catchedDescription.getDisplayName()); |
| } |
| |
| public static class Failed { |
| private static Description catchedDescription; |
| private static Throwable catchedThrowable; |
| |
| @Rule |
| public final TestRule watcher = new TestWatcher() { |
| @Override |
| protected void failed(Throwable e, Description description) { |
| catchedDescription = description; |
| catchedThrowable = e; |
| } |
| }; |
| |
| @Test |
| public void test() { |
| fail("test failed"); |
| } |
| } |
| |
| @Test |
| public void failed() { |
| JUnitCore.runClasses(Failed.class); |
| assertEquals("test failed", Failed.catchedThrowable.getMessage()); |
| assertEquals(AssertionError.class, Failed.catchedThrowable.getClass()); |
| assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$Failed)", |
| Failed.catchedDescription.getDisplayName()); |
| } |
| |
| public static class Skipped { |
| private static Description catchedDescription; |
| private static org.junit.AssumptionViolatedException catchedException; |
| |
| @Rule |
| public final TestRule watcher = new TestWatcher() { |
| @Override |
| protected void skipped(org.junit.AssumptionViolatedException e, Description description) { |
| catchedDescription = description; |
| catchedException = e; |
| } |
| }; |
| |
| @Test |
| public void test() { |
| assumeTrue("test skipped", false); |
| } |
| } |
| |
| @Test |
| public void skipped() { |
| JUnitCore.runClasses(Skipped.class); |
| assertEquals("test skipped", Skipped.catchedException.getMessage()); |
| assertEquals(org.junit.AssumptionViolatedException.class, Skipped.catchedException.getClass()); |
| assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$Skipped)", |
| Skipped.catchedDescription.getDisplayName()); |
| } |
| |
| public static class DeprecatedSkipped { |
| private static Description catchedDescription; |
| private static AssumptionViolatedException catchedException; |
| |
| @Rule |
| public final TestRule watcher = new TestWatcher() { |
| @Override |
| @SuppressWarnings("deprecation") |
| protected void skipped(AssumptionViolatedException e, Description description) { |
| catchedDescription = description; |
| catchedException = e; |
| } |
| }; |
| |
| @SuppressWarnings("deprecation") |
| @Test |
| public void test() { |
| throw new AssumptionViolatedException("test skipped"); |
| } |
| } |
| |
| @Test |
| public void deprecatedSkipped() { |
| JUnitCore.runClasses(DeprecatedSkipped.class); |
| assertEquals("test skipped", DeprecatedSkipped.catchedException.getMessage()); |
| assertEquals(AssumptionViolatedException.class, DeprecatedSkipped.catchedException.getClass()); |
| assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$DeprecatedSkipped)", |
| DeprecatedSkipped.catchedDescription.getDisplayName()); |
| } |
| |
| public static class Starting { |
| private static Description catchedDescription; |
| |
| @Rule |
| public final TestRule watcher = new TestWatcher() { |
| @Override |
| protected void starting(Description description) { |
| catchedDescription = description; |
| } |
| }; |
| |
| @Test |
| public void test() { |
| } |
| } |
| |
| @Test |
| public void starting() { |
| JUnitCore.runClasses(Starting.class); |
| assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$Starting)", |
| Starting.catchedDescription.getDisplayName()); |
| } |
| |
| public static class Finished { |
| private static Description catchedDescription; |
| |
| @Rule |
| public final TestRule watcher = new TestWatcher() { |
| @Override |
| protected void finished(Description description) { |
| catchedDescription = description; |
| } |
| }; |
| |
| @Test |
| public void test() { |
| } |
| } |
| |
| @Test |
| public void finished() { |
| JUnitCore.runClasses(Finished.class); |
| assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$Finished)", |
| Finished.catchedDescription.getDisplayName()); |
| } |
| } |
| |
| //The following tests check the information in TestWatcher's Javadoc |
| //regarding interplay with other rules. |
| public static class InterplayWithOtherRules { |
| private static StringBuilder log; |
| |
| public static class ExpectedExceptionTest { |
| @Rule(order = Integer.MIN_VALUE) |
| //the field name must be alphabetically lower than "thrown" in order |
| //to make the test failing if order is not set |
| public final TestRule a = new LoggingTestWatcher(log); |
| |
| @Rule |
| public final ExpectedException thrown = none(); |
| |
| @Test |
| public void testWithExpectedException() { |
| thrown.expect(RuntimeException.class); |
| throw new RuntimeException("expected exception"); |
| } |
| } |
| |
| @Test |
| public void expectedExceptionIsSeenAsSuccessfulTest() { |
| log = new StringBuilder(); |
| JUnitCore.runClasses(ExpectedExceptionTest.class); |
| assertEquals("starting succeeded finished ", log.toString()); |
| } |
| |
| public static class ErrorCollectorTest { |
| @Rule(order = Integer.MIN_VALUE) |
| //the field name must be alphabetically lower than "collector" in |
| //order to make the test failing if order is not set |
| public final TestRule a = new LoggingTestWatcher(log); |
| |
| @Rule |
| public final ErrorCollector collector = new ErrorCollector(); |
| |
| @Test |
| public void test() { |
| collector.addError(new RuntimeException("expected exception")); |
| } |
| } |
| |
| @Test |
| public void testIsSeenAsFailedBecauseOfCollectedError() { |
| log = new StringBuilder(); |
| JUnitCore.runClasses(ErrorCollectorTest.class); |
| assertEquals("starting failed finished ", log.toString()); |
| } |
| } |
| } |