}
            }
        """

        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()

 */

package org.gradle.kotlin.dsl.fixtures

import org.gradle.integtests.fixtures.AbstractIntegrationTest
import org.gradle.integtests.fixtures.executer.ExecutionFailure
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.IntegrationTestBuildContext
import org.gradle.kotlin.dsl.resolver.GradleInstallation
import org.gradle.kotlin.dsl.support.zipTo
import org.junit.Before

    def markerFile
    def welcomeMessage

    def setup() {
        executer.requireDaemon().requireIsolatedDaemons()
        executer.withGradleUserHomeDir(customGradleUserHomeDir)
        executer.withWelcomeMessageEnabled()
        markerFile = new File(executer.gradleUserHomeDir, "notifications/$distribution.version.version/release-features.rendered")

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'

    protected void interactiveExecution() {
        executer.withStdinPipe().withForceInteractive(true)
    }

    protected void withRichConsole(boolean enabled) {
        if (enabled) {
            executer.withConsole(ConsoleOutput.Rich)
        }
    }

    protected void withParallel() {
        executer.withArgument('--parallel')
    }

import org.gradle.api.logging.configuration.ConsoleOutput
import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.RichConsoleStyling
import org.gradle.integtests.fixtures.executer.GradleHandle
import org.gradle.test.fixtures.ConcurrentTestUtil
import org.gradle.test.fixtures.server.http.BlockingHttpServer
import org.junit.Rule

                    name = 'cool-contrib'
                }
            }
        """

        executer.withTasks("idea").run()
        assert getFile(project: 'shared/api', "shared-api.iml").exists()
        assert getFile(project: 'contrib', "cool-contrib.iml").exists()

        //when
        executer.withTasks("cleanIdea").run()

        //then

        keyStore.configureServerCert(executer)
        succeeds 'publish'

        then:
        verifyPublications()
    }

    def "publish with server and client certificate"() {
        given:
        keyStore.enableSslWithServerAndClientCerts(server)
        initBuild()

        when:
        expectPublication()
        keyStore.configureServerAndClientCerts(executer)
        succeeds 'publish'

                        assert !logger.${nextLevel}Enabled
                    }
                }
            }
        """
        expect:
        executer.withArguments(flags)
        succeeds("assertLogging")
        outputContains(message)

        where:
        logLevel    | nextLevel   | flags
        'quiet'     | 'warn'      | ['-Dorg.gradle.logging.level=quiet']

        expect:
        //TODO: fix dependency resolution results usage in this test and remove this flag
        executer.withBuildJvmOpts("-Dorg.gradle.configuration-cache.internal.task-execution-access-pre-stable=true")

        if (expression == "getFirstLevelModuleDependencies { true }") {