import org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache
import org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.ProjectLifecycleFixture
import org.gradle.integtests.fixtures.extensions.FluidDependenciesResolveTest
import org.gradle.integtests.fixtures.timeout.IntegrationTestTimeout

            if (GradleContextualExecuter.isConfigCache()) {
                executer.expectDocumentedDeprecationWarning(wrapUtilWarning)
            } else {
                executer.beforeExecute {
                    executer.expectDocumentedDeprecationWarning(wrapUtilWarning)
                }
            }
            executer.expectDocumentedDeprecationWarning(

            println(gradleProp + '!')
        """

        when:
        executer.withEnvironmentVars([
            (ENV_PROJECT_PROPERTIES_PREFIX + 'gradleProp'): 1
        ])
        configurationCacheRun "help"

        then:
        outputContains '1!'
        configurationCache.assertStateStored()

        when:
        executer.withEnvironmentVars([
            (ENV_PROJECT_PROPERTIES_PREFIX + 'gradleProp'): 1

        NO    | "no"  | false
    }

    def "can ask yes/no and handle invalid input in interactive build"() {
        given:
        interactiveExecution()

        when:
        def gradleHandle = executer.withTasks("askYesNo").start()

        then:
        poll(INTERACTIVE_WAIT_TIME_SECONDS) {
            assert gradleHandle.standardOutput.contains(YES_NO_PROMPT)
        }

                }
            }
        """
    }

    def "restores only projects that have work scheduled"(List<String> tasks) {
        def fixture = new BuildOperationsFixture(executer, temporaryFolder)
        executer.beforeExecute {
            withArgument("-Dorg.gradle.configuration-cache.internal.load-after-store=true")
        }
        createDirs("a", "b", "c", "custom")
        settingsFile << """

                    classpath(files("./second/build/classes/java/main"))
                }
            }
        """

        when:
        executer.inDirectory(file("first")).withTasks("classes").run()
        executer.inDirectory(file("second")).withTasks("classes").run()
        run("tasks", "--info")

        then:
        allTransformsFor("main") ==~ [

    }

    private GradleHandle startInteractiveExecutorWithTasks(String... names) {
        executer.withForceInteractive(true)
        executer.withStdinPipe()
        executer.withTasks(names)
        executer.start()
    }

    private static ExecutionResult closeInteractiveExecutor(GradleHandle handle) {
        handle.stdinPipe.close()

    def "script plugin buildscript does not affect client"() {
        given:
        def jar = file("plugin.jar")
        pluginBuilder.addPlugin("project.task('hello')")
        pluginBuilder.publishTo(executer, jar)

        settingsFile << "include 'sub'"

        buildScript """
            apply from: "script.gradle"

            try {
                getClass().classLoader.loadClass(pluginClass.name)

        customSettings.parentFile.createDirs("child")
        customSettings << """
            include("child")
        """

        when:
        executer.usingSettingsFile(customSettings)
        executer.expectDocumentedDeprecationWarning("Specifying custom settings file location has been deprecated. This is scheduled to be removed in Gradle 9.0. " +

            }
        """
    }

    String plugins() {
        """
            plugins { id "$id" version "$runtimeVersion" }
        """
    }

    void publishDummyPlugin(GradleExecuter executer) {
        executer.beforeExecute {
            publishDummyPluginNow()
        }
    }

    private String getPropertyPrefix() {
        simpleClassName.uncapitalize()
    }

    void publishDummyPluginNow() {