return new NullRemovalListener<>();
  }

  /** Type-inferring factory method for creating a {@link QueuingRemovalListener}. */
  @GwtIncompatible // ConcurrentLinkedQueue
  static <K, V> QueuingRemovalListener<K, V> queuingRemovalListener() {
    return new QueuingRemovalListener<>();
  }

  /** Type-inferring factory method for creating a {@link CountingRemovalListener}. */

    }

    public void test_ingest_withFactory() {
        // Setup ingest factory
        TestIngester ingester = new TestIngester();
        ingestFactory.ingesters.add(ingester);
        ComponentUtil.register(ingestFactory, "ingestFactory");

        // Reinitialize to pick up factory
        indexUpdateCallback.init();

        DataStoreParams paramMap = new DataStoreParams();

 * address also includes the SSL socket factory, hostname verifier, and certificate pinner.
 *
 * HTTP requests that share the same [Address] may also share the same [Connection].
 */
class Address(
  uriHost: String,
  uriPort: Int,
  /** Returns the service that will be used to resolve IP addresses for hostnames. */
  @get:JvmName("dns") val dns: Dns,
  /** Returns the socket factory for new connections. */

  companion object {
    @JvmStatic
    @Parameters(name = "{0}")
    fun data(): Collection<SocketAdapter> =
      listOfNotNull(
        DeferredSocketAdapter(ConscryptSocketAdapter.factory),
        DeferredSocketAdapter(AndroidSocketAdapter.factory("org.conscrypt")),
        StandardAndroidSocketAdapter.buildIfSupported("org.conscrypt"),
      )
  }

    }

    /**
     * Registers this ingester with the ingest factory.
     * This makes the ingester available for processing documents.
     */
    public void register() {
        getIngestFactory().add(this);
    }

    /**
     * Gets the ingest factory instance for managing ingesters.
     *
     * @return the ingest factory instance
     */
    protected IngestFactory getIngestFactory() {

class RetryConnectionTest {
  private val factory = TestValueFactory()
  private val handshakeCertificates = localhost()
  private val retryableException = SSLHandshakeException("Simulated handshake exception")

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private var client = clientTestRule.newClient()

  @AfterEach internal fun tearDown() {
    factory.close()
  }

    }

    // Test register with null factory throws exception
    public void test_register_nullFactory() {
        ComponentUtil.register(null, "scriptEngineFactory");

        try {
            testScriptEngine.register();
            fail("Should throw exception when factory is null");
        } catch (NullPointerException e) {
            // Expected exception
        }

      ).isEqualTo(
        "sun.security.ssl.SSLSocketImpl",
      )
    }
  }

  @Test
  fun testSupportedProtocols() {
    val factory = SSLSocketFactory.getDefault()
    assertThat(factory.javaClass.name).isEqualTo("sun.security.ssl.SSLSocketFactoryImpl")
    val s = factory.createSocket() as SSLSocket

    when {
      PlatformVersion.majorVersion > 11 ->
        assertThat(s.enabledProtocols.toList()).containsExactly(

package org.codelibs.fess.api;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import jakarta.servlet.http.HttpServletRequest;

/**
 * Factory class for managing and retrieving web API managers.
 * This factory maintains a collection of web API managers and provides
 * functionality to find the appropriate manager for incoming requests.
 */
public class WebApiManagerFactory {

    /**

  open fun newSSLContext(): SSLContext = SSLContext.getInstance("TLS")

  open fun platformTrustManager(): X509TrustManager {
    val factory =
      TrustManagerFactory.getInstance(
        TrustManagerFactory.getDefaultAlgorithm(),
      )
    factory.init(null as KeyStore?)
    val trustManagers = factory.trustManagers!!
    check(trustManagers.size == 1 && trustManagers[0] is X509TrustManager) {