}

  public void testAddListenerAfterCallback() throws Throwable {
    inputFuture.set(VALID_INPUT_DATA);

    listener.assertSuccess(getSuccessfulResult());
  }

  public void testFutureBeforeCallback() throws Throwable {
    inputFuture.set(VALID_INPUT_DATA);

    listener.assertSuccess(getSuccessfulResult());
  }

  public void testInputFutureToString() throws Throwable {

            }
        }
    }

    @Override
    public void failure(Object testId, Throwable throwable) {
        if (activeDescriptorsById.containsKey(testId)) {
            activeDescriptorsById.remove(testId);
            try {
                delegate.failure(testId, throwable);
            } catch (IllegalArgumentException illegalArgumentException) {

    assertThat(s2).isNotInstanceOf(Subscriber.SynchronizedSubscriber.class);
  }

  public void testInvokeSubscriberMethod_basicMethodCall() throws Throwable {
    Method method = getTestSubscriberMethod("recordingMethod");
    Subscriber subscriber = Subscriber.create(bus, this, method);

    subscriber.invokeSubscriberMethod(FIXTURE_ARGUMENT);

     */
    public ClIllegalStateException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Creates a {@link ClIllegalStateException}.
     *
     * @param cause
     *            The original exception
     */
    public ClIllegalStateException(final Throwable cause) {
        super(cause);
    }

    public ToolchainFactoryException(String message) {
        super(message);
    }

    public ToolchainFactoryException(String message, Throwable cause) {
        super(message, cause);
    }

    public ToolchainFactoryException(Throwable cause) {
        super(cause);
    }

    executionThread = new Thread(runnable);
    executionThread.setUncaughtExceptionHandler(
        (thread, throwable) -> thrownByExecutionThread = throwable);
    executionThread.start();
  }

  private static void throwIfSet(Throwable t) throws Throwable {
    if (t != null) {
      throw t;
    }
  }

  public void testStopUnstartedService() throws Exception {

    executionThread = new Thread(runnable);
    executionThread.setUncaughtExceptionHandler(
        (thread, throwable) -> thrownByExecutionThread = throwable);
    executionThread.start();
  }

  private static void throwIfSet(Throwable t) throws Throwable {
    if (t != null) {
      throw t;
    }
  }

  public void testStopUnstartedService() throws Exception {

    public MavenExecutionRequestPopulationException(String message) {
        super(message);
    }

    public MavenExecutionRequestPopulationException(Throwable cause) {
        super(cause);
    }

    public MavenExecutionRequestPopulationException(String message, Throwable cause) {
        super(message, cause);
    }

                      resolve.onInvoke(value);
                    }

                    @Override
                    public void onFailure(Throwable throwable) {
                      reject.onInvoke(throwable.getBackingJsObject());
                    }
                  },
                  MoreExecutors.directExecutor());
            })
        .then(onFulfilled, onRejected);
  }
}

    }

    /**
     * Test constructor DcerpcException(String msg, Throwable rootCause).
     */
    @Test
    void testConstructorWithMessageAndCause() {
        String message = "Test message with cause.";
        Throwable cause = new RuntimeException("Original cause.");
        DcerpcException exception = new DcerpcException(message, cause);