def buildDir(buildNum) {
        file("builds/$buildNum")
    }

    def buildDirWithScript(buildNum, buildScript) {
        def dir = buildDir(buildNum)
        dir.file("settings.gradle").touch()
        dir.file("build.gradle") << buildScript
        dir
    }

    void startBuild(String javaHome = null, String buildEncoding = null) {
        run {
            executer.withTasks("watch")

        where:
        scriptType      | scriptBlock   | scriptFileName
        "project build" | 'buildscript' | getDefaultBuildFileName()
        "script plugin" | 'buildscript' | "scriptPlugin.gradle"
        "settings"      | 'buildscript' | 'settings.gradle'
        "init"          | 'initscript'  | 'init.gradle'
    }

    }

    @ToBeFixedForConfigurationCache(because = "changing buildscript files dependency")
    def "build script is recompiled when project's classpath changes"() {
        createJarWithProperties("lib/foo.jar", [source: 1])
        root {
            'build.gradle'(simpleBuild('''
                buildscript {
                    dependencies {
                        classpath files('lib/foo.jar')

                void apply(Gradle gradle) {
                    def mirrorClosure = { Project project ->
                        project.buildscript.configurations["classpath"].incoming.beforeResolve {
                            withMirrors(project.buildscript.repositories)
                        }
                        project.afterEvaluate {
                            withMirrors(project.repositories)

        generateExternalPlugin("first", "FirstPlugin", "first.property")
        generateExternalPlugin("second", "SecondPlugin", "second.property")
        buildFile.text = """
            buildscript {
                dependencies {
                    classpath(files("./first/build/classes/java/main"))
                    classpath(files("./second/build/classes/java/main"))
                }
            }

        """

        file("buildSrc/build.gradle.kts") << """
            plugins {
                `kotlin-dsl`
            }
            ${mavenCentralRepository(GradleDsl.KOTLIN)}
        """

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

        when:
        configurationCacheRun("-Dsome.property=some.value")

        then:
        configurationCache.assertStateStored()

        buildFile << getPluginDescriptors(pluginIds)
        projectDir.file('settings.gradle').write("")
    }

    void publishTo(GradleExecuter executer, TestFile testFile, String buildScript = "") {
        prepareToExecute()
        buildFile << buildScript
        buildFile << """
            jar {
                archiveFileName = "$testFile.name"

            executer.withPluginRepositoryMirrorDisabled();
        }

        return executer;
    }

    @Override
    @Deprecated
    public GradleExecuter usingBuildScript(File buildScript) {
        this.buildScript = buildScript;
        return this;
    }

    @Override
    public GradleExecuter usingProjectDirectory(File projectDir) {
        this.projectDir = projectDir;
        return this;
    }

    def "build service can be injected to build task with #injectionAnnotation"() {
        given:
        def configurationCache = newConfigurationCacheFixture()

        buildScript("""
            ${constantServiceImpl("ConstantBuildService", "constant")}
            def serviceProvider = gradle.sharedServices.registerIfAbsent("constant", ConstantBuildService) {}

    def "native services flag should be passed to the daemon and to the worker"() {
        given:
        executer.withArguments(systemProperties.collect { it.toString() })
        buildScript("""
            import org.gradle.workers.WorkParameters
            import org.gradle.internal.nativeintegration.services.NativeServices
            import org.gradle.internal.nativeintegration.NativeCapabilities