@Requires(IntegTestPreconditions.NotParallelExecutor)
    def "reasonable failure message when --max-workers=#value"() {
        given:
        executer.requireDaemon().requireIsolatedDaemons()  // otherwise exception gets thrown in testing infrastructure

        when:
        executer.withArgument("--max-workers=$value")

        then:
        fails "help"

        and:

    void configureServerCert(GradleExecuter executer) {
        def args = getTrustStoreArguments()
        if (GradleContextualExecuter.embedded) {
            args.each {
                executer.withArgument(it)
            }
        } else {
            executer.withBuildJvmOpts(args)
        }
    }

    void configureIncorrectServerCert(GradleExecuter executer) {
        // intentionally use wrong trust store

                }
            }
        """

        when:
        executer.withArgument("-Dfile.encoding=UTF-8")
        run("verify")

        then:
        daemons.daemons.size() == 1

        when:
        executer.withArgument("-Dfile.encoding=ISO-8859-1")
        run("verify")

        then:
        output.contains("verified = ISO-8859-1")

        and:
        executer.beforeExecute {
            if (!GradleContextualExecuter.embedded) {
                executer.withArgument("-D$REUSE_USER_HOME_SERVICES=true")
            }
        }
        executer.withTasks('help').start().waitForFinish()

        then:
        resource.assertDoesNotExist()

                    }
                }
            }
        """

        when:
        // This prevents the executer fixture from adding "default" values to the build jvm options
        executer.useOnlyRequestedJvmOpts()
        executer.withEnvironmentVars(JAVA_TOOL_OPTIONS: javaToolOptions)
        run "verify"

        then:
        String gradleVersion = (output =~ /GRADLE_VERSION: (.*)/)[0][1]

package org.gradle.performance.fixture

import groovy.transform.CompileStatic
import org.gradle.integtests.fixtures.executer.GradleDistribution
import org.gradle.integtests.fixtures.executer.GradleExecuter
import org.gradle.integtests.fixtures.executer.IntegrationTestBuildContext
import org.gradle.integtests.fixtures.executer.NoDaemonGradleExecuter
import org.gradle.test.fixtures.file.TestDirectoryProvider
import org.gradle.test.fixtures.file.TestFile

        and:
        daemons.daemon.stops()
    }

    def "forks build when default client VM memory is used and user didn't specify a different limit"() {
        executer.withCommandLineGradleOpts('-Xmx64m')
        executer.useOnlyRequestedJvmOpts()
        executer.requireDaemon()

        when:
        succeeds()

        then:
        wasForked()

        and:
        daemons.daemon.stops()
    }

            it.name == "root"
            it.tasks.size() > 0
            it.children.size() == 1
            it.children[0].children.size() == 1
        }

        when: "fetching with Isolated Projects"
        executer.withArguments(ENABLE_CLI)
        def projectModel = fetchModel(GradleProject)

        then:
        fixture.assertStateStored {
            modelsCreated(":", GradleProject, IsolatedGradleProjectInternal)

    @UsesSample("dependencyManagement/declaringDependencies-concreteVersion")
    def "can use declare and resolve dependency with concrete version with #dsl dsl"() {
        TestFile dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)

        when:
        succeeds(COPY_LIBS_TASK_NAME)

        then:
        dslDir.file('build/libs/spring-web-5.0.2.RELEASE.jar').isFile()

        where:

    def setup() {
        executer.withRepositoryMirrors()
    }

    @UsesSample("dependencyManagement/managingTransitiveDependencies-versionsWithConstraints")
    def "respects dependency constraints for direct and transitive dependencies with #dsl dsl"() {
        TestFile dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)

        when:
        succeeds(COPY_LIBS_TASK_NAME)