delegate.dispatch(event);
        startedIds.add(event.getDescriptor().getId());
    }

    void finished(InternalOperationFinishedProgressEvent event) {
        startedIds.remove(event.getDescriptor().getId());
        delegate.dispatch(event);
    }

    void progress(InternalProgressEvent event) {
        delegate.dispatch(event);
    }

   */
  @Test
  fun canceledBeforeIOSignalsOnFailure() {
    // Force requests to be executed serially.
    val dispatcher = Dispatcher(client.dispatcher.executorService)
    dispatcher.maxRequests = 1
    client =
      client.newBuilder()
        .dispatcher(dispatcher)
        .build()
    val requestA = Request(server.url("/a"))
    val requestB = Request(server.url("/b"))

            }

            /**
             * Returns correct importable name for implicitly dispatched callable - that is, a callable
             * which has a dispatch receiver, but whose dispatch receiver is present implicitly. The most
             * important case for that is the following:
             *
             * ```kt
             * import MyObject.bar

import org.gradle.internal.UncheckedException;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.locks.Condition;

public class EndPointQueue implements Dispatch<InterHubMessage> {

    private static final Logger LOGGER = Logging.getLogger(ReportStatusDispatcher.class);

    public Status dispatch(Connection<Message> connection, Command statusCommand) {
        Status returnedStatus = null;
        Throwable failure = null;
        try {
            connection.dispatch(statusCommand);
            Result result = (Result) connection.receive();
            if (result instanceof Failure) {

  fun setUp() {
    platform.assumeLoom()
    assertThat(System.getProperty("jdk.tracePinnedThreads")).isNotEmpty()

    client =
      OkHttpClient.Builder()
        .trustMockServer()
        .dispatcher(Dispatcher(newVirtualThreadPerTaskExecutor()))
        .build()

    executor = newVirtualThreadPerTaskExecutor()

    // Capture non-deterministic but probable sysout warnings of pinned threads

        throwWhen(new IOException("Could not dispatch a message to the daemon.", new IOException("An existing connection was forcibly closed by the remote host")), iteration == 1)

        then:
        IOException ioe = thrown()
        ioe.message == "Could not dispatch a message to the daemon."
    }

    private static void throwWhen(Throwable throwable, boolean condition) {

import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * A consumer for build events provided by the build requester. This can be used to forward events to the build requester.
 */
@ServiceScope(Scope.BuildSession.class)
public interface BuildEventConsumer extends Dispatch<Object> {

	DISPATCH(runtime·call1024, 1024)
	DISPATCH(runtime·call2048, 2048)
	DISPATCH(runtime·call4096, 4096)
	DISPATCH(runtime·call8192, 8192)
	DISPATCH(runtime·call16384, 16384)
	DISPATCH(runtime·call32768, 32768)
	DISPATCH(runtime·call65536, 65536)
	DISPATCH(runtime·call131072, 131072)
	DISPATCH(runtime·call262144, 262144)
	DISPATCH(runtime·call524288, 524288)
	DISPATCH(runtime·call1048576, 1048576)

 * limitations under the License.
 */

package org.gradle.internal.dispatch;

import org.gradle.internal.UncheckedException;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectionDispatch implements Dispatch<MethodInvocation> {
    private final Object target;

    public ReflectionDispatch(Object target) {