return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {

   * values. This includes both successful load operations and those that threw exceptions. This is
   * defined as {@code loadSuccessCount + loadExceptionCount}.
   *
   * <p><b>Note:</b> the values of the metrics are undefined in case of overflow (though it is
   * guaranteed not to throw an exception). If you require specific handling, we recommend
   * implementing your own stats collector.
   */

   * values. This includes both successful load operations and those that threw exceptions. This is
   * defined as {@code loadSuccessCount + loadExceptionCount}.
   *
   * <p><b>Note:</b> the values of the metrics are undefined in case of overflow (though it is
   * guaranteed not to throw an exception). If you require specific handling, we recommend
   * implementing your own stats collector.
   */

        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {

    return eventBus;
  }

  /** Returns the event object that caused the subscriber to throw. */
  public Object getEvent() {
    return event;
  }

  /** Returns the object context that the subscriber was called on. */
  public Object getSubscriber() {
    return subscriber;
  }

  /** Returns the subscribed method that threw the exception. */
  public Method getSubscriberMethod() {
    return subscriberMethod;
  }

    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("I bet you didn't think Thread.interrupt could throw");
    /*
     * We need to wait for the runner to exit. It used to be that the runner would get stuck in the
     * busy loop when interrupt threw.
     *
     * While we're at it, we confirm that the interrupt happened as expected.
     */
    ExecutionException fromRunInterruptibly =

      throws IOException {
    try {
      Closeables.close(closeable, swallowException);
      if (expectThrown) {
        fail("Didn't throw exception.");
      }
    } catch (IOException e) {
      if (!expectThrown) {
        fail("Threw exception");
      }
    }
    verify(closeable).close();
  }

    } catch (PermittedMetaException e) {
      referenceException = e;
    } catch (UnknownElementException e) {
      throw new AssertionError(e);
    }

    if (referenceException == null) {
      if (targetException != null) {
        throw new AssertionError("Target threw exception when reference did not", targetException);
      }

      /*

   *   <li>To get uninterruptibility and remove checked exceptions, use {@link
   *       Futures#getUnchecked}.
   * </ul>
   *
   * @throws ExecutionException if the computation threw an exception
   * @throws CancellationException if the computation was cancelled
   */
  @CanIgnoreReturnValue
  @ParametricNullness
  public static <V extends @Nullable Object> V getUninterruptibly(Future<V> future)

        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {