inputStream.read(new byte[1024])
            "result"
        }
        1 * context.progress(1562, 4096, 'bytes', '1.5 KiB/4 KiB downloaded')
        1 * context.progress(3162, 4096, 'bytes', '3 KiB/4 KiB downloaded')
        1 * context.progress(4096, 4096, 'bytes', '4 KiB/4 KiB downloaded')
        0 * context.progress(_)
    }

    def "fires complete event when action complete with partially read stream"() {

        when:
        operation.logProcessedBytes(512 * 1)
        operation.logProcessedBytes(512 * 2)
        then:
        1 * context.progress(1024, 10240, "bytes", "1 KiB/10 KiB downloaded")
        1 * context.progress(2048, 10240, "bytes", "2 KiB/10 KiB downloaded")
        0 * context.progress(_)
    }

    def "last chunk of bytes <1KiB is not logged"() {
        given:

        512               | '512 B'
        1010              | '1010 B'
        1025              | '1 KiB'
        1126              | '1 KiB'
        1127              | '1.1 KiB'

        1024L**1          | '1 KiB'
        1024L**1 + 1      | '1 KiB'
        1024L**1 * 987    | '987 KiB'
        1024L**2 - 1      | '1023.9 KiB'

        1024L**2          | '1 MiB'
        1024L**2 + 1      | '1 MiB'

        then:
        ConcurrentTestUtil.poll {
            outputContainsProgress(build,
                "> :resolve > Resolve dependencies of :compile",
                "> one-1.2.pom > 1 KiB/2 KiB downloaded", "> two-1.2.pom > 1 KiB/2 KiB downloaded"
            )
        }

        when:
        getM1Pom.release()
        getM2Pom.release()
        jars.waitForAllPendingCalls()

        then:

        runningStats.getAllBuildsTime() >> 1000

        then:
        healthStats.healthInfo == "[uptime: 3 mins, performance: 98%, GC rate: 1.00/s, heap usage: 10% of 1 KiB, non-heap usage: 50% of 2 KiB]"
    }

    def "handles no garbage collection data"() {
        when:
        gcInfo.getCollectionTime() >> 25
        runningStats.getPrettyUpTime() >> "3 mins"

            return 0;
        }
        float out = fraction * 100.0f / total;
        return (int) out;
    }

    /**
     * Formats bytes, e.g. 1010 -> 1010 B, -1025 -> -1 KiB, 1127 -> 1.1 KiB
     */
    public static String formatBytes(@Nullable Long bytes) {
        if (bytes == null) {
            return "unknown size";
        } else if (bytes < 0) {
            return "-" + formatBytes(-bytes);

            assert stream.read(new byte[1024]) == 48
        }
        1 * inputStream.read(_, 0, 1024) >> 1024
        1 * inputStream.read(_, 0, 1024) >> 48
        1 * context.progress(1024, 1072, "bytes", "1 KiB/1 KiB uploaded")
        0 * context.progress(_)
    }

    def "uploads empty file"() {
        setup:
        expectPutBuildOperation(0)

        when:
        uploader.upload(resource, location)

        putModule.waitForAllPendingCalls()

        then:
        ConcurrentTestUtil.poll {
            RichConsoleStyling.assertHasWorkInProgress(build, "> :publishMavenPublicationToMavenRepository > test-1.2.module > 1.8 KiB/1.8 KiB uploaded")
        }

        when:
        putModule.releaseAll()
        getMetaData.waitForAllPendingCalls()

        then:
        ConcurrentTestUtil.poll {

	to change, but currently it is:
		scav # KiB work (bg), # KiB work (eager), # KiB total, #% util
	where the fields are as follows:
		# KiB work (bg)    the amount of memory returned to the OS in the background since
		                   the last line
		# KiB work (eager) the amount of memory returned to the OS eagerly since the last line
		# KiB now          the amount of address space currently returned to the OS

	m.readsKBPerSec = float64(ioStats.ReadSectors) * float64(sectorSize) / kib / durationSecs
	if ioStats.ReadIOs > 0 {
		m.readsAwait = float64(ioStats.ReadTicks) / float64(ioStats.ReadIOs)
	}

	m.writesPerSec = float64(ioStats.WriteIOs) / durationSecs
	m.writesKBPerSec = float64(ioStats.WriteSectors) * float64(sectorSize) / kib / durationSecs
	if ioStats.WriteIOs > 0 {