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