}
                task succeeds {
                }
                task checkContinueFlag {
                    def continueFlag = gradle.startParameter.continueOnFailure
                    doLast {
                        println "continueOnFailure = " + continueFlag
                    }
                }
"""
        }
        buildC = singleProjectBuild("buildC") {
            buildFile << """

        when:
        executionPlan.continueOnFailure = continueOnFailure
        addToGraph(dep, target, entry)
        populateGraph()

        then:
        scheduledNodes == [dep, target, entry]
        assertNodeReady(dep)
        assertNodesReady(preNode1, preNode2)
        assertAllWorkComplete(continueOnFailure)

        where:
        continueOnFailure << [false, true]
    }

        newParameter.gradleUserHomeDir == parameter.gradleUserHomeDir
        newParameter.logLevel == parameter.logLevel
        newParameter.consoleOutput == parameter.consoleOutput
        newParameter.continueOnFailure == parameter.continueOnFailure
        newParameter.refreshDependencies == parameter.refreshDependencies
        newParameter.rerunTasks == parameter.rerunTasks
        newParameter.systemPropertiesArgs == parameter.systemPropertiesArgs

    public void addFilter(Spec<? super Task> filter) {
        this.filter = Specs.intersect(this.filter, filter);
    }

    @Override
    public void setContinueOnFailure(boolean continueOnFailure) {
        this.continueOnFailure = continueOnFailure;
    }

    @Override
    public int size() {
        return nodeMapping.getNumberOfPublicNodes();
    }

    static class NodeMapping extends AbstractCollection<Node> {

     */
    public boolean isContinueOnFailure() {
        return continueOnFailure;
    }

    /**
     * Specifies whether the build should continue on task failure. The default is false.
     */
    public void setContinueOnFailure(boolean continueOnFailure) {
        this.continueOnFailure = continueOnFailure;
    }

    /**

        this.lockCoordinator = lockCoordinator;
        this.ordinalNodeAccess = ordinalNodeAccess;
        this.continueOnFailure = continueOnFailure;
        this.contents = contents;
        this.completionHandler = completionHandler;

        SetMultimap<FinalizerGroup, FinalizerGroup> reachableGroups = LinkedHashMultimap.create();
        for (Node node : scheduledNodes) {

 */
@NotThreadSafe
public interface ExecutionPlan extends Describable, Closeable {
    void addFilter(Spec<? super Task> filter);

    void setContinueOnFailure(boolean continueOnFailure);

    void setScheduledWork(ScheduledWork work);

    /**
     * Adds an entry task to the execution plan. If called multiple times then execution plan follows the method invocation order.
     *
     */

        addToGraphAndPopulate([c])
        executionPlan.setContinueOnFailure(continueOnFailure)
        assert executedTasks == [a]

        when:
        executionPlan = newExecutionPlan()
        addToGraphAndPopulate([b])

        then:
        executes(b)

        where:
        continueOnFailure << [true, false]
    }

    @Issue("https://github.com/gradle/gradle/issues/22853")

        final Task a = brokenTask("a", failure)
        final Task b = task("b")
        final Task c = task("c", b)

        when:
        executionPlan.continueOnFailure = true
        executionPlan.addFilter(new Spec<Task>() {
            boolean isSatisfiedBy(Task element) {
                return element != b
            }
        })
        populateAndExecute([a, c])