final ReadingConverterChain chain = new ReadingConverterChain();
        chain.addConverter(new AnalyzerConverter(client, settings));
        chain.addConverter(new KatakanaToAlphabetConverter());
        return chain;
    }

    /**
     * Creates a default ReadingConverterChain with a KatakanaToAlphabetConverter.
     *

      this.host = host;
    }

    @Override public Response intercept(Chain chain) throws IOException {
      Request request = chain.request();
      if (request.url().host().equals(host)) {
        request = request.newBuilder()
            .header("Authorization", credentials)
            .build();
      }
      return chain.proceed(request);
    }
  }

        TODO()
      }

      override fun withCookieJar(cookieJar: CookieJar): Interceptor.Chain {
        TODO()
      }

      override fun withCache(cache: Cache?): Interceptor.Chain {
        TODO()
      }

      override fun withProxy(proxy: Proxy?): Interceptor.Chain {
        TODO()
      }

      chain[0] = heldCertificate.certificate
      intermediates.copyInto(chain, 1)
      keyStore.setKeyEntry("private", heldCertificate.keyPair.private, password, chain)
    }

    // https://github.com/bcgit/bc-java/issues/1160
    val isBouncyCastle = keyStore.provider.name == "BC"
    val algorithm = if (isBouncyCastle) "PKIX" else KeyManagerFactory.getDefaultAlgorithm()

    val factory = KeyManagerFactory.getInstance(algorithm)

        // Default constructor
    }

    @Override
    public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain)
            throws IOException, ServletException {
        if (!ComponentUtil.available()) {
            chain.doFilter(request, response);
            return;
        }

        final HttpServletRequest httpRequest = (HttpServletRequest) request;

        RealRoutePlanner(
          taskRunner = client.taskRunner,
          connectionPool = chain.connectionPool.delegate,
          readTimeoutMillis = chain.readTimeoutMillis,
          writeTimeoutMillis = chain.writeTimeoutMillis,
          socketConnectTimeoutMillis = chain.connectTimeoutMillis,
          socketReadTimeoutMillis = chain.readTimeoutMillis,
          pingIntervalMillis = client.pingIntervalMillis,

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#chain(jcifs.internal.smb2.ServerMessageBlock2)
     */
    @Override
    public boolean chain(final ServerMessageBlock2 n) {
        n.setTreeId(Smb2Constants.UNSPECIFIED_TREEID);
        return super.chain(n);
    }

    /**
     * {@inheritDoc}
     *

        try {
            webApiFilter.doFilter(request, response, chain);
            fail("Expected IOException");
        } catch (IOException e) {
            assertEquals("Chain IOException", e.getMessage());
        } catch (ServletException e) {
            fail("Unexpected ServletException: " + e.getMessage());
        }
    }

    // Test doFilter when chain.doFilter throws ServletException
    @Test

    )
    fun getLevel(): Level = level

    @Throws(IOException::class)
    override fun intercept(chain: Interceptor.Chain): Response {
      val level = this.level

      val request = chain.request()
      if (level == Level.NONE) {
        return chain.proceed(request)
      }

      val logBody = level == Level.BODY
      val logHeaders = logBody || level == Level.HEADERS

   * status and second by priority, you might use {@code byStatus.compound(byPriority)}. For a
   * compound ordering with three or more components, simply chain multiple calls to this method.
   *
   * <p>An ordering produced by this method, or a chain of calls to this method, is equivalent to
   * one created using {@link Ordering#compound(Iterable)} on the same component comparators.
   *