super("default", executor, Dispatcher.legacyAsync(), subscriberExceptionHandler);
  }

  /**
   * Creates a new AsyncEventBus that will use {@code executor} to dispatch events.
   *
   * @param executor Executor to use to dispatch events. It is the caller's responsibility to shut
   *     down the executor after the last event has been posted to this event bus.
   */

    def dispatcher = new ReportStatusDispatcher()
    def connection = Mock(Connection)

    def "ignores failed dispatch and does not receive"() {
        given:
        def message = new ReportStatus(UUID.randomUUID(), "TOKEN".bytes)
        connection.dispatch(message) >> { throw new RuntimeException("Cannot dispatch") }

        when:
        dispatcher.dispatch(connection, message)

        then:

public class StopDispatcherTest extends Specification {

    def dispatcher = new StopDispatcher()
    def connection = Mock(Connection)

    def "ignores failed dispatch and does not receive"() {
        given:
        def message = new Stop(UUID.randomUUID())
        connection.dispatch(message) >> { throw new RuntimeException("Cannot dispatch") }

        when:
        dispatcher.dispatch(connection, message)

        then:

    super("default", executor, Dispatcher.legacyAsync(), subscriberExceptionHandler);
  }

  /**
   * Creates a new AsyncEventBus that will use {@code executor} to dispatch events.
   *
   * @param executor Executor to use to dispatch events. It is the caller's responsibility to shut
   *     down the executor after the last event has been posted to this event bus.
   */

 */
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>

        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