queue = (BlockingQueue<String>) constructor.newInstance(capacity);

    strings = new String[capacity];
    for (int i = 0; i < capacity; i++) {
      strings[i] = String.valueOf(Math.random());
    }
  }

  @Benchmark
  void addsAndRemoves(int reps) {
    int capacity = this.capacity;
    BlockingQueue<String> queue = this.queue;
    String[] strings = this.strings;

  }

  /**
   * Creates an {@code MonitorBasedArrayBlockingQueue} with the given (fixed) capacity and default
   * access policy.
   *
   * @param capacity the capacity of this queue
   * @throws IllegalArgumentException if {@code capacity} is less than 1
   */
  public MonitorBasedArrayBlockingQueue(int capacity) {
    this(capacity, false);
  }

  /**

}

const (
	healthCapacityRawTotalBytes    = "capacity_raw_total_bytes"
	healthCapacityRawFreeBytes     = "capacity_raw_free_bytes"
	healthCapacityUsableTotalBytes = "capacity_usable_total_bytes"
	healthCapacityUsableFreeBytes  = "capacity_usable_free_bytes"
)

var (
	healthCapacityRawTotalBytesMD = NewGaugeMD(healthCapacityRawTotalBytes,
		"Total cluster raw storage capacity in bytes")

)

// GetTotalCapacity gets the total capacity in the cluster.
func GetTotalCapacity(diskInfo []madmin.Disk) (capacity uint64) {
	for _, disk := range diskInfo {
		capacity += disk.TotalSpace
	}
	return
}

// GetTotalUsableCapacity gets the total usable capacity in the cluster.
func GetTotalUsableCapacity(diskInfo []madmin.Disk, s StorageInfo) (capacity uint64) {
	for _, disk := range diskInfo {
		// Ignore invalid.

//
// The following three cases all imply that no capacity is available for
// a certain combination:
// - no object exists with suitable topology and storage class name
// - such an object exists, but the capacity is unset
// - such an object exists, but the capacity is zero
//
// The producer of these objects can decide which approach is more suitable.
//

   * @since 12.0
   */
  @J2ktIncompatible
  @GwtIncompatible // LinkedBlockingDeque
  public static <E> LinkedBlockingDeque<E> newLinkedBlockingDeque(int capacity) {
    return new LinkedBlockingDeque<>(capacity);
  }

  /**
   * Creates a {@code LinkedBlockingDeque} with a capacity of {@link Integer#MAX_VALUE}, containing

    queue = (BlockingQueue<String>) constructor.newInstance(capacity);

    strings = new String[capacity];
    for (int i = 0; i < capacity; i++) {
      strings[i] = String.valueOf(Math.random());
    }
  }

  @Benchmark
  void addsAndRemoves(int reps) {
    int capacity = this.capacity;
    BlockingQueue<String> queue = this.queue;
    String[] strings = this.strings;

  @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];

          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());

//
// The following three cases all imply that no capacity is available for
// a certain combination:
// - no object exists with suitable topology and storage class name
// - such an object exists, but the capacity is unset
// - such an object exists, but the capacity is zero
//
// The producer of these objects can decide which approach is more suitable.
//