assertNotSame(exception1, exception2);
        assertNotSame(exception2, exception3);
        assertNotSame(exception1, exception3);

        assertEquals("Error 1", exception1.getMessage());
        assertEquals("Error 2", exception2.getMessage());
        assertEquals("Error 3", exception3.getMessage());
    }

    @Test

        assertNull(exception.getMessage());
        assertNull(exception.getCause());
    }

    @Test
    public void test_constructor_withEmptyMessage() {
        // Test with empty message
        String message = "";
        LdapConfigurationException exception = new LdapConfigurationException(message);

        assertNotNull(exception);
        assertEquals(message, exception.getMessage());

        assertEquals(message, exception.getMessage());
        assertEquals(cause, exception.getCause());
    }

    @Test
    public void test_constructorWithNullMessage() {
        // Test constructor with null message
        StorageException exception = new StorageException(null);

        assertNotNull(exception);
        assertNull(exception.getMessage());
        assertNull(exception.getCause());
    }

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

    @Test
    public void test_serializable() {
        // Test that the exception has serialVersionUID
        WebApiException exception = new WebApiException(404, "Not Found");

        UserRoleLoginException exception1 = new UserRoleLoginException(RootAction.class);
        UserRoleLoginException exception2 = new UserRoleLoginException(RootAction.class);

        assertNotSame(exception1, exception2);
        assertEquals(exception1.getActionClass(), exception2.getActionClass());
        assertSame(RootAction.class, exception1.getActionClass());

        ResultOffsetExceededException exception1 = new ResultOffsetExceededException("First instance");
        ResultOffsetExceededException exception2 = new ResultOffsetExceededException("Second instance");
        ResultOffsetExceededException exception3 = new ResultOffsetExceededException("Third instance");

        assertNotSame(exception1, exception2);
        assertNotSame(exception2, exception3);

        String message1 = "First exception";
        String message2 = "Second exception";

        UnsupportedSearchException exception1 = new UnsupportedSearchException(message1);
        UnsupportedSearchException exception2 = new UnsupportedSearchException(message2);

        assertNotSame(exception1, exception2);
        assertEquals(message1, exception1.getMessage());

        Exception exception = new Exception("Test failure");
        result.addFailure(exception);

        assertTrue(result.hasFailure());
        assertEquals(1, result.getFailures().size());
        assertEquals(exception, result.getFailures().get(0));
    }

    @Test
    public void test_addMultipleFailures() throws Exception {
        SuggestWriterResult result = new SuggestWriterResult();

        // Test with checked exception
        String message = "SSO I/O error";
        java.io.IOException ioException = new java.io.IOException("Network connection failed");
        SsoProcessException exception = new SsoProcessException(message, ioException);

        assertEquals(message, exception.getMessage());
        assertTrue(exception.getCause() instanceof java.io.IOException);
        assertEquals(ioException, exception.getCause());
    }

        // Verify backward compatibility - Exception types still work
        String url = "http://example.com/test";
        String message = "Crawling error";

        // Test with IOException
        java.io.IOException ioException = new java.io.IOException("Network error");
        DataStoreCrawlingException exception1 = new DataStoreCrawlingException(url, message, ioException);
        assertTrue(exception1.getCause() instanceof java.io.IOException);