.addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> Set<T> wrap(Set<T> delegate) {
    return new ForwardingSet<T>() {
      @Override
      protected Set<T> delegate() {
        return delegate;
      }
    };
  }

    }
  }

  private class ProgressRequestBody(
    private val delegate: RequestBody,
    private val progressListener: ProgressListener,
  ) : RequestBody() {
    override fun contentType() = delegate.contentType()

    @Throws(IOException::class)
    override fun contentLength(): Long = delegate.contentLength()

    @Throws(IOException::class)
    override fun writeTo(sink: BufferedSink) {

        .asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    ListMultimap<String, Integer> delegate = ArrayListMultimap.create();
    populate(delegate);
    return Multimaps.transformValues(delegate, Functions.<Integer>identity()).asMap();
  }

    return tailMap(fromKey);
  }

  private ImmutableSortedMap<K, V> newView(SortedMap<K, V> delegate) {
    return newView(delegate, comparator);
  }

  private static <K, V> ImmutableSortedMap<K, V> newView(
      SortedMap<K, V> delegate, Comparator<? super K> comparator) {
    return new ImmutableSortedMap<K, V>(delegate, comparator);
  }

  /*

          // requireNonNull(delegate) is safe for reasons similar to requireNonNull(sequencer).
          submittingTaskQueue.nextExecutor = requireNonNull(delegate);
          delegate = null;
        } else {
          // requireNonNull(delegate) is safe for reasons similar to requireNonNull(sequencer).
          Executor localDelegate = requireNonNull(delegate);
          delegate = null;
          this.task = task;

  /** Constructor for use by subclasses. */
  protected ForwardingSet() {}

  @Override
  protected abstract Set<E> delegate();

  @Override
  public boolean equals(@Nullable Object object) {
    return object == this || delegate().equals(object);
  }

  @Override
  public int hashCode() {
    return delegate().hashCode();
  }

  /**

 */
internal class MockWebServerSocket(
  val javaNetSocket: Socket,
) : Closeable,
  BufferedSocket {
  private val delegate = javaNetSocket.asOkioSocket()
  private val closedLatch = CountDownLatch(2)

  override val source: BufferedSource =
    object : ForwardingSource(delegate.source) {
      private var closed = false

      override fun close() {
        if (closed) return
        try {

  }

  @J2ktIncompatible
  @GwtIncompatible
  static Reader ignoringReader(Reader delegate, String toIgnore) {
    checkNotNull(delegate);
    checkNotNull(toIgnore);
    return new Reader() {
      @Override
      public int read() throws IOException {
        int readChar;
        do {
          readChar = delegate.read();
        } while (readChar != -1 && toIgnore.indexOf((char) readChar) >= 0);

/**
 * A sink that executes [trigger] after [triggerByteCount] bytes are written, and then skips all
 * subsequent bytes.
 */
internal class TriggerSink(
  private val delegate: Sink,
  private val triggerByteCount: Long,
  private val trigger: () -> Unit,
) : Sink by delegate {
  private var bytesWritten = 0L

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {

        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> SortedMultiset<T> wrap(SortedMultiset<T> delegate) {
    return new ForwardingSortedMultiset<T>() {
      @Override
      protected SortedMultiset<T> delegate() {
        return delegate;
      }
    };
  }