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

/**
 * A {@code ModelBuilder} allows you to fetch a snapshot of some model for a project or a build.
 * Instances of {@code ModelBuilder} are not thread-safe.
 * <p>
 * You use a {@code ModelBuilder} as follows:
 *
 * <ul>
 * <li>Create an instance of {@code ModelBuilder} by calling {@link org.gradle.tooling.ProjectConnection#model(Class)}.

import org.gradle.api.problems.Severity;
import org.gradle.tooling.provider.model.ToolingModelBuilder;

import javax.inject.Inject;

public class ModelBuilder implements ToolingModelBuilder {

    private final Problems problems;

    @Inject
    public ModelBuilder(Problems problems) {
        this.problems = problems;
    }

    @Override
    public boolean canBuild(String modelName) {

    /**
     * Performs only the part of {@link ModelBuilder#build(ModelBuildingRequest)} that loads the raw model
     *
     * @deprecated Use {@link #buildRawModel(Path, int, boolean)} instead.
     */
    @Deprecated
    Result<? extends Model> buildRawModel(File pomFile, int validationLevel, boolean locationTracking);

    /**
     * Performs only the part of {@link ModelBuilder#build(ModelBuildingRequest)} that loads the raw model

 * under the License.
 */
package org.apache.maven.api.services;

import java.util.List;

import org.apache.maven.api.Service;
import org.apache.maven.api.model.Model;

public interface ModelBuilder extends Service {

    List<String> VALID_MODEL_VERSIONS = List.of("4.0.0", "4.1.0");

    ModelBuilderResult build(ModelBuilderRequest request) throws ModelBuilderException;

    }
}

class ToolingApiModelBuilder<T> implements ModelBuilder<T>, ToolingApiConfigurableLauncher<ModelBuilder<T>> {
    @Delegate
    private final ModelBuilder<T> modelBuilder

    ToolingApiModelBuilder(ModelBuilder<T> modelBuilder, OutputStream stdout, OutputStream stderr) {
        initTrait(modelBuilder, stdout, stderr)
        this.modelBuilder = modelBuilder
    }
}

/**

    def "closed project build dependencies are executed on build"() {
        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")

@Named("classpath")
@Singleton
@Deprecated
public class TestProjectBuilder extends DefaultProjectBuilder {
    @Inject
    public TestProjectBuilder(
            ModelBuilder modelBuilder,
            ModelProcessor modelProcessor,
            ProjectBuildingHelper projectBuildingHelper,
            MavenRepositorySystem repositorySystem,
            RepositorySystem repoSystem,

        }
    }

    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:

        assertHasConfigureSuccessfulLogging()

        where:
        description                 | action
        "no task names specified"   | { ModelBuilder b -> }
        "empty array of task names" | { ModelBuilder b -> b.forTasks() }
        "empty list of task names"  | { ModelBuilder b -> b.forTasks([]) }
    }

    def "#description means do not run any tasks even when build logic injects tasks to execute"() {

        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");