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;
    }

        def factory = new DefaultFailureFactory(StackTraceClassifier.USER_CODE)

        def e0 = SimulatedJavaException.simulateDeeperException()
        def e = new RuntimeException("BOOM", e0)
        e0.initCause(e)
        e0.addSuppressed(e)

        when:
        def failure = factory.create(e)
        def failureCause = failure.causes[0]

        then:

   *     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() {}

  /**

            }
        };
        causeRef.set(cause2);

        Plugin plugin = new Plugin();
        Exception cause = new PluginContainerException(plugin, null, null, cause2);
        cause2.initCause(cause);
        PluginDescriptor pluginDescriptor = new PluginDescriptor();
        MojoDescriptor mojoDescriptor = new MojoDescriptor();
        mojoDescriptor.setPluginDescriptor(pluginDescriptor);

    }

    def "can handle circular exception"() {
        buildFile << """
            Exception selfReferencingException = new Exception("BOOM self")
            selfReferencingException.initCause(new Exception("BOOM cause", selfReferencingException))
            throw selfReferencingException
        """

        when:
        fails("help", "-s")

        then:
        failureCauseContains("BOOM self")

 *
 */
@Deprecated
public class LocalRepositoryNotAccessibleException extends IOException {

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

    public LocalRepositoryNotAccessibleException(String message) {
        super(message);
    }

    try {
      return x509TrustManagerExtensions.checkServerTrusted(certificates, "RSA", hostname)
    } catch (ce: CertificateException) {
      throw SSLPeerUnverifiedException(ce.message).apply { initCause(ce) }
    }
  }

  override fun equals(other: Any?): Boolean =
    other is AndroidCertificateChainCleaner &&
      other.trustManager === this.trustManager

        this.exceptionClassName = exceptionClassName;
        this.getMessageException = getMessageException;
        this.toString = toString;
        this.toStringRuntimeEx = toStringException;
        initCause(cause);
    }

    @Override
    public String getExceptionClassName() {
        return exceptionClassName;
    }

    @Override
    public String getMessage() {
        if (getMessageException != null) {

            return copy;
        } catch (Exception ex) {
            throw (RuntimeException)
                    new UnsupportedOperationException(getClass().getName() + " does not support clone()").initCause(ex);
        }
    } // -- InputSource clone()

    /**
     * Get the path/URL of the POM or {@code null} if unknown.
     *
     * @return String
     */
    public String getLocation() {

        private final JavaVersion version;
        public UnsupportedClassVersionErrorWithJavaVersion(UnsupportedClassVersionError cause, JavaVersion version) {
            super(cause.getMessage());
            initCause(cause);
            this.version = version;
        }

        public JavaVersion getVersion() {
            return version;
        }
    }