var bodyLimit: Long by delegate::bodyLimit

  var serverSocketFactory: ServerSocketFactory? by delegate::serverSocketFactory

  var dispatcher: Dispatcher = QueueDispatcher()
    set(value) {
      field = value
      delegate.dispatcher = value.wrap()
    }

  val port: Int
    get() {
      before() // This implicitly starts the delegate.
      return delegate.port
    }

        1 * connection.dispatch({it instanceof ReportStatus})
        1 * connection.receive() >> new Success(new Status(12345, "3.0", "BOGUS"))
        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()

        and:
        1 * connector.maybeConnect(daemon2) >>> connection
        _ * connection.daemon >> daemon2
        1 * connection.dispatch({it instanceof ReportStatus})

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal

import okhttp3.Cache
import okhttp3.Dispatcher
import okhttp3.Response
import okhttp3.internal.connection.Exchange
import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RealConnection
import okio.FileSystem
import okio.Path

    def "delegate when not a phase action result"() {
        def event = new Object()

        when:
        eventConsumer.dispatch(event)

        then:
        1 * delegateEventConsumer.dispatch(event)
        0 * phasedActionResultListener.onResult(_)
    }

    def "deserialize and correctly map results"() {
        def result1 = 'result1'

package org.gradle.internal.remote.internal.hub.queue

import org.gradle.internal.dispatch.Dispatch
import org.gradle.internal.remote.internal.hub.protocol.EndOfStream
import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage

class QueueInitializerTest extends AbstractQueueTest {
    final QueueInitializer initializer = new QueueInitializer()
    final Dispatch<InterHubMessage> queue = Mock()

        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);
    }

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) {