)

var allDriveLabels = []string{driveL, poolIndexL, setIndexL, driveIndexL}

const (
	driveUsedBytes               = "used_bytes"
	driveFreeBytes               = "free_bytes"
	driveTotalBytes              = "total_bytes"
	driveUsedInodes              = "used_inodes"
	driveFreeInodes              = "free_inodes"
	driveTotalInodes             = "total_inodes"
	driveTimeoutErrorsTotal      = "timeout_errors_total"

	rcharBytes      MetricName = "rchar_bytes"
	receivedBytes   MetricName = "received_bytes"
	latencyMilliSec MetricName = "latency_ms"
	sentBytes       MetricName = "sent_bytes"
	totalBytes      MetricName = "total_bytes"
	usedBytes       MetricName = "used_bytes"
	writeBytes      MetricName = "write_bytes"
	wcharBytes      MetricName = "wchar_bytes"

	latencyMicroSec MetricName = "latency_us"

        void testDecodeVariousTotalBytesWritten(int totalBytes) throws SMBProtocolDecodingException {
            byte[] buffer = createValidCopyChunkResponse(0, 0, totalBytes);

            int bytesDecoded = response.decode(buffer, 0, buffer.length);

            assertEquals(12, bytesDecoded);
            assertEquals(totalBytes, response.getTotalBytesWritten());
        }

        @ParameterizedTest

        final long freeBytes = runtime.freeMemory();
        final long maxBytes = runtime.maxMemory();
        final long totalBytes = runtime.totalMemory();
        final long usedBytes = totalBytes - freeBytes;
        return "Mem:{used " + byteCountToDisplaySize(usedBytes) + ", heap " + byteCountToDisplaySize(totalBytes) + ", max "
                + byteCountToDisplaySize(maxBytes) + "}";
    }

    /**

    var publicSuffixListBytes: ByteString?
    var publicSuffixExceptionListBytes: ByteString?

    try {
      listSource().buffer().use { bufferedSource ->
        val totalBytes = bufferedSource.readInt()
        publicSuffixListBytes = bufferedSource.readByteString(totalBytes.toLong())

        val totalExceptionBytes = bufferedSource.readInt()
        publicSuffixExceptionListBytes = bufferedSource.readByteString(totalExceptionBytes.toLong())

        long totalBytes = bytesEncrypted.get() + additionalBytes;

        boolean needsRotation = (keyRotationBytesLimit > 0 && totalBytes >= keyRotationBytesLimit)
                || (keyRotationTimeLimit > 0 && timeSinceStart >= keyRotationTimeLimit);

        if (needsRotation) {
            log.info("Key rotation needed - bytes: {} / {} MB, time: {} / {} hours", totalBytes / (1024 * 1024),

		writesAwait:       "Average time for write requests to be served on a drive",
		percUtil:          "Percentage of time the disk was busy",
		usedBytes:         "Used bytes on a drive",
		totalBytes:        "Total bytes on a drive",
		usedInodes:        "Total inodes used on a drive",
		totalInodes:       "Total inodes on a drive",
		cpuUser:           "CPU user time",
		cpuSystem:         "CPU system time",

            byte[] buffer = new byte[200];

            // When
            int totalBytes = copy.encode(buffer, 0);

            // Then
            assertEquals(HEADER_SIZE + 20 + 24 + 22, totalBytes);
            verify(mockChunk1).encode(buffer, HEADER_SIZE);
            verify(mockChunk2).encode(buffer, HEADER_SIZE + 20);