for i, part := range fi.Parts {
		partIndex = i
		// Offset is smaller than size we have reached the proper part offset.
		if partOffset < part.Size {
			return partIndex, partOffset, nil
		}
		// Continue to towards the next part.
		partOffset -= part.Size
	}
	internalLogIf(ctx, InvalidRange{})
	// Offset beyond the size of the object return InvalidRange.
	return 0, 0, InvalidRange{}
}

   */
  private static char[] growBuffer(char[] dest, int index, int size) {
    if (size < 0) { // overflow - should be OutOfMemoryError but GWT/j2cl don't support it
      throw new AssertionError("Cannot increase internal buffer any further");
    }
    char[] copy = new char[size];
    if (index > 0) {
      System.arraycopy(dest, 0, copy, 0, index);
    }
    return copy;
  }

        .testEquals();
  }

  /** Returns a {@link Set} with a {@link Set#size()} of {@code size}. */
  private static ContiguousSet<Integer> setSize(int size) {
    checkArgument(size >= 0);
    ContiguousSet<Integer> set = ContiguousSet.closedOpen(0, size);
    checkState(set.size() == size);
    return set;
  }

  /**

    List<String> stringEvents = stringCatcher.getEvents();
    assertEquals("Only one String should be delivered.", 1, stringEvents.size());
    assertEquals("Correct string should be delivered.", EVENT, stringEvents.get(0));

    // Check the Catcher<Object>...
    assertEquals("Three Objects should be delivered.", 3, objectEvents.size());
    assertEquals("String fixture must be first object delivered.", EVENT, objectEvents.get(0));

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String permissions;

    /** The boost score multiplier applied to elevated documents */
    @Required
    @ValidateTypeFailure
    public Float boost;

    /** The username of who created this elevate word entry */
    @Size(max = 1000)
    public String createdBy;

    this.forward = forward;
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return forward.contains(object);
  }

  @Override
  public int size() {
    return forward.size();
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return forward.descendingIterator();
  }

  @Override
  ImmutableSortedSet<E> headSetImpl(E toElement, boolean inclusive) {

      tableSize <<= 1;
      return (tableSize > 0) ? tableSize : MAX_TABLE_SIZE;
    }
    return tableSize;
  }

  static boolean needsResizing(int size, int tableSize, double loadFactor) {
    return size > loadFactor * tableSize && tableSize < MAX_TABLE_SIZE;
  }

        Set set = project1.getArtifacts();
        assertNotNull(set, "No artifacts");
        assertFalse(set.isEmpty(), "No Artifacts");
        assertTrue(set.size() == 3, "Set size should be 3, is " + set.size());

        for (Object aSet : set) {
            Artifact artifact = (Artifact) aSet;
            assertFalse(artifact.getArtifactId().equals("t07-d"));

    List<Object> values = new ArrayList<>(map.values());
    assertEquals(2 * entries.size(), alternatingKeysAndValues.length);
    assertEquals(2 * keys.size(), alternatingKeysAndValues.length);
    assertEquals(2 * values.size(), alternatingKeysAndValues.length);
    for (int i = 0; i < map.size(); i++) {
      Object expectedKey = alternatingKeysAndValues[2 * i];

    }

    /**
     * Sets the polling fetch size.
     * @param pollingFetchSize The polling fetch size.
     */
    public void setPollingFetchSize(final int pollingFetchSize) {
        this.pollingFetchSize = pollingFetchSize;
    }

    /**
     * Sets the maximum crawling queue size.
     * @param maxCrawlingQueueSize The maximum crawling queue size.
     */