diff options
Diffstat (limited to 'junit4/src/test/java/org/junit/tests/experimental/max')
3 files changed, 370 insertions, 0 deletions
diff --git a/junit4/src/test/java/org/junit/tests/experimental/max/DescriptionTest.java b/junit4/src/test/java/org/junit/tests/experimental/max/DescriptionTest.java new file mode 100644 index 0000000..c020320 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/experimental/max/DescriptionTest.java @@ -0,0 +1,24 @@ +package org.junit.tests.experimental.max; + +import static org.junit.Assert.assertNull; +import org.junit.Test; +import org.junit.runner.Description; + +public class DescriptionTest { + + @Test + public void parseClass_whenCantParse() { + assertNull(Description.TEST_MECHANISM.getTestClass()); + } + + @Test + public void parseMethod_whenCantParse() { + assertNull(Description.TEST_MECHANISM.getMethodName()); + } + + @Test(expected= IllegalArgumentException.class) + public void createSuiteDescription_whenZeroLength() { + Description.createSuiteDescription(""); + } + +} diff --git a/junit4/src/test/java/org/junit/tests/experimental/max/JUnit38SortingTest.java b/junit4/src/test/java/org/junit/tests/experimental/max/JUnit38SortingTest.java new file mode 100644 index 0000000..68a25d6 --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/experimental/max/JUnit38SortingTest.java @@ -0,0 +1,53 @@ +package org.junit.tests.experimental.max; + +import static org.junit.Assert.assertEquals; + +import java.io.File; +import java.util.List; + +import junit.framework.TestCase; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.experimental.max.MaxCore; +import org.junit.runner.Description; +import org.junit.runner.Request; + +public class JUnit38SortingTest { + private MaxCore fMax; + private File fMaxFile; + + @Before + public void createMax() { + fMaxFile= new File("MaxCore.ser"); + if (fMaxFile.exists()) + fMaxFile.delete(); + fMax= MaxCore.storedLocally(fMaxFile); + } + + @After + public void forgetMax() { + fMaxFile.delete(); + } + + public static class JUnit4Test { + @Test public void pass() {} + } + + public static class JUnit38Test extends TestCase { + public void testFails() { fail(); } + public void testSucceeds() {} + public void testSucceedsToo() {} + } + + @Test + public void preferRecentlyFailed38Test() { + Request request= Request.classes(JUnit4Test.class, JUnit38Test.class); + fMax.run(request); + List<Description> tests= fMax.sortedLeavesForTest(request); + Description dontSucceed= Description.createTestDescription( + JUnit38Test.class, "testFails"); + assertEquals(dontSucceed, tests.get(0)); + } + +} diff --git a/junit4/src/test/java/org/junit/tests/experimental/max/MaxStarterTest.java b/junit4/src/test/java/org/junit/tests/experimental/max/MaxStarterTest.java new file mode 100644 index 0000000..372af8f --- /dev/null +++ b/junit4/src/test/java/org/junit/tests/experimental/max/MaxStarterTest.java @@ -0,0 +1,293 @@ +package org.junit.tests.experimental.max; + +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.File; +import java.util.ArrayList; +import java.util.List; + +import junit.framework.TestCase; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.experimental.max.MaxCore; +import org.junit.internal.runners.JUnit38ClassRunner; +import org.junit.runner.Computer; +import org.junit.runner.Description; +import org.junit.runner.JUnitCore; +import org.junit.runner.Request; +import org.junit.runner.Result; +import org.junit.runner.Runner; +import org.junit.runner.manipulation.Filter; +import org.junit.runner.notification.Failure; +import org.junit.runner.notification.RunListener; +import org.junit.tests.AllTests; + +public class MaxStarterTest { + private MaxCore fMax; + + private File fMaxFile; + + @Before + public void createMax() { + fMaxFile= new File("MaxCore.ser"); + if (fMaxFile.exists()) + fMaxFile.delete(); + fMax= MaxCore.storedLocally(fMaxFile); + } + + @After + public void forgetMax() { + fMaxFile.delete(); + } + + public static class TwoTests { + @Test + public void succeed() { + } + + @Test + public void dontSucceed() { + fail(); + } + } + + @Test + public void twoTestsNotRunComeBackInRandomOrder() { + Request request= Request.aClass(TwoTests.class); + List<Description> things= fMax.sortedLeavesForTest(request); + Description succeed= Description.createTestDescription(TwoTests.class, + "succeed"); + Description dontSucceed= Description.createTestDescription( + TwoTests.class, "dontSucceed"); + assertTrue(things.contains(succeed)); + assertTrue(things.contains(dontSucceed)); + assertEquals(2, things.size()); + } + + @Test + public void preferNewTests() { + Request one= Request.method(TwoTests.class, "succeed"); + fMax.run(one); + Request two= Request.aClass(TwoTests.class); + List<Description> things= fMax.sortedLeavesForTest(two); + Description dontSucceed= Description.createTestDescription( + TwoTests.class, "dontSucceed"); + assertEquals(dontSucceed, things.get(0)); + assertEquals(2, things.size()); + } + + // This covers a seemingly-unlikely case, where you had a test that failed + // on the + // last run and you also introduced new tests. In such a case it pretty much + // doesn't matter + // which order they run, you just want them both to be early in the sequence + @Test + public void preferNewTestsOverTestsThatFailed() { + Request one= Request.method(TwoTests.class, "dontSucceed"); + fMax.run(one); + Request two= Request.aClass(TwoTests.class); + List<Description> things= fMax.sortedLeavesForTest(two); + Description succeed= Description.createTestDescription(TwoTests.class, + "succeed"); + assertEquals(succeed, things.get(0)); + assertEquals(2, things.size()); + } + + @Test + public void preferRecentlyFailed() { + Request request= Request.aClass(TwoTests.class); + fMax.run(request); + List<Description> tests= fMax.sortedLeavesForTest(request); + Description dontSucceed= Description.createTestDescription( + TwoTests.class, "dontSucceed"); + assertEquals(dontSucceed, tests.get(0)); + } + + @Test + public void sortTestsInMultipleClasses() { + Request request= Request.classes(Computer.serial(), TwoTests.class, + TwoTests.class); + fMax.run(request); + List<Description> tests= fMax.sortedLeavesForTest(request); + Description dontSucceed= Description.createTestDescription( + TwoTests.class, "dontSucceed"); + assertEquals(dontSucceed, tests.get(0)); + assertEquals(dontSucceed, tests.get(1)); + } + + public static class TwoUnEqualTests { + @Test + public void slow() throws InterruptedException { + Thread.sleep(100); + fail(); + } + + @Test + public void fast() { + fail(); + } + + } + + @Test + public void rememberOldRuns() { + fMax.run(TwoUnEqualTests.class); + + MaxCore reincarnation= MaxCore.storedLocally(fMaxFile); + List<Failure> failures= reincarnation.run(TwoUnEqualTests.class) + .getFailures(); + assertEquals("fast", failures.get(0).getDescription().getMethodName()); + assertEquals("slow", failures.get(1).getDescription().getMethodName()); + } + + @Test + public void preferFast() { + Request request= Request.aClass(TwoUnEqualTests.class); + fMax.run(request); + Description thing= fMax.sortedLeavesForTest(request).get(1); + assertEquals(Description.createTestDescription(TwoUnEqualTests.class, + "slow"), thing); + } + + @Test + public void listenersAreCalledCorrectlyInTheFaceOfFailures() + throws Exception { + JUnitCore core= new JUnitCore(); + final List<Failure> failures= new ArrayList<Failure>(); + core.addListener(new RunListener() { + @Override + public void testRunFinished(Result result) throws Exception { + failures.addAll(result.getFailures()); + } + }); + fMax.run(Request.aClass(TwoTests.class), core); + assertEquals(1, failures.size()); + } + + @Test + public void testsAreOnlyIncludedOnceWhenExpandingForSorting() + throws Exception { + Result result= fMax.run(Request.aClass(TwoTests.class)); + assertEquals(2, result.getRunCount()); + } + + public static class TwoOldTests extends TestCase { + public void testOne() { + } + + public void testTwo() { + } + } + + @Test + public void junit3TestsAreRunOnce() throws Exception { + Result result= fMax.run(Request.aClass(TwoOldTests.class), + new JUnitCore()); + assertEquals(2, result.getRunCount()); + } + + @Test + public void filterSingleMethodFromOldTestClass() throws Exception { + final Description method= Description.createTestDescription( + TwoOldTests.class, "testOne"); + Filter filter= Filter.matchMethodDescription(method); + JUnit38ClassRunner child= new JUnit38ClassRunner(TwoOldTests.class); + child.filter(filter); + assertEquals(1, child.testCount()); + } + + @Test + public void testCountsStandUpToFiltration() { + assertFilterLeavesTestUnscathed(AllTests.class); + } + + private void assertFilterLeavesTestUnscathed(Class<?> testClass) { + Request oneClass= Request.aClass(testClass); + Request filtered= oneClass.filterWith(new Filter() { + @Override + public boolean shouldRun(Description description) { + return true; + } + + @Override + public String describe() { + return "Everything"; + } + }); + + int filterCount= filtered.getRunner().testCount(); + int coreCount= oneClass.getRunner().testCount(); + assertEquals("Counts match up in " + testClass, coreCount, filterCount); + } + + private static class MalformedJUnit38Test { + private MalformedJUnit38Test() { + } + + @SuppressWarnings("unused") + public void testSucceeds() { + } + } + + @Test + public void maxShouldSkipMalformedJUnit38Classes() { + Request request= Request.aClass(MalformedJUnit38Test.class); + fMax.run(request); + } + + public static class MalformedJUnit38TestMethod extends TestCase { + @SuppressWarnings("unused") + private void testNothing() { + } + } + + String fMessage= null; + + @Test + public void correctErrorFromMalformedTest() { + Request request= Request.aClass(MalformedJUnit38TestMethod.class); + JUnitCore core= new JUnitCore(); + Request sorted= fMax.sortRequest(request); + Runner runner= sorted.getRunner(); + Result result= core.run(runner); + Failure failure= result.getFailures().get(0); + assertThat(failure.toString(), containsString("MalformedJUnit38TestMethod")); + assertThat(failure.toString(), containsString("testNothing")); + assertThat(failure.toString(), containsString("isn't public")); + } + + public static class HalfMalformedJUnit38TestMethod extends TestCase { + public void testSomething() { + } + + @SuppressWarnings("unused") + private void testNothing() { + } + } + + @Test + public void halfMalformed() { + assertThat(JUnitCore.runClasses(HalfMalformedJUnit38TestMethod.class) + .getFailureCount(), is(1)); + } + + + @Test + public void correctErrorFromHalfMalformedTest() { + Request request= Request.aClass(HalfMalformedJUnit38TestMethod.class); + JUnitCore core= new JUnitCore(); + Request sorted= fMax.sortRequest(request); + Runner runner= sorted.getRunner(); + Result result= core.run(runner); + Failure failure= result.getFailures().get(0); + assertThat(failure.toString(), containsString("MalformedJUnit38TestMethod")); + assertThat(failure.toString(), containsString("testNothing")); + assertThat(failure.toString(), containsString("isn't public")); + } +} |