g := errgroup.WithNErrs(len(sys.peerClients))
	for index, client := range sys.peerClients {
		if client == nil {
			continue
		}
		index := index
		g.Go(func() error {
			var err error
			reply[index], err = sys.peerClients[index].GetCPUs(ctx)
			return err
		}, index)
	}

	for index, err := range g.Wait() {
		if err != nil {
			sys.addNodeErr(&reply[index], sys.peerClients[index], err)
		}
	}

        }

      private fun isStaticHeader(index: Int): Boolean = index >= 0 && index <= STATIC_HEADER_TABLE.size - 1

      /** index == -1 when new. */
      private fun insertIntoDynamicTable(
        index: Int,
        entry: Header,
      ) {
        var index = index
        headerList.add(entry)

        var delta = entry.hpackSize
        if (index != -1) { // Index -1 == new header.

        return index;
    }

    /**
     * Sets the current index position in the buffer.
     *
     * @param index the new index position
     */
    public void setIndex(final int index) {
        this.index = index;
    }

    /**
     * Returns the capacity of the buffer.
     *
     * @return the buffer capacity
     */
    public int getCapacity() {
        return buf.length - start;

    size = 0;
    distinctElements = 0;
  }

  abstract class Itr<T> implements Iterator<T> {
    int index = 0;
    int toRemove = -1;

    abstract T output(int index);

    @Override
    public boolean hasNext() {
      for (; index < enumConstants.length; index++) {
        if (counts[index] > 0) {
          return true;
        }
      }
      return false;
    }

    @Override

    }

    /**
     * Get values from array index.
     * @param index Index
     * @param type Type
     * @param key Key
     * @return Values
     */
    @SuppressWarnings("unchecked")
    protected Map<String, Object>[] getFromArrayIndex(final String index, final String type, final String key) {
        final String actualIndex = index + "." + type.toLowerCase(Locale.ENGLISH);
        try {

    for (int i = 0; i < reps; i++) {
      for (int index = 0; index < size; index++) {
        sum += array[index].hashCode();
      }
    }
    return sum;
  }

  @Benchmark
  int arrayIndexedLength(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (int index = 0; index < array.length; index++) {
        sum += array[index].hashCode();
      }
    }
    return sum;
  }

        }
        return value;
    }

    /**
     * Creates a new index with default settings.
     *
     * @param index     the index configuration name
     * @param indexName the actual index name to create
     * @return true if the index was created successfully, false otherwise
     */
    public boolean createIndex(final String index, final String indexName) {

    // Inlineable fast-path loop which hands off to escapeSlow() only if needed
    int length = string.length();
    for (int index = 0; index < length; index++) {
      if (escape(string.charAt(index)) != null) {
        return escapeSlow(string, index);
      }
    }
    return string;
  }

  /**
   * Returns the escaped form of the given character, or {@code null} if this character does not

import org.codelibs.fess.opensearch.client.SearchEngineClient;

import org.codelibs.fess.unit.UnitFessTestCase;
import org.codelibs.fess.util.ComponentUtil;
import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;
import org.opensearch.index.query.RangeQueryBuilder;

public class PurgeDocJobTest extends UnitFessTestCase {

    private PurgeDocJob purgeDocJob;
    private SearchEngineClient searchEngineClient;

   * @param index the index of the first character to decode
   * @param end the index beyond the last valid character to decode
   * @return the Unicode code point for the given index or the negated value of the trailing high
   *     surrogate character at the end of the sequence
   */
  protected static int codePointAt(CharSequence seq, int index, int end) {
    checkNotNull(seq);