@CollectionSize.Require(ZERO)
  public void testPeek_empty() {
    assertNull("emptyQueue.peek() should return null", getQueue().peek());
    expectUnchanged();
  }

  @CollectionSize.Require(ONE)
  public void testPeek_size1() {
    assertEquals("size1Queue.peek() should return first element", e0(), getQueue().peek());
    expectUnchanged();
  }

  @CollectionFeature.Require(KNOWN_ORDER)

 * an HTTP call to a remote server.
 */
interface TrailersSource {
  @Throws(IOException::class)
  fun peek(): Headers? = null

  @Throws(IOException::class)
  fun get(): Headers

  companion object {
    @JvmField
    val EMPTY: TrailersSource =
      object : TrailersSource {
        override fun peek() = Headers.EMPTY

        override fun get() = Headers.EMPTY
      }
  }

    // other threads waiting on take() will also return.
    if (result == DEAD_LETTER) responseQueue.add(DEAD_LETTER)

    return result
  }

  public override fun peek(): MockResponse = responseQueue.peek() ?: failFastResponse ?: super.peek()

  public open fun enqueue(response: MockResponse) {
    responseQueue.add(response)
  }

  public open fun clear() {
    responseQueue.clear()
  }

    assertEquals(3, (int) mmHeap.pollLast());
    assertEquals(1, (int) mmHeap.peek());
    assertEquals(2, (int) mmHeap.peekLast());
    assertEquals(2, (int) mmHeap.pollLast());
    assertEquals(1, (int) mmHeap.peek());
    assertEquals(1, (int) mmHeap.peekLast());
    assertEquals(1, (int) mmHeap.pollLast());
    assertNull(mmHeap.peek());
    assertNull(mmHeap.peekLast());
    assertNull(mmHeap.pollLast());
  }

public abstract class okhttp3/mockwebserver/Dispatcher {
	public fun <init> ()V
	public abstract fun dispatch (Lokhttp3/mockwebserver/RecordedRequest;)Lokhttp3/mockwebserver/MockResponse;
	public fun peek ()Lokhttp3/mockwebserver/MockResponse;
	public fun shutdown ()V
}

public final class okhttp3/mockwebserver/MockResponse : java/lang/Cloneable {
	public static final field Companion Lokhttp3/mockwebserver/MockResponse$Companion;

 * limitations under the License.
 */
package okhttp3.mockwebserver

abstract class Dispatcher {
  @Throws(InterruptedException::class)
  abstract fun dispatch(request: RecordedRequest): MockResponse

  open fun peek(): MockResponse = MockResponse().apply { this.socketPolicy = SocketPolicy.KEEP_OPEN }

  open fun shutdown() {}

    public boolean remove(Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.remove(object);
    }

    @Override
    public @Nullable E peek() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.peek();
    }

    @Override
    public E element() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.element();
    }

    @Override

  @Test @Ignore
  fun dispatcherFromMockWebServer() {
    val dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse = TODO()

        override fun peek(): MockResponse = TODO()

        override fun shutdown() = TODO()
      }
  }

  @Test @Ignore
  fun mockResponse() {
    var mockResponse: MockResponse = MockResponse()

                object : TrailersSource {
                  override fun peek() = exchange.peekTrailers()

                  override fun get(): Headers {
                    val source = responseBody.source()
                    if (source.isOpen) {
                      source.skipAll()
                    }
                    return peek() ?: error("null trailers after exhausting response body?!")
                  }

    segment.readCount.incrementAndGet();
    segment.count = 1;
    segment.totalWeight = 1;

    assertSame(entry, table.get(0));
    assertSame(entry, segment.accessQueue.peek());
    assertSame(entry, segment.writeQueue.peek());

    segment.clear();
    assertNull(table.get(0));
    assertTrue(segment.accessQueue.isEmpty());
    assertTrue(segment.writeQueue.isEmpty());