expect:
        result.failures == [failure1, failure2]
        result.failure instanceof MultipleBuildFailures
        result.failure.causes == [failure1, failure2]
        result.failureOrNull instanceof MultipleBuildFailures
        result.failureOrNull.causes == [failure1, failure2]

        when:
        result.valueOrRethrow

        then:

    def stopRethrowsFirstExecutionException() {
        given:
        def failure1 = new RuntimeException()
        def runnable1 = {
            instant.broken1
            throw failure1
        }

        def failure2 = new RuntimeException()
        def runnable2 = {
            instant.broken2
            throw failure2
        }

        when:
        def executor = factory.create('test')

        when:
        collector.beforeTest(test)
        collector.afterTest(test, result)

        then:
        def failures = results["FooTest"].results[0].failures
        failures.size() == 2
        failures[0].exceptionType == RuntimeException.name
        failures[0].message == failure1.rawFailure.toString()
        failures[0].stackTrace.startsWith(failure1.rawFailure.toString())

        def e = thrown(MultipleBuildOperationFailures)
        e.causes == [failure1, failure2]

        1 * buildModelParameters.isParallelToolingApiActions() >> false
        1 * action1.get() >> { throw failure1 }
        1 * action2.get() >> { throw failure2 }
        1 * action3.get() >> "three"
        0 * _
    }

    def "collects all failures from actions when queued to run in parallel"() {
        given:

        stream.forCurrentCaller().stack.empty

        def failure1 = new Exception("broken")
        def diagnostics1 = stream.forCurrentCaller(failure1)
        diagnostics1.exception == failure1
        !diagnostics1.stack.empty

        def failure2 = new Exception("broken")
        def diagnostics2 = factory.forException(failure2)
        diagnostics2.exception == failure2
        !diagnostics2.stack.empty
    }

        when:
        dispatch.dispatchFailed("message1", failure1)
        dispatch.dispatchFailed("message2", failure2)
        dispatch.stop()

        then:
        def e = thrown(DispatchException)
        e.cause == failure1
        1 * logger.error('broken2', failure2)
        0 * logger._
    }

    def stopDoesNothingWhenThereWereNoFailures() {
        when:
        dispatch.stop()

        and:
        1 * listener.afterEvaluate(project, state) >> { throw failure2 }

        then:
        failsWithCause(failure1, failure2)

        and:
        operations.size() == 3
        assertConfigureOp(operations[0], failure1)
        assertBeforeEvaluateOp(operations[1])
        assertAfterEvaluateOp(operations[2], failure2)
    }

        then:
        executionResult.failures == [failure, failure2]

        when:
        def finishResult = controller.finishBuild(null)

        then:
        1 * exceptionAnalyser.transform([failure, failure2]) >> transformedException
        1 * buildListener.buildFinished({ it.failure == transformedException }) >> { throw failure3 }
        finishResult.failures == [failure3]

        when:

        ]

        and:
        failure1 != null
        failure2 != null
        failure3 != null
    }

    def "fails when too many concurrent requests happen while waiting for multiple concurrent requests to automatically release"() {
        def failure1 = null
        def failure2 = null
        def failure3 = null

        given:
        server.start()

        RuntimeException failure1 = new RuntimeException()
        RuntimeException failure2 = new RuntimeException()
        stoppable.add(a)
        stoppable.add(b)

        when:
        stoppable.stop()

        then:
        1 * a.stop() >> { throw failure1 }
        1 * b.stop() >> { throw failure2 }
        def e = thrown(RuntimeException)
        e == failure1
    }