diff options
Diffstat (limited to 'junit4/src/test/java/org/junit/tests/running')
19 files changed, 2206 insertions, 0 deletions
diff --git a/junit4/src/test/java/org/junit/tests/running/classes/BlockJUnit4ClassRunnerTest.java b/junit4/src/test/java/org/junit/tests/running/classes/BlockJUnit4ClassRunnerTest.java new file mode 100644 index 0000000..a19cd94 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/classes/BlockJUnit4ClassRunnerTest.java @@ -0,0 +1,33 @@ +package org.junit.tests.running.classes; + +import static org.junit.Assert.assertEquals; + +import java.util.List; + +import org.junit.Test; +import org.junit.runners.BlockJUnit4ClassRunner; +import org.junit.runners.model.InitializationError; + +public class BlockJUnit4ClassRunnerTest { + public static class OuterClass { + public class Enclosed { + @Test + public void test() { + } + } + } + + @Test + public void detectNonStaticEnclosedClass() throws Exception { + try { + new BlockJUnit4ClassRunner(OuterClass.Enclosed.class); + } catch (InitializationError e) { + List<Throwable> causes= e.getCauses(); + assertEquals("Wrong number of causes.", 1, causes.size()); + assertEquals( + "Wrong exception.", + "The inner class org.junit.tests.running.classes.BlockJUnit4ClassRunnerTest$OuterClass$Enclosed is not static.", + causes.get(0).getMessage()); + } + } +}
\ No newline at end of file diff --git a/junit4/src/test/java/org/junit/tests/running/classes/EnclosedTest.java b/junit4/src/test/java/org/junit/tests/running/classes/EnclosedTest.java new file mode 100644 index 0000000..8a6973a --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/classes/EnclosedTest.java @@ -0,0 +1,40 @@ +package org.junit.tests.running.classes; + +import static org.junit.Assert.assertEquals; +import org.junit.Test; +import org.junit.experimental.runners.Enclosed; +import org.junit.runner.JUnitCore; +import org.junit.runner.Request; +import org.junit.runner.Result; +import org.junit.runner.RunWith; +import org.junit.runner.Runner; + +public class EnclosedTest { + @RunWith(Enclosed.class) + public static class Enclosing { + public static class A { + @Test public void a() {} + @Test public void b() {} + } + public static class B { + @Test public void a() {} + @Test public void b() {} + @Test public void c() {} + } + } + + @Test public void enclosedRunnerPlansEnclosedClasses() throws Exception { + Runner runner= Request.aClass(Enclosing.class).getRunner(); + assertEquals(5, runner.testCount()); + } + + @Test public void enclosedRunnerRunsEnclosedClasses() throws Exception { + Result result= JUnitCore.runClasses(Enclosing.class); + assertEquals(5, result.getRunCount()); + } + + @Test public void enclosedRunnerIsNamedForEnclosingClass() throws Exception { + assertEquals(Enclosing.class.getName(), Request.aClass(Enclosing.class) + .getRunner().getDescription().getDisplayName()); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/classes/IgnoreClassTest.java b/junit4/src/test/java/org/junit/tests/running/classes/IgnoreClassTest.java new file mode 100644 index 0000000..e193712 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/classes/IgnoreClassTest.java @@ -0,0 +1,26 @@ +package org.junit.tests.running.classes; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; + +public class IgnoreClassTest { + @Ignore("For a good reason") public static class IgnoreMe { + @Test public void iFail() { + fail(); + } + + @Test public void iFailToo() { + fail(); + } + } + + @Test public void ignoreClass() { + Result result= JUnitCore.runClasses(IgnoreMe.class); + assertEquals(0, result.getFailureCount()); + assertEquals(1, result.getIgnoreCount()); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/classes/ParameterizedTestTest.java b/junit4/src/test/java/org/junit/tests/running/classes/ParameterizedTestTest.java new file mode 100644 index 0000000..d48433f --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/classes/ParameterizedTestTest.java @@ -0,0 +1,216 @@ +package org.junit.tests.running.classes; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; +import static org.junit.experimental.results.PrintableResult.testResult; +import static org.junit.matchers.JUnitMatchers.containsString; + +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; + +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.Description; +import org.junit.runner.JUnitCore; +import org.junit.runner.Request; +import org.junit.runner.Result; +import org.junit.runner.RunWith; +import org.junit.runner.Runner; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; +import org.junit.runners.model.InitializationError; + +public class ParameterizedTestTest { + @RunWith(Parameterized.class) + static public class FibonacciTest { + @Parameters + public static Collection<Object[]> data() { + return Arrays.asList(new Object[][] { { 0, 0 }, { 1, 1 }, { 2, 1 }, + { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 } }); + } + + private int fInput; + + private int fExpected; + + public FibonacciTest(int input, int expected) { + fInput= input; + fExpected= expected; + } + + @Test + public void test() { + assertEquals(fExpected, fib(fInput)); + } + + private int fib(int x) { + return 0; + } + } + + @Test + public void count() { + Result result= JUnitCore.runClasses(FibonacciTest.class); + assertEquals(7, result.getRunCount()); + assertEquals(6, result.getFailureCount()); + } + + @Test + public void failuresNamedCorrectly() { + Result result= JUnitCore.runClasses(FibonacciTest.class); + assertEquals(String + .format("test[1](%s)", FibonacciTest.class.getName()), result + .getFailures().get(0).getTestHeader()); + } + + @Test + public void countBeforeRun() throws Exception { + Runner runner= Request.aClass(FibonacciTest.class).getRunner(); + assertEquals(7, runner.testCount()); + } + + @Test + public void plansNamedCorrectly() throws Exception { + Runner runner= Request.aClass(FibonacciTest.class).getRunner(); + Description description= runner.getDescription(); + assertEquals("[0]", description.getChildren().get(0).getDisplayName()); + } + + private static String fLog; + + @RunWith(Parameterized.class) + static public class BeforeAndAfter { + @BeforeClass + public static void before() { + fLog+= "before "; + } + + @AfterClass + public static void after() { + fLog+= "after "; + } + + public BeforeAndAfter(int x) { + + } + + @Parameters + public static Collection<Object[]> data() { + return Arrays.asList(new Object[][] { { 3 } }); + } + + @Test + public void aTest() { + } + } + + @Test + public void beforeAndAfterClassAreRun() { + fLog= ""; + JUnitCore.runClasses(BeforeAndAfter.class); + assertEquals("before after ", fLog); + } + + @RunWith(Parameterized.class) + static public class EmptyTest { + @BeforeClass + public static void before() { + fLog+= "before "; + } + + @AfterClass + public static void after() { + fLog+= "after "; + } + } + + @Test + public void validateClassCatchesNoParameters() { + Result result= JUnitCore.runClasses(EmptyTest.class); + assertEquals(1, result.getFailureCount()); + } + + @RunWith(Parameterized.class) + static public class IncorrectTest { + @Test + public int test() { + return 0; + } + + @Parameters + public static Collection<Object[]> data() { + return Collections.singletonList(new Object[] {1}); + } + } + + @Test + public void failuresAddedForBadTestMethod() throws Exception { + Result result= JUnitCore.runClasses(IncorrectTest.class); + assertEquals(1, result.getFailureCount()); + } + + @RunWith(Parameterized.class) + static public class ProtectedParametersTest { + @Parameters + protected static Collection<Object[]> data() { + return Collections.emptyList(); + } + + @Test + public void aTest() { + } + } + + @Test + public void meaningfulFailureWhenParametersNotPublic() throws Exception { + Result result= JUnitCore.runClasses(ProtectedParametersTest.class); + String expected= String.format( + "No public static parameters method on class %s", + ProtectedParametersTest.class.getName()); + assertEquals(expected, result.getFailures().get(0).getMessage()); + } + + @RunWith(Parameterized.class) + static public class WrongElementType { + @Parameters + public static Collection<String> data() { + return Arrays.asList("a", "b", "c"); + } + + @Test + public void aTest() { + } + } + + @Test + public void meaningfulFailureWhenParameterListsAreNotArrays() { + String expected= String.format( + "%s.data() must return a Collection of arrays.", + WrongElementType.class.getName()); + assertThat(testResult(WrongElementType.class).toString(), + containsString(expected)); + } + + @RunWith(Parameterized.class) + static public class PrivateConstructor { + private PrivateConstructor(int x) { + + } + + @Parameters + public static Collection<Object[]> data() { + return Arrays.asList(new Object[][] { { 3 } }); + } + + @Test + public void aTest() { + } + } + + @Test(expected=InitializationError.class) + public void exceptionWhenPrivateConstructor() throws Throwable { + new Parameterized(PrivateConstructor.class); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/classes/ParentRunnerFilteringTest.java b/junit4/src/test/java/org/junit/tests/running/classes/ParentRunnerFilteringTest.java new file mode 100644 index 0000000..9bf542f --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/classes/ParentRunnerFilteringTest.java @@ -0,0 +1,171 @@ +package org.junit.tests.running.classes; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.fail; +import static org.junit.experimental.results.PrintableResult.testResult; +import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining; +import static org.junit.runner.Description.createSuiteDescription; +import static org.junit.runner.Description.createTestDescription; + +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Test; +import org.junit.runner.Description; +import org.junit.runner.JUnitCore; +import org.junit.runner.Request; +import org.junit.runner.Result; +import org.junit.runner.RunWith; +import org.junit.runner.Runner; +import org.junit.runner.manipulation.Filter; +import org.junit.runner.manipulation.NoTestsRemainException; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; +import org.junit.runners.model.InitializationError; +import org.junit.runners.model.RunnerBuilder; + +public class ParentRunnerFilteringTest { + private static Filter notThisMethodName(final String methodName) { + return new Filter() { + @Override + public boolean shouldRun(Description description) { + return description.getMethodName() == null + || !description.getMethodName().equals(methodName); + } + + @Override + public String describe() { + return "don't run method name: " + methodName; + } + }; + } + + private static class CountingFilter extends Filter { + private final Map<Description, Integer> countMap= new HashMap<Description, Integer>(); + + @Override + public boolean shouldRun(Description description) { + Integer count= countMap.get(description); + if (count == null) { + countMap.put(description, 1); + } else { + countMap.put(description, count + 1); + } + return true; + } + + @Override + public String describe() { + return "filter counter"; + } + + public int getCount(final Description desc) { + if (!countMap.containsKey(desc)) { + throw new IllegalArgumentException("Looking for " + desc + + ", but only contains: " + countMap.keySet()); + } + return countMap.get(desc); + } + } + + public static class ExampleTest { + @Test + public void test1() throws Exception { + // passes + } + } + + @RunWith(Suite.class) + @SuiteClasses({ ExampleTest.class }) + public static class ExampleSuite { + } + + @Test + public void testSuiteFiltering() throws Exception { + Runner runner= Request.aClass(ExampleSuite.class).getRunner(); + Filter filter= notThisMethodName("test1"); + try { + filter.apply(runner); + } catch (NoTestsRemainException e) { + return; + } + fail("Expected 'NoTestsRemainException' due to complete filtering"); + } + + public static class SuiteWithUnmodifyableChildList extends Suite { + + public SuiteWithUnmodifyableChildList( + Class<?> klass, RunnerBuilder builder) + throws InitializationError { + super(klass, builder); + } + + @Override + protected List<Runner> getChildren() { + return Collections.unmodifiableList(super.getChildren()); + } + } + + @RunWith(SuiteWithUnmodifyableChildList.class) + @SuiteClasses({ ExampleTest.class }) + public static class ExampleSuiteWithUnmodifyableChildList { + } + + @Test + public void testSuiteFilteringWithUnmodifyableChildList() throws Exception { + Runner runner= Request.aClass(ExampleSuiteWithUnmodifyableChildList.class) + .getRunner(); + Filter filter= notThisMethodName("test1"); + try { + filter.apply(runner); + } catch (NoTestsRemainException e) { + return; + } + fail("Expected 'NoTestsRemainException' due to complete filtering"); + } + + @Test + public void testRunSuiteFiltering() throws Exception { + Request request= Request.aClass(ExampleSuite.class); + Request requestFiltered= request.filterWith(notThisMethodName("test1")); + assertThat(testResult(requestFiltered), + hasSingleFailureContaining("don't run method name: test1")); + } + + @Test + public void testCountClassFiltering() throws Exception { + JUnitCore junitCore= new JUnitCore(); + Request request= Request.aClass(ExampleTest.class); + CountingFilter countingFilter= new CountingFilter(); + Request requestFiltered= request.filterWith(countingFilter); + Result result= junitCore.run(requestFiltered); + assertEquals(1, result.getRunCount()); + assertEquals(0, result.getFailureCount()); + + Description desc= createTestDescription(ExampleTest.class, "test1"); + assertEquals(1, countingFilter.getCount(desc)); + } + + @Test + public void testCountSuiteFiltering() throws Exception { + Class<ExampleSuite> suiteClazz= ExampleSuite.class; + Class<ExampleTest> clazz= ExampleTest.class; + + JUnitCore junitCore= new JUnitCore(); + Request request= Request.aClass(suiteClazz); + CountingFilter countingFilter= new CountingFilter(); + Request requestFiltered= request.filterWith(countingFilter); + Result result= junitCore.run(requestFiltered); + assertEquals(1, result.getRunCount()); + assertEquals(0, result.getFailureCount()); + + Description suiteDesc= createSuiteDescription(clazz); + assertEquals(1, countingFilter.getCount(suiteDesc)); + + Description desc= createTestDescription(ExampleTest.class, "test1"); + assertEquals(1, countingFilter.getCount(desc)); + } +}
\ No newline at end of file diff --git a/junit4/src/test/java/org/junit/tests/running/classes/ParentRunnerTest.java b/junit4/src/test/java/org/junit/tests/running/classes/ParentRunnerTest.java new file mode 100644 index 0000000..21c22b8 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/classes/ParentRunnerTest.java @@ -0,0 +1,139 @@ +package org.junit.tests.running.classes; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; + +import java.util.List; + +import org.hamcrest.Matcher; +import org.junit.Test; +import org.junit.internal.matchers.TypeSafeMatcher; +import org.junit.runner.Description; +import org.junit.runner.JUnitCore; +import org.junit.runner.Request; +import org.junit.runner.Result; +import org.junit.runner.manipulation.Filter; +import org.junit.runner.notification.RunNotifier; +import org.junit.runners.BlockJUnit4ClassRunner; +import org.junit.runners.ParentRunner; +import org.junit.runners.model.InitializationError; +import org.junit.runners.model.RunnerScheduler; +import org.junit.tests.experimental.rules.RuleFieldValidatorTest.TestWithNonStaticClassRule; +import org.junit.tests.experimental.rules.RuleFieldValidatorTest.TestWithProtectedClassRule; + +public class ParentRunnerTest { + public static String log= ""; + + public static class FruitTest { + @Test + public void apple() { + log+= "apple "; + } + + @Test + public void banana() { + log+= "banana "; + } + } + + @Test + public void useChildHarvester() throws InitializationError { + log= ""; + ParentRunner<?> runner= new BlockJUnit4ClassRunner(FruitTest.class); + runner.setScheduler(new RunnerScheduler() { + public void schedule(Runnable childStatement) { + log+= "before "; + childStatement.run(); + log+= "after "; + } + + public void finished() { + log+= "afterAll "; + } + }); + + runner.run(new RunNotifier()); + assertEquals("before apple after before banana after afterAll ", log); + } + + @Test + public void testMultipleFilters() throws Exception { + JUnitCore junitCore= new JUnitCore(); + Request request= Request.aClass(ExampleTest.class); + Request requestFiltered= request.filterWith(new Exclude("test1")); + Request requestFilteredFiltered= requestFiltered + .filterWith(new Exclude("test2")); + Result result= junitCore.run(requestFilteredFiltered); + assertThat(result.getFailures(), isEmpty()); + assertEquals(1, result.getRunCount()); + } + + private Matcher<List<?>> isEmpty() { + return new TypeSafeMatcher<List<?>>() { + public void describeTo(org.hamcrest.Description description) { + description.appendText("is empty"); + } + + @Override + public boolean matchesSafely(List<?> item) { + return item.size() == 0; + } + }; + } + + private static class Exclude extends Filter { + private String methodName; + + public Exclude(String methodName) { + this.methodName= methodName; + } + + @Override + public boolean shouldRun(Description description) { + return !description.getMethodName().equals(methodName); + } + + @Override + public String describe() { + return "filter method name: " + methodName; + } + } + + public static class ExampleTest { + @Test + public void test1() throws Exception { + } + + @Test + public void test2() throws Exception { + } + + @Test + public void test3() throws Exception { + } + } + + @Test + public void failWithHelpfulMessageForProtectedClassRule() { + assertClassHasFailureMessage(TestWithProtectedClassRule.class, + "The @ClassRule 'temporaryFolder' must be public."); + } + + @Test + public void failWithHelpfulMessageForNonStaticClassRule() { + assertClassHasFailureMessage(TestWithNonStaticClassRule.class, + "The @ClassRule 'temporaryFolder' must be static."); + } + + private void assertClassHasFailureMessage(Class<?> klass, String message) { + JUnitCore junitCore= new JUnitCore(); + Request request= Request.aClass(klass); + Result result= junitCore.run(request); + assertThat(result.getFailureCount(), is(2)); //the second failure is no runnable methods + assertThat(result.getFailures().get(0).getMessage(), + is(equalTo(message))); + + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/classes/RunWithTest.java b/junit4/src/test/java/org/junit/tests/running/classes/RunWithTest.java new file mode 100644 index 0000000..1df0167 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/classes/RunWithTest.java @@ -0,0 +1,85 @@ +package org.junit.tests.running.classes; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import org.junit.Test; +import org.junit.runner.Description; +import org.junit.runner.JUnitCore; +import org.junit.runner.RunWith; +import org.junit.runner.Runner; +import org.junit.runner.notification.RunNotifier; + +public class RunWithTest { + + private static String log; + + public static class ExampleRunner extends Runner { + public ExampleRunner(Class<?> klass) { + log+= "initialize"; + } + + @Override + public void run(RunNotifier notifier) { + log+= "run"; + } + + @Override + public int testCount() { + log+= "count"; + return 0; + } + + @Override + public Description getDescription() { + log+= "plan"; + return Description.createSuiteDescription("example"); + } + } + + @RunWith(ExampleRunner.class) + public static class ExampleTest { + } + + @Test public void run() { + log= ""; + + JUnitCore.runClasses(ExampleTest.class); + assertTrue(log.contains("plan")); + assertTrue(log.contains("initialize")); + assertTrue(log.contains("run")); + } + + public static class SubExampleTest extends ExampleTest { + } + + @Test public void runWithExtendsToSubclasses() { + log= ""; + + JUnitCore.runClasses(SubExampleTest.class); + assertTrue(log.contains("run")); + } + + public static class BadRunner extends Runner { + @Override + public Description getDescription() { + return null; + } + + @Override + public void run(RunNotifier notifier) { + // do nothing + } + } + + @RunWith(BadRunner.class) + public static class Empty { + } + + @Test + public void characterizeErrorMessageFromBadRunner() { + assertEquals( + "Custom runner class BadRunner should have a public constructor with signature BadRunner(Class testClass)", + JUnitCore.runClasses(Empty.class).getFailures().get(0) + .getMessage()); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/classes/SuiteTest.java b/junit4/src/test/java/org/junit/tests/running/classes/SuiteTest.java new file mode 100644 index 0000000..bda24fd --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/classes/SuiteTest.java @@ -0,0 +1,167 @@ +package org.junit.tests.running.classes; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.experimental.results.PrintableResult.testResult; +import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining; + +import java.util.List; + +import junit.framework.JUnit4TestAdapter; +import junit.framework.TestResult; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.JUnitCore; +import org.junit.runner.Request; +import org.junit.runner.Result; +import org.junit.runner.RunWith; +import org.junit.runner.Runner; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +public class SuiteTest { + public static class TestA { + @Test public void pass() { + } + } + + public static class TestB { + @Test public void fail() { + Assert.fail(); + } + } + + @RunWith(Suite.class) + @SuiteClasses({TestA.class, TestB.class}) + public static class All { + } + + public static class InheritsAll extends All { + } + + @Test public void ensureTestIsRun() { + JUnitCore core= new JUnitCore(); + Result result= core.run(All.class); + assertEquals(2, result.getRunCount()); + assertEquals(1, result.getFailureCount()); + } + + @Test public void ensureInheritedTestIsRun() { + JUnitCore core= new JUnitCore(); + Result result= core.run(InheritsAll.class); + assertEquals(2, result.getRunCount()); + assertEquals(1, result.getFailureCount()); + } + + @Test public void suiteTestCountIsCorrect() throws Exception { + Runner runner= Request.aClass(All.class).getRunner(); + assertEquals(2, runner.testCount()); + } + + @Test public void ensureSuitesWorkWithForwardCompatibility() { + junit.framework.Test test= new JUnit4TestAdapter(All.class); + TestResult result= new TestResult(); + test.run(result); + assertEquals(2, result.runCount()); + } + + @Test public void forwardCompatibilityWorksWithGetTests() { + JUnit4TestAdapter adapter= new JUnit4TestAdapter(All.class); + List<? extends junit.framework.Test> tests= adapter.getTests(); + assertEquals(2, tests.size()); + } + + @Test public void forwardCompatibilityWorksWithTestCount() { + JUnit4TestAdapter adapter= new JUnit4TestAdapter(All.class); + assertEquals(2, adapter.countTestCases()); + } + + + private static String log= ""; + @RunWith(Suite.class) + @SuiteClasses({TestA.class, TestB.class}) + public static class AllWithBeforeAndAfterClass { + @BeforeClass public static void before() { log+= "before "; } + @AfterClass public static void after() { log+= "after "; } + } + + @Test public void beforeAndAfterClassRunOnSuite() { + log= ""; + JUnitCore.runClasses(AllWithBeforeAndAfterClass.class); + assertEquals("before after ", log); + } + + @RunWith(Suite.class) + public static class AllWithOutAnnotation { + } + + @Test public void withoutSuiteClassAnnotationProducesFailure() { + Result result= JUnitCore.runClasses(AllWithOutAnnotation.class); + assertEquals(1, result.getFailureCount()); + String expected= String.format( + "class '%s' must have a SuiteClasses annotation", + AllWithOutAnnotation.class.getName()); + assertEquals(expected, result.getFailures().get(0).getMessage()); + } + + @RunWith(Suite.class) + @SuiteClasses(InfiniteLoop.class) + static public class InfiniteLoop { } + + @Test public void whatHappensWhenASuiteHasACycle() { + Result result= JUnitCore.runClasses(InfiniteLoop.class); + assertEquals(1, result.getFailureCount()); + } + + @RunWith(Suite.class) + @SuiteClasses({BiInfiniteLoop.class, BiInfiniteLoop.class}) + static public class BiInfiniteLoop { } + + @Test public void whatHappensWhenASuiteHasAForkingCycle() { + Result result= JUnitCore.runClasses(BiInfiniteLoop.class); + assertEquals(2, result.getFailureCount()); + } + + // The interesting case here is that Hydra indirectly contains two copies of + // itself (if it only contains one, Java's StackOverflowError eventually + // bails us out) + + @RunWith(Suite.class) + @SuiteClasses({Hercules.class}) + static public class Hydra { } + + @RunWith(Suite.class) + @SuiteClasses({Hydra.class, Hydra.class}) + static public class Hercules { } + + @Test public void whatHappensWhenASuiteContainsItselfIndirectly() { + Result result= JUnitCore.runClasses(Hydra.class); + assertEquals(2, result.getFailureCount()); + } + + @RunWith(Suite.class) + @SuiteClasses( {}) + public class WithoutDefaultConstructor { + public WithoutDefaultConstructor(int i) { + + } + } + + @Test + public void suiteShouldBeOKwithNonDefaultConstructor() throws Exception { + Result result= JUnitCore.runClasses(WithoutDefaultConstructor.class); + assertTrue(result.wasSuccessful()); + } + + @RunWith(Suite.class) + public class NoSuiteClassesAnnotation { + } + + @Test + public void suiteShouldComplainAboutNoSuiteClassesAnnotation() { + assertThat(testResult(NoSuiteClassesAnnotation.class), hasSingleFailureContaining("SuiteClasses")); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/classes/TestClassTest.java b/junit4/src/test/java/org/junit/tests/running/classes/TestClassTest.java new file mode 100644 index 0000000..7b738d9 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/classes/TestClassTest.java @@ -0,0 +1,121 @@ +package org.junit.tests.running.classes; + +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TestRule; +import org.junit.runners.model.TestClass; + +public class TestClassTest { + public static class TwoConstructors { + public TwoConstructors() { + } + + public TwoConstructors(int x) { + } + } + + @Test(expected= IllegalArgumentException.class) + public void complainIfMultipleConstructors() { + new TestClass(TwoConstructors.class); + } + + public static class ManyMethods { + @Test + public void a() { + } + + @Before + public void b() { + } + + @Ignore + @Test + public void c() { + } + + @Ignore + @After + public void d() { + } + + public void e() { + } + + @BeforeClass + public void f() { + } + + public void g() { + } + + @AfterClass + public void h() { + } + + @Test + public void i() { + } + + @Test + public void j() { + } + } + + public static class SuperclassWithField { + @Rule + public TestRule x; + } + + public static class SubclassWithField extends SuperclassWithField { + @Rule + public TestRule x; + } + + @Test + public void fieldsOnSubclassesShadowSuperclasses() { + assertThat(new TestClass(SubclassWithField.class).getAnnotatedFields( + Rule.class).size(), is(1)); + } + + public static class OuterClass { + public class NonStaticInnerClass { + } + } + + @Test + public void identifyNonStaticInnerClass() { + assertThat( + new TestClass(OuterClass.NonStaticInnerClass.class) + .isANonStaticInnerClass(), + is(true)); + } + + public static class OuterClass2 { + public static class StaticInnerClass { + } + } + + @Test + public void dontMarkStaticInnerClassAsNonStatic() { + assertThat( + new TestClass(OuterClass2.StaticInnerClass.class) + .isANonStaticInnerClass(), + is(false)); + } + + public static class SimpleClass { + } + + @Test + public void dontMarkNonInnerClassAsInnerClass() { + assertThat(new TestClass(SimpleClass.class).isANonStaticInnerClass(), + is(false)); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/classes/UseSuiteAsASuperclassTest.java b/junit4/src/test/java/org/junit/tests/running/classes/UseSuiteAsASuperclassTest.java new file mode 100644 index 0000000..2917181 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/classes/UseSuiteAsASuperclassTest.java @@ -0,0 +1,44 @@ +package org.junit.tests.running.classes; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; +import org.junit.Test; +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.model.InitializationError; + +public class UseSuiteAsASuperclassTest { + + public static class TestA { + @Test + public void pass() { + } + } + + public static class TestB { + @Test + public void dontPass() { + fail(); + } + } + + public static class MySuite extends Suite { + public MySuite(Class<?> klass) throws InitializationError { + super(klass, new Class[] { TestA.class, TestB.class }); + } + } + + @RunWith(MySuite.class) + public static class AllWithMySuite { + } + + @Test + public void ensureTestsAreRun() { + JUnitCore core= new JUnitCore(); + Result result= core.run(AllWithMySuite.class); + assertEquals(2, result.getRunCount()); + assertEquals(1, result.getFailureCount()); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/core/CommandLineTest.java b/junit4/src/test/java/org/junit/tests/running/core/CommandLineTest.java new file mode 100644 index 0000000..cdf8b55 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/core/CommandLineTest.java @@ -0,0 +1,67 @@ +package org.junit.tests.running.core; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.internal.RealSystem; +import org.junit.runner.JUnitCore; + +public class CommandLineTest { + private ByteArrayOutputStream results; + private PrintStream oldOut; + private static boolean testWasRun; + + @Before public void before() { + oldOut= System.out; + results= new ByteArrayOutputStream(); + System.setOut(new PrintStream(results)); + } + + @After public void after() { + System.setOut(oldOut); + } + + static public class Example { + @Test public void test() { + testWasRun= true; + } + } + + @Test public void runATest() { + testWasRun= false; // todo create a TestSystem instead + new JUnitCore().runMain(new RealSystem(), new String[]{"org.junit.tests.running.core.CommandLineTest$Example"}); + assertTrue(testWasRun); + } + + @Test public void runAClass() { + testWasRun= false; + JUnitCore.runClasses(Example.class); + assertTrue(testWasRun); + } + + private static int fCount; + + static public class Count { + @Test public void increment() { + fCount++; + } + } + + @Test public void runTwoClassesAsArray() { + fCount= 0; + JUnitCore.runClasses(new Class[] {Count.class, Count.class}); + assertEquals(2, fCount); + } + + @Test public void runTwoClasses() { + fCount= 0; + JUnitCore.runClasses(Count.class, Count.class); + assertEquals(2, fCount); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/core/JUnitCoreReturnsCorrectExitCodeTest.java b/junit4/src/test/java/org/junit/tests/running/core/JUnitCoreReturnsCorrectExitCodeTest.java new file mode 100644 index 0000000..0d8bb37 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/core/JUnitCoreReturnsCorrectExitCodeTest.java @@ -0,0 +1,39 @@ +package org.junit.tests.running.core; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; +import org.junit.Test; +import org.junit.runner.JUnitCore; +import org.junit.tests.TestSystem; + +public class JUnitCoreReturnsCorrectExitCodeTest { + + static public class Fail { + @Test public void kaboom() { + fail(); + } + } + + @Test public void failureCausesExitCodeOf1() throws Exception { + runClass(getClass().getName() + "$Fail", 1); + } + + @Test public void missingClassCausesExitCodeOf1() throws Exception { + runClass("Foo", 1); + } + + static public class Succeed { + @Test public void peacefulSilence() { + } + } + + @Test public void successCausesExitCodeOf0() throws Exception { + runClass(getClass().getName() + "$Succeed", 0); + } + + private void runClass(String className, int returnCode) { + TestSystem system= new TestSystem(); + JUnitCore.runMainAndExit(system, className); + assertEquals(returnCode, system.fCode); + } +} diff --git a/junit4/src/test/java/org/junit/tests/running/core/SystemExitTest.java b/junit4/src/test/java/org/junit/tests/running/core/SystemExitTest.java new file mode 100644 index 0000000..1460119 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/running/core/SystemExitTest.java @@ -0,0 +1,30 @@ +package org.junit.tests.running.core; + +import static org.junit.Assert.assertEquals; + +import java.io.File; +import java.io.InputStream; + +import org.junit.Test; + +// Make sure System.exit works as expected. We've had problems with this on some platforms. +public class SystemExitTest { + + private static final int EXIT_CODE= 5; + + static public class Exit { + public static void main(String[] args) { + System.exit(EXIT_CODE); + } + } + + @Test public void failureCausesExitCodeOf1() throws Exception { + String java= System.getProperty("java.home")+File.separator+"bin"+File.separator+"java"; + String classPath= getClass().getClassLoader().getResource(".").getFile() + File.pathSeparator + System.getProperty("java.class.path"); + String [] cmd= { java, "-cp", classPath, getClass().getName() + "$Exit"}; + Process process= Runtime.getRuntime().exec(cmd); + InputStream input= process.getInputStream(); + while((input.read()) != -1); + assertEquals(EXIT_CODE, process.waitFor()); + } +} 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)); + } +} |