* @param message the message to be logged
     * @param error the associated exception, or null if not applicable
     */
    void log(@Nonnull Level level, @Nonnull String message, @Nullable Throwable error);

    /**
     * Logs a debug message without an associated exception.
     *
     * @param message the debug message to be logged
     */
    default void debug(String message) {

import gradlebuild.docs.DocGenerationException;

public class ClassDocGenerationException extends DocGenerationException {
    public ClassDocGenerationException(String message, Throwable throwable) {
        super(message, throwable);
    }

    }

    /**
     * Construct a new <code>MojoFailureException</code> exception wrapping an underlying <code>Throwable</code>
     * and providing a <code>message</code>.
     *
     * @param message
     * @param cause
     * @since 2.0.9
     */
    public MojoFailureException(String message, Throwable cause) {
        super(message, cause);
    }

    /**

public class DocGenerationException extends RuntimeException {
    public DocGenerationException(String message) {
        super(message);
    }

    public DocGenerationException(String message, Throwable throwable) {
        super(message, throwable);
    }

      return weakSetValidator();
    }
  }

  // TODO(cpovirk): change parameter order to match other helper methods (Class, Throwable)?
  private static <X extends Exception> void wrapAndThrowExceptionOrError(
      Throwable cause, Class<X> exceptionClass) throws X {
    if (cause instanceof Error) {
      throw new ExecutionError((Error) cause);
    }

   * returns the expected data.
   *
   * @throws Throwable if the listener isn't called or if it resulted in a throwable or if the
   *     result doesn't match the expected value.
   */
  public void assertSuccess(Object expectedData) throws Throwable {
    // Verify that the listener executed in a reasonable amount of time.
    Assert.assertTrue(countDownLatch.await(1L, SECONDS));

        super(message);
    }

    public AbstractMojoExecutionException(String message, Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new {@code AbstractMojoExecutionException} exception wrapping an underlying {@code Throwable}.
     *
     * @param cause the cause which is saved for later retrieval by the {@link #getCause()} method.

    }

    @Test
    public void test_nestedExceptionChain() {
        // Test nested exception chain
        Throwable rootCause = new IllegalArgumentException("Root cause");
        Throwable middleCause = new IllegalStateException("Middle cause", rootCause);
        ScheduledJobException exception = new ScheduledJobException("Top level error", middleCause);

    private final Mojo mojo;

    private final Throwable cause;

    public MojoExecutionEvent(MavenSession session, MavenProject project, MojoExecution mojoExecution, Mojo mojo) {
        this(session, project, mojoExecution, mojo, null);
    }

    public MojoExecutionEvent(
            MavenSession session, MavenProject project, MojoExecution mojoExecution, Mojo mojo, Throwable cause) {
        this.session = session;

     * has failed.
     */
    final @Nullable Throwable failure;

    StateSnapshot(State internalState) {
      this(internalState, false, null);
    }

    StateSnapshot(
        State internalState, boolean shutdownWhenStartupFinishes, @Nullable Throwable failure) {
      checkArgument(
          !shutdownWhenStartupFinishes || internalState == STARTING,