}

        @Override
        public void dispatch(MethodInvocation message) {
        }
    }

    private static class SingletonDispatch<T> extends BroadcastDispatch<T> {
        private final Object handler;
        private final Dispatch<MethodInvocation> dispatch;

        SingletonDispatch(Class<T> type, Object handler, Dispatch<MethodInvocation> dispatch) {
            super(type);

 */
package org.gradle.internal.dispatch

import spock.lang.Specification

class FailureHandlingDispatchTest extends Specification {
    final Dispatch<String> target = Mock()
    final DispatchFailureHandler<String> handler = Mock()
    final FailureHandlingDispatch<String> dispatch = new FailureHandlingDispatch<String>(target, handler)

    def "dispatches message to target"() {
        when:

    val requestsMade = mutableListOf<RecordedRequest>()
    val dispatcher: Dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse {
          requestsMade.add(request)
          return MockResponse()
        }
      }
    assertThat(requestsMade.size).isEqualTo(0)
    mockWebServer.dispatcher = dispatcher
    val url = mockWebServer.url("/").toUrl()

 */

package org.gradle.internal.remote.internal;

import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.Receive;

/**
 * <p>A messaging endpoint which allows push-style dispatch and pull-style receive.
 *
 * <p>Implementations are not guaranteed to be completely thread-safe.
 * However, the implementations:
 * <ul>

            return result;
        }

        private void endNotification(List<Dispatch<MethodInvocation>> dispatchers) {
            for (Dispatch<MethodInvocation> dispatcher : dispatchers) {
                if (dispatcher instanceof ListenerDetails) {
                    ListenerDetails listener = (ListenerDetails) dispatcher;
                    listener.endNotification();
                }
            }

        connection.stop()

        then:
        1 * delegate.stop()
        0 * staleAddressDetector._
    }

    def "dispatches messages"() {
        def message = Stub(Message)

        when:
        connection.dispatch(message)

        then:
        1 * delegate.dispatch(message)
        0 * staleAddressDetector._
    }

    def "receives messages"() {
        def message = Stub(Message)

 */

package org.gradle.internal.dispatch;

/**
 * A sink for a bounded stream of messages.
 *
 * <p>Implementations are not required to be thread-safe.
 */
public interface BoundedDispatch<T> extends Dispatch<T>, StreamCompletion {
    /**
     * Signals the end of the stream of messages. No further messages should be dispatched using the {@link Dispatch#dispatch(Object)} method after this method is called.
     */

```

#### Dispatcher

By default MockWebServer uses a queue to specify a series of responses. Use a
Dispatcher (`import okhttp3.mockwebserver.Dispatcher`) to handle requests using another policy. One natural policy is to
dispatch on the request path.
You can, for example, filter the request instead of using `server.enqueue()`.

```java
final Dispatcher dispatcher = new Dispatcher() {

    @Override

    mockWebServer.start(0)
    mockWebServer.start(InetAddress.getLocalHost(), 0)
    mockWebServer.shutdown()
    var dispatcher: Dispatcher = mockWebServer.dispatcher
    dispatcher = mockWebServer.dispatcher
    mockWebServer.dispatcher = QueueDispatcher()
    mockWebServer.dispatcher = QueueDispatcher()
    mockWebServer.close()
  }

  @Test @Ignore
  fun pushPromise() {

import mockwebserver3.SocketPolicy.StallSocketAtStart

internal fun Dispatcher.wrap(): mockwebserver3.Dispatcher {
  if (this is QueueDispatcher) return this.delegate

  val delegate = this
  return object : mockwebserver3.Dispatcher() {
    override fun dispatch(request: mockwebserver3.RecordedRequest): mockwebserver3.MockResponse {
      return delegate.dispatch(request.unwrap()).wrap()
    }