*
   * @param bytes a byte array
   * @param off the start offset in the array
   * @param len the number of bytes to write
   * @return this instance
   * @throws IndexOutOfBoundsException if {@code off < 0} or {@code off + len > bytes.length} or
   *     {@code len < 0}
   */
  @CanIgnoreReturnValue
  PrimitiveSink putBytes(byte[] bytes, int off, int len);

  /**

   * call to {@link #next()} will return the element at that index, if available. Calls to {@link
   * #previous()} can retrieve the preceding {@code position} elements.
   *
   * @throws IndexOutOfBoundsException if {@code position} is negative or is greater than {@code
   *     size}
   * @throws IllegalArgumentException if {@code size} is negative
   */
  protected AbstractIndexedListIterator(int size, int position) {

  }

  /**
   * Returns a new {@link ByteArrayDataInput} instance to read from the {@code bytes} array,
   * starting at the given position.
   *
   * @throws IndexOutOfBoundsException if {@code start} is negative or greater than the length of
   *     the array
   */
  @J2ktIncompatible
  public static ByteArrayDataInput newDataInput(byte[] bytes, int start) {

   * call to {@link #next()} will return the element at that index, if available. Calls to {@link
   * #previous()} can retrieve the preceding {@code position} elements.
   *
   * @throws IndexOutOfBoundsException if {@code position} is negative or is greater than {@code
   *     size}
   * @throws IllegalArgumentException if {@code size} is negative
   */
  protected AbstractIndexedListIterator(int size, int position) {

   * @throws IndexOutOfBoundsException if either index is negative, {@code rowIndex} is greater than
   *     or equal to the number of allowed row keys, or {@code columnIndex} is greater than or equal
   *     to the number of allowed column keys
   */
  public @Nullable V at(int rowIndex, int columnIndex) {
    // In GWT array access never throws IndexOutOfBoundsException.
    checkElementIndex(rowIndex, rowList.size());

  }

  public void testWriteBytesToUndersizedArray() {
    byte[] dest = new byte[3];
    assertThrows(IndexOutOfBoundsException.class, () -> HASH_ABCD.writeBytesTo(dest, 0, 4));
  }

  public void testWriteBytesToUndersizedArrayLongMaxLength() {
    byte[] dest = new byte[3];
    assertThrows(IndexOutOfBoundsException.class, () -> HASH_ABCD.writeBytesTo(dest, 0, 5));
  }

      fail();
    } catch (IndexOutOfBoundsException expected) {
    }
    assertThat(Iterables.get(iterable, 0)).isEqualTo("a");
    assertThat(Iterables.get(iterable, 1)).isEqualTo("b");
    assertThat(Iterables.get(iterable, 2)).isEqualTo("c");
    try {
      Iterables.get(iterable, 3);
      fail();
    } catch (IndexOutOfBoundsException nsee) {
    }
    try {

   * this method will never fail silently when encountering an invalid surrogate pair.
   *
   * <p>The behaviour of this method is as follows:
   *
   * <ol>
   *   <li>If {@code index >= end}, {@link IndexOutOfBoundsException} is thrown.
   *   <li><b>If the character at the specified index is not a surrogate, it is returned.</b>
   *   <li>If the first character was a high surrogate value, then an attempt is made to read the

    assertThat(e.escape("\0HeLLo \uD800\uDC00 WorlD!\n"))
        .isEqualTo("\0HELLO \uD800\uDC00 WORLD!\n");
  }

  public void testCodePointAt_indexOutOfBoundsException() {
    assertThrows(
        IndexOutOfBoundsException.class, () -> UnicodeEscaper.codePointAt("Testing...", 4, 2));
  }

  private static String escapeAsString(Escaper e, String s) {
    return e.escape(s);
  }

   * exclusive. This is equivalent to {@code
   * Collections.reverse(Bytes.asList(array).subList(fromIndex, toIndex))}, but is likely to be more
   * efficient.
   *
   * @throws IndexOutOfBoundsException if {@code fromIndex < 0}, {@code toIndex > array.length}, or
   *     {@code toIndex > fromIndex}
   * @since 23.1
   */
  public static void reverse(byte[] array, int fromIndex, int toIndex) {