setup:
        project.eclipse.project.natures = ['nature.a', 'nature.b']
        def modelBuilder = createEclipseModelBuilder()

        when:
        def eclipseModel = modelBuilder.buildAll("org.gradle.tooling.model.eclipse.EclipseProject", project)

        then:
        eclipseModel.projectNatures.collect { it.id } == ['nature.a', 'nature.b']
    }

        }
    }

    def "project dependencies are mapped to eclipse model"() {
        setup:
        def modelBuilder = createEclipseModelBuilder()

        when:
        def eclipseModel = modelBuilder.buildAll("org.gradle.tooling.model.eclipse.EclipseProject", project)

        then:
        DefaultEclipseProject eclipseChild2 = eclipseModel.children.find { it.name == 'child2' }

        actualBuilder != builder2

        when:
        def result = actualBuilder.buildAll("model", project)

        then:
        result == "result"

        and:
        1 * projectStateRegistry.allowUncontrolledAccessToAnyProject(_) >> { Factory factory -> factory.create() }
        1 * builder2.buildAll("model", project) >> "result"
        0 * _
    }

                        return CustomParameter.class;
                    }
                    Object buildAll(String modelName, Project project) {
                        return new DefaultCustomModel();
                    }
                    Object buildAll(String modelName, CustomParameter parameter, Project project) {
                        return new DefaultCustomModel(parameter);
                    }

    }

    @Override
    public IsolatedIdeaModuleInternal buildAll(String modelName, IdeaModelParameter parameter, Project project) {
        return build(project, parameter.getOfflineDependencyResolution());
    }

    @Override
    public IsolatedIdeaModuleInternal buildAll(String modelName, Project project) {
        return build(project, false);
    }

            return delegate.canBuild(modelName);
        }

        @Override
        public Object buildAll(String modelName, Project project) {
            return projectStateRegistry.allowUncontrolledAccessToAnyProject(() -> delegate.buildAll(modelName, project));
        }
    }

    private static abstract class DelegatingBuilder implements Builder {
        final Builder delegate;

        return modelName.equals(MODEL_NAME);
    }

    @Override
    public Object buildAll(String modelName, PluginApplyingParameter parameter, Project project) {
        project.getPluginManager().apply(parameter.getPluginType());
        return true;
    }

    @Override
    public Object buildAll(String modelName, Project project) {

        setup:
        def eclipseRuntime = eclipseRuntime([gradleProject(child1, false), gradleProject(child2)])
        def modelBuilder = createBuilder()

        when:
        modelBuilder.buildAll("org.gradle.tooling.model.eclipse.RunClosedProjectBuildDependencies", eclipseRuntime, project)

        then:
        def buildTask = project.tasks.getByName("eclipseClosedDependencies")
        buildTask != null

 */

package org.gradle.tooling.provider.model;

import org.gradle.api.Project;

/**
 * Responsible for building tooling models to return to the tooling API client.
 *
 * <p>The {@link #buildAll(String, Project)} method is called to create a model for a given project. The model is serialized to the client process and passed
 * to the client application.</p>
 *

        this.problems = problems;
    }

    @Override
    public boolean canBuild(String modelName) {
        return DemoModel.class.getName().equals(modelName);
    }

    @Override
    public Object buildAll(String modelName, Project project) {
        problems.forNamespace("reporters.model.builder").reporting(problem -> problem
            .id("unused", "Demo model")
            .severity(Severity.WARNING)