when:
        result = wrapperExecuter.withTasks("emptyTask").run()

        then:
        outputDoesNotContain("Welcome to Gradle $wrapperExecuter.distribution.version.version!")
    }

    def "wrapper renders welcome message when executed the first time after being executed in quiet mode"() {
        given:
        prepareWrapper()

        when:
        args '-q'

        when:
        wrapperExecuter.withStackTraceChecksDisabled()
        def failure = wrapperExecuter.runWithFailure()

        then:
        failure.error.contains('Server returned HTTP response code: 500')

        when:
        server.expect(server.get("/$TEST_DISTRIBUTION_URL").sendFile(distribution.binDistribution))

        and:
        wrapperExecuter.run()

        then:

        def releasedDistributionChecksum = getDistributionHash(releasedDistribution)
        wrapperExecuter.withTasks("wrapper", "--gradle-distribution-url", releasedDistributionUrl, "--gradle-distribution-sha256-sum", releasedDistributionChecksum).run()

        then:
        file(WRAPPER_PROPERTIES_PATH).getProperties().get(WrapperExecutor.DISTRIBUTION_SHA_256_SUM) == releasedDistributionChecksum
    }

    def "provides reasonable failure message when attempting to run under java #jdk.javaVersion"() {
        given:
        prepareWrapper()
        wrapperExecuter.withJavaHome(jdk.javaHome)

        expect:
        def failure = wrapperExecuter.withTasks("help").runWithFailure()

        server.expect(server.get(GRADLE_BIN_ZIP).sendFile(distribution.binDistribution))
        server.start()

        prepareWrapperWithGradleBin()

        when:
        def success = wrapperExecuter.run()

        then:
        assertSucces(success)
    }

    private prepareWrapperWithGradleBin() {
        prepareWrapper(new URI("$server.uri$GRADLE_BIN_ZIP"))
    }

import static org.gradle.test.matchers.UserAgentMatcher.matchesNameAndVersion
import static org.hamcrest.CoreMatchers.containsString
import static org.hamcrest.MatcherAssert.assertThat

// wrapperExecuter requires a real distribution
@Requires(IntegTestPreconditions.NotEmbeddedExecutor)
@LocalOnly(because = "https://github.com/gradle/gradle-private/issues/3799")

        }
    }
"""
    }

    void "has non-zero exit code on build failure"() {
        given:
        prepareWrapper()

        when:
        def failure = wrapperExecuter.withTasks('unknown').runWithFailure()

        then:
        failure.assertThatDescription(CoreMatchers.startsWith("Task 'unknown' not found in root project"))
    }

    void 'uses gradle user home set by -Dgradle.user.home'() {
        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
    }

        given:
        prepareWrapper()

        expect:
        wrapperExecuter.withTasks('wrapper').run()
    }

    def "prints helpful error message on invalid version argument format: #badVersion"() {
        given:
        prepareWrapper()

        expect:
        def failure = wrapperExecuter.withTasks("wrapper", "--gradle-version", badVersion).runWithFailure()

        and:

    def "concurrent downloads do not stomp over each other"() {
        given:
        prepareWrapper(server.uri("gradle-bin.zip"))

        when:
        def results = [1..4].collect { wrapperExecuter.start() }*.waitForFinish()

        then:
        results.findAll { it.output.contains("Downloading") }.size() == 1
    }