OrdinalNode producerLocations = ordinal.getPrevious().getProducerLocationsNode();
            maybeSchedule(ordinalNodeConsumer, producerLocations);
            destroyer.addDependencySuccessor(producerLocations);
        }
    }

    void addProducerNode(OrdinalGroup ordinal, LocalTaskNode producer, Consumer<Node> ordinalNodeConsumer) {

        if (producerLocationsNode == null) {
            producerLocationsNode = new OrdinalNode(OrdinalNode.Type.PRODUCER, this);
            if (previous != null) {
                producerLocationsNode.addDependencySuccessor(previous.getProducerLocationsNode());
            }
        }
        return producerLocationsNode;
    }

    public OrdinalNode getDestroyerLocationsNode() {
        if (destroyerLocationsNode == null) {

        // Only add hard successors that will actually be executed
        Node prepareNode = taskNode.getPrepareNode();
        if (taskNode.isRequired()) {
            prepareNode.require();
            addDependencySuccessor(prepareNode);
        }
    }

        TaskDependencyContainer dependencies = action::visitDependencies;
        for (Node node : dependencyResolver.resolveDependenciesFor(null, dependencies)) {
            addDependencySuccessor(node);
        }
    }

    @Nullable
    public WorkNodeAction getAction() {
        return action;
    }

    @Override
    public String toString() {
        return "work action " + action;

            }
        }
    }

    private
    fun ReadContext.readSuccessorReferencesOf(node: Node, nodesById: Map<Int, Node>) {
        readSuccessorReferences(nodesById) {
            node.addDependencySuccessor(it)
        }
        when (node) {
            is TaskNode -> {
                readSuccessorReferences(nodesById) {
                    node.addShouldSuccessor(it)
                }

        // Make sure it has been configured
        taskProject.getTasks().prepareForExecution(task);

        for (Node targetNode : getDependencies(dependencyResolver)) {
            addDependencySuccessor(targetNode);
        }

        lifecycleSuccessors = dependencyResolver.resolveDependenciesFor(task, task.getLifecycleDependencies());

        for (Node targetNode : getFinalizedBy(dependencyResolver)) {

                        prepareNode.setIndex(node.getIndex());
                        prepareNode.require();
                        prepareNode.updateAllDependenciesComplete();
                        node.addDependencySuccessor(prepareNode);
                        addNodeToPlan(prepareNode);
                    });
                    node.forceAllDependenciesCompleteUpdate();
                    if (!node.allDependenciesComplete()) {

    }

    protected void processDependencies(Set<Node> dependencies) {
        for (Node dependency : dependencies) {
            addDependencySuccessor(dependency);
        }
    }

    public static class InitialTransformStepNode extends TransformStepNode {
        private final CalculatedValueContainer<TransformStepSubject, TransformInitialArtifact> result;

            nodes[3].nodeDependencies*.name == []
        }
    }

    def dependsOn(TestNode node, List<TestNode> dependencies) {
        dependencies.forEach { node.addDependencySuccessor(it) }
    }

    def stubConverter(Class<? extends Node> supportedNodeType, NodeType nodeType) {
        Stub(ToPlannedNodeConverter) {
            getSupportedNodeType() >> supportedNodeType

        return dependentNodes.getDependencyPredecessors();
    }

    public Set<Node> getDependencySuccessors() {
        return dependencyNodes.getDependencySuccessors();
    }

    public void addDependencySuccessor(Node toNode) {
        dependencyNodes = dependencyNodes.addDependency(toNode);
        toNode.addDependencyPredecessor(this);
    }

    void addDependencyPredecessor(Node fromNode) {