*/
    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 cause The underlying exception that caused this SSO login failure
     */

                    failures.add(lines.joinToString("\n"))
                }
            }
        }

        if (shouldFix) {
            // Only write the mutations if there were no failures
            if (failures.isNotEmpty()) {
                val lines = listOf("""

 * 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;

    /**

    }

    /**
     * Safely registers a class with Kryo, logging any registration failures at WARN level.
     * <p>
     * This method catches exceptions for individual class registrations to ensure
     * that a failure to register one class doesn't prevent other classes from being registered.
     * Registration failures are logged at WARN level since they may cause serialization errors later.
     * </p>
     *

        return EventListener.NONE;
      }
    }
  };

  ...
}
```

### Events with Failures

When an operation fails, a failure method is called. This is `connectFailed()` for failures while building a connection to the server, and `callFailed()` when the HTTP call fails permanently. When a failure happens it is possible that a `start` event won’t have a corresponding `end` event.

     */
    fun withSocketFactory(socketFactory: SocketFactory): Chain

    /**
     * Returns true if the call should retry on connection failures.
     */
    val retryOnConnectionFailure: Boolean

    /**
     * Returns a new chain with the specified retry on connection failure setting.
     */
    fun withRetryOnConnectionFailure(retryOnConnectionFailure: Boolean): Chain

    /**

                    final String urlValue = Pattern.quote(u);
                    crawler.addExcludeFilter(urlValue);
                    if (logger.isInfoEnabled()) {
                        logger.info("Excluded URL from failures: {}", urlValue);
                    }
                });
            }

            if (logger.isDebugEnabled()) {
                logger.debug("Crawling {}", urlsStr);
            }

        .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();
    }

   * test case failure. Only the first failure is recorded; subsequent calls to this method from
   * within the same test have no effect.
   */
  final void threadRecordFailure(Throwable t) {
    threadFailure.compareAndSet(null, t);
  }

  /**
   * Extra checks that get done for all test cases.
   *
   * <p>Triggers test case failure if any thread assertions have failed, by rethrowing, in the test

        }
    }

    /**
     * Builds a failure message from a bulk response containing failed operations.
     *
     * @param bulkResponse The bulk response containing potential failures.
     * @param ignoreAlreadyExists Whether to ignore already existing document failures.
     * @return The formatted failure message, or empty string if no failures to report.
     */