try {
                                values.advance(docId);
                                if (values.docValueCount() != 1) {
                                    throw new IllegalArgumentException("script only works when there is exactly one value");
                                }
                                return values.nextValue();
                            } catch (IOException e) {

            for (CoreExtension extension : selectedExtensions.values()) {
                context.logger.warn(
                        "* " + extension.getId() + " configured in " + formatLocation(extension.getLocation("")));
            }
        }

        context.logger.debug("Selected core extensions (in loading order):");
        for (CoreExtension source : selectedExtensions.values()) {

  /**
   * Verifies that {@code rowKey}, {@code columnKey} and {@code value} are non-null, and returns a
   * new entry with those values.
   */
  static <R, C, V> Cell<R, C, V> cellOf(R rowKey, C columnKey, V value) {
    return immutableCell(
        checkNotNull(rowKey, "rowKey"),
        checkNotNull(columnKey, "columnKey"),
        checkNotNull(value, "value"));
  }

  /**

        nBestExamples = settings.get(NBEST_EXAMPLES);
    }

    private static String parse(String rule, Set<String> dup) {
        String[] values = CSVUtil.parse(rule);
        if (dup.add(values[0]) == false) {
            throw new IllegalArgumentException("Found duplicate term [" + values[0] + "] in user dictionary.");
        }
        return rule;
    }

        item.put("url", artifact.getUrl());
        return item;
    }

    private Artifact getArtifactFromInstallForm(final InstallForm form) {
        final String[] values = form.id.split(":");
        return ComponentUtil.getPluginHelper().getArtifact(values[0], values[1]);
    }

    /**
     * Installs the specified artifact in a background thread.
     * Also removes any previously installed versions of the same plugin.
     *

        // Test negative values - should throw NullPointerException in private method via BigInteger.valueOf
        try {
            MemoryUtil.byteCountToDisplaySize(-1L);
            // If no exception, verify it handles negative as expected
        } catch (Exception e) {
            // Expected for negative values
        }

        // Test boundary values

    }
    // add the intersection of CollectionFeature.values() and mapFeatures
    for (CollectionFeature feature : CollectionFeature.values()) {
      if (mapFeatures.contains(feature)) {
        derivedFeatures.add(feature);
      }
    }
    // add the intersection of CollectionSize.values() and mapFeatures
    for (CollectionSize size : CollectionSize.values()) {
      if (mapFeatures.contains(size)) {

    }

    @ParameterizedTest
    @ValueSource(longs = { 0L, 1024L, 1048576L, 2147483647L })
    void testDifferentFileSizes(long fileSize) {
        // Test various file size values (excluding values that would overflow signed int)
        response = new SmbComQueryInformationResponse(mockConfig, 0L);
        setFieldValue(response, "wordCount", 10);

        byte[] buffer = new byte[256];

        setCreatedTime_PercentileRanks(values, null);
    }

    public void setCreatedTime_PercentileRanks(double[] values, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
        setCreatedTime_PercentileRanks("createdTime", values, opLambda);
    }

    public void setCreatedTime_PercentileRanks(String name, double[] values,

    Set<K> ks = keySet;
    return (ks != null) ? ks : (keySet = new KeySet());
  }

  @LazyInit transient @Nullable Collection<V> values;

  @Override
  public Collection<V> values() {
    Collection<V> vs = values;
    return (vs != null) ? vs : (values = new Values());
  }

  @LazyInit transient @Nullable Set<Entry<K, V>> entrySet;

  @Override
  public Set<Entry<K, V>> entrySet() {