}

    def "can read natures"() {
        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']
    }

        this.artifactResolver = Objects.requireNonNull(artifactResolver, "artifactResolver cannot be null");
        this.modelBuilder = Objects.requireNonNull(modelBuilder, "modelBuilder cannot be null");
        this.repositoryEventDispatcher =
                Objects.requireNonNull(repositoryEventDispatcher, "repositoryEventDispatcher cannot be null");

        """

        when:
        toolingApi.withConnection { ProjectConnection connection ->
            ModelBuilder<GradleProject> modelBuilder = connection.model(GradleProject.class)
            collectOutputs(modelBuilder)
            modelBuilder.forTasks([':other-build:sub:doSomething'])
            modelBuilder.get()
        }

        then:
        stdout.toString().contains("do something")
    }

        this.registry = registry;
    }

    @Override
    public void apply(Project target) {
        ModelBuilder modelBuilder = target.getObjects().newInstance(ModelBuilder.class);
        registry.register(modelBuilder);
    }

class KotlinScriptModelParameters {
    static setModelParameters(modelBuilder, boolean lenient, boolean explicitlyRequestPreparationTasks = true, Iterable<File> scripts = []) {
        if (lenient) {
            modelBuilder.setJvmArguments([KotlinDslModelsParameters.CLASSPATH_MODE_SYSTEM_PROPERTY_DECLARATION])
        } else {
            modelBuilder.setJvmArguments([KotlinDslModelsParameters.STRICT_CLASSPATH_MODE_SYSTEM_PROPERTY_DECLARATION])

    }

    public void buildModel() {
        try (ProjectConnection connection = createGradleConnection()) {
            ModelBuilder<DemoModel> modelBuilder = connection.model(DemoModel.class).addArguments("--quiet");
            ProblemListener.createAndRegister(modelBuilder);
            modelBuilder.get();
        }
    }

    public void runBuild() {
        try (ProjectConnection connection = createGradleConnection()) {

        return this
    }

    List getProgressMessages() {
        return progressMessages
    }

    ConfigurableOperation buildModel() {
        assert operation instanceof ModelBuilder
        def model = (ModelBuilder) operation;
        this.modelInstance = model.get()
        this
    }

    Object getModel() {
        assert modelInstance != null : "Model was not built."
        this.modelInstance
    }

            + "    </dependencies>\n"
            + "  </dependencyManagement>\n"
            + "</project>\n";

    @Test
    void testCycleInImports() throws Exception {
        ModelBuilder builder = new DefaultModelBuilderFactory().newInstance();
        assertNotNull(builder);

        DefaultModelBuildingRequest request = new DefaultModelBuildingRequest();

 * limitations under the License.
 */
package org.gradle.tooling.internal.consumer;

import org.gradle.tooling.GradleConnectionException;
import org.gradle.tooling.ModelBuilder;
import org.gradle.tooling.ResultHandler;
import org.gradle.tooling.internal.consumer.async.AsyncConsumerActionExecutor;
import org.gradle.tooling.internal.consumer.connection.ConsumerAction;

    }

    def "can request model from buildSrc without settings file"() {
        expect:
        def gradleProject = withConnectionToBuildSrc { connection ->
             def modelBuilder = connection.model(GradleProject)
            modelBuilder.get()
        }
        gradleProject.projectDirectory == buildSrc
        gradleProject.path == ':'
        gradleProject.children.size() == 0
    }