"Request header not permitted: 'Sec-WebSocket-Extensions'",
    )
  }

  @Test
  fun webSocketAndApplicationInterceptors() {
    val interceptedCount = AtomicInteger()
    client =
      client.newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain ->
            assertThat(chain.request().body).isNull()
            val response = chain.proceed(chain.request())

  }

  @Test
  fun newBuilderUrlResetsUrl() {
    val requestWithoutCache = Request.Builder().url("http://localhost/api").build()
    val builtRequestWithoutCache = requestWithoutCache.newBuilder().url("http://localhost/api/foo").build()
    assertThat(builtRequestWithoutCache.url).isEqualTo(
      "http://localhost/api/foo".toHttpUrl(),
    )
    val requestWithCache =
      Request.Builder()

        .connectTimeout(60, TimeUnit.SECONDS) // Deliberately exacerbate slow fallbacks.
        .dns { dnsResults }
        .fastFallback(true)
        .build()
    url =
      serverIpv4.url("/")
        .newBuilder()
        .host("localhost")
        .build()
  }

  @AfterEach
  internal fun tearDown() {
    serverIpv4.shutdown()
    serverIpv6.shutdown()
  }

  @Test

      }

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

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

    component: Component,
  ) {
    val builder = "http://host/".toHttpUrl().newBuilder()
    assertFailsWith<IllegalArgumentException> {
      component[builder] = codePointString
    }
  }

  private fun testPunycode(
    codePointString: String,
    component: Component,
  ) {
    val builder = "http://host/".toHttpUrl().newBuilder()
    component[builder] = codePointString
    val url = builder.build()

   * [newBuilder].
   *
   * @suppress this method breaks Dokka! https://github.com/Kotlin/dokka/issues/2473
   */
  fun tag(): Any? = tag<Any>()

  /**
   * Returns the tag attached with [type] as a key, or null if no tag is attached with that
   * key.
   */
  fun <T> tag(type: Class<out T>): T? = tag(type.kotlin)

  fun newBuilder(): Builder = Builder(this)

  /**

    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()

  }

  @Test
  fun newBuilderUrlResetsUrl() {
    val requestWithoutCache = Request.Builder().url("http://localhost/api").build()
    val builtRequestWithoutCache = requestWithoutCache.newBuilder().url("http://localhost/api/foo").build()
    assertThat(builtRequestWithoutCache.url).isEqualTo(
      "http://localhost/api/foo".toHttpUrl(),
    )
    val requestWithCache =
      Request.Builder()

                                    && versioning.getSnapshot().getBuildNumber() > 0) {
                                versioning = Versioning.newBuilder()
                                        .lastUpdated(versioning.getLastUpdated())
                                        .snapshot(Snapshot.newBuilder()
                                                .localCopy(true)
                                                .build())

          }
          newRoutePlanner = false
          continue
        }

        // Clear out downstream interceptor's additional request headers, cookies, etc.
        response =
          response.newBuilder()
            .request(request)
            .priorResponse(priorResponse?.stripBody())
            .build()

        val exchange = call.interceptorScopedExchange