}

    @Nullable
    @Override
    public Throwable getNodeFailure() {
        return failure;
    }

    @Override
    public boolean isCanCancel() {
        return node.isCanCancel();
    }

    @Override
    public void resolveDependencies(TaskDependencyResolver dependencyResolver) {
    }

    @Nullable
    @Override
    public ResourceLock getProjectToLock() {

        }
    }

    @Override
    public Set<FinalizerGroup> getFinalizerGroups() {
        return finalizerGroups;
    }

    @Override
    public boolean isCanCancel() {
        return isCanCancel(finalizerGroups);
    }

    @Override
    public Node.DependenciesState checkSuccessorsCompleteFor(Node node) {
        if (ordinalGroup.isReachableFromEntryPoint()) {

        for (Node member : members) {
            visitor.accept(member);
        }
    }

    @Override
    public boolean isCanCancel() {
        if (!isCanCancel(Collections.singletonList(this))) {
            return false;
        } else {
            return delegate.isCanCancel();
        }
    }

    public boolean isCanCancelSelf() {

import java.util.Set;

abstract class HasFinalizers extends NodeGroup {
    public abstract NodeGroup getOrdinalGroup();

    public abstract Set<FinalizerGroup> getFinalizerGroups();

    protected boolean isCanCancel(Collection<FinalizerGroup> groups) {
        // A node cannot be cancelled if it belongs to a finalizer group that contains a finalized node that has started execution or that cannot be cancelled, and whose finalizer

        return null;
    }

    public Node.DependenciesState checkSuccessorsCompleteFor(Node node) {
        return Node.DependenciesState.COMPLETE_AND_SUCCESSFUL;
    }

    public boolean isCanCancel() {
        return true;
    }

    public void addMember(Node node) {
    }

    public void removeMember(Node node) {
    }

    /**

     */
    public boolean isReady() {
        return state == ExecutionState.SHOULD_RUN;
    }

    public boolean isCanCancel() {
        return group.isCanCancel();
    }

    public boolean isInKnownState() {
        return state != ExecutionState.NOT_SCHEDULED;
    }

    public boolean isExecuting() {

    }

    private boolean abortExecution(boolean abortAll) {
        MutableBoolean cancelled = new MutableBoolean();
        visitWaitingNodes(node -> {
            if (node.isRequired() && (abortAll || node.isCanCancel())) {
                // Allow currently executing and enforced tasks to complete, but skip everything else.
                // If abortAll is set, also stop everything.