var input: String? = null
  var base: String? = null
  var scheme = ""
  var username = ""
  var password: String? = null
  var host = ""
  var port = ""
  var path = ""
  var query = ""
  var fragment = ""

  fun expectParseFailure() = scheme.isEmpty()

  private operator fun set(
    name: String,
    value: String,
  ) {
    when (name) {
      "s" -> scheme = value
      "u" -> username = value

    val queryParameter: String? = httpUrl.queryParameter("")
    val queryParameterNames: Set<String> = httpUrl.queryParameterNames()
    val encodedFragment: String? = httpUrl.encodedFragment()
    val fragment: String? = httpUrl.fragment()
    val getFromUrl: HttpUrl? = HttpUrl.get(URL(""))
    val getFromUri: HttpUrl? = HttpUrl.get(URI(""))
    val parse: HttpUrl? = HttpUrl.parse("")
  }

  @Test @Disabled

    public Query toQuery(final QueryShardContext context) throws IOException {
        return queryBuilder.toQuery(context);
    }

    /**
     * Returns whether this query builder is a fragment.
     *
     * @return true if this is a fragment, false otherwise
     */
    @Override
    public boolean isFragment() {
        return queryBuilder.isFragment();
    }

    /**
     * Sets the query name.
     *

        String parentUrl = "http://example.com/parent?query=test&id=123";
        String url = "http://example.com/child#fragment";
        ContentNotFoundException exception = new ContentNotFoundException(parentUrl, url);

        assertNotNull(exception);
        assertEquals("Not Found: http://example.com/child#fragment Parent: http://example.com/parent?query=test&id=123",
                exception.getMessage());

  |I|S|S|S| CODE  |  |A|             |
  |N|V|V|V|       |  |S|             |
  | |1|2|3|       |  |K|             |
  +-+-+-+-+-------+  +-+-------------+
   */

  /** Byte 0 flag for whether this is the final fragment in a message. */
  internal const val B0_FLAG_FIN = 128

  /** Byte 0 reserved flag 1. Must be 0 unless negotiated otherwise. */
  internal const val B0_FLAG_RSV1 = 64

    val queryParameterName: String = httpUrl.queryParameterName(0)
    val queryParameterValue: String? = httpUrl.queryParameterValue(0)
    val encodedFragment: String? = httpUrl.encodedFragment
    val fragment: String? = httpUrl.fragment
    val redact: String = httpUrl.redact()
    var builder: HttpUrl.Builder = httpUrl.newBuilder()
    var resolveBuilder: HttpUrl.Builder? = httpUrl.newBuilder("")

        .escapeForUri(
          '%'.code,
          '\\'.code,
          '^'.code,
          '`'.code,
          '{'.code,
          '|'.code,
          '}'.code,
        )

    Component.FRAGMENT ->
      UrlComponentEncodingTesterJvmPlatform()
        .escapeForUri(
          '%'.code,
          ' '.code,
          '"'.code,
          '#'.code,
          '<'.code,
          '>'.code,

        HttpUrl link = response.request().url().resolve(href);
        if (link == null) continue; // URL is either invalid or its scheme isn't http/https.
        HttpUrl linkWithoutFragment = link.newBuilder().fragment(null).build();
        if (!queue.offer(linkWithoutFragment)) break; // Queue is full.
      }
    }
  }

  public static void main(String[] args) throws IOException {
    if (args.length != 2) {

 * **Headers**: size
 * **HeldCertificate**: certificate, keyPair
 * **HttpLoggingInterceptor**: level
 * **HttpUrl**: encodedFragment, encodedPassword, encodedPath, encodedPathSegments, encodedQuery,
   encodedUsername, fragment, host, password, pathSegments, pathSize, port, query,
   queryParameterNames, querySize, scheme, username
 * **MockResponse**: headers, http2ErrorCode, socketPolicy, status, trailers

   */
  @get:JvmName("proxySelector") val proxySelector: ProxySelector,
) {
  /**
   * Returns a URL with the hostname and port of the origin server. The path, query, and fragment of
   * this URL are always empty, since they are not significant for planning a route.
   */
  @get:JvmName("url")
  val url: HttpUrl =
    HttpUrl
      .Builder()