* @return the least index {@code i} for which {@code array[i] == target}, or {@code -1} if no
   *     such index exists.
   */
  public static int indexOf(boolean[] array, boolean target) {
    return indexOf(array, target, 0, array.length);
  }

  // TODO(kevinb): consider making this public
  private static int indexOf(boolean[] array, boolean target, int start, int end) {

        SuggestResponse response = new SuggestResponse("my-index", 50, words, 5, new ArrayList<>());

        assertEquals("my-index", response.getIndex());
    }

    @Test
    public void test_getTookMs() throws Exception {
        List<String> words = new ArrayList<>();
        SuggestResponse response = new SuggestResponse("test-index", 250, words, 5, new ArrayList<>());

    }

    /**
     * Encodes a String as UTF-8 bytes.
     *
     * @param str the String to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array
     * @param dlim the maximum index in the destination array
     * @return the number of bytes written
     * @throws IOException if an encoding error occurs
     */

    public boolean hasNext() {
        for (; index < iterators.length; ++index) {
            if (iterators[index].hasNext()) {
                return true;
            }
        }
        return false;
    }

    @Override
    public E next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return iterators[index].next();
    }

    @Override

     * @return sequence element cast to type
     * @throws PACDecodingException if types are incompatible
     */
    public static <T extends ASN1Primitive> T as(final Class<T> type, final ASN1Sequence sequence, final int index)
            throws PACDecodingException {
        return as(type, sequence.getObjectAt(index));
    }

    /**
     * Read a tagged object without parsing it's contents
     *

                _dst.enc_ndr_long(_name_buffers);
                _dst.enc_ndr_long(0);
                _dst.enc_ndr_long(_name_bufferl);
                final int _name_bufferi = _dst.index;
                _dst.advance(2 * _name_bufferl);

                _dst = _dst.derive(_name_bufferi);
                for (int _i = 0; _i < _name_bufferl; _i++) {

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opensearch.action.bulk.BulkRequestBuilder;
import org.opensearch.action.index.IndexAction;
import org.opensearch.action.index.IndexRequestBuilder;
import org.opensearch.index.IndexNotFoundException;
import org.opensearch.search.sort.SortBuilders;
import org.opensearch.search.sort.SortOrder;
import org.opensearch.transport.client.Client;

   */
  @Override
  protected int nextEscapeIndex(CharSequence csq, int index, int end) {
    checkNotNull(csq);
    for (; index < end; index++) {
      char c = csq.charAt(index);
      if (c >= safeOctets.length || !safeOctets[c]) {
        break;
      }
    }
    return index;
  }

  /*

        val index = orderBy.indexOfFirst { it.matches(ianaSuite) }
        if (index == -1) Integer.MAX_VALUE else index
      }
    for (suiteId in sortedSuites) {
      print(suiteId.name)
      for (client in clients) {
        print("\t")
        val index = client.enabled.indexOfFirst { it.matches(suiteId) }
        if (index != -1) {
          print(index + 1)
        }
      }
      println()

        @DisplayName("writeSetupWireFormat returns 0 for all indices")
        void writeSetupWireFormatReturnsZero(int index) {
            TransWaitNamedPipeResponse resp = new TransWaitNamedPipeResponse();
            assertEquals(0, resp.writeSetupWireFormat(new byte[10], index), "writeSetupWireFormat should always return 0");
        }

        @ParameterizedTest