* {@code GwtIncompatible}. This is more accurate for {@link Futures#catching}, which is available
 * under GWT but with a slightly different signature.
 *
 * <p>We can't use {@code PartiallyGwtIncompatible} because then the GWT compiler wouldn't recognize
 * it as a {@code GwtIncompatible} annotation. And for {@code Futures.catching}, we need the GWT

        assertEquals("Exception 2", exception2.getMessage());
        assertNotNull(exception3.getCause());
    }

    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String expectedMessage = "Test throw and catch";

        try {
            throw new SearchQueryException(expectedMessage);
        } catch (SearchQueryException e) {

                foundTestMethod = true;
                break;
            }
        }
        assertTrue(foundTestMethod);
    }

    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String expectedMessage = "Offset limit exceeded: 10000";

        try {
            throw new ResultOffsetExceededException(expectedMessage);
        } catch (ResultOffsetExceededException e) {

        assertEquals("Root cause", exception.getCause().getCause().getMessage());
    }

    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String expectedMessage = "Job execution failed";
        boolean exceptionCaught = false;

        try {
            throw new ScheduledJobException(expectedMessage);

        assertEquals(level1, level3.getCause().getCause());
        assertEquals("Level 1", level3.getCause().getCause().getMessage());
    }

    public void test_throwAndCatchException() {
        // Test throwing and catching the exception
        String expectedMessage = "Storage failure";

        try {
            throw new StorageException(expectedMessage);
        } catch (StorageException e) {

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

    public void test_throwAndCatch() {
        // Test throwing and catching PluginException
        String expectedMessage = "Plugin loading failed";

        try {
            throw new PluginException(expectedMessage);
        } catch (PluginException e) {

                foundTestMethod = true;
                break;
            }
        }
        assertTrue(foundTestMethod);
    }

    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String message = "Throw and catch test";

        try {
            throw new SearchEngineClientException(message);
        } catch (SearchEngineClientException e) {

        StackTraceElement firstElement = stackTrace[0];
        assertEquals(this.getClass().getName(), firstElement.getClassName());
    }

    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String username = "nonexistentuser";

        try {
            throw new FessUserNotFoundException(username);
        } catch (FessUserNotFoundException e) {

        UserRoleLoginException exception = new UserRoleLoginException(RootAction.class);
        assertNull(exception.getCause());
    }

    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        try {
            throw new UserRoleLoginException(RootAction.class);
        } catch (UserRoleLoginException e) {
            assertEquals(RootAction.class, e.getActionClass());

  @Partially.GwtIncompatible("AVAILABLE but requires exceptionType to be Throwable.class")
  public final <X extends Throwable> FluentFuture<V> catching(
      Class<X> exceptionType, Function<? super X, ? extends V> fallback, Executor executor) {
    return (FluentFuture<V>) Futures.catching(this, exceptionType, fallback, executor);
  }

  /**
   * Returns a {@code Future} whose result is taken from this {@code Future} or, if this {@code