class ThrowableTypeAssert<T extends Throwable> implements Descriptable<ThrowableTypeAssert<T>> {

  @VisibleForTesting
  protected final Class<? extends T> expectedThrowableType;

  protected Description description;

  /**
   * Default constructor.
   *
   * @param throwableType class representing the target (expected) exception.
   */
  public ThrowableTypeAssert(final Class<? extends T> throwableType) {
    this.expectedThrowableType = requireNonNull(throwableType, "exceptionType");
  }

  /**
   * Assert that an exception of type T is thrown by the {@code throwingCallable}
   * and allow to chain assertions on the thrown exception.
   * <p>
   * Example:
   * <pre><code class='java'> assertThatExceptionOfType(IOException.class).isThrownBy(() -&gt; { throw new IOException("boom!"); })
   *                                       .withMessage("boom!"); </code></pre>
   *
   * @param throwingCallable code throwing the exception of expected type
   * @return return a {@link ThrowableAssertAlternative}.
   */
  public ThrowableAssertAlternative<T> isThrownBy(final ThrowingCallable throwingCallable) {<FILL_FUNCTION_BODY>}

  protected void checkThrowableType(Throwable throwable) {
    assertThat(throwable).as(description).hasBeenThrown().isInstanceOf(expectedThrowableType);
  }

  protected ThrowableAssertAlternative<T> buildThrowableTypeAssert(T throwable) {
    return new ThrowableAssertAlternative<>(throwable);
  }

  /** {@inheritDoc} */
  @Override
  @CheckReturnValue
  public ThrowableTypeAssert<T> describedAs(Description description) {
    this.description = description;
    return this;
  }

}

    Throwable throwable = ThrowableAssert.catchThrowable(throwingCallable);
    checkThrowableType(throwable);
    @SuppressWarnings("unchecked")
    T castThrowable = (T) throwable;
    return buildThrowableTypeAssert(castThrowable).as(description);
  
<no_super_class>