keyStore.enableSslWithServerCert(server)

        setupBuildFile(repoType)

        when:
        executer.withStackTraceChecksDisabled() // Jetty logs stuff to console
        keyStore.configureIncorrectServerCert(executer)
        fails "libs"

        then:
        failure.assertHasCause("Could not GET '${server.uri}/repo1/my-group/my-module/1.0/")

        given:
        prepareWrapper()
        def gradleUserHome = testDirectory.file('some-custom-user-home')

        when:
        def executer = wrapperExecuter.withGradleUserHomeDir(null)
        executer.withArguments("-Dgradle.user.home=$gradleUserHome.absolutePath")
        executer.run()

        then:
        installationIn gradleUserHome
    }

    @Issue('https://issues.gradle.org/browse/GRADLE-2802')

    }

    protected ExecutionResult succeeds(BuildTestFile build, String... tasks) {
        executer.inDirectory(build)
        return succeeds(tasks)
    }

    protected void fails(BuildTestFile build, String task, Iterable<String> arguments = []) {
        prepare(arguments)
        executer.inDirectory(build)
        fails(task)
        assertSingleBuildOperationsTreeOfType(RunBuildBuildOperationType)

    @UsesSample("files/copy")
    def "can copy a single file using task properties for the paths with #dsl dsl"() {
        given:
        def dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)

        when:
        succeeds('copyReport2')

        then:
        dslDir.file('build/toArchive/my-report.pdf').isFile()

        where:
        dsl << ['groovy', 'kotlin']
    }

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

        when:
        executer.withArguments(ENABLE_CLI)
        def model = runBuildAction(new FetchCustomModelForEachProjectInTree())

        then:
        model.size() == 2
        model[0].message == "It works from project :"

    @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:

                }
            }
        """

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

    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

        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]