}

  public void testConcurrencyLevel_zero() {
    Interners.InternerBuilder builder = Interners.newBuilder();
    assertThrows(IllegalArgumentException.class, () -> builder.concurrencyLevel(0));
  }

  public void testConcurrencyLevel_negative() {
    Interners.InternerBuilder builder = Interners.newBuilder();
    assertThrows(IllegalArgumentException.class, () -> builder.concurrencyLevel(-42));
  }

        .also {
          listener.satisfactionFailure(call, it)
        }
    }

    // If we don't need the network, we're done.
    if (networkRequest == null) {
      return cacheResponse!!
        .newBuilder()
        .cacheResponse(cacheResponse.stripBody())
        .build()
        .also {
          listener.cacheHit(call, it)
        }
    }

    if (cacheResponse != null) {

   */
  public <N1 extends N> NetworkBuilder<N1, E> nodeOrder(ElementOrder<N1> nodeOrder) {
    NetworkBuilder<N1, E> newBuilder = cast();
    newBuilder.nodeOrder = checkNotNull(nodeOrder);
    return newBuilder;
  }

  /**
   * Specifies the order of iteration for the elements of {@link Network#edges()}.
   *

  private fun enableProtocol(protocol: Protocol) {
    enableTls()
    client =
      client
        .newBuilder()
        .protocols(listOf(protocol, Protocol.HTTP_1_1))
        .build()
    server.protocols = client.protocols
  }

  private fun enableTls() {
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),

      }

      val conditionalRequestHeaders = request.headers.newBuilder()
      conditionalRequestHeaders.addLenient(conditionName, conditionValue!!)

      val conditionalRequest =
        request
          .newBuilder()
          .headers(conditionalRequestHeaders.build())
          .build()
      return CacheStrategy(conditionalRequest, cacheResponse)

      "ConnectionReleased",
      "CallEnd",
    )
  }

  @Test
  fun sseReauths() {
    client =
      client
        .newBuilder()
        .authenticator { route, response ->
          response.request
            .newBuilder()
            .header("Authorization", "XYZ")
            .build()
        }.build()
    server.enqueue(
      MockResponse(
        code = 401,

 * This interface represents a single node in an XML document tree, containing information about
 * the node's name, value, attributes, and child nodes.
 *
 * <p>Example usage:</p>
 * <pre>
 * XmlNode node = XmlNode.newBuilder()
 *     .name("configuration")
 *     .attribute("version", "1.0")
 *     .child(XmlNode.newInstance("property", "value"))
 *     .build();
 * </pre>
 *
 * @since 4.0.0
 */
@Experimental
@ThreadSafe

    val httpClient =
      HttpClient
        .newBuilder()
        .followRedirects(NORMAL)
        .build()

    server.enqueue(
      MockResponse
        .Builder()
        .body("hello, Java HTTP Client")
        .build(),
    )

    val request =
      HttpRequest
        .newBuilder(server.url("/").toUri())
        .header("Accept", "text/plain")
        .build()

  override fun intercept(chain: Interceptor.Chain): Response =
    if (algorithms.isNotEmpty() && chain.request().header("Accept-Encoding") == null) {
      val request =
        chain
          .request()
          .newBuilder()
          .header("Accept-Encoding", acceptEncoding)
          .build()

      val response = chain.proceed(request)

      decompress(response)
    } else {
      chain.proceed(chain.request())
    }

    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("")
    val topPrivateDomain: String? = httpUrl.topPrivateDomain()
    val resolve: HttpUrl? = httpUrl.resolve("")
    val getFromUrl: HttpUrl? = URL("").toHttpUrlOrNull()