outputContains("agent applied = $applied")
    }

    private void withAgent() {
        withAgentApplied(true)
    }

    private void withAgentApplied(boolean shouldApply) {
        executer.withArgument("-D${DaemonBuildOptions.ApplyInstrumentationAgentOption.GRADLE_PROPERTY}=$shouldApply")
    }

    private void withoutAgent() {
        withAgentApplied(false)
    }

    DaemonLogsAnalyzer getDaemons() {

            assert configurations.runtimeClasspath.attributes.getAttribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE) == ${javaVersion}
        """

        expect:
        executer.withArgument("-Porg.gradle.java.installations.paths=" + jdk.javaHome.absolutePath)
        succeeds("compileJava")
    }

        gradleExecuterFor(arrayOf("check", "publish"), rootDir = file("plugin"))
            .withJavaHome(currentJvm.javaHome)
            .withArgument("-Porg.gradle.java.installations.paths=$installationPaths")
            .run()

        withSettingsIn("consumer", """
            pluginManagement {
                repositories {

        this.path = projectDir.testDirectory.file(operationsTraceName).absolutePath
        executer.beforeExecute {
            this.tree = null
            executer.withArgument("-D$BuildOperationTrace.SYSPROP=$path")
        }
    }

    @Override
    List<BuildOperationRecord> getRoots() {
        getTree().roots
    }

    List<BuildOperationRecord> getDanglingChildren() {

        switch (enablement) {
            case CCDebugEnablement.DEBUG_LOG_LEVEL:
                withDebugLogging()
                break
            case CCDebugEnablement.SYSTEM_PROPERTY:
                executer.withArgument "-D$ConfigurationCacheDebugOption.PROPERTY_NAME=true"
                break
            case CCDebugEnablement.GRADLE_PROPERTIES_FILE:

                    new Thing();
                }
            }
        """

        when:
        executer.beforeExecute({
            withArgument("-Porg.gradle.java.installations.paths=" + jvm.getJavaHome().getAbsolutePath())
        })
        fails("build")

        then:
        failure.assertHasDescription("Execution failed for task ':compileJava'.")

            }
        """

        file("src/main/java/Thing.java") << """
            /** Some thing. */
            public class Thing { }
        """
        executer.withArgument("-Porg.gradle.java.installations.paths=" + jvm.javaHome.absolutePath)
    }

    def "can compile source and run JUnit tests using target Java version"() {
        given:

@Requires(IntegTestPreconditions.NotDaemonExecutor)
class SingleUseDaemonIntegrationTest extends AbstractIntegrationSpec implements DaemonJvmPropertiesFixture, JavaToolchainFixture {

    def setup() {
        executer.withArgument("--no-daemon")
        executer.requireIsolatedDaemons()
    }

    def "forks build when JVM args are requested"() {
        requireJvmArg('-Xmx64m')

        file('build.gradle') << "println 'hello world'"

        and:
        pidFile().exists()
        def pid2 = pidFile().text.strip() as long
        pid2 == pid1
    }

    private void startBuild(String task) {
        executer
            .withArgument('--debug')
            .withWorkerDaemonsExpirationDisabled()
            .withTasks(task)

        client = new DaemonClientFixture(executer.start())
    }

    private void cancelBuild() {

        logger.debug("debugging stuff")
        logger.info("infoing stuff")
"""

        when:
        String debug = withBuild { it.withArguments('-d') }.standardOutput

        and:
        String info = withBuild { it.withArguments('-i') }.standardOutput

        then:
        debug.count("debugging stuff") == 1
        debug.count("infoing stuff") == 1

        and: