}
        }

        return Node.DependenciesState.COMPLETE_AND_SUCCESSFUL;
    }

    @Override
    public void healthDiagnostics(StringBuilder builder) {
        delegate.healthDiagnostics(builder);
        if (!orderedMustSuccessors.isEmpty()) {
            builder.append(", must-run-after=").append(Node.formatNodes(orderedMustSuccessors));
        }
    }

        }

        @Override
        public Node.DependenciesState getState(Node node) {
            return Node.DependenciesState.COMPLETE_AND_SUCCESSFUL;
        }

        @Override
        public void healthDiagnostics(StringBuilder builder) {
            builder.append("no dependencies");
        }
    };

    NavigableSet<Node> getDependencySuccessors();

    DependencyNodesSet addDependency(Node toNode);

    /**
     * Invokes the given action when this task completes (as per {@link Node#isComplete()}). Does nothing if this task has already completed.
     */
    void onComplete(Runnable action);

    String healthDiagnostics();

     */
    void onComplete(Runnable action);

    TaskInternal getTask();

    State getTaskState();

    String healthDiagnostics();

        }

        @Override
        public State getTaskState() {
            return taskNode.getTaskState();
        }

        @Override
        public String healthDiagnostics() {
            return taskNode.healthDiagnostics();
        }
    }

    protected void nodeSpecificHealthDiagnostics(StringBuilder builder) {
        super.nodeSpecificHealthDiagnostics(builder);
        builder.append(", taskState=").append(taskState).append(", ").append(getTarget().healthDiagnostics());
    }

    @Override
    public void execute(NodeExecutionContext context) {
        // This node does not do anything itself
    }

            return Node.DependenciesState.COMPLETE_AND_SUCCESSFUL;
        } else {
            return Node.DependenciesState.NOT_COMPLETE;
        }
    }

    @Override
    public void healthDiagnostics(StringBuilder builder) {
        builder.append("dependencies=").append(Node.formatNodes(orderedDependencies));
        if (waitingFor != null && !waitingFor.isEmpty()) {

            return State.MaybeWorkReadyToStart;
        } else {
            return State.NoWorkReadyToStart;
        }
    }

    @Override
    public Diagnostics healthDiagnostics() {
        lockCoordinator.assertHasStateLock();

        List<String> ordinalGroups = new ArrayList<>();
        for (OrdinalGroup group : ordinalNodeAccess.getAllGroups()) {

        boolean shouldSchedule() {
            synchronized (lock) {
                return taskNode == null || !taskNode.isRequired();
            }
        }

        @Override
        public String healthDiagnostics() {
            synchronized (lock) {
                return "exportedTaskState=" + getTaskState();
            }
        }

        public void fireCompleted() {
            synchronized (lock) {

     *
     * <p>The implementation does not need to be particularly efficient, as it is called only when a fatal problem is detected.</p>
     */
    Diagnostics healthDiagnostics();