} catch (e: Exception) {
      synchronized(failures) {
        failures.add(e)
      }
    }
  }

  @Throws(UnknownHostException::class)
  private fun throwBestFailure(
    hostname: String,
    failures: List<Exception>,
  ): List<InetAddress> {
    if (failures.isEmpty()) {
      throw UnknownHostException(hostname)
    }

    val failure = failures[0]

    if (failure is UnknownHostException) {

import java.net.URI
import okhttp3.internal.format

class RecordingProxySelector : ProxySelector() {
  @JvmField val proxies = mutableListOf<Proxy>()

  val requestedUris = mutableListOf<URI>()
  val failures = mutableListOf<String>()

  override fun select(uri: URI): List<Proxy> {
    requestedUris.add(uri)
    return proxies
  }

  fun assertRequests(vararg expectedUris: URI?) {

    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
  ) {
  }

  /**
   * Invoked when a connection attempt fails. This failure is not terminal if further routes are
   * available and failure recovery is enabled.
   *
   * If the `call` uses HTTPS, this will be invoked after [secureConnectStart], otherwise it will
   * invoked after [connectStart].
   */

     */
    public SsoLoginException(final String message) {
        super(message);
    }

    /**
     * Constructs a new SsoLoginException with the specified detail message and cause.
     *
     * @param message The detail message explaining the SSO login failure
     * @param e The underlying exception that caused this SSO login failure
     */

 * of SSO authentication and authorization processes. It extends FessSystemException
 * to provide consistent error handling within the Fess system for SSO-related
 * processing failures such as token validation errors, communication failures
 * with SSO providers, or configuration issues.
 */
public class SsoProcessException extends FessSystemException {

    private static final long serialVersionUID = 1L;

    /**

package org.codelibs.fess.exception;

/**
 * System exception class for the Fess search engine.
 * This exception is thrown when system-level errors occur in the Fess application,
 * such as configuration errors, initialization failures, or critical runtime issues.
 */
public class FessSystemException extends RuntimeException {

    /** Serial version UID for serialization compatibility */
    private static final long serialVersionUID = 1L;

 *  * The configuration is incapable of carrying the request, such as when the client is configured
 *    to use `H2_PRIOR_KNOWLEDGE` but the URL's scheme is `https:`.
 *  * Preemptive proxy authentication failed.
 *
 * Planning failures are not necessarily fatal. For example, even if we can't DNS lookup the first
 * proxy in a list, looking up a subsequent one may succeed.
 */
internal class FailedPlan(
  e: Throwable,
) : RoutePlanner.Plan {

        .isTrue();
    if (!failures.isEmpty()) {
      StringWriter message = new StringWriter();
      PrintWriter writer = new PrintWriter(message);
      writer.println("Expected no failures, but found:");
      for (AssertionError failure : failures) {
        failure.printStackTrace(writer);
      }
      failures.clear();
      assertWithMessage(message.toString()).fail();
    }

    e is SSLHandshakeException && e.cause is CertificateException -> false

    // e.g. a certificate pinning error.
    e is SSLPeerUnverifiedException -> false

    // Retry for all other SSL failures.
    e is SSLException -> true

    else -> false

     */
    @Size(max = 10)
    public String thumbnail;

    /**
     * Types of crawling failures to ignore during crawling operations.
     * Specified failure types will not be logged or counted as errors.
     */
    @Size(max = 1000)
    public String ignoreFailureType;

    /**
     * Threshold for failure count before stopping crawling of a URL.
     * Set to -1 to disable the threshold check.
     */