//
// 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.
//

	if err != nil {
		return false, err
	}

	sizeInBytes := quantity.Value()
	for _, capacity := range capacities {
		if capacity.StorageClassName == storageClass.Name &&
			capacitySufficient(capacity, sizeInBytes) &&
			b.nodeHasAccess(logger, node, capacity) {
			// Enough capacity found.
			return true, nil
		}
	}

	metrics = NewMetricsStatFS(tmpDir)
	actual, err = metrics.GetMetrics()
	if err != nil {
		t.Errorf("Unexpected error when calling GetMetrics %v", err)
	}

	if a := actual.Capacity.Value(); a <= 0 {
		t.Errorf("Expected Capacity %d to be greater than 0.", a)
	}
	if a := actual.Available.Value(); a <= 0 {
		t.Errorf("Expected Available %d to be greater than 0.", a)
	}

		n -= next
		off += int64(next)
	}
	return buf, nil
}

// SliceCapWithSize returns the capacity to use when allocating a slice.
// After the slice is allocated with the capacity, it should be
// built using append. This will avoid allocating too much memory
// if the capacity is large and incorrect.
//
// A negative result means that the value is always too big.
func SliceCapWithSize(size, c uint64) int {

public class DefaultSlidingWindow<T> implements SlidingWindow<T> {
    final LinkedBlockingDeque<T> deque;
    final ReentrantLock lock = new ReentrantLock();

    public DefaultSlidingWindow(int capacity) {
        this.deque = new LinkedBlockingDeque<T>(capacity);
    }

    @Override
    public void slideAndInsert(T element) {
        lock.lock();
        try {
            while (!deque.offerLast(element)) {

            val opacity = Attribute.of("opacity", String::class.java)

            configurations {
                consumable("blueRoundTransparentElements") {
                    attributes.attribute(color, "blue")
                    attributes.attribute(shape, "round")
                    attributes.attribute(opacity, "transparent")
                }

//
// 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.
//

      absl::MutexLock l(&mu_);
      // Do not update state if the block is already to be evicted.
      if (block->timestamp != 0) {
        // Use capacity() instead of size() to account for all  memory
        // used by the cache.
        cache_size_ += block->data.capacity();
        // Put to beginning of LRA list.
        lra_list_.erase(block->lra_iterator);
        lra_list_.push_front(key);

//
// 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.
//

//
// 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.
//