component: Component,
  ) {
    val expected = component.canonicalize(encoding.encode(codePoint))
    val urlString = component.urlString(expected)
    val url = urlString.toHttpUrl()
    val actual = component.encodedValue(url)
    if (actual != expected) {
      fail("Encoding $component $codePoint using $encoding: '$actual' != '$expected'")
    }
  }

  private fun testEncodeAndDecode(
    codePoint: Int,

  fun encodedName(index: Int): String = encodedNames[index]

  fun name(index: Int): String = encodedName(index).percentDecode(plusIsSpace = true)

  fun encodedValue(index: Int): String = encodedValues[index]

  fun value(index: Int): String = encodedValue(index).percentDecode(plusIsSpace = true)

  override fun contentType(): MediaType = CONTENT_TYPE

  override fun contentLength(): Long = writeOrCountBytes(null, true)

    assertThat(body.name(1)).isEqualTo("space, the")
    assertThat(body.name(2)).isEqualTo("%25")
    assertThat(body.encodedValue(0)).isEqualTo("c%2B%3D%26+d")
    assertThat(body.encodedValue(1)).isEqualTo("final+frontier")
    assertThat(body.encodedValue(2)).isEqualTo("%2525")
    assertThat(body.value(0)).isEqualTo("c+=& d")
    assertThat(body.value(1)).isEqualTo("final frontier")

      addQueryParameter(name, value)
    }

    fun setEncodedQueryParameter(
      encodedName: String,
      encodedValue: String?,
    ) = apply {
      removeAllEncodedQueryParameters(encodedName)
      addEncodedQueryParameter(encodedName, encodedValue)
    }

    fun removeAllQueryParameters(name: String) =
      apply {
        if (encodedQueryNamesAndValues == null) return this

    val formBody: FormBody = FormBody.Builder().build()
    val size: Int = formBody.size
    val encodedName: String = formBody.encodedName(0)
    val name: String = formBody.name(0)
    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())

	public final fun -deprecated_size ()I
	public fun contentLength ()J
	public fun contentType ()Lokhttp3/MediaType;
	public final fun encodedName (I)Ljava/lang/String;
	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
}

                    exclude_none=exclude_none,
                    custom_encoder=custom_encoder,
                    sqlalchemy_safe=sqlalchemy_safe,
                )
                encoded_value = jsonable_encoder(
                    value,
                    by_alias=by_alias,
                    exclude_unset=exclude_unset,
                    exclude_none=exclude_none,

pkg encoding/gob, method (*Decoder) Decode(interface{}) error
pkg encoding/gob, method (*Decoder) DecodeValue(reflect.Value) error
pkg encoding/gob, method (*Encoder) Encode(interface{}) error
pkg encoding/gob, method (*Encoder) EncodeValue(reflect.Value) error
pkg encoding/gob, type CommonType struct
pkg encoding/gob, type CommonType struct, Id typeId
pkg encoding/gob, type CommonType struct, Name string
pkg encoding/gob, type Decoder struct