throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      Helpers.assertContentsInOrder(list, "a", "c", "b");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      Helpers.assertContentsInOrder(list, "a", "B", "c");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    assertThat(verticalValuesAccumulatorByAddAllPartitionedPairedStats.sampleCovariance())
        .isWithin(ALLOWED_ERROR)
        .of(0.0);
    assertThat(constantValuesAccumulator.sampleCovariance()).isWithin(ALLOWED_ERROR).of(0.0);
    assertThat(constantValuesAccumulatorByAddAllPartitionedPairedStats.sampleCovariance())
        .isWithin(ALLOWED_ERROR)
        .of(0.0);
  }

    assertThat(verticalValuesAccumulatorByAddAllPartitionedPairedStats.sampleCovariance())
        .isWithin(ALLOWED_ERROR)
        .of(0.0);
    assertThat(constantValuesAccumulator.sampleCovariance()).isWithin(ALLOWED_ERROR).of(0.0);
    assertThat(constantValuesAccumulatorByAddAllPartitionedPairedStats.sampleCovariance())
        .isWithin(ALLOWED_ERROR)
        .of(0.0);
  }

    assertEquals(RUNTIME_EXCEPTION, expected);
  }

  public void testGetCheckedUntimed_Error() throws TwoArgConstructorException {
    try {
      getChecked(ERROR_FUTURE, TwoArgConstructorException.class);
    } catch (Error expected) {
      assertEquals(ERROR, expected);
      return;
    }
    fail();
  }

  @Override
  public void run() {
    T result = null;
    Throwable error = null;
    if (isDone()) {
      return;
    }
    try {
      result = runInterruptibly();
    } catch (Throwable t) {
      error = t;
    }
    if (error == null) {
      // The cast is safe because of the `run` and `error` checks.
      afterRanInterruptiblySuccess(uncheckedCastNullableTToT(result));
    } else {

import com.google.common.annotations.GwtCompatible;
import javax.annotation.CheckForNull;

/**
 * {@link Error} variant of {@link java.util.concurrent.ExecutionException}. As with {@code
 * ExecutionException}, the error's {@linkplain #getCause() cause} comes from a failed task,
 * possibly run in another thread. That cause should itself be an {@code Error}; if not, use {@code
 * ExecutionException} or {@link UncheckedExecutionException}. This allows the client code to

     * The error's stacktrace will be output when this error level is enabled.
     *
     * @param content
     * @param error
     */
    void error(CharSequence content, Throwable error);

    /**
     * Send an exception to the user in the <b>error</b> error level.<br>
     * The stack trace for this exception will be output when this error level is enabled.
     *
     * @param error

 */
@GwtCompatible
final class UncheckedThrowingFuture<V> extends AbstractFuture<V> {

  public static <V> ListenableFuture<V> throwingError(Error error) {
    UncheckedThrowingFuture<V> future = new UncheckedThrowingFuture<V>();
    future.complete(checkNotNull(error));
    return future;
  }

  public static <V> ListenableFuture<V> throwingRuntimeException(RuntimeException e) {

    };

    static final String[] DCERPC_FAULT_MESSAGES = {
        "DCERPC_FAULT_OTHER", "DCERPC_FAULT_ACCESS_DENIED", "DCERPC_FAULT_CANT_PERFORM", "DCERPC_FAULT_NDR", "DCERPC_FAULT_INVALID_TAG",
        "DCERPC_FAULT_CONTEXT_MISMATCH", "DCERPC_FAULT_OP_RNG_ERROR", "DCERPC_FAULT_UNK_IF", "DCERPC_FAULT_PROTO_ERROR"
    };

    public void error(CharSequence content, Throwable error) {
        if (isErrorEnabled()) {
            logger.error(toString(content), error);
        }
    }

    @Override
    public void error(Throwable error) {
        logger.error("", error);
    }

    @Override
    public boolean isDebugEnabled() {
        return logger.isDebugEnabled();
    }

    @Override