public void testIndexing() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int index : new int[] {-1, SIZE}) {
      assertThrows(IndexOutOfBoundsException.class, () -> aa.get(index));
      assertThrows(IndexOutOfBoundsException.class, () -> aa.set(index, 1.0));
      assertThrows(IndexOutOfBoundsException.class, () -> aa.lazySet(index, 1.0));

  public void testAddAtIndex_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().add(-1, e3()));
    expectUnchanged();
    expectMissing(e3());
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  public void testAddAtIndex_tooLarge() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().add(getNumElements() + 1, e3()));
    expectUnchanged();

          .put(IllegalArgumentException.class, e -> e instanceof IllegalArgumentException)
          .put(IllegalStateException.class, e -> e instanceof IllegalStateException)
          .put(IndexOutOfBoundsException.class, e -> e instanceof IndexOutOfBoundsException)
          .put(NoSuchElementException.class, e -> e instanceof NoSuchElementException)
          .put(NullPointerException.class, e -> e instanceof NullPointerException)

          .put(IllegalArgumentException.class, e -> e instanceof IllegalArgumentException)
          .put(IllegalStateException.class, e -> e instanceof IllegalStateException)
          .put(IndexOutOfBoundsException.class, e -> e instanceof IndexOutOfBoundsException)
          .put(NoSuchElementException.class, e -> e instanceof NoSuchElementException)
          .put(NullPointerException.class, e -> e instanceof NullPointerException)

    expectContents(createOrderedArray());
  }

  public void testGet_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().get(-1));
  }

  public void testGet_tooLarge() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().get(getNumElements()));
  }

    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkElementIndex(-1, 1));
    assertThat(expected).hasMessageThat().isEqualTo("index (-1) must not be negative");
  }

  public void testCheckElementIndex_tooHigh() {
    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkElementIndex(1, 1));

    char[] buf = new char[10];
    assertThrows(IndexOutOfBoundsException.class, () -> reader.read(buf, 0, 11));

    assertThrows(IndexOutOfBoundsException.class, () -> reader.read(buf, 10, 1));

    assertThrows(IndexOutOfBoundsException.class, () -> reader.read(buf, 11, 0));

    assertThrows(IndexOutOfBoundsException.class, () -> reader.read(buf, -1, 5));

    assertThrows(IndexOutOfBoundsException.class, () -> reader.read(buf, 5, -1));

  @Throws(IOException::class)
  fun write(
    pos: Long,
    source: Buffer,
    byteCount: Long,
  ) {
    if (byteCount < 0L || byteCount > source.size) {
      throw IndexOutOfBoundsException()
    }
    var mutablePos = pos
    var mutableByteCount = byteCount

    while (mutableByteCount > 0L) {
      val bytesWritten = fileChannel.transferFrom(source, mutablePos, mutableByteCount)

    counter.write(data, 2, 5);
    written += 5;
    assertEquals(written, out.size());
    assertEquals(written, counter.getCount());

    // Test that illegal arguments do not affect count
    assertThrows(IndexOutOfBoundsException.class, () -> counter.write(data, 0, data.length + 1));
    assertEquals(written, out.size());
    assertEquals(written, counter.getCount());
  }

  }

  @ListFeature.Require(SUPPORTS_SET)
  public void testSet_indexTooLow() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().set(-1, e3()));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_SET)
  public void testSet_indexTooHigh() {
    int index = getNumElements();
    assertThrows(IndexOutOfBoundsException.class, () -> getList().set(index, e3()));
    expectUnchanged();
  }