}
}
// Apply the plugin defined in the buildscript block
plugins {
  id("org.barfuin.gradle.taskinfo") version "2.1.0"
}
----

|<<sec:script_plugins,4>>
|Apply a *local* script plugins.
|<<sec:script_plugins,The legacy `apply()` method in the build file>>
a|
[source,kotlin]
----
apply(plugin = "org.barfuin.gradle.taskinfo")
apply<MyPlugin>()
----
|===

            rootProject.name = 'root'
            include 'a', 'b'
        """
        buildFile << """
            allprojects {
                apply plugin: ToolchainPlugin
                apply plugin: 'java'

                java {
                    toolchain {
                        // Using a toolchain that triggers auto-provisioning is needed

	if err != nil {
		panic(err)
	}

	return c.Eval(ns, args, templates...)
}

func (c *configPlan) Apply(opts ...apply.Option) error {
	// Apply the options.
	options := apply.Options{}
	for _, o := range opts {
		o.Set(&options)
	}

	// Apply for each namespace concurrently.
	g, _ := errgroup.WithContext(context.TODO())
	for ns, y := range c.yamlText {
		ns, y := ns, y

    def setup() {
        settingsFile << 'rootProject.name = "root"'
    }

    def "Has no access rules"() {
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   containers 'classpathContainerPath'
               }
           }
        """

        when:

        def jdk11 = AvailableJavaHomes.getJdk(JavaVersion.VERSION_11)
        def jdk17 = AvailableJavaHomes.getJdk(JavaVersion.VERSION_17)

        buildFile << """
            apply plugin: "java"
            apply plugin: "application"

            application.mainClass = "Main"

            java {
                sourceCompatibility = "${JavaVersion.VERSION_11}"
            }

        testDirAttributes.find { it.name == 'gradle_used_by_scope' && it.value == 'test' }
    }

    def "Source folder defines additional classpath attributes"() {
        buildFile <<
            """apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   file {
                       whenMerged { classpath ->

        """
        buildFile << """
            project(':app') {
                apply plugin: 'cpp-application'
                application {
                    dependencies { implementation project(':lib') }
                }
            }
            project(':lib') {
                apply plugin: 'cpp-library'
                apply plugin: 'cpp-unit-test'
            }
        """

        when:

    def "Eclipse model provides javadoc location via classpath attributes"() {
        setup:
        settingsFile << 'rootProject.name = "root"'
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'eclipse'
           ${mavenCentralRepository()}
           dependencies { ${implementationConfiguration} 'com.google.guava:guava:18.0' }
           eclipse {
               classpath {

            public class SneakyPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    Object value = ${read.javaExpression};
                    System.out.println("apply = " + value);

                    project.getTasks().register("thing", t -> {
                        t.doLast(new Action<Task>() {

        settingsFile << """
            include("a")
            include("b")
        """
        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """
        // Intentionally don't apply to project b. Should split this case (some projects don't have the model available) out into a separate test

        when: