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:

        """
        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

 * limitations under the License.
 */

package org.gradle.internal.enterprise.core

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.internal.enterprise.DevelocityPluginCheckInFixture
import org.gradle.internal.enterprise.GradleEnterprisePluginCheckInFixture

    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'

		if err == nil || !errors.Is(err, driver.ErrBadConn) {
			return err
		}
	}

	return fn(alwaysNewConn)
}

// PrepareContext creates a prepared statement for later queries or executions.
// Multiple queries or executions may be run concurrently from the
// returned statement.
// The caller must call the statement's [*Stmt.Close] method
// when the statement is no longer needed.
//

        private final ManagedExecutor executor;
        private final BlockingQueue<Object> events = new LinkedBlockingQueue<>();
        private final AtomicReference<Exception> failure = new AtomicReference<>();

        public AbstractListener(ExecutorFactory executorFactory) {
            this.executor = executorFactory.create("build event listener");
            Future<?> ignored = executor.submit(this::run);
        }

import org.gradle.integtests.fixtures.build.BuildTestFile
import org.gradle.integtests.fixtures.build.BuildTestFixture
import org.gradle.integtests.fixtures.executer.OutputScrapingExecutionFailure
import org.gradle.integtests.fixtures.executer.OutputScrapingExecutionResult
import org.gradle.internal.Pair
import org.gradle.test.fixtures.file.TestFile
import org.gradle.tooling.BuildAction

            plugins.apply(my.MyPlugin)
            println("configuring root")
        """
    }

    def "parameterized models are reused in the same build action"() {
        when:
        executer.withArguments(ENABLE_CLI)
        def models = runBuildAction(new FetchParameterizedCustomModelForEachProject(["fetch1", "fetch2", "fetch1", "fetch2"]))

        then:
        fixture.assertStateStored {

        cleanupMethod.maybeExpectDeprecationWarning(executer)
        run()

        then:
        existsBuildCacheEntry("0" * hashStringLength)
        existsBuildCacheEntry("1" * hashStringLength)
        assertCacheWasNotCleanedUpSince(lastCleanupCheck)

        when:
        lastCleanupCheck = markCacheLastCleaned(twoDaysAgo())
        executer.noDeprecationChecks()
        run()

        then: