@Requires(IntegTestPreconditions.NotConfigCached)
    def "generates build lifecycle operations for included build used as buildscript and production dependency"() {
        given:
        buildA.buildFile.prepend("""
            buildscript {
                dependencies {
                    classpath 'org.test:b1:1.0'
                }
            }
        """)

        def buildScript = """
            tasks.register('executionCredentials') {
                def providers = project.providers
                doLast {
                    providers.credentials($credentialsType, 'test').get()
                }
            }
        """
        file('submodule1/build.gradle') << buildScript
        file('submodule2/build.gradle') << buildScript

    def "does not download gradleApi() sources when sources download is disabled"() {
        given:
        executer.withEnvironmentVars('GRADLE_REPO_OVERRIDE': "$server.uri/")

        buildScript """
            apply plugin: "java"
            apply plugin: "idea"
            apply plugin: "eclipse"

            dependencies {
                implementation gradleApi()
            }

    }

    // TODO: remove in Gradle 9.0
    def "nag with deprecation warnings when using legacy TestReport APIs"() {
        given:
        buildScript """
            apply plugin: 'java'
            $junitSetup
            tasks.register('otherTests', Test) {
                binaryResultsDirectory = file("bin")
                classpath = files('blahClasspath')

        "newer"  | PLUGIN_NEWER_VERSION
    }

    def "uses #sequence version of plugin when added to buildscript classpath"() {
        when:
        fixture.runtimeVersion = version
        fixture.artifactVersion = version
        settingsFile.text = """
            buildscript {
                repositories {
                    maven { url '${mavenRepo.uri}' }
                }

        when:
        buildScript plugin.useDeclaration
        def result = runner()
            .withPluginClasspath([])
            .buildAndFail()

        then:
        !execFailure(result).error.contains("Gradle TestKit (classpath:")
    }

    def "injected classpath is indicated in error message if plugin not found"() {
        when:
        buildScript plugin.useDeclaration

        succeeds('customTask')

        then:
        operations.hasOperation(SnapshotTaskInputsBuildOperationType)
    }

    def "handles task with no outputs"() {
        when:
        buildScript """
            task noOutputs {
                doLast {}
            }
        """
        succeeds('noOutputs', "--build-cache")

        then:

-----------------
init - Initializes a new Gradle build.
updateDaemonJvm - Generates or updates the Gradle Daemon JVM criteria.
wrapper - Generates Gradle wrapper files.

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project '$projectName'.
dependencies - Displays all dependencies declared in root project '$projectName'.
dependencyInsight - Displays the insight into a specific dependency in root project '$projectName'.

        }
    }

    def "pluginManagement block must come before buildScript blocks in the settings.gradle script"() {
        given:
        settingsFile << """
            buildScript {}
            pluginManagement {}
        """

        when:
        fails 'help'

        then:
        failure.assertHasLineNumber(3)

        programKind: ProgramKind,
        programTarget: ProgramTarget
    ): CompiledScript {

        // TODO: consider computing stage 1 accessors only when there's a buildscript or plugins block
        // TODO: consider splitting buildscript/plugins block accessors
        val stage1BlocksAccessorsClassPath = when (programTarget) {
            ProgramTarget.Project -> host.stage1BlocksAccessorsFor(scriptHost)