Throwable reportableFailure = failure;
            if (reportableFailure == null && !stageFailures.getFailures().isEmpty()) {
                reportableFailure = exceptionAnalyser.transform(stageFailures.getFailures());
            }
            BuildResult buildResult = new BuildResult(hasTasks ? "Build" : "Configure", gradle, reportableFailure);

        def testResult = Mock(InternalTestFailureResult)
        _ * testResult.getStartTime() >> 1
        _ * testResult.getEndTime() >> 2
        _ * testResult.getFailures() >> [Stub(InternalFailure)]

        def failedEvent = Mock(InternalTestFinishedProgressEvent)
        _ * failedEvent.getEventTime() >> 999
        _ * failedEvent.getDisplayName() >> 'test suite failed'

        def transformResult = Mock(InternalFailureResult)
        _ * transformResult.getStartTime() >> 1
        _ * transformResult.getEndTime() >> 2
        _ * transformResult.getFailures() >> [Stub(InternalFailure)]

        def failedEvent = Mock(InternalOperationFinishedProgressEvent)
        _ * failedEvent.getEventTime() >> 999
        _ * failedEvent.getDisplayName() >> 'Transform failed'

        ExecutionResult<Void> result;
        try {
            result = action.apply(currentResult);
        } catch (Throwable t) {
            result = ExecutionResult.failed(t);
        }
        if (!result.getFailures().isEmpty()) {
            state = state.failed(result);
        } else {
            state = state.nextState(toState);
        }
        return result;
    }

            case FAILURE:
                return new DefaultTestFailureResult(result.getStartTime(), result.getEndTime(), convertExceptions(result.getFailures()));
            default:
                throw new IllegalStateException("Unknown test result type: " + resultType);
        }
    }

        _ * projectConfigurationResult.getStartTime() >> 1
        _ * projectConfigurationResult.getEndTime() >> 2
        _ * projectConfigurationResult.getFailures() >> [Stub(InternalFailure)]
        _ * projectConfigurationResult.getPluginApplicationResults() >> [binaryPluginApplicationResult, scriptPluginApplicationResult]

    // TODO Use Guava's immutable collections here
    private static final Set<String> CANDIDATE_GET_CAUSES = Collections.unmodifiableSet(
        new HashSet<String>() {{
            add("getCauses");
            add("getFailures");
        }}
    );
    private static final long serialVersionUID = 1L;
    private static final Logger LOGGER = LoggerFactory.getLogger(ExceptionPlaceholder.class);
    private final String type;

    }

    private Iterable<TestCaseExecution> failures(final long classId, final TestMethodResult methodResult, final FailureType failureType) {
        List<TestFailure> failures = methodResult.getFailures();
        if (failures.isEmpty()) {
            // This can happen with a failing engine. For now, we just ignore this.
            return Collections.emptyList();
        }

        def testResult = Mock(InternalTaskFailureResult)
        _ * testResult.getStartTime() >> 1
        _ * testResult.getEndTime() >> 2
        _ * testResult.getFailures() >> [Stub(InternalFailure)]

        def failedEvent = Mock(InternalOperationFinishedProgressEvent)
        _ * failedEvent.getEventTime() >> 999
        _ * failedEvent.getDisplayName() >> 'task failed'

        frameworkFailures[1].causes.empty
        frameworkFailures[1].className == 'java.lang.RuntimeException'
        frameworkFailures[1].stacktrace == frameworkFailures[1].description
    }

    List<Failure> getFailures() {
        progressEventCollector.failures
    }

    private def runTestTaskWithFailureCollection() {
        withConnection { connection ->
            connection.newBuild()