| package org.junit.tests.running.methods; |
| |
| import static org.hamcrest.CoreMatchers.allOf; |
| import static org.hamcrest.CoreMatchers.containsString; |
| import static org.hamcrest.MatcherAssert.assertThat; |
| import static org.junit.experimental.results.PrintableResult.testResult; |
| import static org.junit.experimental.results.ResultMatchers.isSuccessful; |
| |
| import java.util.Collection; |
| import java.util.HashSet; |
| |
| import junit.framework.TestCase; |
| import junit.framework.TestSuite; |
| import org.junit.After; |
| import org.junit.AfterClass; |
| import org.junit.Before; |
| import org.junit.BeforeClass; |
| import org.junit.ClassRule; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.rules.ExternalResource; |
| import org.junit.rules.TestRule; |
| import org.junit.runner.Description; |
| import org.junit.runner.JUnitCore; |
| import org.junit.runner.Result; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| public class AnnotationTest extends TestCase { |
| static boolean run; |
| |
| @Override |
| public void setUp() { |
| run = false; |
| } |
| |
| public static class SimpleTest { |
| @Test |
| public void success() { |
| run = true; |
| } |
| } |
| |
| public void testAnnotatedMethod() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| runner.run(SimpleTest.class); |
| assertTrue(run); |
| } |
| |
| @RunWith(JUnit4.class) |
| public static class SimpleTestWithFutureProofExplicitRunner { |
| @Test |
| public void success() { |
| run = true; |
| } |
| } |
| |
| public void testAnnotatedMethodWithFutureProofExplicitRunner() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| runner.run(SimpleTestWithFutureProofExplicitRunner.class); |
| assertTrue(run); |
| } |
| |
| public static class SetupTest { |
| @Before |
| public void before() { |
| run = true; |
| } |
| |
| @Test |
| public void success() { |
| } |
| } |
| |
| public void testSetup() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| runner.run(SetupTest.class); |
| assertTrue(run); |
| } |
| |
| public static class TeardownTest { |
| @After |
| public void after() { |
| run = true; |
| } |
| |
| @Test |
| public void success() { |
| } |
| } |
| |
| public void testTeardown() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| runner.run(TeardownTest.class); |
| assertTrue(run); |
| } |
| |
| public static class FailureTest { |
| @Test |
| public void error() throws Exception { |
| org.junit.Assert.fail(); |
| } |
| } |
| |
| public void testRunFailure() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| Result result = runner.run(FailureTest.class); |
| assertEquals(1, result.getRunCount()); |
| assertEquals(1, result.getFailureCount()); |
| assertEquals(AssertionError.class, result.getFailures().get(0).getException().getClass()); |
| } |
| |
| public static class SetupFailureTest { |
| @Before |
| public void before() { |
| throw new Error(); |
| } |
| |
| @Test |
| public void test() { |
| run = true; |
| } |
| } |
| |
| public void testSetupFailure() throws Exception { |
| JUnitCore core = new JUnitCore(); |
| Result runner = core.run(SetupFailureTest.class); |
| assertEquals(1, runner.getRunCount()); |
| assertEquals(1, runner.getFailureCount()); |
| assertEquals(Error.class, runner.getFailures().get(0).getException().getClass()); |
| assertFalse(run); |
| } |
| |
| public static class TeardownFailureTest { |
| @After |
| public void after() { |
| throw new Error(); |
| } |
| |
| @Test |
| public void test() { |
| } |
| } |
| |
| public void testTeardownFailure() throws Exception { |
| JUnitCore core = new JUnitCore(); |
| Result runner = core.run(TeardownFailureTest.class); |
| assertEquals(1, runner.getRunCount()); |
| assertEquals(1, runner.getFailureCount()); |
| assertEquals(Error.class, runner.getFailures().get(0).getException().getClass()); |
| } |
| |
| public static class TestAndTeardownFailureTest { |
| @After |
| public void after() { |
| throw new Error("hereAfter"); |
| } |
| |
| @Test |
| public void test() throws Exception { |
| throw new Exception("inTest"); |
| } |
| } |
| |
| public void testTestAndTeardownFailure() throws Exception { |
| JUnitCore core = new JUnitCore(); |
| Result runner = core.run(TestAndTeardownFailureTest.class); |
| assertEquals(1, runner.getRunCount()); |
| assertEquals(2, runner.getFailureCount()); |
| assertThat(runner.getFailures().toString(), allOf(containsString("hereAfter"), containsString("inTest"))); |
| } |
| |
| public static class TeardownAfterFailureTest { |
| @After |
| public void after() { |
| run = true; |
| } |
| |
| @Test |
| public void test() throws Exception { |
| throw new Exception(); |
| } |
| } |
| |
| public void testTeardownAfterFailure() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| runner.run(TeardownAfterFailureTest.class); |
| assertTrue(run); |
| } |
| |
| static int count; |
| static Collection<Object> tests; |
| |
| public static class TwoTests { |
| @Test |
| public void one() { |
| count++; |
| tests.add(this); |
| } |
| |
| @Test |
| public void two() { |
| count++; |
| tests.add(this); |
| } |
| } |
| |
| public void testTwoTests() throws Exception { |
| count = 0; |
| tests = new HashSet<Object>(); |
| JUnitCore runner = new JUnitCore(); |
| runner.run(TwoTests.class); |
| assertEquals(2, count); |
| assertEquals(2, tests.size()); |
| } |
| |
| public static class OldTest extends TestCase { |
| public void test() { |
| run = true; |
| } |
| } |
| |
| public void testOldTest() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| runner.run(OldTest.class); |
| assertTrue(run); |
| } |
| |
| public static class OldSuiteTest extends TestCase { |
| public void testOne() { |
| run = true; |
| } |
| } |
| |
| public void testOldSuiteTest() throws Exception { |
| TestSuite suite = new TestSuite(OldSuiteTest.class); |
| JUnitCore runner = new JUnitCore(); |
| runner.run(suite); |
| assertTrue(run); |
| } |
| |
| public static class ExceptionTest { |
| @Test(expected = Error.class) |
| public void expectedException() { |
| throw new Error(); |
| } |
| } |
| |
| public void testException() throws Exception { |
| JUnitCore core = new JUnitCore(); |
| Result result = core.run(ExceptionTest.class); |
| assertEquals(0, result.getFailureCount()); |
| } |
| |
| public static class NoExceptionTest { |
| @Test(expected = Error.class) |
| public void expectedException() { |
| } |
| } |
| |
| public void testExceptionNotThrown() throws Exception { |
| JUnitCore core = new JUnitCore(); |
| Result result = core.run(NoExceptionTest.class); |
| assertEquals(1, result.getFailureCount()); |
| assertEquals("Expected exception: java.lang.Error", result.getFailures().get(0).getMessage()); |
| } |
| |
| public static class OneTimeSetup { |
| @BeforeClass |
| public static void once() { |
| count++; |
| } |
| |
| @Test |
| public void one() { |
| } |
| |
| @Test |
| public void two() { |
| } |
| } |
| |
| public void testOneTimeSetup() throws Exception { |
| count = 0; |
| JUnitCore core = new JUnitCore(); |
| core.run(OneTimeSetup.class); |
| assertEquals(1, count); |
| } |
| |
| public static class OneTimeTeardown { |
| @AfterClass |
| public static void once() { |
| count++; |
| } |
| |
| @Test |
| public void one() { |
| } |
| |
| @Test |
| public void two() { |
| } |
| } |
| |
| public void testOneTimeTeardown() throws Exception { |
| count = 0; |
| JUnitCore core = new JUnitCore(); |
| core.run(OneTimeTeardown.class); |
| assertEquals(1, count); |
| } |
| |
| static String log; |
| |
| public static class OrderTest { |
| @BeforeClass |
| public static void onceBefore() { |
| log += "beforeClass "; |
| } |
| |
| @Before |
| public void before() { |
| log += "before "; |
| } |
| |
| @Test |
| public void test() { |
| log += "test "; |
| } |
| |
| @After |
| public void after() { |
| log += "after "; |
| } |
| |
| @AfterClass |
| public static void onceAfter() { |
| log += "afterClass "; |
| } |
| } |
| |
| public void testOrder() throws Exception { |
| log = ""; |
| JUnitCore core = new JUnitCore(); |
| core.run(OrderTest.class); |
| assertEquals("beforeClass before test after afterClass ", log); |
| } |
| |
| public static class NonStaticOneTimeSetup { |
| @BeforeClass |
| public void once() { |
| } |
| |
| @Test |
| public void aTest() { |
| } |
| } |
| |
| public void testNonStaticOneTimeSetup() throws Exception { |
| JUnitCore core = new JUnitCore(); |
| Result result = core.run(NonStaticOneTimeSetup.class); |
| assertEquals(1, result.getFailureCount()); |
| } |
| |
| public static class ErrorInBeforeClass { |
| @BeforeClass |
| public static void before() throws Exception { |
| throw new Exception(); |
| } |
| |
| @Test |
| public void test() { |
| run = true; |
| } |
| } |
| |
| public void testErrorInBeforeClass() throws Exception { |
| run = false; |
| JUnitCore core = new JUnitCore(); |
| Result result = core.run(ErrorInBeforeClass.class); |
| assertFalse(run); |
| assertEquals(1, result.getFailureCount()); |
| Description description = result.getFailures().get(0).getDescription(); |
| assertEquals(ErrorInBeforeClass.class.getName(), description.getDisplayName()); |
| } |
| |
| public static class ErrorInAfterClass { |
| @Test |
| public void test() { |
| run = true; |
| } |
| |
| @AfterClass |
| public static void after() throws Exception { |
| throw new Exception(); |
| } |
| } |
| |
| public void testErrorInAfterClass() throws Exception { |
| run = false; |
| JUnitCore core = new JUnitCore(); |
| Result result = core.run(ErrorInAfterClass.class); |
| assertTrue(run); |
| assertEquals(1, result.getFailureCount()); |
| } |
| |
| static class SuperInheritance { |
| @BeforeClass |
| public static void beforeClassSuper() { |
| log += "Before class super "; |
| } |
| |
| @AfterClass |
| public static void afterClassSuper() { |
| log += "After class super "; |
| } |
| |
| @Before |
| public void beforeSuper() { |
| log += "Before super "; |
| } |
| |
| @After |
| public void afterSuper() { |
| log += "After super "; |
| } |
| } |
| |
| public static class SubInheritance extends SuperInheritance { |
| @BeforeClass |
| public static void beforeClassSub() { |
| log += "Before class sub "; |
| } |
| |
| @AfterClass |
| public static void afterClassSub() { |
| log += "After class sub "; |
| } |
| |
| @Before |
| public void beforeSub() { |
| log += "Before sub "; |
| } |
| |
| @After |
| public void afterSub() { |
| log += "After sub "; |
| } |
| |
| @Test |
| public void test() { |
| log += "Test "; |
| } |
| } |
| |
| public void testOrderingOfInheritance() throws Exception { |
| log = ""; |
| JUnitCore core = new JUnitCore(); |
| core.run(SubInheritance.class); |
| assertEquals("Before class super Before class sub Before super Before sub Test After sub After super After class sub After class super ", log); |
| } |
| |
| public abstract static class SuperShadowing { |
| |
| @Rule |
| public TestRule rule() { |
| return new ExternalResource() { |
| @Override |
| protected void before() throws Throwable { |
| log += "super.rule().before() "; |
| } |
| |
| @Override |
| protected void after() { |
| log += "super.rule().after() "; |
| } |
| }; |
| } |
| |
| @Before |
| public void before() { |
| log += "super.before() "; |
| } |
| |
| @After |
| public void after() { |
| log += "super.after() "; |
| } |
| } |
| |
| public static class SubShadowing extends SuperShadowing { |
| |
| @Override |
| @Rule |
| public TestRule rule() { |
| return new ExternalResource() { |
| @Override |
| protected void before() throws Throwable { |
| log += "sub.rule().before() "; |
| } |
| |
| @Override |
| protected void after() { |
| log += "sub.rule().after() "; |
| } |
| }; |
| } |
| |
| @Override |
| @Before |
| public void before() { |
| super.before(); |
| log += "sub.before() "; |
| } |
| |
| @Before |
| public void anotherBefore() { |
| log += "sub.anotherBefore() "; |
| } |
| |
| @Override |
| @After |
| public void after() { |
| log += "sub.after() "; |
| super.after(); |
| } |
| |
| @After |
| public void anotherAfter() { |
| log += "sub.anotherAfter() "; |
| } |
| |
| @Test |
| public void test() { |
| log += "Test "; |
| } |
| } |
| |
| public void testShadowing() throws Exception { |
| log = ""; |
| assertThat(testResult(SubShadowing.class), isSuccessful()); |
| assertEquals( |
| "sub.rule().before() sub.anotherBefore() super.before() sub.before() " |
| + "Test " |
| + "sub.anotherAfter() sub.after() super.after() sub.rule().after() ", |
| log); |
| } |
| |
| public abstract static class SuperStaticMethodShadowing { |
| |
| @ClassRule |
| public static TestRule rule() { |
| return new ExternalResource() { |
| @Override |
| protected void before() throws Throwable { |
| log += "super.rule().before() "; |
| } |
| |
| @Override |
| protected void after() { |
| log += "super.rule().after() "; |
| } |
| }; |
| } |
| } |
| |
| public static class SubStaticMethodShadowing extends SuperStaticMethodShadowing { |
| |
| @ClassRule |
| public static TestRule rule() { |
| return new ExternalResource() { |
| @Override |
| protected void before() throws Throwable { |
| log += "sub.rule().before() "; |
| } |
| |
| @Override |
| protected void after() { |
| log += "sub.rule().after() "; |
| } |
| }; |
| } |
| |
| @Test |
| public void test() { |
| log += "Test "; |
| } |
| } |
| |
| public void testStaticMethodsCanBeTreatedAsShadowed() throws Exception { |
| log = ""; |
| assertThat(testResult(SubStaticMethodShadowing.class), isSuccessful()); |
| assertEquals( |
| "sub.rule().before() " |
| + "Test " |
| + "sub.rule().after() ", |
| log); |
| } |
| |
| public abstract static class SuperFieldShadowing { |
| |
| @Rule |
| public final TestRule rule = new ExternalResource() { |
| @Override |
| protected void before() throws Throwable { |
| log += "super.rule.before() "; |
| } |
| |
| @Override |
| protected void after() { |
| log += "super.rule.after() "; |
| } |
| }; |
| } |
| |
| public static class SubFieldShadowing extends SuperFieldShadowing { |
| |
| @Rule |
| public final TestRule rule = new ExternalResource() { |
| @Override |
| protected void before() throws Throwable { |
| log += "sub.rule.before() "; |
| } |
| |
| @Override |
| protected void after() { |
| log += "sub.rule.after() "; |
| } |
| }; |
| |
| @Test |
| public void test() { |
| log += "Test "; |
| } |
| } |
| |
| public void testFieldsShadowFieldsFromParent() throws Exception { |
| log = ""; |
| assertThat(testResult(SubFieldShadowing.class), isSuccessful()); |
| assertEquals( |
| "sub.rule.before() " |
| + "Test " |
| + "sub.rule.after() ", |
| log); |
| } |
| |
| public abstract static class SuperStaticFieldShadowing { |
| |
| @ClassRule |
| public static TestRule rule = new ExternalResource() { |
| @Override |
| protected void before() throws Throwable { |
| log += "super.rule.before() "; |
| } |
| |
| @Override |
| protected void after() { |
| log += "super.rule.after() "; |
| } |
| }; |
| } |
| |
| public static class SubStaticFieldShadowing extends SuperStaticFieldShadowing { |
| |
| @ClassRule |
| public static TestRule rule = new ExternalResource() { |
| @Override |
| protected void before() throws Throwable { |
| log += "sub.rule.before() "; |
| } |
| |
| @Override |
| protected void after() { |
| log += "sub.rule.after() "; |
| } |
| }; |
| |
| @Test |
| public void test() { |
| log += "Test "; |
| } |
| } |
| |
| public void testStaticFieldsCanBeTreatedAsShadowed() throws Exception { |
| log = ""; |
| assertThat(testResult(SubStaticFieldShadowing.class), isSuccessful()); |
| assertEquals( |
| "sub.rule.before() " |
| + "Test " |
| + "sub.rule.after() ", |
| log); |
| } |
| |
| public static class SuperTest { |
| @Test |
| public void one() { |
| log += "Super"; |
| } |
| |
| @Test |
| public void two() { |
| log += "Two"; |
| } |
| } |
| |
| public static class SubTest extends SuperTest { |
| @Override |
| @Test |
| public void one() { |
| log += "Sub"; |
| } |
| } |
| |
| public void testTestInheritance() throws Exception { |
| log = ""; |
| JUnitCore core = new JUnitCore(); |
| core.run(SubTest.class); |
| // The order in which the test methods are called is unspecified |
| assertTrue(log.contains("Sub")); |
| assertTrue(log.contains("Two")); |
| assertFalse(log.contains("Super")); |
| } |
| |
| public static class RunAllAfters { |
| @Before |
| public void good() { |
| } |
| |
| @Before |
| public void bad() { |
| throw new Error(); |
| } |
| |
| @Test |
| public void empty() { |
| } |
| |
| @After |
| public void one() { |
| log += "one"; |
| } |
| |
| @After |
| public void two() { |
| log += "two"; |
| } |
| } |
| |
| public void testRunAllAfters() { |
| log = ""; |
| JUnitCore core = new JUnitCore(); |
| core.run(RunAllAfters.class); |
| assertTrue(log.contains("one")); |
| assertTrue(log.contains("two")); |
| } |
| |
| public static class RunAllAftersRegardless { |
| @Test |
| public void empty() { |
| } |
| |
| @After |
| public void one() { |
| log += "one"; |
| throw new Error(); |
| } |
| |
| @After |
| public void two() { |
| log += "two"; |
| throw new Error(); |
| } |
| } |
| |
| public void testRunAllAftersRegardless() { |
| log = ""; |
| JUnitCore core = new JUnitCore(); |
| Result result = core.run(RunAllAftersRegardless.class); |
| assertTrue(log.contains("one")); |
| assertTrue(log.contains("two")); |
| assertEquals(2, result.getFailureCount()); |
| } |
| |
| public static class RunAllAfterClasses { |
| @Before |
| public void good() { |
| } |
| |
| @BeforeClass |
| public static void bad() { |
| throw new Error(); |
| } |
| |
| @Test |
| public void empty() { |
| } |
| |
| @AfterClass |
| public static void one() { |
| log += "one"; |
| } |
| |
| @AfterClass |
| public static void two() { |
| log += "two"; |
| } |
| } |
| |
| public void testRunAllAfterClasses() { |
| log = ""; |
| JUnitCore core = new JUnitCore(); |
| core.run(RunAllAfterClasses.class); |
| assertTrue(log.contains("one")); |
| assertTrue(log.contains("two")); |
| } |
| |
| public static class RunAllAfterClassesRegardless { |
| @Test |
| public void empty() { |
| } |
| |
| @AfterClass |
| public static void one() { |
| log += "one"; |
| throw new Error(); |
| } |
| |
| @AfterClass |
| public static void two() { |
| log += "two"; |
| throw new Error(); |
| } |
| } |
| |
| public void testRunAllAfterClassesRegardless() { |
| log = ""; |
| JUnitCore core = new JUnitCore(); |
| Result result = core.run(RunAllAfterClassesRegardless.class); |
| assertTrue(log.contains("one")); |
| assertTrue(log.contains("two")); |
| assertEquals(2, result.getFailureCount()); |
| } |
| } |