*     write {@code throw sneakyThrow(t);} to convince the compiler that the statement will always
   *     throw.
   */
  @CanIgnoreReturnValue
  static Error sneakyThrow(Throwable t) {
    throw new SneakyThrows<Error>().throwIt(t);
  }

  @SuppressWarnings("unchecked") // not really safe, but that's the point
  private Error throwIt(Throwable t) throws T {
    throw (T) t;
  }

  private SneakyThrows() {}

   *
   * @throws NoSuchFileException if the file does not exist <i>(optional specific exception)</i>
   * @throws NotDirectoryException if the file could not be opened because it is not a directory
   *     <i>(optional specific exception)</i>
   * @throws IOException if an I/O error occurs
   */
  public static ImmutableList<Path> listFiles(Path dir) throws IOException {

   * null will be returned.
   *
   * @throws ParameterNotInstantiableException if the static methods cannot be invoked because the
   *     default value of a parameter cannot be determined.
   * @throws IllegalAccessException if the class isn't public or is nested inside a non-public
   *     class, preventing its methods from being accessible.
   * @throws InvocationTargetException if a static method threw exception.
   */

     * available.
     *
     * @throws InterruptedException if the current thread was interrupted before or during the call
     *     (optional but recommended).
     * @throws CancellationException {@inheritDoc}
     */
    @CanIgnoreReturnValue
    @Override
    public V get(long timeout, TimeUnit unit)
        throws InterruptedException, TimeoutException, ExecutionException {
      return sync.get(unit.toNanos(timeout));
    }

    methodCalled = true;
    methodArgument = arg;
  }

  @Subscribe
  public void exceptionThrowingMethod(Object arg) throws Exception {
    throw new IntentionalException();
  }

  /** Local exception subclass to check variety of exception thrown. */
  static final class IntentionalException extends Exception {

    private static final long serialVersionUID = -2500191180248181379L;
  }

                    return;
                case 2:
                    throw new IllegalArgumentException("Invalid argument");
                case 3:
                    throw new IllegalStateException("Invalid state");
                case 4:
                    throw new NullPointerException("Null pointer");
                default:
                    throw new RuntimeException("Generic error");
                }
            }

   * @throws Exception if unable to load the result
   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is
   *     treated like any other {@code Exception} in all respects except that, when it is caught,
   *     the thread's interrupted status is set
   */
  public abstract V load(K key) throws Exception;

  /**

    methodCalled = true;
    methodArgument = arg;
  }

  @Subscribe
  public void exceptionThrowingMethod(Object arg) throws Exception {
    throw new IntentionalException();
  }

  /** Local exception subclass to check variety of exception thrown. */
  static final class IntentionalException extends Exception {

    private static final long serialVersionUID = -2500191180248181379L;
  }

    final int throwAfterCount;
    final RuntimeException thrown;
    int count;

    ThrowingRunnable(int throwAfterCount, RuntimeException thrown) {
      this.throwAfterCount = throwAfterCount;
      this.thrown = thrown;
    }

    @Override
    public void run() {
      if (++count >= throwAfterCount) {
        throw thrown;
      }
    }
  }

   *     an {@code IOException}.
   * @see Closeables#close
   */
  @SuppressWarnings("IdentifierName") // See Closeables.close
  public static void flush(Flushable flushable, boolean swallowIOException) throws IOException {
    try {
      flushable.flush();
    } catch (IOException e) {
      if (swallowIOException) {
        logger.log(Level.WARNING, "IOException thrown while flushing Flushable.", e);
      } else {
        throw e;