.put(RuntimeException.class, e -> e instanceof RuntimeException)
          .put(TimeoutException.class, e -> e instanceof TimeoutException)
          .put(UncheckedExecutionException.class, e -> e instanceof UncheckedExecutionException)
          .put(UnsupportedCharsetException.class, e -> e instanceof UnsupportedCharsetException)
          .put(UnsupportedOperationException.class, e -> e instanceof UnsupportedOperationException)

  }

  public void testGetCheckedUntimed_executionExceptionUnchecked()
      throws TwoArgConstructorException {
    UncheckedExecutionException expected =
        assertThrows(
            UncheckedExecutionException.class,
            () -> getChecked(FAILED_FUTURE_UNCHECKED_EXCEPTION, TwoArgConstructorException.class));
    assertThat(expected).hasCauseThat().isEqualTo(UNCHECKED_EXCEPTION);
  }

    checkNotNull(callable);
    checkNotNull(timeoutUnit);
    try {
      return callable.call();
    } catch (RuntimeException e) {
      throw new UncheckedExecutionException(e);
    } catch (Exception e) {
      restoreInterruptIfIsInterruptedException(e);
      throw new ExecutionException(e);
    } catch (Error e) {
      throw new ExecutionError(e);
    }
  }

    checkNotNull(callable);
    checkNotNull(timeoutUnit);
    try {
      return callable.call();
    } catch (RuntimeException e) {
      throw new UncheckedExecutionException(e);
    } catch (Exception e) {
      restoreInterruptIfIsInterruptedException(e);
      throw new ExecutionException(e);
    } catch (Error e) {
      throw new ExecutionError(e);
    }
  }

   * @throws InterruptedException if the current thread was interrupted during execution
   * @throws ExecutionException if {@code callable} throws a checked exception
   * @throws UncheckedExecutionException if {@code callable} throws a {@code RuntimeException}
   * @throws ExecutionError if {@code callable} throws an {@code Error}
   * @since 22.0
   */
  @CanIgnoreReturnValue
  @ParametricNullness

import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.primitives.Primitives;
import com.google.common.reflect.TypeToken;
import com.google.common.util.concurrent.UncheckedExecutionException;
import com.google.j2objc.annotations.Weak;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import static com.google.common.truth.Truth.assertThat;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static org.junit.Assert.assertThrows;

import com.google.common.util.concurrent.UncheckedExecutionException;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutionException;

          .put(SomeUncheckedException.class, e -> e instanceof SomeUncheckedException)
          .put(TimeoutException.class, e -> e instanceof TimeoutException)
          .put(UncheckedExecutionException.class, e -> e instanceof UncheckedExecutionException)
          .put(UnsupportedCharsetException.class, e -> e instanceof UnsupportedCharsetException)
          .put(UnsupportedOperationException.class, e -> e instanceof UnsupportedOperationException)

   * from the underlying computation in an {@code UncheckedExecutionException} or {@code
   * ExecutionError}.
   *
   * <p>For an uninterruptible {@code get} that preserves other exceptions, see {@link
   * Uninterruptibles#getUninterruptibly(Future)}.
   *
   * @throws UncheckedExecutionException if {@code get} throws an {@code ExecutionException} with an
   *     {@code Exception} as its cause

      throw new UncheckedExecutionException(cause);
    } else {
      throw new ExecutionException(cause);
    }
  }

  private void wrapAndThrowRuntimeExecutionExceptionOrError(Throwable cause) {
    if (cause instanceof Error) {
      throw new ExecutionError((Error) cause);
    } else {
      throw new UncheckedExecutionException(cause);
    }
  }