default int getMaxReadingNum() {
        return 10;
    }

    /**
     * Initializes the converter.
     *
     * @throws IOException if an I/O error occurs during initialization.
     */
    void init() throws IOException;

    /**
     * Converts the given text into a list of readings based on the specified field and languages.
     *
     * @param text the text to be converted.

        val socketFactory = keyStoreFactory.sslContext().socketFactory

        val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
        trustManagerFactory.init(keyStoreFactory.loadOrCreateKeyStore())
        val trustManager = trustManagerFactory.trustManagers.first() as X509TrustManager

        sslSocketFactory(socketFactory, trustManager)
      }
  }

                return (context, query, boost) -> {
                    called.set(true);
                    return QueryBuilders.boolQuery();
                };
            }
        };
        queryProcessor.init();

        QueryContext context = new QueryContext(null, false);
        MatchAllDocsQuery query = new MatchAllDocsQuery();

        QueryBuilder queryBuilder = queryProcessor.execute(context, query, 1.0f);

  val adapter: SocketAdapter,
) {
  val context: SSLContext by lazy {
    val provider: Provider = Conscrypt.newProviderBuilder().provideTrustManager(true).build()

    SSLContext.getInstance("TLS", provider).apply {
      init(null, null, null)
    }
  }

  @Test
  fun testMatchesSupportedSocket() {
    val socketFactory = context.socketFactory

    val sslSocket = socketFactory.createSocket() as SSLSocket

        final String settingsTypeName = "test-settings-type";
        final String id = "BuildTest";

        final ReadingConverter converter = new ReadingConverter() {
            @Override
            public void init() throws IOException {

            }

            @Override
            public List<String> convert(String text, final String field, String... langs) throws IOException {
                return null;
            }

        ReadingConverterChain chain = new ReadingConverterChain();
        // chain.addConverter(new KatakanaConverter());
        chain.addConverter(new KatakanaToAlphabetConverter());
        chain.init();
        return chain;
    }

    protected Normalizer createDefaultNormalizer() {
        // TODO
        return new NormalizerChain();
    }

            final CrawlerContext crawlerContext = new CrawlerContext();
            final String sessionId = "id1";
            urlFilter.init(sessionId);
            crawlerContext.setUrlFilter(urlFilter);
            CrawlingParameterUtil.setCrawlerContext(crawlerContext);
            httpClient.init();
            httpClient.processRobotsTxt(url);
            assertEquals(1, crawlerContext.getRobotsTxtUrlSet().size());

    protected String[] fileProtocols = StringUtil.EMPTY_STRINGS;

    /**
     * Default constructor for ProtocolHelper.
     * Initializes the helper with empty protocol arrays that will be populated during init().
     */
    public ProtocolHelper() {
        // Default constructor
    }

    /**
     * Initializes the protocol helper by loading configured protocols from FessConfig

   */
  private val FLAGS = arrayOfNulls<String>(0x40) // Highest bit flag is 0x20.
  private val BINARY =
    Array(256) {
      format("%8s", Integer.toBinaryString(it)).replace(' ', '0')
    }

  init {
    FLAGS[FLAG_NONE] = ""
    FLAGS[FLAG_END_STREAM] = "END_STREAM"

    val prefixFlags = intArrayOf(FLAG_END_STREAM)

    FLAGS[FLAG_PADDED] = "PADDED"
    for (prefixFlag in prefixFlags) {

    /**
     * Whether to enter local passive mode.
     */
    protected boolean enterLocalPassiveMode;

    @Override
    public synchronized void init() {
        if (ftpAuthenticationHolder != null) {
            return;
        }

        super.init();

        final String systemKey = getInitParameter("ftpConfigSystemKey", FTPClientConfig.SYST_UNIX, String.class);