client -> "$okHttpName $peerName"
          else -> "MockWebServer $peerName"
        }
      this.source = source
      this.sink = sink
    }

    fun listener(listener: Listener) =
      apply {
        this.listener = listener
      }

    fun pushObserver(pushObserver: PushObserver) =
      apply {
        this.pushObserver = pushObserver
      }

  val dispatcher = Dispatcher(executor)
  val listener = RecordingEventListener()
  var client =
    clientTestRule.newClientBuilder()
      .dns { throw UnknownHostException() }
      .dispatcher(dispatcher)
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()

  @BeforeEach
  fun setUp() {
    dispatcher.maxRequests = 20
    dispatcher.maxRequestsPerHost = 10
    listener.forbidLock(dispatcher)
  }

  @Test

  protected SettableFuture<Integer> inputFuture;
  protected ListenableFuture<T> resultFuture;
  protected MockFutureListener listener;

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    inputFuture = SettableFuture.create();
    resultFuture = buildChainingFuture(inputFuture);
    listener = new MockFutureListener(resultFuture);
  }

  public void testFutureGetBeforeCallback() throws Exception {

public class BlockDetailRenderer {
    private final GenerationListener listener;
    private final LinkRenderer linkRenderer;
    private final ElementWarningsRenderer warningsRenderer = new ElementWarningsRenderer();

    public BlockDetailRenderer(LinkRenderer linkRenderer, GenerationListener listener) {
        this.linkRenderer = linkRenderer;
        this.listener = listener;
    }

    public void renderTo(BlockDoc blockDoc, Element parent) {

 * listener.
 *
 * @deprecated use {@link org.apache.maven.api.services.ModelBuilder} instead
 */
@Deprecated(since = "4.0.0")
interface ModelBuildingEventCatapult {

    /**
     * Notifies the specified listener of the given event.
     *
     * @param listener The listener to notify, must not be {@code null}.

    val response =
      Response.Builder().request(request).code(200).message("").protocol(Protocol.HTTP_2)
        .build()
    val listener = loggingEventListenerFactory.create(call)
    listener.cacheConditionalHit(call, response)
    listener.cacheHit(call, response)
    listener.cacheMiss(call)
    listener.satisfactionFailure(call, response)
    logRecorder

    return delegate!!.session
  }

  override fun addHandshakeCompletedListener(listener: HandshakeCompletedListener) {
    delegate!!.addHandshakeCompletedListener(listener)
  }

  override fun removeHandshakeCompletedListener(listener: HandshakeCompletedListener) {
    delegate!!.removeHandshakeCompletedListener(listener)
  }

  @Throws(IOException::class)
  override fun startHandshake() {

    }
    responseBody.close()
    assertEquals(if (connectionType == H2) 1 else 0, client.connectionPool.connectionCount())

    cancelLatch.await()

    val events = listener.eventSequence.filter { isConnectionEvent(it) }.map { it.name }
    listener.clearAllEvents()

    assertThat(events).startsWith("CallStart", "ConnectStart", "ConnectEnd", "ConnectionAcquired")
    if (cancelMode == CANCEL) {

  ) {
  }

  /**
   * TODO description.
   *
   * No further calls to this listener will be made.
   */
  open fun onClosed(eventSource: EventSource) {
  }

  /**
   * Invoked when an event source has been closed due to an error reading from or writing to the
   * network. Incoming events may have been lost. No further calls to this listener will be made.
   */
  open fun onFailure(
    eventSource: EventSource,

            final Object bean = instantiateObject(implType);
            if (null == value) {
                processConfiguration(lookup, bean, loader, configuration, evaluator, listener);
            } else {
                new CompositeBeanHelper(lookup, loader, evaluator, listener).setDefault(bean, value, configuration);
            }
            return bean;
        } catch (final ComponentConfigurationException e) {