private String message;

    public DefaultMultiCauseException(String message) {
        super(message);
        this.message = message;
    }

    public DefaultMultiCauseException(String message, Throwable... causes) {
        super(message);
        this.message = message;
        this.causes.addAll(Arrays.asList(causes));
    }

    public DefaultMultiCauseException(String message, Iterable<? extends Throwable> causes) {

        def branch1 = new DefaultMultiCauseException("first failure", ultimateCause)
        def branch2 = new DefaultMultiCauseException("second failure", ultimateCause)
        def intermediateFailure = new DefaultMultiCauseException("intermediate failure", ultimateCause)
        def branch3 = new DefaultMultiCauseException("third failure", intermediateFailure)

 * limitations under the License.
 */

package org.gradle.internal.failure

import com.google.common.collect.ImmutableList
import org.gradle.internal.exceptions.DefaultMultiCauseException
import org.gradle.internal.exceptions.MultiCauseException
import org.gradle.internal.problems.failure.DefaultFailure
import org.gradle.internal.problems.failure.Failure

 */

package org.gradle.internal.cc.impl

import org.gradle.api.internal.DocumentationRegistry
import org.gradle.internal.exceptions.Contextual
import org.gradle.internal.exceptions.DefaultMultiCauseException


/**
 * Marker interface for exception handling.
 */
internal
interface ConfigurationCacheThrowable


/**
 * State might be corrupted and should be discarded.
 */
@Contextual

import org.gradle.internal.exceptions.DefaultMultiCauseException;

/**
 * <p>An opaque exception, thrown when dependency resolution fails for some reason.</p>
 *
 * <strong>This type should only be extended and/or thrown by Gradle internal code.</strong>
 */
@Contextual
@HasInternalProtocol
public class ResolveException extends DefaultMultiCauseException {

    /**
     * Do not call this constructor.
     *

import org.gradle.internal.exceptions.Contextual;
import org.gradle.internal.exceptions.DefaultMultiCauseException;

import javax.annotation.Nullable;

/**
 * A {@code ListenerNotificationException} is thrown when a listener cannot be notified of an event.
 */
@Contextual
public class ListenerNotificationException extends DefaultMultiCauseException {
    private final MethodInvocation event;

 * limitations under the License.
 */
package org.gradle.internal.serialize

import groovy.transform.CompileStatic
import org.gradle.internal.exceptions.Contextual
import org.gradle.internal.exceptions.DefaultMultiCauseException
import spock.lang.Issue
import spock.lang.Specification

class MessageTest extends Specification {
    GroovyClassLoader source = new GroovyClassLoader(getClass().classLoader)

import org.gradle.api.internal.plugins.software.SoftwareType
import org.gradle.api.internal.tasks.properties.InspectionScheme
import org.gradle.internal.exceptions.DefaultMultiCauseException
import org.gradle.internal.properties.annotations.PropertyMetadata
import org.gradle.internal.properties.annotations.TypeMetadata
import org.gradle.internal.properties.annotations.TypeMetadataStore

    }

    def "visitor visits causes of multi-cause exception"() {
        def childCause1 = new RuntimeException()
        def childCause2 = new RuntimeException()
        def cause = new DefaultMultiCauseException("broken", childCause1, childCause2)
        def e = new ContextAwareException(cause)

        when:
        e.accept(visitor)

        then:
        1 * visitor.visitCause(cause)

import org.gradle.api.problems.internal.DefaultProblemId;
import org.gradle.api.problems.internal.GradleCoreProblemGroup;
import org.gradle.api.problems.internal.Problem;
import org.gradle.internal.exceptions.DefaultMultiCauseException;
import org.gradle.internal.reflect.validation.TypeValidationProblemRenderer;
import org.gradle.model.internal.type.ModelType;

import javax.annotation.Nullable;
import java.util.Optional;