trailersWithServerTruncatedResponse(Protocol.HTTP_2)
  }

  /**
   * If the server closes the connection while the client is consuming the response body, attempts
   * to peek or read the trailers should throw.
   */
  private fun trailersWithServerTruncatedResponse(protocol: Protocol) {
    val responseBody = "a".repeat(OKHTTP_CLIENT_WINDOW_SIZE)
    enableProtocol(protocol)

    server.enqueue(
      MockResponse

            @Override
            public <T> T lookup(Class<T> type) {
                throw new LookupException("empty lookup");
            }

            @Override
            public <T> T lookup(Class<T> type, String name) {
                throw new LookupException("empty lookup");
            }

            @Override

     */
    public boolean isStopped() {
        return status == STOPPED;
    }

    /**
     * Stops the timer.
     */
    public void stop() {
        if (status != ACTIVE) {
            throw new ClIllegalStateException(String.valueOf(status));
        }
        status = STOPPED;
    }

    /**
     * Restarts the timer.
     */
    public void restart() {
        status = ACTIVE;

        super(domain, username, (String) null, AuthenticationType.USER);
        if (passwordHash == null || passwordHash.length != 16) {
            throw new IllegalArgumentException("Password hash must be provided, expected length 16 byte");
        }
        this.ntHash = passwordHash;
    }

    /**
     * Create username/password credentials with specified domain

import okhttp3.Route
import okio.IOException

/**
 * Listener for connection events. Extend this class to monitor the new connections and closes.
 *
 * All event methods must execute fast, without external locking, cannot throw exceptions,
 * attempt to mutate the event parameters, or be reentrant back into the client.
 * Any IO - writing to files or network should be done asynchronously.
 */
internal abstract class ConnectionListener {
  /**

  @Override
  public final boolean hasNext() {
    return nextOrNull != null;
  }

  @Override
  public final T next() {
    if (nextOrNull == null) {
      throw new NoSuchElementException();
    }
    T oldNext = nextOrNull;
    nextOrNull = computeNext(oldNext);
    return oldNext;
  }

            if (logger.isDebugEnabled()) {
                logger.debug("{}:{}", query, boost);
            }
            return convertTermRangeQuery(context, termRangeQuery, boost);
        }
        throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**

    }

    /**
     * Returns the OSDD as a stream response.
     *
     * @return the stream response
     */
    public StreamResponse asStream() {
        if (osddFile == null) {
            throw ComponentUtil.getResponseManager().new404("Unsupported Open Search Description Document response.");
        }

  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_unsupportedPresentExistingValue() {
    try {
      assertEquals(
          "putIfAbsent(present, existingValue) should return present or throw",
          v0(),
          putIfAbsent(e0()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)

    if (cancel) {
      cancel = false
      eventSource.cancel()
    }
  }

  private fun nextEvent(): Any =
    events.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for event.")

  fun assertExhausted() {
    assertThat(events).isEmpty()
  }

  fun assertEvent(
    id: String?,
    type: String?,
    data: String,
  ) {