*/
package org.gradle.tooling;

/**
 * A handler for an asynchronous operation which returns an object of type T.
 *
 * @param <T> The result type.
 * @since 1.0-milestone-3
 */
public interface ResultHandler<T> {

    /**
     * Handles successful completion of the operation.
     *
     * @param result the result
     * @since 1.0-milestone-3
     */
    void onComplete(T result);

    /**

latch.await()
"""

    }

    void buildWasCancelled(TestResultHandler resultHandler, String failureMessage = 'Could not execute build using') {
        resultHandler.assertFailedWith(BuildCancelledException)
        assert resultHandler.failure.message.startsWith(failureMessage)

        if (targetIsGradle51OrLater()) {
            verifyBuildCancelledExceptionMessage(resultHandler)
        }

    }
}
"""

        when:
        def resultHandler = new TestResultHandler()
        def sync = server.expectAndBlock("waiting")
        def output = new TestOutputStream()
        withConnection { ProjectConnection connection ->
            def build = connection.newBuild()
            build.standardOutput = output
            build.forTasks("log")
            build.run(resultHandler)
            sync.waitForAllPendingCalls(resultHandler)

        def resultHandler = new TestResultHandler()

        when:
        withConnection { ProjectConnection connection ->
            def build = connection.newTestLauncher()
            build.withJvmTestClasses("Broken")
            build.withCancellationToken(cancel.token())
            build.run(resultHandler)
            sync.waitForAllPendingCalls(resultHandler)
            cancel.cancel()

package org.gradle.tooling.internal.consumer;

import org.gradle.tooling.ResultHandler;
import org.gradle.tooling.internal.protocol.ResultHandlerVersion1;

/**
 * Adapts a {@link ResultHandler} to a {@link ResultHandlerVersion1}.
 *
 * @param <T> The result type.
 */
public class ResultHandlerAdapter<T> implements ResultHandlerVersion1<T> {
    private final ResultHandler<? super T> handler;

 */

package org.gradle.tooling.internal.consumer

import org.gradle.test.fixtures.concurrent.ConcurrentSpec
import org.gradle.tooling.GradleConnectionException
import org.gradle.tooling.ResultHandler
import org.gradle.tooling.internal.consumer.async.AsyncConsumerActionExecutor
import org.gradle.tooling.internal.consumer.connection.ConsumerAction
import org.gradle.tooling.internal.consumer.connection.ConsumerConnection

            build.withCancellationToken(cancel.token())
            build.run(resultHandler)
            sync.waitForAllPendingCalls(resultHandler)
            cancel.cancel()
            sync.releaseAll()
            resultHandler.finished()
        }

        then:
        buildWasCancelled(resultHandler)

        where:
        configureOnDemand << [true, false]
    }

            collectOutputs(build)
            build.run(resultHandler)
            sync.waitForAllPendingCalls(resultHandler)
            cancel.cancel()
            sync.releaseAll()
            resultHandler.finished()
        }

        then:
        configureWasCancelled(resultHandler, "Could not run phased build action using")
    }

        private final BuildAction<T> buildAction;
        private final IntermediateResultHandler<? super T> resultHandler;

        DefaultBuildActionWrapper(BuildAction<T> buildAction, IntermediateResultHandler<? super T> resultHandler) {
            this.buildAction = buildAction;
            this.resultHandler = resultHandler;
        }

        @Override
        public BuildAction<T> getAction() {
            return buildAction;

        build.forTasks('hang').withCancellationToken(cancellation.token()).run(resultHandler)
        sync.waitForAllPendingCalls(resultHandler)
        cancellation.cancel()
        Thread.sleep(200) // The daemon seems to drop messages arriving the same time
        connector.disconnect()
        resultHandler.finished()

        then:
        resultHandler.assertFailedWith(BuildCancelledException)
    }