import java.util.List;

public class TestClassResult {
    private final List<TestMethodResult> methodResults = new ArrayList<TestMethodResult>();
    private final String className;
    private final String classDisplayName;
    private long startTime;
    private int failuresCount;
    private int skippedCount;
    private long id;

    public TestClassResult(long id, String className, long startTime) {

            TestMethodResult methodResult = new TestMethodResult(internalIdCounter++, EXECUTION_FAILURE);
            TestClassResult classResult = new TestClassResult(internalIdCounter++, suite.getName(), result.getStartTime());
            for (Throwable throwable : result.getExceptions()) {

        }
    }

    private void write(Collection<TestClassResult> results, Encoder encoder) throws IOException {
        encoder.writeSmallInt(results.size());
        for (TestClassResult result : results) {
            write(result, encoder);
        }
    }

    private void write(TestClassResult classResult, Encoder encoder) throws IOException {
        encoder.writeSmallLong(classResult.getId());

            this.provider = provider;
        }
    }

    private static class OverlaidIdProxyingTestClassResult extends TestClassResult {
        private final Map<Long, TestClassResult> delegates = new LinkedHashMap<Long, TestClassResult>();

        public OverlaidIdProxyingTestClassResult(long id, TestClassResult delegate) {
            super(id, delegate.getClassName(), delegate.getStartTime());
            addTestClassResult(delegate);

    private startTime = 1353344968049

    def "writes xml JUnit result"() {
        given:
        def options = new JUnitXmlResultOptions(false, false, true, true)

        and:
        TestClassResult result = new TestClassResult(1, "com.foo.FooTest", startTime)
        result.add(new TestMethodResult(1, "some test", SUCCESS, 15, startTime + 25))
        result.add(new TestMethodResult(2, "some test two", SUCCESS, 15, startTime + 30))

    def "visits classes from each provider and reassigns class ids"() {
        def action = Mock(Action)
        def class1 = Stub(TestClassResult) {
            getClassName() >> 'class-1'
        }
        def class2 = Stub(TestClassResult) {
            getClassName() >> 'class-2'
        }

        when:
        provider.visitClasses(action)

        then:

    }

    TestResultsProvider passingBuildResults() {
        buildResults {
            testClassResult("org.gradle.passing.Passed") {
                testcase("passed") {
                    duration = 1000;
                }
            }
            testClassResult("org.gradle.passing.subpackage.AlsoPassed") {
                testcase("passedToo") {
                    duration = 1000;

        def readClass2 = read[1]
        readClass2.className == 'Class2'
        readClass2.startTime == 5678
        readClass2.results.empty
    }

    List<TestClassResult> serialize(Collection<TestClassResult> results) {
        def serializer = new TestResultSerializer(tmp.createDir("results"))
        serializer.write(results)
        def result = []
        serializer.read({ result << it } as Action)

 * limitations under the License.
 */

package org.gradle.api.internal.tasks.testing

import org.gradle.api.Action
import org.gradle.api.internal.tasks.testing.junit.result.TestClassResult
import org.gradle.api.internal.tasks.testing.junit.result.TestFailure
import org.gradle.api.internal.tasks.testing.junit.result.TestMethodResult
import org.gradle.api.internal.tasks.testing.junit.result.TestResultsProvider

import java.io.Writer;

public class InMemoryTestResultsProvider extends TestOutputStoreBackedResultsProvider {
    private final Iterable<TestClassResult> results;

    public InMemoryTestResultsProvider(Iterable<TestClassResult> results, TestOutputStore outputStore) {
        super(outputStore);
        this.results = results;
    }

    @Override