def inputStream = Mock(InputStream)

        when:
        decodeFrom(inputStream) { Decoder decoder ->
            decoder.inputStream.close()
        }

        then:
        0 * inputStream.close()
    }

    def "ignores close or flush on OutputStream"() {
        def outputStream = Mock(OutputStream)

        when:
        encodeTo(outputStream) { Encoder encoder ->

        buildFile.text = """
        task aTask
        """
        when:
        configurationCacheFails "help", "--task", "bTask"
        then:
        failure.assertHasCause("Task 'bTask' not found in root project")
        configurationCache.assertStateStored()

        when:
        configurationCacheFails "help", "--task", "cTask"
        then:

    def "does nothing to empty classpath when transform is none"() {
        given:
        def classpath = DefaultClassPath.of()

        when:
        def cachedClasspath = transformer.transform(classpath, None)

        then:
        cachedClasspath.empty

        and:
        0 * fileAccessTimeJournal._
    }

    def "does nothing to empty classpath when transform is build logic"() {
        given:

        builder.withContext("Context.")

        when:
        builder.willBeRemovedInGradle9().undocumented().nagUser()

        then:
        expectMessage "Summary is deprecated. This is scheduled to be removed in Gradle ${NEXT_GRADLE_VERSION}. Context. Advice."
    }

    def "logs generic deprecation message for specific thing"() {
        when:

    }

    def "creates with gradle.properties when using #scriptDsl build scripts with --incubating"() {
        when:
        run ('init', '--type', 'java-library', '--incubating', '--dsl', scriptDsl.id, '--java-version', JavaVersion.current().majorVersion)

        then:
        gradlePropertiesGenerated()

        when:
        succeeds('test')

        then:

            }
        """

        when:
        configurationCacheRun "run"

        then:
        output.count("NOT CI") == 1
        configurationCache.assertStateStored()

        when:
        configurationCacheRun "run"

        then:
        output.count("NOT CI") == 1
        configurationCache.assertStateLoaded()

        when:
        configurationCacheRun "run", "-Dci=true"

        when:
        task = project.tasks[BasePlugin.ASSEMBLE_TASK_NAME]

        then:
        task dependsOn(JvmConstants.JAR_TASK_NAME)

        when:
        task = project.tasks[JavaBasePlugin.CHECK_TASK_NAME]

        then:
        task instanceof DefaultTask
        task dependsOn(JvmConstants.TEST_TASK_NAME)

        when:

            }
        """

        when:
        withBuildCache().run "customTask"
        then:
        executedAndNotSkipped ":customTask"

        when:
        cleanBuildDir()
        withBuildCache().run "customTask"
        then:
        skipped ":customTask"


        when:
        buildFile << """
            customTask.outputs.cacheIf { false }

        when:
        fails 'clean', 'build'

        then:
        // when tests fail, jar may not exist
        failure.assertHasDescription("Execution failed for task ':test'.")
        failure.assertHasCause("There were failing tests.")
    }

    def "singleModule - with continue, when tests fail, jar should exist"() {
        def dsl = dslFixtureFor(scriptDsl)

        }
        starter.startDaemon(options) >> client

        when:
        manager.reserveNewClient(options)

        then:
        manager.reserveIdleClient(options) == null

        when:
        manager.release(client)

        then:
        manager.reserveIdleClient(options) == client
    }

    def "clients are discarded when log level changes"() {
        OutputEventListener listener