import org.gradle.internal.deprecation.Documentation;
import org.gradle.internal.exceptions.DefaultMultiCauseException;
import org.gradle.internal.exceptions.ResolutionProvider;

import java.util.Collections;
import java.util.List;

public class NoUsableDaemonFoundException extends DefaultMultiCauseException implements ResolutionProvider {

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

/**
 * <p>A {@code TaskExecutionException} is thrown when a task fails to execute successfully.</p>
 */
@Contextual
public class TaskExecutionException extends DefaultMultiCauseException {
    private final Task task;

    public TaskExecutionException(Task task, Throwable cause) {

                    def fail1 = new TestResolutionProviderException('resolution1')
                    def fail2 = new TestResolutionProviderException('resolution2')
                    throw new org.gradle.internal.exceptions.DefaultMultiCauseException('failure', fail1, fail2)
                }
            }
        """

        when:
        fails 'myTask'

        then:
        failure.assertHasDescription("Execution failed for task ':myTask'.")

 * limitations under the License.
 */

package org.gradle.execution;

import org.gradle.internal.exceptions.DefaultMultiCauseException;

import java.util.Collection;
import java.util.List;

public class MultipleBuildFailures extends DefaultMultiCauseException {
    public MultipleBuildFailures(Collection<? extends Throwable> causes) {
        super("Build completed with " + causes.size() + " failures.", causes);

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)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.initialization;

import org.gradle.internal.exceptions.DefaultMultiCauseException;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class DefaultBuildCancellationToken implements BuildCancellationToken {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.initialization

import org.gradle.internal.exceptions.DefaultMultiCauseException
import spock.lang.Specification

class DefaultBuildCancellationTokenSpec extends Specification {
    def 'can cancel token'() {
        when:
        def token = new DefaultBuildCancellationToken()

import org.gradle.integtests.fixtures.executer.CommitDistribution
import org.gradle.integtests.fixtures.executer.IntegrationTestBuildContext
import org.gradle.internal.exceptions.DefaultMultiCauseException
import org.gradle.testfixtures.ProjectBuilder
import org.gradle.testfixtures.internal.ProjectBuilderImpl

class ToolingApiDistributionResolver {

    static interface ResolverAction<T> {