*     public static boolean isApplied()
 * </pre>
 * that returns if the agent is applied, i.e. if one of its {@code premain} or {@code agentmain} entry methods was called.
 * <p>
 * It is possible to have an agent in the classpath without actually applying it, so checking for the availability of the class is not enough.
 */
class AgentControl {
    private static final String INSTRUMENTATION_AGENT_CLASS_NAME = "org.gradle.instrumentation.agent.Agent";

    crossVersionTestDistributionRuntimeOnly(project(":distributions-basics"))
}

tasks.withType<Test>().configureEach {
    if (!javaVersion.isJava9Compatible) {
        classpath += javaLauncher.get().metadata.installationPath.files("lib/tools.jar")
    }
}

tasks.withType<JavaCompile>().configureEach {
    options.release = null
    sourceCompatibility = "8"

Class <org.gradle.plugins.ide.eclipse.model.Classpath> extends/implements org.gradle.plugins.ide.internal.generator.XmlPersistableConfigurationObject that is Gradle Internal API in (Classpath.java:0)

        }
        """
    }

    protected String emptyJavaClasspath() {
        """
            tasks.compileJava {
                // Avoid resolving the classpath when caching the configuration
                classpath = files()
            }
        """
    }

    // Helpers for writing buildscripts using a common syntax

    String renderString(String content) {

                inputs.files(manifestClasspath)
                val classpath = manifestClasspath.elements.map { classpathDependency ->
                    classpathDependency.joinToString(" ") {
                        it.asFile.name
                    }
                }
                manifest.attributes("Class-Path" to classpath)
            }

            dependencies {

import org.gradle.api.internal.ClassPathRegistry
import org.gradle.api.internal.DefaultClassPathProvider
import org.gradle.api.internal.DefaultClassPathRegistry
import org.gradle.api.internal.classpath.ModuleRegistry
import org.gradle.api.internal.file.TestFiles
import org.gradle.api.internal.file.temp.TemporaryFileProvider
import org.gradle.api.logging.LogLevel
import org.gradle.cache.UnscopedCacheBuilderFactory

    into(layout.buildDirectory.dir("generated-resources/tested-versions"))
}

val generateLanguageAnnotations by tasks.registering(GenerateLanguageAnnotations::class) {
    classpath.from(configurations.integTestDistributionRuntimeClasspath)
    packageName = "org.gradle.integtests.fixtures"
    destDir = layout.buildDirectory.dir("generated/sources/language-annotations/groovy/main")
}

        """
    }

    @SuppressWarnings('unused')
    // called by string
    def javaExecTask(Map<String, String> args) {
        """
            tasks.register("run", JavaExec) {
                classpath = project.layout.files(compileJava)
                mainClass = "Main"
                ${formatArgument args["extraArg"], { "args '$it'" }}

                ${formatStreamArgument args, "standardInput"}

                outputClasses = layout.buildDirectory.dir("producerOutput")
            }

            abstract class MyTask extends DefaultTask {
                @Classpath abstract ConfigurableFileCollection getClasses()
                @Inject abstract ProjectLayout getLayout()
                @TaskAction void doStuff() {
                    def root = layout.projectDirectory.asFile

        file("included/settings.gradle") << "rootProject.name = 'included'"
        buildFile.text = """
            buildscript {
                dependencies {
                    classpath(files("./included/build/libs/included.jar"))
                }
            }
            apply plugin: MyPlugin
        """
        settingsFile << """rootProject.name = 'root'"""

        when: