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