plugin.assertAutoApplied(output, false)
    }

    def "is not auto-applied when added to classpath via buildscript block"() {
        given:
        def coordinates = "${groupId}:${artifactId}:${plugin.runtimeVersion}"
        settingsFile << """
            buildscript {
                repositories {
                    maven { url '${mavenRepo.uri}' }
                }
                dependencies {

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

                    ?.singleSectionOf(TopLevelBlockId.plugins)
                    ?.let { sourceWithoutComments.fragment(it) }

            val buildscript =
                buildscriptFragment?.takeIf { it.isNotBlank() }?.let(Program::Buildscript)

            val pluginManagement =
                pluginManagementFragment?.takeIf { it.isNotBlank() }?.let(Program::PluginManagement)

            val plugins =

    }

    def "tasks added via task container and not explicitly required but executed are self closed"() {
        given:
        buildScript """
            ${ruleBasedTasks()}

            class Rules extends RuleSource {
                @Mutate
                void configureDependencyTask(@Path("tasks.dependency") EchoTask task) {

        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

        settingsFile << """
            include "p1"
            include "p2"
        """

        when:
        file("p1/build.gradle") << USE
        file("p2/build.gradle") << USE

        buildScript """
            evaluationDependsOnChildren()
            task verify {
                def p1PluginClass = project(":p1").pluginClass
                def p2PluginClass = project(":p2").pluginClass
                doLast {

        )

        assert(
            build("-I", initScript.canonicalPath)
                .output.contains("*42*")
        )
    }

    @Test
    fun `Kotlin init scripts from init dir can add buildscript repositories to projects`() {

        val testRepositoryDir = file("test-repository").apply { mkdirs() }

        val guh = file("gradle-user-home").apply { mkdirs() }
        guh.withFolders {
            "init.d" {

     * This method was originally added in order to release the resources of the {@code classpath}
     * configurations used for resolving buildscript classpaths, as they consumed a non-negligible
     * amount of memory even after the buildscript classpath was assembled.
     * <p>
     * Future work in this area should remove the need of this method by instead caching resolution

                }
            }
        }
    """
    def pluginClasspathDependency = "org.gradle:gradle-hello-world-plugin:0.2"

    def "buildscript dependencies can be resolved from gradlePluginPortal()"() {
        given:
        buildFile << """
            buildscript {
                $gradlePluginPortalRepository
                dependencies {
                    classpath("$pluginClasspathDependency")
                }

        result.testClass("LoggingTest").assertStderr(equalTo("stderr.\n"))
    }

    def "test report task can handle test tasks that did not run tests"() {
        given:
        buildScript """
            $junitSetup

            def test = tasks.named('test', Test)

            def otherTests = tasks.register('otherTests', Test) {
                binaryResultsDirectory = file("bin")