buildFile << """
            allprojects {
                plugins.apply('java-library')
            }
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModelFails()

        then:
        fixture.assertStateStoredAndDiscarded {
            projectConfigured(":buildSrc")
            modelsCreated(":")

                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                    <plugin>
                        <artifactId>maven-source-plugin</artifactId>
                        <version>3.3.1</version>
                        <executions>
                            <execution>
                                <id>attach-sources</id>

                <version>1.11.1</version>
                <executions>
                    <execution>
                        <id>check</id>
                        <goals>
                            <goal>check</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>

        output.contains('system_property_available in included settings.gradle: true')

        cleanup:
        cleanupDaemons(executer, executionVersion)
    }

    static void cleanupDaemons(GradleExecuter executer, GradleDistribution executionVersion) {
        new DaemonLogsAnalyzer(executer.daemonBaseDir, executionVersion.version.version).killAll()
    }

        prepareWrapper()
        def gradleUserHome = testDirectory.file('some-custom-user-home')
        when:
        def executer = wrapperExecuter.withGradleUserHomeDir(gradleUserHome)
        result = executer.withTasks("hello").run()
        then:
        result.assertTaskExecuted(":hello")
        executer.stop()

        when:
        // Delete important file in distribution
        boolean deletedSomething = false

        executer.requireOwnGradleUserHomeDir("needs to test toolchain download functionality")
                .withToolchainDownloadEnabled()
    }

    def cleanup() {
        executer.gradleUserHomeDir.file("jdks").deleteDir()
    }

    def "can download missing jdk automatically"() {
        when:
        result = executer
                .withTasks("compileJava")

        }

        then:
        jvmTestEvents {
            task(":test") {
                suite("Gradle Test Run :test") {
                    suite("Gradle Test Executor") {
                        testClass("org.example.SimpleTests") {
                            testDisplayName "SimpleTests"
                            test("success test") {

import org.gradle.util.internal.TextUtil

class StdioIntegrationTest extends AbstractIntegrationSpec {
    def setup() {
        executer.requireDaemon()
        // This isn't actually required - the test is fine with shared daemons
        // In fact, it would be much better to test this feature using shared daemons
        executer.requireIsolatedDaemons()
    }

    def "task can read stdin when stdin has bounded length"() {
        given:

    final ProviderOperationParameters providerParameters = Stub()

    //declared type-lessly to work around groovy eclipse plugin bug
    final executer = new LoggingBridgingBuildActionExecuter(target, loggingManager)

    def configuresLoggingWhileActionIsExecuting() {
        when:
        executer.execute(action, parameters, buildRequestContext)

        then:
        1 * loggingManager.addOutputEventListener(!null)

import org.gradle.api.logging.configuration.ConsoleOutput
import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache
import org.gradle.integtests.fixtures.executer.ExecutionResult

abstract class AbstractConsoleJvmTestLoggingFunctionalTest extends AbstractIntegrationSpec {
    private static final String TEST_TASK_NAME = 'test'