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

    /**
     * Creates a new DictionaryException with the specified message.
     *
     * @param message the detail message
     */

     *
     * @param message The detail message.
     * @param cause   The cause of the exception.
     */
    public StorageException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new storage exception with the specified detail message.
     *
     * @param message The detail message.
     */

          }
        };

    List<Throwable> exceptions = runThreadsAndReturnExceptions(numThreads, task);

    assertThat(exceptions).isEmpty();
  }

  private static List<Throwable> runThreadsAndReturnExceptions(int numThreads, Runnable task) {
    List<Thread> threads = new ArrayList<>(numThreads);
    List<Throwable> exceptions = new ArrayList<>(numThreads);

   * network. Incoming events may have been lost. No further calls to this listener will be made.
   */
  open fun onFailure(
    eventSource: EventSource,
    t: Throwable?,
    response: Response?,
  ) {
  }

   *   <li>{@code get()} must not block, and it must throw an {@code ExecutionException} with the
   *       return value of this method as its cause
   * </ul>
   */
  public static
      Throwable
      tryInternalFastPathGetFailure(InternalFutureFailureAccess future) {
    return future.tryInternalFastPathGetFailure();
  }

  private InternalFutures() {}

     * @param cause the underlying exception
     */
    public NoSuchMethodRuntimeException(final Class<?> targetClass, final String methodName, final Class<?>[] argTypes,
            final Throwable cause) {
        super("ECL0057", asArray(targetClass.getName(), MethodUtil.getSignature(methodName, argTypes)), cause);
        this.targetClass = targetClass;
        this.methodName = methodName;

      supplier =
          new Supplier<LongAddable>() {
            @Override
            public LongAddable get() {
              return new LongAdder();
            }
          };
    } catch (Throwable t) { // we really want to catch *everything*
      supplier =
          new Supplier<LongAddable>() {
            @Override
            public LongAddable get() {
              return new PureJavaLongAddable();

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

    public void test_serialization() {
        // Test that the exception has serialVersionUID defined
        JobNotFoundException exception = new JobNotFoundException("test");

              SerializableTester.reserializeAndAssert(instance);
            } else {
              SerializableTester.reserialize(instance);
            }
          }
        } catch (Throwable e) {
          throw sanityError(classToTest, SERIALIZABLE_TEST_METHOD_NAMES, "serializable test", e);
        }
      }
    }
  }

  /**

  void awaitTerminated(long timeout, TimeUnit unit) throws TimeoutException;

  /**
   * Returns the {@link Throwable} that caused this service to fail.
   *
   * @throws IllegalStateException if this service's state isn't {@linkplain State#FAILED FAILED}.
   * @since 14.0
   */
  Throwable failureCause();

  /**
   * Registers a {@link Listener} to be {@linkplain Executor#execute executed} on the given