}
                """.trimIndent()
            )

        setupPluginRequirements()
    }

    /**
     * Create projects and files required for plugins applied to the project (including transitively applied plugins).
     * These files are not required to run the task itself, but are required to apply the binary-compatibility plugin.
     */
    protected

    @ToBeFixedForIsolatedProjects(because = "Configure projects from root")
    def "uses target instead of parent"() {
        when:
        createDirs("a", "b")
        settingsFile << """
            include "a"
            include "b"
        """
        buildFile """
            class Plugin1 implements Plugin {
                void apply(project) {
                    project.rootProject.project(":b").apply(plugin: Plugin2)

Resolving a configuration can have side effects on Gradle's project model.
As a result, Gradle must manage access to each project's configurations.
There are a number of ways a configuration might be resolved unsafely.
For example:

* A task from one project directly resolves a configuration in another project in the task's action.
* A task specifies a configuration from another project as an input file collection.

                    project.getGroupId(), project.getArtifactId(), project.getVersion(), null, project.getPackaging());
            project.setArtifact(projectArtifact);

            // only set those on 2nd phase, ignore on 1st pass
            if (project.getFile() != null) {
                Build build = project.getBuild().getDelegate();
                project.addScriptSourceRoot(build.getScriptSourceDirectory());

        File f = getFileForClasspathResource(dir + "project-with-scoped-dependencies.xml");

        MavenProject project = getProjectWithDependencies(f);

        Artifact artifact;

        assertNotNull(project, "Test project can't be null!");

        checkArtifactIdScope(project, "provided", "provided");
        checkArtifactIdScope(project, "test", "test");
        checkArtifactIdScope(project, "compile", "compile");

            codenarc {
                configFile = project.file("codenarc-config")
            }
            assert project.codenarc.configFile == project.file("codenarc-config") // computed property
            assert project.tasks.codenarcMain.configFile == project.file("codenarc-config")
            assert project.tasks.codenarcTest.configFile == project.file("codenarc-config")
        '''.stripIndent()

        expect:

    }

    @ToBeFixedForIsolatedProjects(because = "Configuring projects from root")
    def "different tasks match name but only one accepts the option"() {
        given:
        createDirs("other")
        settingsFile << "include 'other'"
        buildFile << """
            task someTask(type: SomeTask)
            project(":other") {
              task someTask
            }

        outputContains("creating model with parameter='fetch1' for root project 'root'")
        outputContains("creating model with parameter='fetch2' for root project 'root'")
        outputContains("configuring project ':a'")
        outputContains("creating model with parameter='fetch1' for project ':a'")
        outputContains("creating model with parameter='fetch2' for project ':a'")

        and:
        model1.keySet() ==~ [":", ":a"]

[[sec:binary_plugin_example]]
[source, build.gradle.kts]
----
class MyPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        println("Plugin ${this.javaClass.simpleName} applied on ${project.name}")
    }
}

apply<MyPlugin>()
----

/**
 * A model resolver to assist building of projects. This resolver gives priority to those repositories that have been
 * declared in the POM.
 *
 */
public class ProjectModelResolver implements ModelResolver {

    private static final int MAX_CAP = 0x7fff;

    private final RepositorySystemSession session;

    private final RequestTrace trace;

    private final String context = "project";