chain.add(normalizer1);
        chain.add(normalizer2);
        chain.add(normalizer3);

        String result = chain.normalize("test", "field");

        assertEquals("test-1-2-3", result);
    }

    @Test
    public void test_chainWithCustomNormalizer() throws Exception {
        NormalizerChain chain = new NormalizerChain();
        chain.add((text, field, langs) -> text.trim());

            break;
        case FAVORITE:
            processFavoriteRequest(request, response, chain);
            break;
        case FAVORITES:
            processFavoritesRequest(request, response, chain);
            break;
        case PING:
            processPingRequest(request, response, chain);
            break;
        case SCROLL:

 * be used for the returned response, or to validate a cached response with a conditional GET.
 */
object ConnectInterceptor : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    val exchange = realChain.call.initExchange(realChain)
    val connectedChain = realChain.copy(exchange = exchange)
    return connectedChain.proceed(realChain.request)
  }

- L'API vérifie ce `username` et ce `password`, et répond avec un « token » (nous n'avons encore rien implémenté de tout cela).
    - Un « token » n'est qu'une chaîne contenant des informations que nous pouvons utiliser plus tard pour vérifier cet utilisateur.
    - Normalement, un token est configuré pour expirer après un certain temps.

    @Override public Response intercept(Chain chain) throws IOException {
      long t1 = System.nanoTime();
      Request request = chain.request();
      logger.info(String.format("Sending request %s on %s%n%s",
          request.url(), chain.connection(), request.headers()));
      Response response = chain.proceed(request);

      long t2 = System.nanoTime();

      ),
    isDefault: Boolean,
  ) {
    fun <T> Override<T>.testApplicationInterceptor(chain: Interceptor.Chain): Response {
      val defaultValue = chain.value()
      assertThat(isDefaultValue(chain.value())).isTrue()
      val withOverride = chain.withOverride(nonDefaultValue)
      assertThat(chain).isNotSameInstanceAs(withOverride)
      assertThat(isDefaultValue(withOverride.value())).isFalse()

import okhttp3.internal.platform.Platform

/**
 * Computes the effective certificate chain from the raw array returned by Java's built in TLS APIs.
 * Cleaning a chain returns a list of certificates where the first element is `chain[0]`, each
 * certificate is signed by the certificate that follows, and the last certificate is a trusted CA
 * certificate.
 *
 * Use of the chain cleaner is necessary to omit unexpected certificates that aren't relevant to

     * @param request The servlet request
     * @param response The servlet response
     * @param chain The filter chain
     * @throws IOException If an I/O error occurs
     * @throws ServletException If a servlet error occurs
     */
    @Override
    public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain)
            throws IOException, ServletException {

        TestFilterChain chain = new TestFilterChain();

        manager.process(request, response, chain);

        assertTrue(manager.isProcessCalled());
        assertFalse(chain.wasDoFilterCalled());
    }

    @Test
    public void test_process_withChainContinuation() throws IOException, ServletException {
        // Test process with chain continuation

 * [IOException] if the call was canceled.
 */
class RetryAndFollowUpInterceptor : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    var request = chain.request
    val call = realChain.call
    var followUpCount = 0
    var priorResponse: Response? = null
    var newRoutePlanner = true