doLast {
                    configurations.compileClasspath.files
                    $queries
                }
            }
        """
        executer.withArgument("--no-configuration-cache") // task uses Configuration API
        run ":populateCache"
        executer.stop()
        copyToReadOnlyCache()
        buildFile.setText("")

        buildFile << """

                'init.gradle'("""
                    // init script
                    ${this.instrument('"init"')}
                """)
            }
        }

        when:
        executer.withArgument('-Igradle/init.gradle')
        run 'help'

        then:
        def scripts = scriptDetails()
        scripts.size() == 2
        hasScript('init', scripts)

        then:
        skipped(":someTask")

        // add property
        when:
        buildFile << """
someTask.inputs.property("b", 12)
"""
        and:
        executer.withArgument("-i")
        run "someTask"

        then:
        executedAndNotSkipped(":someTask")
        outputContains("Input property 'b' has been added for task ':someTask'")

        when:

@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'"

            // For java.util.concurrent.CopyOnWriteArrayList from DefaultMultiCauseException being serialized reflectively by configuration cache
            executer.withArgument('-Dorg.gradle.jvmargs=--add-opens java.base/java.util.concurrent=ALL-UNNAMED')
        }
        fails "verify"

        then:
        if (FluidDependenciesResolveInterceptor.isFluid()) {

                return sourceFile
            }
        }

        executer.beforeExecute {
            withWatchFs()
            // running in parallel, so the soak test doesn't take this long.
            withArgument("--parallel")
            vfsLogs = enableVerboseVfsLogs()
            inDirectory(rootProject)
        }
    }

    def "file watching works with multiple builds on the same daemon"() {

        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() {

        m2.assertNoLeftoverState()

        m2.isolateMavenLocalRepo(executer)
        executer.beforeExecute {
            withArgument("-Dorg.gradle.internal.repository.max.tentatives=$maxHttpRetries")
            if (maxUploadAttempts != null) {
                withArgument("-Dorg.gradle.internal.network.retry.max.attempts=$maxUploadAttempts")
            }
        }
    }

    def cleanup() {

                        requireDaemon().requireIsolatedDaemons().
                        withGradleUserHomeDir(workspace.file("user-home"))
                8.times {
                    executer.inDirectory(buildDir).withArgument("--refresh-dependencies").withTasks('check').run()
                }
            }
        }
        concurrent.finished()
    }

    static class StressHttpServer extends ExternalResource {

            barrier.expectConcurrent("child-build-finished", "1-finished", "2-finished")
        }

        when:
        runs.times {
            executer.withArgument("--parallel")
            run 'otherBuild'
        }

        then:
        noExceptionThrown()

        and:
        def runNestedBuildOps = buildOperations.all(RunNestedBuildBuildOperationType)