public abstract fun withCache (Lokhttp3/Cache;)Lokhttp3/Interceptor$Chain;
	public abstract fun withCertificatePinner (Lokhttp3/CertificatePinner;)Lokhttp3/Interceptor$Chain;
	public abstract fun withConnectTimeout (ILjava/util/concurrent/TimeUnit;)Lokhttp3/Interceptor$Chain;
	public abstract fun withConnectionPool (Lokhttp3/ConnectionPool;)Lokhttp3/Interceptor$Chain;

    inline fun addInterceptor(crossinline block: (chain: Interceptor.Chain) -> Response) =
      addInterceptor(Interceptor { chain -> block(chain) })

    /**
     * Returns a modifiable list of interceptors that observe a single network request and response.
     * These interceptors must call [Interceptor.Chain.proceed] exactly once: it is an error for a

        // Verify the exception chain
        assertNotNull(runtimeException);
        assertEquals(servletException, runtimeException.getCause());
        assertEquals(rootCause, servletException.getCause());

        // Verify messages in the chain
        assertTrue(runtimeException.getMessage().contains(ServletException.class.getName()));

          break;
        }
      }
    }
  }

  /**
   * Represents a detected cycle in lock acquisition ordering. The exception includes a causal chain
   * of {@code ExampleStackTrace} instances to illustrate the cycle, e.g.
   *
   * <pre>
   * com....PotentialDeadlockException: Potential Deadlock from LockC -&gt; ReadWriteA
   *   at ...
   *   at ...

- `path` - Le chemin du fichier à diffuser.
- `headers` - D'éventuels en-têtes personnalisés à inclure, sous forme de dictionnaire.
- `media_type` - Une chaîne donnant le media type. Si non défini, le nom du fichier ou le chemin sera utilisé pour en déduire un media type.
- `filename` - Si défini, sera inclus dans l'en-tête `Content-Disposition` de la réponse.

    assert resp.status_code == 200
    assert resp.json() == {"status": "ok"}
    assert resp.headers.get("X-Direct") == "set"


def test_response_dependency_chain():
    """Response dependency should work in a chain of dependencies."""
    app = FastAPI()

    def first_modifier(response: Response) -> Response:
        response.headers["X-First"] = "1"
        return response

    def second_modifier(

  internal fun newCodec(
    client: OkHttpClient,
    chain: RealInterceptorChain,
  ): ExchangeCodec {
    val okHttpSocket = this.socket
    val http2Connection = this.http2Connection

    return if (http2Connection != null) {
      Http2ExchangeCodec(client, this, chain, http2Connection)
    } else {
      javaNetSocket.soTimeout = chain.readTimeoutMillis()

      client
        .newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain ->
            ready.countDown()
            try {
              proceed.await(5, TimeUnit.SECONDS)
            } catch (e: InterruptedException) {
              throw RuntimeException(e)
            }
            chain.proceed(chain.request())
          },
        ).build()

            converter = new LangAnalyzerConverter(null);
        } else {
            final ReadingConverterChain chain = new ReadingConverterChain();
            for (final String lang : langs) {
                chain.addConverter(new LangAnalyzerConverter(lang));
            }
            converter = chain;
        }
        return converter.convert(text, field);
    }

    /**

    protected static ReadingConverter createDefaultReadingConverter() throws IOException {
        ReadingConverterChain chain = new ReadingConverterChain();
        chain.addConverter(new KatakanaToAlphabetConverter());
        chain.init();
        return chain;
    }

    protected static Normalizer createDefaultNormalizer() {
        return new NormalizerChain();
    }