realizeTask(MODEL_PATH.child(task.getName()), ModelNode.State.GraphClosed);
        }
    }

    /**
     * @return true if this method _may_ have done some work.
     */
    private boolean maybeCreateTasks(String name) {
        if (modelNode != null && modelNode.hasLink(name)) {
            realizeTask(MODEL_PATH.child(name), ModelNode.State.Initialized);

    }

    @Override
    public DefaultGradleProject buildForRoot(Project project) {
        boolean realizeTasks = GradleProjectBuilderOptions.shouldRealizeTasks();
        return buildHierarchy(project.getRootProject(), realizeTasks);
    }

    /**
     * When {@code realizeTasks} is false, the project's task graph will not be realized, and the task list in the model will be empty
     */

    }

    ModelMap<Task> realizeTasks() {
        project.modelRegistry.find 'tasks', modelMap(Task)
    }

    def "creates link and install task for executable"() {
        when:
        project.model {
            components {
                test(NativeExecutableSpec)
            }
        }

        realizeTasks()
        def binaries = realizeBinaries()

    public IsolatedGradleProjectInternal buildAll(String modelName, Project project) {
        return build(project, true);
    }

    private static IsolatedGradleProjectInternal build(Project project, boolean realizeTasks) {
        IsolatedGradleProjectInternal gradleProject = new IsolatedGradleProjectInternal()
            .setProjectIdentifier(new DefaultProjectIdentifier(project.getRootDir(), project.getPath()))

    @Rule SetRuleContext setContext = new SetRuleContext()

    def realize(String name) {
        project.modelRegistry.find(name, ModelType.UNTYPED)
    }

    ModelMap<Task> realizeTasks() {
        project.modelRegistry.find("tasks", ModelTypes.modelMap(Task))
    }

    ComponentSpecContainer realizeComponents() {
        project.modelRegistry.find("components", ComponentSpecContainer)
    }

            .setBuildTreePath(model.getBuildTreePath());
        target.setProject(owner);
        return target;
    }

    private static IsolatedGradleProjectParameter createParameter(boolean realizeTasks) {
        return () -> realizeTasks;
    }

            model {
                binaries {
                    bin1(BinarySpec)
                    bin2(BinarySpec)
                }
            }
        }

        then:
        def tasks = realizeTasks()
        def binaries = realizeBinaries()
        tasks.bin1 == binaries.bin1.buildTask
        tasks.bin2 == binaries.bin2.buildTask
    }

                        }
                    }
                    comp2(ComponentSpec)
                }
            }
        }

        then:
        def tasks = realizeTasks()
        def components = realizeComponents()
        tasks.comp1Bin1 == components.comp1.binaries.bin1.tasks.build
        tasks.comp1Bin2 == components.comp1.binaries.bin2.tasks.build
    }

    def "creates publish task for publication and repository"() {
        when:
        publishing.publications.create("test", IvyPublication)
        publishing.repositories { ivy { url = "http://foo.com" } }
        realizeTasks()
        def publishTask = project.tasks["publishTestPublicationToIvyRepository"]

        then:
        publishTask != null
        project.tasks["publish"].dependsOn.contains publishTask.name
    }