@ParameterizedTest
    @ValueSource(longs = { 0L, -1L, Long.MAX_VALUE })
    @DisplayName("capacity may be any long value")
    void testCapacityEdgeValues(long capacity) {
        when(mockAllocInfo.getCapacity()).thenReturn(capacity);
        assertEquals(capacity, mockAllocInfo.getCapacity());
    }

    /**
     * Null pointer scenario – calls on a null reference should raise

			capacity += disk.TotalSpace
		}
	}
	return capacity
}

// GetTotalCapacityFree gets the total capacity free in the cluster.
func GetTotalCapacityFree(diskInfo []madmin.Disk) (capacity uint64) {
	for _, d := range diskInfo {
		capacity += d.AvailableSpace
	}
	return capacity
}

// GetTotalUsableCapacityFree gets the total usable capacity free in the cluster.

     */
    public CaseInsensitiveMap() {
    }

    /**
     * Creates a {@link CaseInsensitiveMap}.
     *
     * @param capacity the initial capacity
     */
    public CaseInsensitiveMap(final int capacity) {
        super(capacity);
    }

    /**
     * Returns whether the key is contained.
     *
     * @param key the key
     * @return whether the key is contained
     */

/**
 * Interface for file system allocation information providing capacity and free space details.
 * Used in SMB protocol operations to query disk space information from remote SMB shares.
 *
 * @author mbechler
 */
public interface AllocInfo extends FileSystemInformation {

    /**
     * Gets the total capacity of the allocation.
     *
     * @return total capacity
     */
    long getCapacity();

    /**

	for range size {
		bp.Get() // discard
	}

	// Try putting some invalid buffers into pool
	bp.Put(make([]byte, bp.w, bp.wcap-1)) // wrong capacity is rejected (less)
	bp.Put(make([]byte, bp.w, bp.wcap+1)) // wrong capacity is rejected (more)
	bp.Put(make([]byte, width))           // wrong capacity is rejected (very less)
	if len(bp.c) > 0 {
		t.Fatal("bytepool should have rejected invalid packets")
	}

var (
	healthCapacityRawTotalBytesMD = NewGaugeMD(healthCapacityRawTotalBytes,
		"Total cluster raw storage capacity in bytes")
	healthCapacityRawFreeBytesMD = NewGaugeMD(healthCapacityRawFreeBytes,
		"Total cluster raw storage free in bytes")
	healthCapacityUsableTotalBytesMD = NewGaugeMD(healthCapacityUsableTotalBytes,
		"Total cluster usable storage capacity in bytes")
	healthCapacityUsableFreeBytesMD = NewGaugeMD(healthCapacityUsableFreeBytes,

  @Param({"16", "32", "64", "128", "256", "512", "1024", "2048", "4096", "8192"})
  int capacity;

  private Segment<Object, Object> segment;

  @BeforeExperiment
  void setUp() {
    LocalCache<Object, Object> cache =
        new LocalCache<>(
            CacheBuilder.newBuilder().concurrencyLevel(1).initialCapacity(capacity), null);
    checkState(cache.segments.length == 1);
    segment = cache.segments[0];

When using Veeam Backup and Replication, you can use S3 compatible object storage such as MinIO as a capacity tier for backups.  This disaggregates storage for the Veeam infrastructure and allows you to retain control of your data. With the ease of use of setup and administration of MinIO, it allows a Veeam backup admin to easily deploy their own object store for capacity tiering.

## Prerequisites

			Optional:    true,
			Type:        "string",
		},
		config.HelpKV{
			Key:         Optimize,
			Description: `optimize parity calculation for standard storage class, set 'capacity' for capacity optimized (no additional parity)` + defaultHelpPostfix(Optimize),
			Optional:    true,
			Type:        "string",
		},
		config.HelpKV{
			Key:         config.Comment,
			Description: config.DefaultComment,

          return 0; // Not called.
        }
      }
    }
  }

  /** Returns a new CharBuffer identical to buf, except twice the capacity. */
  private static CharBuffer grow(CharBuffer buf) {
    char[] copy = Arrays.copyOf(buf.array(), buf.capacity() * 2);
    CharBuffer bigger = CharBuffer.wrap(copy);
    Java8Compatibility.position(bigger, buf.position());
    Java8Compatibility.limit(bigger, buf.limit());