Iterator<String> cycle = Iterators.cycle(iterable);
    assertTrue(cycle.hasNext());
    assertEquals("a", cycle.next());
    assertTrue(cycle.hasNext());
    cycle.remove();
    assertTrue(iterable.elements.isEmpty());
    assertFalse(cycle.hasNext());
  }

  public void testCycleNoSuchElementException() {
    Iterable<String> iterable = Lists.newArrayList("a");
    Iterator<String> cycle = Iterators.cycle(iterable);

                                        version = versionRange.matchVersion(versions);

                                        if (version == null) {
                                            if (versions.isEmpty()) {
                                                throw new OverConstrainedVersionException(
                                                        "No versions are present in the repository for the artifact"

      if (pairEqualsSign == cookiePairEnd) return null

      val cookieName = setCookie.trimSubstring(endIndex = pairEqualsSign)
      if (cookieName.isEmpty() || cookieName.indexOfControlOrNonAscii() != -1) return null

      val cookieValue = setCookie.trimSubstring(pairEqualsSign + 1, cookiePairEnd)
      if (cookieValue.indexOfControlOrNonAscii() != -1) return null

   */
  public Iterable<L> bulkGet(Iterable<? extends Object> keys) {
    // Initially using the list to store the keys, then reusing it to store the respective L's
    List<Object> result = newArrayList(keys);
    if (result.isEmpty()) {
      return ImmutableList.of();
    }
    int[] stripes = new int[result.size()];
    for (int i = 0; i < result.size(); i++) {
      stripes[i] = indexFor(result.get(i));
    }
    Arrays.sort(stripes);

      }
    }
    OptionalState state = new OptionalState();

    Deque<Spliterator<T>> splits = new ArrayDeque<>();
    splits.addLast(stream.spliterator());

    while (!splits.isEmpty()) {
      Spliterator<T> spliterator = splits.removeLast();

      if (spliterator.getExactSizeIfKnown() == 0) {
        continue; // drop this split
      }

      this.array = array;
      this.start = start;
      this.end = end;
    }

    @Override
    public int size() {
      return end - start;
    }

    @Override
    public boolean isEmpty() {
      return false;
    }

    @Override
    public Integer get(int index) {
      checkElementIndex(index, size());
      return array[start + index];
    }

    @Override
    /*

HSPLkotlin/collections/EmptyList;-><clinit>()V
HSPLkotlin/collections/EmptyList;-><init>()V
HSPLkotlin/collections/EmptyList;->isEmpty()Z
HSPLkotlin/collections/EmptyList;->iterator()Ljava/util/Iterator;
HSPLkotlin/collections/EmptyMap;-><clinit>()V
HSPLkotlin/collections/EmptyMap;-><init>()V
HSPLkotlin/collections/EmptyMap;->isEmpty()Z
HSPLkotlin/collections/EmptySet;-><clinit>()V
HSPLkotlin/collections/EmptySet;-><init>()V

     */
    private fun varyHeaders(
      requestHeaders: Headers,
      responseHeaders: Headers,
    ): Headers {
      val varyFields = responseHeaders.varyFields()
      if (varyFields.isEmpty()) return Headers.EMPTY

      val result = Headers.Builder()
      for (i in 0 until requestHeaders.size) {
        val fieldName = requestHeaders.name(i)
        if (fieldName in varyFields) {

    return pickInstance(Arrays.asList(instances), defaultValue);
  }

  private <T> T pickInstance(Collection<T> instances, T defaultValue) {
    if (instances.isEmpty()) {
      return defaultValue;
    }
    // generateInt() is 1-based.
    return Iterables.get(instances, (generateInt() - 1) % instances.size());
  }

          delta = peerInitialWindowSize - previousPeerSettings.initialWindowSize.toLong()
          streamsToNotify =
            when {
              delta == 0L || streams.isEmpty() -> null // No adjustment is necessary.
              else -> streams.values.toTypedArray()
            }

          peerSettings = newPeerSettings