*     from Guava.)
 */
@Deprecated
@GwtCompatible
public class ComputationException extends RuntimeException {
  /** Creates a new instance with the given cause. */
  public ComputationException(@Nullable Throwable cause) {
    super(cause);
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

     *
     * @param msg the detail message describing the validation failure
     * @param rootCause the underlying cause of the validation failure
     */
    public SMBSignatureValidationException(final String msg, final Throwable rootCause) {
        super(msg, rootCause);
    }

    /**
     * Constructs an SMB signature validation exception with a detail message.
     *
     * @param msg the detail message describing the validation failure

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

    public void test_serialVersionUID() {
        // Test that the exception has a serialVersionUID field
        FessUserNotFoundException exception1 = new FessUserNotFoundException("user1");

    return super.toString() + "[status=SUCCESS, result=[" + value + "]]";
  }

  static final class ImmediateFailedFuture<V extends @Nullable Object> extends TrustedFuture<V> {
    ImmediateFailedFuture(Throwable thrown) {
      setException(thrown);
    }
  }

  static final class ImmediateCancelledFuture<V extends @Nullable Object> extends TrustedFuture<V> {

            method.invoke(multiChannelManager, null, null);
        });

        // Check that the root cause is CIFSException
        assertTrue(exception instanceof java.lang.reflect.InvocationTargetException);
        Throwable cause = ((java.lang.reflect.InvocationTargetException) exception).getCause();
        assertTrue(cause instanceof CIFSException);
        assertTrue(cause.getMessage().contains("Failed to create multi-channel transport"));
    }

      this.map = map;
      this.setUpRan = setUpRan;
    }

    @Override
    public Object invoke(Object target, Method method, Object[] args) throws Throwable {
      assertTrue("setUp should have run", setUpRan.get());
      try {
        return method.invoke(map, args);
      } catch (InvocationTargetException e) {
        throw e.getCause();

     * @param message the detailed error message
     * @param cause the cause of the exception
     */
    public InvalidQueryException(final VaMessenger<FessMessages> messageCode, final String message, final Throwable cause) {
        super(message, cause);
        this.messageCode = messageCode;
    }

    /**
     * Creates a new InvalidQueryException with message code and message.
     *

                    next.getSQLState())).append("], [");
            next = next.getNextException();
        }
        Throwable t = cause.getCause();
        while (t != null) {
            buf.append(t.getMessage()).append("], [");
            t = t.getCause();
        }
        buf.setLength(buf.length() - 4);
        return new String(buf);

    webSocket.close(1000, null);
    System.out.println("onClose (" + code + "): " + reason);
  }

  @Override public void onFailure(WebSocket webSocket, Throwable t, Response response) {
    // TODO(jwilson): can I read the response body? Do I have to?
    System.out.println("onFailure " + response);
  }

  @Override public void close() throws IOException {

        future.completeExceptionally(new IllegalStateException("closed"));
      }

      @Override
      public void onFailure(@NotNull EventSource eventSource, @Nullable Throwable t, @Nullable Response response) {
        future.completeExceptionally(t == null ? new NullPointerException() : t);
      }
    });
    future.get();
  }