buf.Write(fb)
	}
	buf.Write(frag)
	return buf.String(), err
}

// WriteTo implements io.WriterTo.
// This may make multiple calls to the [Reader.Read] method of the underlying [Reader].
// If the underlying reader supports the [Reader.WriteTo] method,
// this calls the underlying [Reader.WriteTo] without buffering.
func (b *Reader) WriteTo(w io.Writer) (n int64, err error) {
	b.lastByte = -1
	b.lastRuneSize = -1

          arraySize * Long.SIZE, BloomFilter.create(unencodedCharsFunnel(), i, fpp).bitSize());
    }
  }

  /**
   * Tests that bitSize() can be used to predict the serialization size produced by writeTo().
   *
   * <p>The serialization format consists of a 6-byte header (1 byte strategy, 1 byte hash
   * functions, 4 bytes array length) followed by the bit array data (bitSize / 8 bytes).
   */

    // Call 1: set a deadline on the request body.
    val requestBody1: RequestBody =
      object : RequestBody() {
        override fun contentType(): MediaType = "text/plain".toMediaType()

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("abc")
          sink.timeout().deadline(5, TimeUnit.SECONDS)
        }
      }
    val request1 =
      Request
        .Builder()

   * versions.
   */
  public byte[] toByteArray() {
    ByteBuffer buff = ByteBuffer.allocate(BYTES).order(ByteOrder.LITTLE_ENDIAN);
    writeTo(buff);
    return buff.array();
  }

  /**
   * Writes to the given {@link ByteBuffer} a byte representation of this instance.
   *

      return null
    }

    val entry = Entry(response)
    var editor: DiskLruCache.Editor? = null
    try {
      editor = cache.edit(key(response.request.url)) ?: return null
      entry.writeTo(editor)
      return RealCacheRequest(editor)
    } catch (_: IOException) {
      abortQuietly(editor)
      return null
    }
  }

  @Throws(IOException::class)

}

public abstract interface class mockwebserver3/MockResponseBody {
	public abstract fun getContentLength ()J
	public abstract fun writeTo (Lokio/BufferedSink;)V
}

public final class mockwebserver3/MockWebServer : java/io/Closeable {
	public fun <init> ()V
	public fun close ()V
	public final fun enqueue (Lmockwebserver3/MockResponse;)V

	public final fun encodedValue (I)Ljava/lang/String;
	public final fun name (I)Ljava/lang/String;
	public final fun size ()I
	public final fun value (I)Ljava/lang/String;
	public fun writeTo (Lokio/BufferedSink;)V
}

public final class okhttp3/FormBody$Builder {
	public fun <init> ()V
	public fun <init> (Ljava/nio/charset/Charset;)V

          url = server.url("/foo"),
          body =
            object : RequestBody() {
              override fun contentType(): MediaType = "text/plain; charset=utf-8".toMediaType()

              override fun writeTo(sink: BufferedSink) {
                sink.write(postBytes)
              }
            },
        ),
      )
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("ABCDE")

    assertThat(request.body?.contentLength()).isEqualTo(-1L)
    assertThat(request.body?.contentType()).isEqualTo(mediaType)

    val requestBodyBytes =
      Buffer()
        .apply {
          request.body?.writeTo(this)
        }

    val decompressedRequestBody =
      GzipSource(requestBodyBytes).use {
        it.buffer().readUtf8()
      }

    val encodedValue: String = formBody.encodedValue(0)
    val value: String = formBody.value(0)
    val contentType: MediaType = formBody.contentType()
    val contentLength: Long = formBody.contentLength()
    formBody.writeTo(Buffer())
    val requestBody: RequestBody = formBody
  }

  @Test
  fun formBodyBuilder() {
    var builder: FormBody.Builder = FormBody.Builder()
    builder = FormBody.Builder(Charsets.UTF_8)