* `datetime.timedelta`:
    * Un `datetime.timedelta` de Python.
    * En requests y responses se representará como un `float` de segundos totales.
    * Pydantic también permite representarlo como una "codificación de diferencia horaria ISO 8601", [consulta la documentación para más información](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).

		partIndex    int
		expectedSize int64
	}{
		// Total size is zero
		{0, 10, 1, 0},
		// part size 2MiB, total size 4MiB
		{4 * humanize.MiByte, 2 * humanize.MiByte, 1, 2 * humanize.MiByte},
		{4 * humanize.MiByte, 2 * humanize.MiByte, 2, 2 * humanize.MiByte},
		{4 * humanize.MiByte, 2 * humanize.MiByte, 3, 0},
		// part size 2MiB, total size 5MiB
		{5 * humanize.MiByte, 2 * humanize.MiByte, 1, 2 * humanize.MiByte},

		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",
		cpuIdle:           "CPU idle time",

            System.out.printf("%nPaths ending with '%s':%n", group.name);
            System.out.printf("Total potential savings: %dKB%n", group.totalSavings / 1024);
            System.out.printf("Total memory: %dKB%n", group.totalMemory / 1024);
            System.out.printf("Total unique values: %d%n", group.totalUnique);
            System.out.printf("Total occurrences: %d%n", group.totalOccurrences);

	replicationAverageDataTransferRateMD = NewGaugeMD(replicationAverageDataTransferRate,
		"Average replication data transfer rate in bytes/sec")
	replicationCurrentActiveWorkersMD = NewGaugeMD(replicationCurrentActiveWorkers,
		"Total number of active replication workers")
	replicationCurrentDataTransferRateMD = NewGaugeMD(replicationCurrentDataTransferRate,
		"Current replication data transfer rate in bytes/sec")

        context.info("=== Overall Results ===");
        context.indent();

        context.info("Total POMs processed: " + overallResult.processedPoms().size());

        if (!overallResult.modifiedPoms().isEmpty()) {
            context.success(
                    "Total POMs modified: " + overallResult.modifiedPoms().size());
        } else {
            context.info("No POMs required modifications");

    }

    @Test
    public void testReadString() throws IOException, PACDecodingException {
        // total=4, unused=1, used=2, string="AB"
        byte[] data = new byte[] { 0x04, 0x00, 0x00, 0x00, // total
                0x01, 0x00, 0x00, 0x00, // unused
                0x02, 0x00, 0x00, 0x00, // used
                0x00, 0x00, // unused char

      Integer result = size;
      if (result == null) {
        long total = 0;
        for (Range<C> range : ranges) {
          total += ContiguousSet.create(range, domain).size();
          if (total >= Integer.MAX_VALUE) {
            break;
          }
        }
        result = size = Ints.saturatedCast(total);
      }
      return result;
    }

    @Override

        long total = totalRequests.get();
        if (total == 0) {
            return 100.0;
        }
        return (totalSuccesses.get() * 100.0) / total;
    }

    /**
     * Calculate availability
     *
     * @return availability as percentage (0-100)
     */
    private double calculateAvailability() {
        long total = totalRequests.get();
        if (total == 0) {

					atomic.AddInt64(&lat, latency)
				})
				spent := time.Since(t)
				if spent > 0 && n > 0 {
					// Since we are benchmarking n parallel servers we need to multiply by n.
					// This will give an estimate of the total ops/s.
					latency := float64(atomic.LoadInt64(&lat)) / float64(time.Millisecond)
					b.ReportMetric(float64(n)*float64(ops)/spent.Seconds(), "vops/s")
					b.ReportMetric(latency/float64(ops), "ms/op")
				}
			})