public void completed(TestDescriptorInternal testDescriptor, TestResult testResult, TestCompleteEvent completeEvent) {
        delegate.completed(testDescriptor, testResult, completeEvent);

        if (!failed && testResult.getResultType() == TestResult.ResultType.FAILURE) {
            failed = true;
            testExecuter.stopNow();
        }
    }

    @Override

        this.testCount = testCount;
        this.successfulCount = successfulCount;
        this.failedCount = failedCount;
        this.failures = failures;
    }

    @Override
    public ResultType getResultType() {
        return resultType;
    }

    @Override
    public Throwable getException() {
        return failures.isEmpty() ? null : failures.get(0).getRawFailure();
    }

    @Override

    public Set<TestResult> getFailures() {
        return failures;
    }

    public Set<TestResult> getIgnored() {
        return ignored;
    }

    @Override
    public ResultType getResultType() {
        if (!failures.isEmpty()) {
            return ResultType.FAILURE;
        }
        if (getIgnoredCount() > 0) {
            return ResultType.SKIPPED;
        }

            logEvent(descriptor, event, details);
        }
    }

    private TestLogEvent getEvent(TestResult result) {
        switch (result.getResultType()) {
            case SUCCESS: return TestLogEvent.PASSED;
            case FAILURE: return TestLogEvent.FAILED;
            case SKIPPED: return TestLogEvent.SKIPPED;
            default: throw new AssertionError();

            if (failedTests > 0) {
                logger.error(TextUtil.getPlatformLineSeparator() + summary());
            }
            progressLogger.completed();

            if (result.getResultType() == TestResult.ResultType.FAILURE) {
                hadFailures = true;
            }
        }
    }

    public boolean hadFailures() {
        return hadFailures;
    }

    }

    private result(boolean failed = false) {
        [getTestCount: { 1L }, getFailedTestCount: { failed ? 1L : 0L }, getSkippedTestCount: { 0L },
                getResultType: { failed ? TestResult.ResultType.FAILURE : TestResult.ResultType.SUCCESS }] as TestResult
    }

        SUCCESS, FAILURE, SKIPPED
    }

    /**
     * Returns the type of result.  Generally one wants it to be SUCCESS!
     *
     * @return The result type.
     */
    ResultType getResultType();

    /**
     * If the test failed with an exception, this will be the exception.  Some test frameworks do not fail without an
     * exception (JUnit), so in those cases this method will never return null.
     *

        encoder.writeSmallLong(methodResult.getId());
        encoder.writeString(methodResult.getName());
        encoder.writeString(methodResult.getDisplayName());
        encoder.writeSmallInt(methodResult.getResultType().ordinal());
        encoder.writeSmallLong(methodResult.getDuration());
        encoder.writeLong(methodResult.getEndTime());
        encoder.writeSmallInt(methodResult.getFailures().size());

                    if (collectedResult.getResultType() == SKIPPED) {
                        testResult.setIgnored();
                    } else {
                        List<TestFailure> failures = collectedResult.getFailures();

        } else {
            return testDescriptor;
        }
    }

    private static AbstractTestResult adapt(TestResult result) {
        TestResult.ResultType resultType = result.getResultType();
        switch (resultType) {
            case SUCCESS:
                return new DefaultTestSuccessResult(result.getStartTime(), result.getEndTime());
            case SKIPPED: