quarkus/extensions/elytron-security-properties-file/runtime/pom.xml
	quarkus/extensions/smallrye-jwt/runtime/pom.xml
	quarkus/test-framework/junit5/pom.xml
quarkus/integration-tests/grpc-interceptors/pom.xml
	quarkus/extensions/resteasy-reactive/quarkus-resteasy-reactive/runtime/pom.xml
	quarkus/extensions/grpc/runtime/pom.xml
	quarkus/test-framework/junit5/pom.xml

    // Capture the protocol as it is observed by the interceptor.
    val protocolRef = AtomicReference<Protocol?>()
    val interceptor =
      Interceptor { chain: Interceptor.Chain ->
        protocolRef.set(chain.connection()!!.protocol())
        chain.proceed(chain.request())
      }
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(interceptor)
        .build()

    // Capture the connection so that we can later make it stale.
    var connection: RealConnection? = null
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain ->
            connection = chain.connection() as RealConnection
            chain.proceed(chain.request())
          },
        ).build()

    server.enqueue(
      MockResponse

    // Seed the cache.
    val url = server.url("/")
    assertThat(get(url).body.string()).isEqualTo("A")

    // Confirm the interceptor isn't exercised.
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(Interceptor { chain: Interceptor.Chain? -> throw AssertionError() })
        .build()
    assertThat(get(url).body.string()).isEqualTo("A")
  }

  @Test

      }

    client =
      client
        .newBuilder()
        .protocols(listOf(Protocol.H2_PRIOR_KNOWLEDGE))
        .socketFactory(socketFactory)
        .addNetworkInterceptor(
          Interceptor { chain ->
            try {
              chain.proceed(chain.request())
            } finally {
              firstConnectLatch.countDown()
            }
          },
        ).build()

HSPLokhttp3/internal/http/BridgeInterceptor;-><init>(Lokhttp3/CookieJar;)V
HSPLokhttp3/internal/http/BridgeInterceptor;->intercept(Lokhttp3/Interceptor$Chain;)Lokhttp3/Response;
HSPLokhttp3/internal/http/CallServerInterceptor;-><init>(Z)V
HSPLokhttp3/internal/http/CallServerInterceptor;->intercept(Lokhttp3/Interceptor$Chain;)Lokhttp3/Response;
HSPLokhttp3/internal/http/HttpHeaders;-><clinit>()V

    server.enqueue(MockResponse(body = "DEF"))
    val client2 =
      client
        .newBuilder()
        .addNetworkInterceptor(
          object : Interceptor {
            var executedCall = false

            override fun intercept(chain: Interceptor.Chain): Response {
              if (!executedCall) {
                // At this point, we have a healthy HTTP/2 connection. This call will trigger the

        "Expected 'Sec-WebSocket-Accept' header value '$acceptExpected' but was '$headerAccept'",
      )
    }

    return response.socket
      ?: throw ProtocolException("Web Socket socket missing: bad interceptor?")
  }

  /**
   * This accepts a [BufferedSource] instead of using [Socket.source], just in case we've already
   * received data from the peer. This accepts a [BufferedSink] for symmetry with the source.
   */

   * as a **network interceptor**. It will strip the `Location` header of impacted responses to
   * prevent the redirect.
   *
   * ```
   * OkHttpClient client = client.newBuilder()
   *   .addNetworkInterceptor(new LegacyRedirectInterceptor())
   *   .build();
   * ```
   */
  internal class LegacyRedirectInterceptor : Interceptor {