then:
        project.tasks*.name.contains "fromModel"
    }

    def "tasks added using model rule can be executed"() {
        when:
        withConnection { connection ->
            def build = connection.newBuild()
            build.forTasks("fromModel")
            build.run()
        }

        then:

        return dependencyPredecessors.getDependencyPredecessors();
    }

    @Override
    public DependentNodesSet addDependencyPredecessors(Node fromNode) {
        dependencyPredecessors.addDependencyPredecessors(fromNode);
        return this;
    }

    @Override
    public SortedSet<Node> getFinalizers() {
        return finalizers;
    }

    @Override

 */
public interface DependentNodesSet {
    DependentNodesSet EMPTY = new DependentNodesSet() {
        @Override
        public DependentNodesSet addDependencyPredecessors(Node fromNode) {
            return new DependencyPredecessorsOnlyNodeSet().addDependencyPredecessors(fromNode);
        }

        @Override
        public DependentNodesSet addFinalizer(Node finalizer) {

    public DependentNodesSet addDependencyPredecessors(Node fromNode) {
        dependencyPredecessors.add(fromNode);
        return this;
    }

    @Override
    public DependentNodesSet addFinalizer(Node finalizer) {
        return new ComplexDependentNodesSet(this).addFinalizer(finalizer);
    }

    @Override
    public DependentNodesSet addMustPredecessor(Node fromNode) {

import java.util.List;
import java.util.Map;
import java.util.Set;

public class DependencyGraphPathResolver {

    public static Collection<List<ComponentIdentifier>> calculatePaths(List<DependencyGraphNode> fromNodes, DependencyGraphNode toNode) {
        // Include the shortest path from each version that has a direct dependency on the broken dependency, back to the root

    StdErr(1);

    private final int code;

     Destination(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }

    public static Destination fromCode(int code) {
        for (Destination d : Destination.values()) {
            if (d.code == code) {
                 return d;
            }
        }

    }

    void addDependencyPredecessor(Node fromNode) {
        dependentNodes = dependentNodes.addDependencyPredecessors(fromNode);
        mutationInfo.addConsumer(fromNode);
    }

    void addMustPredecessor(TaskNode fromNode) {
        dependentNodes = dependentNodes.addMustPredecessor(fromNode);
    }

    protected DependencyNodesSet getDependencyNodes() {

    return leafNodeCode;
  }

  char getInnerNodeCode() {
    return innerNodeCode;
  }

  /** Returns a PublicSuffixType of the right type according to the given code */
  static PublicSuffixType fromCode(char code) {
    for (PublicSuffixType value : values()) {
      if (value.getInnerNodeCode() == code || value.getLeafNodeCode() == code) {
        return value;
      }
    }

    return leafNodeCode;
  }

  char getInnerNodeCode() {
    return innerNodeCode;
  }

  /** Returns a PublicSuffixType of the right type according to the given code */
  static PublicSuffixType fromCode(char code) {
    for (PublicSuffixType value : values()) {
      if (value.getInnerNodeCode() == code || value.getLeafNodeCode() == code) {
        return value;
      }
    }

        Set<Node> seen = new HashSet<>(1024);

        ArrayDeque<Node> queue = new ArrayDeque<>(1024);
        for (Node fromNode : blockedFinalizedMembers) {
            queue.add(fromNode);
            while (!queue.isEmpty()) {
                Node toNode = queue.removeFirst();
                if (members.contains(toNode) && !blockedFinalizedMembers.contains(toNode)) {