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