| package org.junit.rules; |
| |
| import static org.hamcrest.CoreMatchers.is; |
| import static org.hamcrest.MatcherAssert.assertThat; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.experimental.results.PrintableResult.testResult; |
| import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining; |
| import static org.junit.experimental.results.ResultMatchers.isSuccessful; |
| |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.runner.Description; |
| import org.junit.runner.JUnitCore; |
| import org.junit.runner.Result; |
| import org.junit.runners.model.FrameworkMethod; |
| import org.junit.runners.model.Statement; |
| |
| public class TestRuleTest { |
| private static boolean wasRun; |
| |
| public static class ExampleTest { |
| @Rule |
| public TestRule example = new TestRule() { |
| public Statement apply(final Statement base, Description description) { |
| return new Statement() { |
| @Override |
| public void evaluate() throws Throwable { |
| wasRun = true; |
| base.evaluate(); |
| } |
| }; |
| } |
| }; |
| |
| @Test |
| public void nothing() { |
| |
| } |
| } |
| |
| @Test |
| public void ruleIsIntroducedAndEvaluated() { |
| wasRun = false; |
| JUnitCore.runClasses(ExampleTest.class); |
| assertTrue(wasRun); |
| } |
| |
| public static class BothKindsOfRule implements TestRule, org.junit.rules.MethodRule { |
| public int applications = 0; |
| |
| public Statement apply(Statement base, FrameworkMethod method, |
| Object target) { |
| applications++; |
| return base; |
| } |
| |
| public Statement apply(Statement base, Description description) { |
| applications++; |
| return base; |
| } |
| } |
| |
| public static class OneFieldTwoKindsOfRule { |
| @Rule |
| public BothKindsOfRule both = new BothKindsOfRule(); |
| |
| @Test |
| public void onlyOnce() { |
| assertEquals(1, both.applications); |
| } |
| } |
| |
| |
| @Test |
| public void onlyApplyOnceEvenIfImplementsBothInterfaces() { |
| assertTrue(JUnitCore.runClasses(OneFieldTwoKindsOfRule.class).wasSuccessful()); |
| } |
| |
| public static class SonOfExampleTest extends ExampleTest { |
| |
| } |
| |
| @Test |
| public void ruleIsIntroducedAndEvaluatedOnSubclass() { |
| wasRun = false; |
| JUnitCore.runClasses(SonOfExampleTest.class); |
| assertTrue(wasRun); |
| } |
| |
| private static int runCount; |
| |
| public static class MultipleRuleTest { |
| private static class Increment implements TestRule { |
| public Statement apply(final Statement base, Description description) { |
| return new Statement() { |
| @Override |
| public void evaluate() throws Throwable { |
| runCount++; |
| base.evaluate(); |
| } |
| }; |
| } |
| } |
| |
| @Rule |
| public TestRule incrementor1 = new Increment(); |
| |
| @Rule |
| public TestRule incrementor2 = new Increment(); |
| |
| @Test |
| public void nothing() { |
| |
| } |
| } |
| |
| @Test |
| public void multipleRulesAreRun() { |
| runCount = 0; |
| JUnitCore.runClasses(MultipleRuleTest.class); |
| assertEquals(2, runCount); |
| } |
| |
| public static class NoRulesTest { |
| public int x; |
| |
| @Test |
| public void nothing() { |
| |
| } |
| } |
| |
| @Test |
| public void ignoreNonRules() { |
| Result result = JUnitCore.runClasses(NoRulesTest.class); |
| assertEquals(0, result.getFailureCount()); |
| } |
| |
| private static String log; |
| |
| public static class BeforesAndAfters { |
| private static StringBuilder watchedLog = new StringBuilder(); |
| |
| @Before |
| public void before() { |
| watchedLog.append("before "); |
| } |
| |
| @Rule |
| public TestRule watcher = new LoggingTestWatcher(watchedLog); |
| |
| @After |
| public void after() { |
| watchedLog.append("after "); |
| } |
| |
| @Test |
| public void succeeds() { |
| watchedLog.append("test "); |
| } |
| } |
| |
| @Test |
| public void beforesAndAfters() { |
| BeforesAndAfters.watchedLog = new StringBuilder(); |
| JUnitCore.runClasses(BeforesAndAfters.class); |
| assertThat(BeforesAndAfters.watchedLog.toString(), |
| is("starting before test after succeeded finished ")); |
| } |
| |
| public static class WrongTypedField { |
| @Rule |
| public int x = 5; |
| |
| @Test |
| public void foo() { |
| } |
| } |
| |
| @Test |
| public void validateWrongTypedField() { |
| assertThat(testResult(WrongTypedField.class), |
| hasSingleFailureContaining("must implement MethodRule")); |
| } |
| |
| public static class SonOfWrongTypedField extends WrongTypedField { |
| |
| } |
| |
| @Test |
| public void validateWrongTypedFieldInSuperclass() { |
| assertThat(testResult(SonOfWrongTypedField.class), |
| hasSingleFailureContaining("must implement MethodRule")); |
| } |
| |
| public static class PrivateRule { |
| @Rule |
| private TestRule rule = new TestName(); |
| |
| @Test |
| public void foo() { |
| } |
| } |
| |
| @Test |
| public void validatePrivateRule() { |
| assertThat(testResult(PrivateRule.class), |
| hasSingleFailureContaining("must be public")); |
| } |
| |
| public static class CustomTestName implements TestRule { |
| public String name = null; |
| |
| public Statement apply(final Statement base, final Description description) { |
| return new Statement() { |
| @Override |
| public void evaluate() throws Throwable { |
| name = description.getMethodName(); |
| base.evaluate(); |
| } |
| }; |
| } |
| } |
| |
| public static class UsesCustomMethodRule { |
| @Rule |
| public CustomTestName counter = new CustomTestName(); |
| |
| @Test |
| public void foo() { |
| assertEquals("foo", counter.name); |
| } |
| } |
| |
| @Test |
| public void useCustomMethodRule() { |
| assertThat(testResult(UsesCustomMethodRule.class), isSuccessful()); |
| } |
| |
| public static class MethodExampleTest { |
| private TestRule example = new TestRule() { |
| public Statement apply(final Statement base, Description description) { |
| return new Statement() { |
| @Override |
| public void evaluate() throws Throwable { |
| wasRun = true; |
| base.evaluate(); |
| } |
| }; |
| } |
| }; |
| |
| @Rule |
| public TestRule getExample() { |
| return example; |
| } |
| |
| @Test |
| public void nothing() { |
| |
| } |
| } |
| |
| @Test |
| public void methodRuleIsIntroducedAndEvaluated() { |
| wasRun = false; |
| JUnitCore.runClasses(MethodExampleTest.class); |
| assertTrue(wasRun); |
| } |
| |
| public static class MethodBothKindsOfRule implements TestRule, org.junit.rules.MethodRule { |
| public int applications = 0; |
| |
| public Statement apply(Statement base, FrameworkMethod method, |
| Object target) { |
| applications++; |
| return base; |
| } |
| |
| public Statement apply(Statement base, Description description) { |
| applications++; |
| return base; |
| } |
| } |
| |
| public static class MethodOneFieldTwoKindsOfRule { |
| private MethodBothKindsOfRule both = new MethodBothKindsOfRule(); |
| |
| @Rule |
| public MethodBothKindsOfRule getBoth() { |
| return both; |
| } |
| |
| @Test |
| public void onlyOnce() { |
| assertEquals(1, both.applications); |
| } |
| } |
| |
| |
| @Test |
| public void methodOnlyApplyOnceEvenIfImplementsBothInterfaces() { |
| assertTrue(JUnitCore.runClasses(MethodOneFieldTwoKindsOfRule.class).wasSuccessful()); |
| } |
| |
| public static class MethodSonOfExampleTest extends MethodExampleTest { |
| |
| } |
| |
| @Test |
| public void methodRuleIsIntroducedAndEvaluatedOnSubclass() { |
| wasRun = false; |
| JUnitCore.runClasses(MethodSonOfExampleTest.class); |
| assertTrue(wasRun); |
| } |
| |
| public static class MethodMultipleRuleTest { |
| private static class Increment implements TestRule { |
| public Statement apply(final Statement base, Description description) { |
| return new Statement() { |
| @Override |
| public void evaluate() throws Throwable { |
| runCount++; |
| base.evaluate(); |
| } |
| }; |
| } |
| } |
| |
| private TestRule incrementor1 = new Increment(); |
| |
| @Rule |
| public TestRule getIncrementor1() { |
| return incrementor1; |
| } |
| |
| private TestRule incrementor2 = new Increment(); |
| |
| @Rule |
| public TestRule getIncrementor2() { |
| return incrementor2; |
| } |
| |
| @Test |
| public void nothing() { |
| |
| } |
| } |
| |
| @Test |
| public void methodMultipleRulesAreRun() { |
| runCount = 0; |
| JUnitCore.runClasses(MethodMultipleRuleTest.class); |
| assertEquals(2, runCount); |
| } |
| |
| public static class MethodNoRulesTest { |
| public int x; |
| |
| @Test |
| public void nothing() { |
| |
| } |
| } |
| |
| @Test |
| public void methodIgnoreNonRules() { |
| Result result = JUnitCore.runClasses(MethodNoRulesTest.class); |
| assertEquals(0, result.getFailureCount()); |
| } |
| |
| public static class BeforesAndAftersAreEnclosedByRule { |
| private static StringBuilder log; |
| |
| @Rule |
| public TestRule watcher = new LoggingTestWatcher(log); |
| |
| @Before |
| public void before() { |
| log.append("before "); |
| } |
| |
| @After |
| public void after() { |
| log.append("after "); |
| } |
| |
| @Test |
| public void succeeds() { |
| log.append("test "); |
| } |
| } |
| |
| @Test |
| public void beforesAndAftersAreEnclosedByRule() { |
| BeforesAndAftersAreEnclosedByRule.log = new StringBuilder(); |
| JUnitCore.runClasses(BeforesAndAftersAreEnclosedByRule.class); |
| assertEquals("starting before test after succeeded finished ", |
| BeforesAndAftersAreEnclosedByRule.log.toString()); |
| } |
| |
| public static class MethodWrongTypedField { |
| @Rule |
| public int getX() { |
| return 5; |
| } |
| |
| @Test |
| public void foo() { |
| } |
| } |
| |
| @Test |
| public void methodValidateWrongTypedField() { |
| assertThat(testResult(MethodWrongTypedField.class), |
| hasSingleFailureContaining("must return an implementation of MethodRule")); |
| } |
| |
| public static class MethodSonOfWrongTypedField extends MethodWrongTypedField { |
| |
| } |
| |
| @Test |
| public void methodValidateWrongTypedFieldInSuperclass() { |
| assertThat(testResult(MethodSonOfWrongTypedField.class), |
| hasSingleFailureContaining("must return an implementation of MethodRule")); |
| } |
| |
| public static class MethodPrivateRule { |
| @Rule |
| private TestRule getRule() { |
| return new TestName(); |
| } |
| |
| @Test |
| public void foo() { |
| } |
| } |
| |
| @Test |
| public void methodValidatePrivateRule() { |
| assertThat(testResult(MethodPrivateRule.class), |
| hasSingleFailureContaining("must be public")); |
| } |
| |
| public static class MethodUsesCustomMethodRule { |
| private CustomTestName counter = new CustomTestName(); |
| |
| @Rule |
| public CustomTestName getCounter() { |
| return counter; |
| } |
| |
| @Test |
| public void foo() { |
| assertEquals("foo", counter.name); |
| } |
| } |
| |
| @Test |
| public void methodUseCustomMethodRule() { |
| assertThat(testResult(MethodUsesCustomMethodRule.class), isSuccessful()); |
| } |
| |
| private static final List<String> orderList = new LinkedList<String>(); |
| |
| private static class OrderTestRule implements TestRule { |
| private String name; |
| |
| public OrderTestRule(String name) { |
| this.name = name; |
| } |
| |
| public Statement apply(final Statement base, final Description description) { |
| return new Statement() { |
| @Override |
| public void evaluate() throws Throwable { |
| orderList.add(name); |
| base.evaluate(); |
| } |
| }; |
| } |
| } |
| |
| public static class UsesFieldAndMethodRule { |
| @Rule |
| public OrderTestRule orderMethod() { |
| return new OrderTestRule("orderMethod"); |
| } |
| |
| @Rule |
| public OrderTestRule orderField = new OrderTestRule("orderField"); |
| |
| @Test |
| public void foo() { |
| assertEquals("orderField", orderList.get(0)); |
| assertEquals("orderMethod", orderList.get(1)); |
| } |
| } |
| |
| @Test |
| public void usesFieldAndMethodRule() { |
| orderList.clear(); |
| assertThat(testResult(UsesFieldAndMethodRule.class), isSuccessful()); |
| } |
| |
| public static class CallMethodOnlyOnceRule { |
| int countOfMethodCalls = 0; |
| |
| private static class Dummy implements TestRule { |
| public Statement apply(final Statement base, Description description) { |
| return new Statement() { |
| @Override |
| public void evaluate() throws Throwable { |
| base.evaluate(); |
| } |
| }; |
| } |
| } |
| |
| @Rule |
| public Dummy both() { |
| countOfMethodCalls++; |
| return new Dummy(); |
| } |
| |
| @Test |
| public void onlyOnce() { |
| assertEquals(1, countOfMethodCalls); |
| } |
| } |
| |
| @Test |
| public void testCallMethodOnlyOnceRule() { |
| assertTrue(JUnitCore.runClasses(CallMethodOnlyOnceRule.class).wasSuccessful()); |
| } |
| |
| private static final StringBuilder ruleLog = new StringBuilder(); |
| |
| public static class TestRuleIsAroundMethodRule { |
| @Rule |
| public final MethodRule z = new LoggingMethodRule(ruleLog, "methodRule"); |
| |
| @Rule |
| public final TestRule a = new LoggingTestRule(ruleLog, "testRule"); |
| |
| @Test |
| public void foo() { |
| ruleLog.append(" foo"); |
| } |
| } |
| |
| @Test |
| public void testRuleIsAroundMethodRule() { |
| ruleLog.setLength(0); |
| Result result = JUnitCore.runClasses(TestRuleIsAroundMethodRule.class); |
| assertTrue(result.wasSuccessful()); |
| assertEquals(" testRule.begin methodRule.begin foo methodRule.end testRule.end", |
| ruleLog.toString()); |
| } |
| |
| public static class TestRuleOrdering { |
| @Rule(order = 1) |
| public final TestRule a = new LoggingTestRule(ruleLog, "outer"); |
| |
| @Rule(order = 2) |
| public final TestRule z = new LoggingTestRule(ruleLog, "inner"); |
| |
| @Test |
| public void foo() { |
| ruleLog.append(" foo"); |
| } |
| } |
| |
| @Test |
| public void testRuleOrdering() { |
| ruleLog.setLength(0); |
| Result result = JUnitCore.runClasses(TestRuleOrdering.class); |
| assertTrue(result.wasSuccessful()); |
| assertEquals(" outer.begin inner.begin foo inner.end outer.end", ruleLog.toString()); |
| } |
| |
| public static class TestRuleOrderingWithMethodRule { |
| @Rule(order = 1) |
| public final MethodRule z = new LoggingMethodRule(ruleLog, "methodRule"); |
| |
| @Rule(order = 2) |
| public final TestRule a = new LoggingTestRule(ruleLog, "testRule"); |
| |
| @Test |
| public void foo() { |
| ruleLog.append(" foo"); |
| } |
| } |
| |
| @Test |
| public void testRuleOrderingWithMethodRule() { |
| ruleLog.setLength(0); |
| Result result = JUnitCore.runClasses(TestRuleOrderingWithMethodRule.class); |
| assertTrue(result.wasSuccessful()); |
| assertEquals(" methodRule.begin testRule.begin foo testRule.end methodRule.end", |
| ruleLog.toString()); |
| } |
| } |