diff options
Diffstat (limited to 'junit4/src/test/java/org/junit/tests/running/methods')
6 files changed, 1028 insertions, 0 deletions
diff --git a/junit4/src/test/java/org/junit/tests/running/methods/AnnotationTest.java b/junit4/src/test/java/org/junit/tests/running/methods/AnnotationTest.java new file mode 100644 index 0000000..2eb496a --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/methods/AnnotationTest.java @@ -0,0 +1,520 @@ +package org.junit.tests.running.methods; + +import static org.junit.Assert.assertThat; +import static org.junit.matchers.JUnitMatchers.both; +import static org.junit.matchers.JUnitMatchers.containsString; + +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; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +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); + } + + @RunWith(JUnit4.class) + static public class SimpleTestWithFutureProofExplicitRunner { + @Test public void success() { + run= true; + } + } + + public void testAnnotatedMethodWithFutureProofExplicitRunner() throws Exception { + JUnitCore runner= new JUnitCore(); + runner.run(SimpleTestWithFutureProofExplicitRunner.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("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(), both(containsString("hereAfter")).and(containsString("inTest"))); + } + + 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() { + } + + @Test public void aTest() { + } + } + + 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()); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/methods/ExpectedTest.java b/junit4/src/test/java/org/junit/tests/running/methods/ExpectedTest.java new file mode 100644 index 0000000..d16e689 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/methods/ExpectedTest.java @@ -0,0 +1,58 @@ +package org.junit.tests.running.methods; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import org.junit.Test; +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; +import org.junit.runner.notification.Failure; + +public class ExpectedTest { + + public static class Expected { + @Test(expected= Exception.class) public void expected() throws Exception { + throw new Exception(); + } + } + + @Test public void expected() { + JUnitCore core= new JUnitCore(); + Result result= core.run(Expected.class); + assertTrue(result.wasSuccessful()); + } + + public static class Unexpected { + @Test(expected= Exception.class) public void expected() throws Exception { + throw new Error(); + } + } + @Test public void unexpected() { + Result result= JUnitCore.runClasses(Unexpected.class); + Failure failure= result.getFailures().get(0); + String message= failure.getMessage(); + assertTrue(message.contains("expected<java.lang.Exception> but was<java.lang.Error>")); + assertEquals(Error.class, failure.getException().getCause().getClass()); + } + + public static class NoneThrown { + @Test(expected= Exception.class) public void nothing() { + } + } + @Test public void noneThrown() { + JUnitCore core= new JUnitCore(); + Result result= core.run(NoneThrown.class); + assertFalse(result.wasSuccessful()); + String message= result.getFailures().get(0).getMessage(); + assertTrue(message.contains("Expected exception: java.lang.Exception")); + } + + public static class ExpectSuperclass { + @Test(expected= RuntimeException.class) public void throwsSubclass() { + throw new ClassCastException(); + } + } + @Test public void expectsSuperclass() { + assertTrue(new JUnitCore().run(ExpectSuperclass.class).wasSuccessful()); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/methods/InheritedTestTest.java b/junit4/src/test/java/org/junit/tests/running/methods/InheritedTestTest.java new file mode 100644 index 0000000..15f55a6 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/methods/InheritedTestTest.java @@ -0,0 +1,31 @@ +package org.junit.tests.running.methods; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; + +public class InheritedTestTest { + public abstract static class Super { + @Test public void nothing() {} + } + public static class Sub extends Super {} + + @Test public void subclassWithOnlyInheritedTestsRuns() { + Result result= JUnitCore.runClasses(Sub.class); + assertTrue(result.wasSuccessful()); + } + + public static class SubWithBefore extends Super { + @Before public void gack() { + fail(); + } + } + + @Test public void subclassWithInheritedTestAndOwnBeforeRunsBefore() { + assertFalse(JUnitCore.runClasses(SubWithBefore.class).wasSuccessful()); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/methods/ParameterizedTestMethodTest.java b/junit4/src/test/java/org/junit/tests/running/methods/ParameterizedTestMethodTest.java new file mode 100644 index 0000000..4d4dcbd --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/methods/ParameterizedTestMethodTest.java @@ -0,0 +1,102 @@ +package org.junit.tests.running.methods; + +import static org.junit.Assert.assertEquals; + +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +import junit.framework.JUnit4TestAdapter; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.BlockJUnit4ClassRunner; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; +import org.junit.runners.model.InitializationError; + +@RunWith(Parameterized.class) +public class ParameterizedTestMethodTest { + + @SuppressWarnings("all") + public static class EverythingWrong { + private EverythingWrong() {} + @BeforeClass public void notStaticBC() {} + @BeforeClass static void notPublicBC() {} + @BeforeClass public static int nonVoidBC() { return 0; } + @BeforeClass public static void argumentsBC(int i) {} + @BeforeClass public static void fineBC() {} + @AfterClass public void notStaticAC() {} + @AfterClass static void notPublicAC() {} + @AfterClass public static int nonVoidAC() { return 0; } + @AfterClass public static void argumentsAC(int i) {} + @AfterClass public static void fineAC() {} + @After public static void staticA() {} + @After void notPublicA() {} + @After public int nonVoidA() { return 0; } + @After public void argumentsA(int i) {} + @After public void fineA() {} + @Before public static void staticB() {} + @Before void notPublicB() {} + @Before public int nonVoidB() { return 0; } + @Before public void argumentsB(int i) {} + @Before public void fineB() {} + @Test public static void staticT() {} + @Test void notPublicT() {} + @Test public int nonVoidT() { return 0; } + @Test public void argumentsT(int i) {} + @Test public void fineT() {} + } + + private Class<?> fClass; + private int fErrorCount; + + static public class SuperWrong { + @Test void notPublic() { + } + } + + static public class SubWrong extends SuperWrong { + @Test public void justFine() { + } + } + + static public class SubShadows extends SuperWrong { + @Override + @Test public void notPublic() { + } + } + + public ParameterizedTestMethodTest(Class<?> class1, int errorCount) { + fClass= class1; + fErrorCount= errorCount; + } + + @Parameters + public static Collection<Object[]> params() { + return Arrays.asList(new Object[][] { + { EverythingWrong.class, 1 + 4 * 5 }, { SubWrong.class, 1 }, + { SubShadows.class, 0 } }); + } + + private List<Throwable> validateAllMethods(Class<?> clazz) { + try { + new BlockJUnit4ClassRunner(clazz); + } catch (InitializationError e) { + return e.getCauses(); + } + return Collections.emptyList(); + } + + @Test public void testFailures() throws Exception { + List<Throwable> problems= validateAllMethods(fClass); + assertEquals(fErrorCount, problems.size()); + } + public static junit.framework.Test suite() { + return new JUnit4TestAdapter(ParameterizedTestMethodTest.class); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/methods/TestMethodTest.java b/junit4/src/test/java/org/junit/tests/running/methods/TestMethodTest.java new file mode 100644 index 0000000..cbabab2 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/methods/TestMethodTest.java @@ -0,0 +1,147 @@ +package org.junit.tests.running.methods; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.util.Collections; +import java.util.List; + +import junit.framework.JUnit4TestAdapter; +import junit.framework.TestResult; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; +import org.junit.runners.BlockJUnit4ClassRunner; +import org.junit.runners.model.InitializationError; + +public class TestMethodTest { + + @SuppressWarnings("all") + public static class EverythingWrong { + private EverythingWrong() {} + @BeforeClass public void notStaticBC() {} + @BeforeClass static void notPublicBC() {} + @BeforeClass public static int nonVoidBC() { return 0; } + @BeforeClass public static void argumentsBC(int i) {} + @BeforeClass public static void fineBC() {} + @AfterClass public void notStaticAC() {} + @AfterClass static void notPublicAC() {} + @AfterClass public static int nonVoidAC() { return 0; } + @AfterClass public static void argumentsAC(int i) {} + @AfterClass public static void fineAC() {} + @After public static void staticA() {} + @After void notPublicA() {} + @After public int nonVoidA() { return 0; } + @After public void argumentsA(int i) {} + @After public void fineA() {} + @Before public static void staticB() {} + @Before void notPublicB() {} + @Before public int nonVoidB() { return 0; } + @Before public void argumentsB(int i) {} + @Before public void fineB() {} + @Test public static void staticT() {} + @Test void notPublicT() {} + @Test public int nonVoidT() { return 0; } + @Test public void argumentsT(int i) {} + @Test public void fineT() {} + } + + @Test public void testFailures() throws Exception { + List<Throwable> problems= validateAllMethods(EverythingWrong.class); + int errorCount= 1 + 4 * 5; // missing constructor plus four invalid methods for each annotation */ + assertEquals(errorCount, problems.size()); + } + + static public class SuperWrong { + @Test void notPublic() { + } + } + + static public class SubWrong extends SuperWrong { + @Test public void justFine() { + } + } + + @Test public void validateInheritedMethods() throws Exception { + List<Throwable> problems= validateAllMethods(SubWrong.class); + assertEquals(1, problems.size()); + } + + static public class SubShadows extends SuperWrong { + @Override + @Test public void notPublic() { + } + } + + @Test public void dontValidateShadowedMethods() throws Exception { + List<Throwable> problems= validateAllMethods(SubShadows.class); + assertTrue(problems.isEmpty()); + } + + private List<Throwable> validateAllMethods(Class<?> clazz) { + try { + new BlockJUnit4ClassRunner(clazz); + } catch (InitializationError e) { + return e.getCauses(); + } + return Collections.emptyList(); + } + + static public class IgnoredTest { + @Test public void valid() {} + @Ignore @Test public void ignored() {} + @Ignore("For testing purposes") @Test public void withReason() {} + } + + @Test public void ignoreRunner() { + JUnitCore runner= new JUnitCore(); + Result result= runner.run(IgnoredTest.class); + assertEquals(2, result.getIgnoreCount()); + assertEquals(1, result.getRunCount()); + } + + @Test public void compatibility() { + TestResult result= new TestResult(); + new JUnit4TestAdapter(IgnoredTest.class).run(result); + assertEquals(1, result.runCount()); + } + + public static class Confused { + @Test public void a(Object b) { + } + + @Test public void a() { + } + } + + @Test(expected=InitializationError.class) public void overloaded() throws InitializationError { + new BlockJUnit4ClassRunner(Confused.class); + } + + public static class ConstructorParameter { + public ConstructorParameter(Object something) { + } + + @Test public void a() { + } + } + + @Test(expected=InitializationError.class) public void constructorParameter() throws InitializationError { + new BlockJUnit4ClassRunner(ConstructorParameter.class); + } + + public static class OnlyTestIsIgnored { + @Ignore @Test public void ignored() {} + } + + @Test public void onlyIgnoredMethodsIsStillFineTestClass() { + Result result= JUnitCore.runClasses(OnlyTestIsIgnored.class); + assertEquals(0, result.getFailureCount()); + assertEquals(1, result.getIgnoreCount()); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/methods/TimeoutTest.java b/junit4/src/test/java/org/junit/tests/running/methods/TimeoutTest.java new file mode 100644 index 0000000..777b0bd --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/methods/TimeoutTest.java @@ -0,0 +1,170 @@ +package org.junit.tests.running.methods; + +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.junit.matchers.JUnitMatchers.containsString; + +import java.io.PrintWriter; +import java.io.StringWriter; +import java.io.Writer; + +import junit.framework.JUnit4TestAdapter; +import junit.framework.TestResult; +import org.junit.After; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; + +public class TimeoutTest { + + static public class FailureWithTimeoutTest { + @Test(timeout= 1000) public void failure() { + fail(); + } + } + + @Test public void failureWithTimeout() throws Exception { + JUnitCore core= new JUnitCore(); + Result result= core.run(FailureWithTimeoutTest.class); + assertEquals(1, result.getRunCount()); + assertEquals(1, result.getFailureCount()); + assertEquals(AssertionError.class, result.getFailures().get(0).getException().getClass()); + } + + static public class FailureWithTimeoutRunTimeExceptionTest { + @Test(timeout= 1000) public void failure() { + throw new NullPointerException(); + } + } + + @Test public void failureWithTimeoutRunTimeException() throws Exception { + JUnitCore core= new JUnitCore(); + Result result= core.run(FailureWithTimeoutRunTimeExceptionTest.class); + assertEquals(1, result.getRunCount()); + assertEquals(1, result.getFailureCount()); + assertEquals(NullPointerException.class, result.getFailures().get(0).getException().getClass()); + } + + static public class SuccessWithTimeoutTest { + @Test(timeout= 1000) public void success() { + } + } + + @Test public void successWithTimeout() throws Exception { + JUnitCore core= new JUnitCore(); + Result result= core.run(SuccessWithTimeoutTest.class); + assertEquals(1, result.getRunCount()); + assertEquals(0, result.getFailureCount()); + } + + static public class TimeoutFailureTest { + @Test(timeout= 100) public void success() throws InterruptedException { + Thread.sleep(40000); + } + } + + @Ignore("was breaking gump") + @Test public void timeoutFailure() throws Exception { + JUnitCore core= new JUnitCore(); + Result result= core.run(TimeoutFailureTest.class); + assertEquals(1, result.getRunCount()); + assertEquals(1, result.getFailureCount()); + assertEquals(InterruptedException.class, result.getFailures().get(0).getException().getClass()); + } + + static public class InfiniteLoopTest { + @Test(timeout= 100) public void failure() { + infiniteLoop(); + } + + private void infiniteLoop() { + for(;;) + try { + Thread.sleep(10); + } catch (InterruptedException e) { + } + } + } + + @Test public void infiniteLoop() throws Exception { + JUnitCore core= new JUnitCore(); + Result result= core.run(InfiniteLoopTest.class); + assertEquals(1, result.getRunCount()); + assertEquals(1, result.getFailureCount()); + Throwable exception= result.getFailures().get(0).getException(); + assertTrue(exception.getMessage().contains("test timed out after 100 milliseconds")); + } + + static public class ImpatientLoopTest { + @Test(timeout= 1) public void failure() { + infiniteLoop(); + } + + private void infiniteLoop() { + for(;;); + } + } + + @Ignore("This breaks sporadically with time differences just slightly more than 200ms") + @Test public void infiniteLoopRunsForApproximatelyLengthOfTimeout() throws Exception { + // "prime the pump": running these beforehand makes the runtimes more predictable + // (because of class loading?) + JUnitCore.runClasses(InfiniteLoopTest.class, ImpatientLoopTest.class); + long longTime= runAndTime(InfiniteLoopTest.class); + long shortTime= runAndTime(ImpatientLoopTest.class); + long difference= longTime - shortTime; + assertTrue(String.format("Difference was %sms", difference), difference < 200); + } + + private long runAndTime(Class<?> clazz) { + JUnitCore core= new JUnitCore(); + long startTime= System.currentTimeMillis(); + core.run(clazz); + long totalTime = System.currentTimeMillis() - startTime; + return totalTime; + } + + @Test public void stalledThreadAppearsInStackTrace() throws Exception { + JUnitCore core= new JUnitCore(); + Result result= core.run(InfiniteLoopTest.class); + assertEquals(1, result.getRunCount()); + assertEquals(1, result.getFailureCount()); + Throwable exception= result.getFailures().get(0).getException(); + Writer buffer= new StringWriter(); + PrintWriter writer= new PrintWriter(buffer); + exception.printStackTrace(writer); + assertThat(buffer.toString(), containsString("infiniteLoop")); // Make sure we have the stalled frame on the stack somewhere + } + + @Test public void compatibility() { + TestResult result= new TestResult(); + new JUnit4TestAdapter(InfiniteLoopTest.class).run(result); + assertEquals(1, result.errorCount()); + } + + public static class WillTimeOut { + static boolean afterWasCalled= false; + + @Test(timeout=1) public void test() { + for(;;) + try { + Thread.sleep(10000); + } catch (InterruptedException e) { + // ok, tests are over + } + } + + @After public void after() { + afterWasCalled= true; + } + } + + @Test public void makeSureAfterIsCalledAfterATimeout() { + JUnitCore.runClasses(WillTimeOut.class); + assertThat(WillTimeOut.afterWasCalled, is(true)); + } +} |