package org.junit.tests; 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.Test; import org.junit.runner.Description; import org.junit.runner.JUnitCore; import org.junit.runner.Result; public class AnnotationTest extends TestCase { static boolean run; @Override public void setUp() { run= false; } static public class SimpleTest { @Test public void success() { run= true; } } public void testAnnotatedMethod() throws Exception { JUnitCore runner= new JUnitCore(); runner.run(SimpleTest.class); assertTrue(run); } static public 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); } static public 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); } static public 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()); } static public 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); } static public 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()); } static public class TestAndTeardownFailureTest { @After public void after() { throw new Error(); } @Test public void test() throws Exception { throw new Exception(); } } public void testTestAndTeardownFailure() throws Exception { JUnitCore core= new JUnitCore(); Result runner= core.run(TestAndTeardownFailureTest.class); assertEquals(1, runner.getRunCount()); assertEquals(2, runner.getFailureCount()); assertEquals(Exception.class, runner.getFailures().get(0).getException().getClass()); assertEquals(Error.class, runner.getFailures().get(1).getException().getClass()); } static public 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; static public 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()); } static public class OldTest extends TestCase { public void test() { run= true; } } public void testOldTest() throws Exception { JUnitCore runner= new JUnitCore(); runner.run(OldTest.class); assertTrue(run); } static public 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); } static public 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()); } static public 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()); } static public 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); } static public 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); } static public class NonStaticOneTimeSetup { @BeforeClass public void once() { } } public void testNonStaticOneTimeSetup() throws Exception { JUnitCore core= new JUnitCore(); Result result= core.run(NonStaticOneTimeSetup.class); assertEquals(1, result.getFailureCount()); } static public 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()); } static public 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 public class SuperInheritance { @BeforeClass static public void beforeClassSuper() { log+= "Before class super "; } @AfterClass static public void afterClassSuper() { log+= "After class super "; } @Before public void beforeSuper() { log+= "Before super "; } @After public void afterSuper() { log+= "After super "; } } static public class SubInheritance extends SuperInheritance { @BeforeClass static public void beforeClassSub() { log+= "Before class sub "; } @AfterClass static public 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); } static public class SuperShadowing { @Before public void before() { log+= "Before super "; } @After public void after() { log+= "After super "; } } static public class SubShadowing extends SuperShadowing { @Override @Before public void before() { log+= "Before sub "; } @Override @After public void after() { log+= "After sub "; } @Test public void test() { log+= "Test "; } } public void testShadowing() throws Exception { log= ""; JUnitCore core= new JUnitCore(); core.run(SubShadowing.class); assertEquals("Before sub Test After sub ", log); } static public class SuperTest { @Test public void one() { log+= "Super"; } @Test public void two() { log+= "Two"; } } static public 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")); } static public 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")); } static public 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()); } static public 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")); } static public class RunAllAfterClassesRegardless { @Test public void empty() { } @AfterClass static public void one() { log+= "one"; throw new Error(); } @AfterClass static public 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()); } }