public List<? extends Throwable> getCauses() {
        return causes;
    }

    @Override
    public synchronized Throwable initCause(Throwable throwable) {
        causes.clear();
        causes.add(throwable);
        return null;
    }

    public void initCauses(Iterable<? extends Throwable> causes) {
        this.causes.clear();
        for (Throwable cause : causes) {
            this.causes.add(cause);

        this(selector, format("Could not resolve %s.", selector));
        initCause(cause);
    }

    public ModuleVersionResolveException(ComponentSelector selector, Iterable<? extends Throwable> causes) {
        this(selector, format("Could not resolve %s.", selector));
        initCauses(causes);
    }

    public ModuleVersionResolveException(ModuleVersionSelector selector, Factory<String> message) {

                } else {
                    additionalFailures.add(cause);
                }
            }
            if (!additionalFailures.isEmpty()) {
                projectConfigurationException.initCauses(additionalFailures);
                failures.add(transform(projectConfigurationException));
            }
        } else if (exception instanceof ServiceCreationException) {

        failure.initCause(cause1)

        expect:
        failure.cause == cause1
        failure.causes == [cause1]
    }

    def canUseInitCausesToProvideMultipleCause() {
        def cause1 = new RuntimeException()
        def cause2 = new RuntimeException()
        def failure = new TestMultiCauseException('message', [])
        failure.initCauses([cause1, cause2])

        expect:

        this.targetClass = targetClass;
    }

    @Override
    public synchronized InstantiationRuntimeException initCause(final Throwable cause) {
        return (InstantiationRuntimeException) super.initCause(cause);
    }

    /**
     * ターゲットクラスを返します。
     *
     * @return ターゲットクラス
     */
    public Class<?> getTargetClass() {
        return targetClass;
    }

   * and https://github.com/jspecify/jspecify/issues/490.
   *
   * (That would also have ensured that its cause was always an Error, rather than possibly another
   * kind of Throwable that was later passed to initCause. Then we could have declared the override
   * `public final Error getCause()`.)
   */

  /**
   * Creates a new instance with {@code null} as its detail message and no cause.
   *

   * and https://github.com/jspecify/jspecify/issues/490.
   *
   * (That would also have ensured that its cause was always an Error, rather than possibly another
   * kind of Throwable that was later passed to initCause. Then we could have declared the override
   * `public final Error getCause()`.)
   */

  /**
   * Creates a new instance with {@code null} as its detail message and no cause.
   *

                initCause(e)
              },
            )
          }
        },
      )
    } catch (e: Exception) {
      // Handle any errors that might leak out
      // https://issuetracker.google.com/issues/319957694
      callback.onFailure(
        hostname,
        UnknownHostException(e.message).apply {
          initCause(e)
        },
      )
    }
  }

   *     cause. At the moment, you can <i>usually</i> still preserve behavior by passing an explicit
   *     {@code null} cause. Note, however, that passing an explicit {@code null} cause prevents
   *     anyone from calling {@link #initCause} later, so it is not quite equivalent to using a
   *     constructor that omits the cause.
   */
  @Deprecated
  protected UncheckedExecutionException() {}

  /**

    public ListenerFailedException(String message, List<? extends Throwable> failures) {
        super(message);
        listenerFailures = failures;
        if (!failures.isEmpty()) {
            initCause(failures.get(0));
        }
    }

    public List<? extends Throwable> getCauses() {
        return listenerFailures;
    }