if now.After(ent.ExpiresAt) {
			continue
		}
		keys = append(keys, ent.Key)
	}
	return keys
}

// Values returns a slice of the values in the cache, from oldest to newest.
// Expired entries are filtered out.
func (c *LRU[K, V]) Values() []V {
	c.mu.Lock()
	defer c.mu.Unlock()
	values := make([]V, 0, len(c.items))
	now := time.Now()
	for ent := c.evictList.Back(); ent != nil; ent = ent.PrevEntry() {

      @Override
      double mean(double[] values) {
        double sum = 0.0;
        for (double value : values) {
          sum += value;
        }
        return sum / values.length;
      }
    },
    KAHAN {
      @Override
      double mean(double[] values) {
        double sum = 0.0;
        double c = 0.0;
        for (double value : values) {
          double y = value - c;
          double t = sum + y;

        assertEquals("5", KerberosConstants.KERBEROS_VERSION, "KERBEROS_VERSION should have the correct value.");
        assertEquals(23, KerberosConstants.RC4_ENC_TYPE, "RC4_ENC_TYPE should have the correct value.");
        assertEquals("HmacMD5", KerberosConstants.HMAC_ALGORITHM, "HMAC_ALGORITHM should have the correct value.");
    }

                field.setAccessible(true);
                String value = (String) field.get(null);
                assertFalse("Duplicate value found: " + value + " for field: " + field.getName(), values.contains(value));
                values.add(value);
            }
        }
    }

    /**
     * Test specific label constants exist and have correct values
     */
    public void test_specificLabelConstants() {

    }
  }

  private final transient ImmutableList<Range<K>> ranges;
  private final transient ImmutableList<V> values;

  ImmutableRangeMap(ImmutableList<Range<K>> ranges, ImmutableList<V> values) {
    this.ranges = ranges;
    this.values = values;
  }

  @Override
  public @Nullable V get(K key) {
    int index =
        SortedLists.binarySearch(
            ranges,

            "steps": [
              {
                "color": "green",
                "value": null
              },
              {
                "color": "dark-yellow",
                "value": 75000000
              },
              {
                "color": "dark-red",
                "value": 100000000
              }
            ]
          },
          "unit": "short"

                        }
                    } else if (value != null && value.getClass().isArray()) {
                        // Handle array values
                        StringBuilder arrayStr = new StringBuilder();
                        if (value instanceof String[]) {
                            String[] arr = (String[]) value;
                            for (int i = 0; i < arr.length; i++) {

    }

    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> putAll(K key, Iterable<? extends V> values) {
      super.putAll(key, values);
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> putAll(K key, V... values) {
      super.putAll(key, values);
      return this;
    }

    @CanIgnoreReturnValue
    @Override

				for _, v := range condt { // Pre-check all values for type.
					if !isString(v) {
						// All values must be of type string.
						return parsedPolicy, fmt.Errorf("Unknown type %s of conditional field value %s found in POST policy form", reflect.TypeOf(condt).String(), condt)
					}
				}
				operator, matchType, value := toLowerString(condt[0]), toLowerString(condt[1]), toString(condt[2])

        assertEquals(400L, mockAllocInfo.getFree(), "free space should match stubbed value");
        verify(mockAllocInfo, times(1)).getCapacity();
        verify(mockAllocInfo, times(1)).getFree();
    }

    /**
     * Parameterised test of capacity values, including edge cases such as
     * zero and negative capacities.
     */
    @ParameterizedTest