* @param cause a cause
     * @deprecated use {@link #ArtifactMetadataRetrievalException(String, Throwable, Artifact)}
     */
    @Deprecated
    public ArtifactMetadataRetrievalException(String message, Throwable cause) {
        this(message, cause, null);
    }

    public ArtifactMetadataRetrievalException(String message, Throwable cause, Artifact artifact) {
        super(message, cause);
        this.artifact = artifact;
    }

    final Object result;
    final Throwable throwable;

    Response(String methodName, @Nullable Object result, @Nullable Throwable throwable) {
      this.methodName = methodName;
      this.result = result;
      this.throwable = throwable;
    }

    Object getResult() {
      if (throwable != null) {
        throw new AssertionError(throwable);
      }
      return result;
    }

        assertNull(exception.getCause());
    }

    public void test_constructor_withNestedCause() {
        // Test constructor with nested exceptions
        Throwable rootCause = new IllegalStateException("Root cause");
        Throwable intermediateCause = new RuntimeException("Intermediate cause", rootCause);
        String message = "Top level error";

    boolean isFatalEnabled();

    void fatal(String message);

    void fatal(String message, Throwable t);

    boolean isErrorEnabled();

    void error(String message);

    void error(String message, Throwable t);

    boolean isWarnEnabled();

    void warn(String message);

    void warn(String message, Throwable t);

    boolean isInfoEnabled();

    void info(String message);

        assertTrue(exception.getCause().getStackTrace().length > 0);
    }

    public void test_multiLevelCause() {
        // Test with nested exceptions
        Throwable rootCause = new IllegalStateException("Root problem");
        Throwable intermediateCause = new RuntimeException("Intermediate problem", rootCause);
        GsaConfigException exception = new GsaConfigException("Top level GSA error", intermediateCause);

   * 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));

/** Static utility method for unchecked throwing of any {@link Throwable}. */
@GwtCompatible
final class SneakyThrows<T extends Throwable> {
  /**
   * Throws {@code t} as if it were an unchecked {@link Throwable}.
   *
   * <p>This method is useful primarily when we make a reflective call to a method with no {@code
   * throws} clause: Java forces us to handle an arbitrary {@link Throwable} from that method,

/** Static utility method for unchecked throwing of any {@link Throwable}. */
@GwtCompatible
final class SneakyThrows<T extends Throwable> {
  /**
   * Throws {@code t} as if it were an unchecked {@link Throwable}.
   *
   * <p>This method is useful primarily when we make a reflective call to a method with no {@code
   * throws} clause: Java forces us to handle an arbitrary {@link Throwable} from that method,

abstract class InterruptibleTask<T extends @Nullable Object> implements Runnable {

  @Override
  public void run() {
    T result = null;
    Throwable error = null;
    if (isDone()) {
      return;
    }
    try {
      result = runInterruptibly();
    } catch (Throwable t) {
      error = t;
    }
    if (error == null) {
      // The cast is safe because of the `run` and `error` checks.

        this(message, null, null);
    }

    public MetadataRetrievalException(Throwable cause) {
        this(null, cause, null);
    }

    public MetadataRetrievalException(String message, Throwable cause) {
        this(message, cause, null);
    }

    public MetadataRetrievalException(String message, Throwable cause, ArtifactMetadata artifact) {
        super(message, cause);

        this.artifact = artifact;