include("a")
            include("b")
            include("c")
        """
        file("build.gradle") << """
            project(":a") {
                plugins.apply(my.MyPlugin)
            }
            project(":b") {
                plugins.apply(my.MyPlugin)
            }
        """
        file("a/build.gradle") << """
            myExtension.message = "project a"
        """
        file("b/build.gradle") << """

        settingsFile << 'include "b"'
        file("b/build.gradle") << '''
            apply plugin: 'java'
        '''
        file("b/src/main/java/λ.java") << 'public class λ {}'

        buildFile << '''
            apply plugin: 'java'

            dependencies {
               implementation project(':b')
            }
        '''

            public class SomePlugin implements Plugin<Project> {
                public void apply(Project project) {
                    Object returned = $method;
                    System.out.println("returned = " + returned);
                }
            }
        """

        buildScript("""
            apply plugin: SomePlugin
        """)

        when:

	// These are used by preflight.RunPullImagesCheck() when running 'apply'.
	if upgradeApply {
		initCfg.NodeRegistration.ImagePullPolicy = upgradeCfg.Apply.ImagePullPolicy
		initCfg.NodeRegistration.ImagePullSerial = upgradeCfg.Apply.ImagePullSerial
	}

	newK8sVersion := upgradeCfg.Plan.KubernetesVersion
	if upgradeApply {
		newK8sVersion = upgradeCfg.Apply.KubernetesVersion

        kotlinCoreProjectEnvironment.environment.application.apply {
            registerService(serviceInterface, serviceImplementation)
        }
    }

    public fun <T : Any> registerApplicationService(serviceImplementation: Class<T>) {
        kotlinCoreProjectEnvironment.environment.application.apply {
            registerService(serviceImplementation)
        }
    }

        settingsFile << """
            include("a")
            include("b")
        """
        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)

		obj.Node.ImagePullSerial = ptr.To(true)
	}

	if obj.Apply.EtcdUpgrade == nil {
		obj.Apply.EtcdUpgrade = ptr.To(true)
	}
	if obj.Apply.CertificateRenewal == nil {
		obj.Apply.CertificateRenewal = ptr.To(true)
	}
	if len(obj.Apply.ImagePullPolicy) == 0 {
		obj.Apply.ImagePullPolicy = DefaultImagePullPolicy
	}
	if obj.Apply.ImagePullSerial == nil {
		obj.Apply.ImagePullSerial = ptr.To(true)
	}

import org.gradle.api.Project
import org.gradle.integtests.fixtures.GroovyBuildScriptLanguage
import org.gradle.test.fixtures.file.TestFile

/**
 * A set of helpers to generate a Groovy plugin with provided code in buildSrc and apply it to the project under test.
 * The trait is intended to be mixed into something that extends {@link org.gradle.integtests.fixtures.AbstractIntegrationSpec}.
 */
trait DynamicGroovyPluginMixin {

            val kotlinVersion = "1.9.20"

            id("org.jetbrains.kotlin.jvm") version kotlinVersion
            id("org.jetbrains.kotlin.kapt") version kotlinVersion apply false
            val java = id("java")
            val app = id("application")
            app.apply(java.apply)
        }
        """.trimIndent()
    )
    printResolutionResults(result)

    printResolvedAssignments(result)
}


class Tests {

    }

    def "Source directory has output specified"() {
        setup:
        settingsFile << 'rootProject.name = "root"'
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   file {
                       whenMerged { classpath ->