def executer = targetDist.executer(temporaryFolder, getBuildContext())
            .withCommandLineGradleOpts("-Dorg.gradle.deprecation.trace=false") //suppress deprecation stack trace

        if (targetDist.toolingApiMergesStderrIntoStdout) {
            // The TAPI provider merges the streams, so need to merge the streams for command-line execution too
            executer.withArgument("--console=plain")

    @Rule
    Sample sample = new Sample(testDirectoryProvider)

    @UsesSample("files/copy")
    def "can archive a directory with #dsl dsl"() {
        given:
        def dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)
        def archivesDir = dslDir.file("build/toArchive")
        archivesDir.createDir().file("my-report.pdf").touch()
        archivesDir.createDir().file("numbers.csv").touch()

"""

        when:
        executer.withArgument("--dry-run")
        run 'useCompileConfiguration'

        then:
        server.resetExpectations()

        when:
        // Expect downloads when task executed
        module.pom.expectGet()
        module.artifact.expectGet()
        run 'useCompileConfiguration'

        then:
        executed ":child:jar", ":useCompileConfiguration"
    }

        val output = executer.withTasks(*tasks).run().normalizedOutput
        return BuildOperationsAssertions(buildOperations, output)
    }

    protected
    fun configureProjectAndExpectCompileAvoidanceWarnings(vararg tasks: String): BuildOperationsAssertions {
        val buildOperations = BuildOperationsFixture(executer, testDirectoryProvider)

    }

    void configureProxy(GradleExecuter executer) {
        if (port == 0) {
            port = portFinder.assignPort()
        }
        // Daemon | Test worker
        // build -> proxy(localhost) -> repo(localhost)
        //                           -> 127.0.0.1
        //
        executer.withArgument('-DsocksProxyHost=localhost')
        executer.withArgument("-DsocksProxyPort=${port}")

            if (tagSuffix.contains('WithDeprecations')) {
                executer.noDeprecationChecks()
            }
            fileToTest.text = sample
            executer
                .withTasks('help')
                .withArguments("--stacktrace", "--init-script", settingsEvaluatedHook.absolutePath)
            beforeSample(file, tagSuffix)
            executer.run()
            fileToTest.delete()
        }
    }

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:

    @Rule
    public final GcsServer server = new GcsServer(temporaryFolder)

    def setup() {
        executer.withArgument('-i')
        executer.withArgument("-D${GCS_ENDPOINT_PROPERTY}=${server.uri}")
        executer.withArgument("-D${GCS_SERVICE_PATH_PROPERTY}=/")
        executer.withArgument("-D${GCS_DISABLE_AUTH_PROPERTY}=true")
    }

        """
        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        def models = runPhasedBuildAction(new FetchPartialCustomModelForEachProject(), new FetchCustomModelForEachProject())

        then:
        def messages = models.left

                }
            }
        """

        when:
        executer.withStackTraceChecksDisabled() // daemon log may contain stack traces
        executer.noDaemonCrashChecks()
        def block = server.expectAndBlock("block")
        def build = executer.withTasks("block").start()
        block.waitForAllPendingCalls()
        block.releaseAll()