download.successful

        !download.statusEvents.empty

        download.statusEvents.each { statusEvent ->
            def event = statusEvent.event
            assert event.displayName == "Download $distUri ${event.progress}/${event.total} bytes completed"
            assert event.total == distribution.binDistribution.length()

        given:
        server.expect(server.head("/$TEST_DISTRIBUTION_URL"))
        prepareWrapper(getDefaultBaseUrl())
        server.expect(server.get("/$TEST_DISTRIBUTION_URL").sendFile(distribution.binDistribution))

        when:
        def result = wrapperExecuter.withTasks('hello').run()

        then:
        assertThat(result.output, containsString('hello'))

        when:

        def distDir = userHomeDir.file("wrapper/dists/${FilenameUtils.getBaseName(distribution.binDistribution.absolutePath)}").assertIsDir()
        assert distDir.listFiles().length == 1
        distDir.listFiles()[0].file("gradle-${distribution.version.baseVersion.version}").assertIsDir()
    }

    void prepareWrapper(URI distributionUri = distribution.binDistribution.toURI(), Action<GradleExecuter> action = Actions.doNothing()) {

        server.expect(server.get("/$TEST_DISTRIBUTION_URL")
            .expectUserAgent(matchesNameAndVersion("gradlew", Download.UNKNOWN_VERSION))
            .sendFile(distribution.binDistribution))

        when:
        result = wrapperExecuter.withTasks('hello').run()

        then:

    private final TestFile gradleHomeDir;
    private final TestFile binDistribution;

    DefaultGradleDistribution(GradleVersion gradleVersion, TestFile gradleHomeDir, TestFile binDistribution) {
        this.version = gradleVersion;
        this.gradleHomeDir = gradleHomeDir;
        this.binDistribution = binDistribution;
    }

    @Override
    String toString() {
        return version.toString();
    }

        buildFile << """
        wrapper {
            distributionUrl = '${otherVersion.binDistribution.toURI()}'
        }
        task check {
            doLast {
                assert gradle.gradleVersion == '${otherVersion.version.version}'
            }
        }"""
        otherVersion.binDistribution.makeReadable()
        executer.withTasks('wrapper').run()

        when:

        sha256().hashFile(distribution.binDistribution).toZeroPaddedString(sha256().hexDigits)
    }

    def "wrapper preserves new checksum if it was provided in properties"() {
        given:
        configureServer(false)
        def releasedDistribution = IntegrationTestBuildContext.INSTANCE.distribution("7.5")
        prepareWrapper(releasedDistribution.binDistribution.toURI())

        and:

        server.expect(server.get(GRADLE_BIN_ZIP).sendFile(badArchive))
        server.expect(server.get(GRADLE_BIN_HASH).missing())
        server.expect(server.get(GRADLE_BIN_ZIP).sendFile(distribution.binDistribution))
        server.start()

        prepareWrapperWithGradleBin()

        when:
        def success = wrapperExecuter.run()

        then:
        assertSucces(success)
    }

    @Rule BlockingHttpServer server = new BlockingHttpServer()

    def setup() {
        server.expect(server.head("/gradle-bin.zip"))
        server.expect(server.get("/gradle-bin.zip").sendFile(distribution.binDistribution))
        server.start()
    }

    @Issue("https://issues.gradle.org/browse/GRADLE-2699")
    def "concurrent downloads do not stomp over each other"() {
        given:

        given: "malformed distribution"
        // Repackage distribution with bin/gradle removed so permissions cannot be set
        TestFile tempUnzipDir = temporaryFolder.createDir("temp-unzip")
        distribution.binDistribution.unzipTo(tempUnzipDir)
        assert tempUnzipDir.file("gradle-${distribution.version.baseVersion.version}", "bin", "gradle").delete()
        TestFile tempZipDir = temporaryFolder.createDir("temp-zip-foo")