* under the License.
 */
package org.apache.maven.execution;

import org.apache.maven.project.MavenProject;

/**
 * Summarizes the result of a failed project build in the reactor.
 *
 */
public class BuildFailure extends BuildSummary {

    /**
     * The cause of the build failure.
     */
    private final Throwable cause;

    /**
     * Creates a new build summary for the specified project.
     *

        private final Throwable buildFailure;

        public DefaultDevelocityPluginResult(@Nullable Throwable buildFailure) {
            this.buildFailure = buildFailure;
        }

        @Nullable
        @Override
        public Throwable getFailure() {
            return buildFailure;
        }

        @Override

        when:
        def result = runner.run(clientProvidedPhasedAction, buildController)

        then:
        result.hasResult()
        result.clientResult == null
        result.buildFailure == null
        result.clientFailure == null

        and:
        1 * buildController.fromBuildModel(_, _) >> { Boolean b, BuildTreeModelAction modelAction ->
            modelAction.beforeTasks(modelController)

            return new Result(true, null, buildFailure, buildFailure);
        }

        public static Result failed(Throwable buildFailure, RuntimeException clientFailure) {
            return new Result(true, null, buildFailure, clientFailure);
        }

        /**
         * Is there a result, possibly a null object or a build failure?
         */
        public boolean hasResult() {

    // make projects that depend on me, and projects that I depend on
    public static final String MAKE_BOTH_MODE = "make-both";

    private List<String> blackList = new ArrayList<>();

    private Map<String, BuildFailure> buildFailuresByProject = new HashMap<>();

    private Map<String, Map<String, Map>> pluginContextsByProjectAndPluginKey = new HashMap<>();

    private String failureBehavior = FAIL_FAST;

        when:
        def result = runner.run(clientProvidedBuildAction, buildController)

        then:
        result.clientResult == serialized
        result.buildFailure == null
        result.clientFailure == null

        and:
        1 * payloadSerializer.deserialize(action) >> internalAction

        this.unsupported = true;
    }

    public boolean isPresent() {
        return adapter != null;
    }

    public void buildFinished(@Nullable Throwable buildFailure) {
        if (adapter != null) {
            adapter.buildFinished(buildFailure);
        }
    }

    /**
     * This should never happen due to the auto apply behavior.
     * It's only here as a kind of safeguard or fallback.
     */

                            .collect(Collectors.toList());

                    throw  buildFailure(configuration, true, filtered);
                }
            }
        }

        private static GradleException buildFailure(
            ConfigurationInternal configuration,
            boolean withTaskAdvice,
            List<ConfigurationInternal> collisions

import javax.annotation.Nullable;

public interface GradleEnterprisePluginAdapter {

    boolean shouldSaveToConfigurationCache();

    void onLoadFromConfigurationCache();

    void buildFinished(@Nullable Throwable buildFailure);

        this.action = result.getAction();
    }

    public void logResult(Throwable buildFailure) {
        if (action == null) {
            // This logger has been replaced (for example using `Gradle.useLogger()`), so don't log anything
            return;
        }
        BuildResult buildResult = new BuildResult(action, null, buildFailure);
        exceptionReporter.buildFinished(buildResult);