* @author shinsuke
 */
public class BadPaddingRuntimeException extends ClRuntimeException {

    private static final long serialVersionUID = 1L;

    /**
     * Creates a new {@link BadPaddingRuntimeException} with the specified cause.
     *
     * @param cause
     *            the cause
     */

/**
 * Exception thrown when using a key not contained in a {@literal BeanMap}.
 *
 * @author koichik
 */
public class IllegalKeyOfBeanMapException extends ClIllegalArgumentException {

    private static final long serialVersionUID = 3456740832476626338L;

    /**
     * Constructs an instance.
     *
     * @param key
     *            Key of the map
     * @param map
     *            Map
     */

/**
 * Exception thrown when a resource cannot be found.
 *
 * @author higa
 */
public class ResourceNotFoundRuntimeException extends ClRuntimeException {

    private static final long serialVersionUID = 9033370905740809950L;

    /**
     * The path to the resource.
     */
    private final String path;

    /**
     * Creates a {@link ResourceNotFoundRuntimeException}.
     *

  /** Creates a new instance with the given cause. */
  public ComputationException(@Nullable Throwable cause) {
    super(cause);
  }

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

      throws InterruptedException, ExecutionException {
    return future.blockingGet();
  }

  static <V extends @Nullable Object> V get(AbstractFuture<V> future, long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    return future.blockingGet(timeout, unit);
  }

  private Platform() {}

  /** Creates a new instance with the given cause. */
  public ComputationException(@Nullable Throwable cause) {
    super(cause);
  }

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

        keyTail.nextSibling = node;
        node.previousSibling = keyTail;
        keyList.tail = node;
      }
    } else { // non-empty list, insert before nextSibling
      /*
       * requireNonNull is safe as long as callers pass a nextSibling that (a) has the same key and
       * (b) is present in the multimap. (And they do, except maybe in case of concurrent
       * modification, in which case all bets are off.)
       */

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

    @Test
    public void test_veryLongMessage() {
        // Test with very long message
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            sb.append("Long message part ").append(i).append(" ");
        }
        String longMessage = sb.toString();

        public void sendRedirect(String location, int sc, boolean clearBuffer) {
        }

        @Override
        public void setDateHeader(String name, long date) {
        }

        @Override
        public void addDateHeader(String name, long date) {
        }

        @Override
        public void addHeader(String name, String value) {
            headers.put(name, value);
        }

     * The user who created this key match.
     */
    @Size(max = 255)
    public String createdBy;

    /**
     * The timestamp when this key match was created.
     */
    @ValidateTypeFailure
    public Long createdTime;

    /**
     * Initializes the form with default values.
     */
    public void initialize() {
        crudMode = CrudMode.CREATE;
        maxSize = 10;
        boost = 100.0f;