try {
            Throwable t = cae;
            if (t instanceof final MultipleCrawlingAccessException mcae) {
                final Throwable[] causes = mcae.getCauses();
                if (causes.length > 0) {
                    t = causes[causes.length - 1];
                }
            }

            String errorName;
            final Throwable cause = t.getCause();

     *
     * @param message the error message
     * @param cause the underlying cause of this exception
     */
    public DataStoreException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Creates a new DataStoreException with the specified message.
     *
     * @param message the error message
     */

     */
    public JobProcessingException(final Throwable e) {
        super(e);
    }

    /**
     * Constructs a new JobProcessingException with the specified detail message and cause.
     *
     * @param message the detail message explaining the exception
     * @param e the cause of the exception
     */
    public JobProcessingException(final String message, final Throwable e) {
        super(message, e);
    }

    }

    @Test
    public void test_constructor_withComponentNameAndCause() {
        // Test constructor with component name and cause
        String componentName = "myComponent";
        Throwable cause = new RuntimeException("Connection failed");
        ContainerNotAvailableException exception = new ContainerNotAvailableException(componentName, cause);

        assertTrue(exception.getCause().getStackTrace().length > 0);
    }

    @Test
    public void test_multiLevelCause() {
        // Test with nested exceptions
        Throwable rootCause = new IllegalStateException("Root problem");
        Throwable intermediateCause = new RuntimeException("Intermediate problem", rootCause);
        GsaConfigException exception = new GsaConfigException("Top level GSA error", intermediateCause);

        assertTrue(exception instanceof FessSystemException);
        assertTrue(exception instanceof RuntimeException);
        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);
    }

    @Test
    public void test_serialization() {
        // Test serialVersionUID exists
        ResultOffsetExceededException exception = new ResultOffsetExceededException("Test serialization");

        private final String throwable;

        /**
         * Constructs a new LogNotificationEvent.
         *
         * @param timestamp the event timestamp in milliseconds
         * @param level the log level name
         * @param loggerName the logger name
         * @param message the log message
         * @param throwable the throwable string, or null
         */

    }

    @Test
    public void test_constructor_withNestedCause() {
        // Test constructor with nested exception causes
        Throwable rootCause = new IllegalArgumentException("Root cause");
        Throwable middleCause = new IllegalStateException("Middle cause", rootCause);
        String message = "Command execution failed with nested exception";

        assertTrue(exception.aborted());

        // Verify the cause chain
        Throwable cause1 = exception.getCause();
        assertTrue(cause1 instanceof RuntimeException);

        Throwable cause2 = cause1.getCause();
        assertTrue(cause2 instanceof AssertionError);

        Throwable cause3 = cause2.getCause();
        assertTrue(cause3 instanceof NullPointerException);
    }

    @Test

     */
    public ContainerNotAvailableException(final String componentName, final Throwable cause) {
        super(componentName + " is not available.", cause);
        this.componentName = componentName;
    }

    /**
     * Constructor with cause only.
     * @param cause The cause of the exception.
     */
    public ContainerNotAvailableException(final Throwable cause) {
        super("Container is not available.");