public String execute(BuildController controller) {
        CustomProjectsLoadedModel model;
        if (tasks == null || tasks.isEmpty()) {
            model = controller.getModel(CustomProjectsLoadedModel.class);
        } else {
            model = controller.getModel(CustomProjectsLoadedModel.class, CustomParameter.class, new Action<CustomParameter>() {
                @Override
                public void execute(CustomParameter customParameter) {

        for (BasicGradleProject project : controller.getBuildModel().getProjects()) {
            result.put(project.getPath(), controller.getModel(project, CustomModel.class));
        }

        CustomModel rootProjectModel = controller.getModel(controller.getBuildModel().getRootProject(), CustomModel.class);
        for (CustomModel customModel : result.values()) {

        if (workspace != null) {
            models.add(controller.getModel(build.getRootProject(), modelClass, EclipseRuntime.class, new EclipseRuntimeAction(workspace)));
        } else {
            models.add(controller.getModel(build.getRootProject(), modelClass));
        }
        for (GradleBuild includedBuild : build.getIncludedBuilds()) {

    }

    @Override
    public EclipseProject execute(BuildController controller) {
        if (workspace != null) {
            return controller.getModel(EclipseProject.class, EclipseRuntime.class, new EclipseRuntimeAction(workspace));
        }
        return controller.getModel(EclipseProject.class);
    }

    private static class EclipseRuntimeAction implements Action<EclipseRuntime>, Serializable {

    }

    @Override
    public Void execute(BuildController controller) {
        if (workspace != null) {
            controller.getModel(RunClosedProjectBuildDependencies.class, EclipseRuntime.class, new EclipseRuntimeAction(workspace));
        } else {
            controller.getModel(RunClosedProjectBuildDependencies.class);
        }
        return null;
    }

        Result result = new Result();

        GradleBuild buildModel = controller.getBuildModel();
        result.rootBuild = buildModel;
        result.rootIdeaProject = controller.getModel(IdeaProject.class);

        collectAllNestedBuilds(buildModel, controller, result);

        result.allIdeaProjects.add(result.rootIdeaProject);

        setup:
        1 * versionDetails.maySupportModel(SomeModel.class) >> false
        when:
        modelProducer.produceModel(SomeModel.class, Mock(ConsumerOperationParameters))
        then:
        0 * builder.getModel(_, _, _)
        def e = thrown(UnknownModelException)

        when:
        def model = withConnection { getModel(HierarchicalEclipseProject) }

        then:
        model.name == 'module-root'
    }

    def "Eclipse model builder can handle indirect cycles between included builds"() {
        given:
        compositeWithIndirectIncludeCycle()

        when:
        def model = withConnection { getModel(HierarchicalEclipseProject) }

        then:

    public MavenProject getProject() {
        return project;
    }

    public List<Dependency> getDependencies() {
        return project.getModel().getDependencies();
    }

    public List<Dependency> getManagedDependencies() {
        DependencyManagement depMngt = project.getModel().getDependencyManagement();
        return (depMngt != null) ? Collections.unmodifiableList(depMngt.getDependencies()) : Collections.emptyList();
    }

        when:
        BuildEnvironment env = toolingApi.withConnection { connection ->
            connection.newBuild().run() //the assert
            connection.getModel(BuildEnvironment.class)
        }

        then:
        env.java.jvmArguments.contains('-Xmx62m')
    }

    def "tooling api honours java home specified in gradle.properties"() {