diff --git a/pom.xml b/pom.xml
index 65bace2..5240097 100644
--- a/pom.xml
+++ b/pom.xml
@@ -176,6 +176,7 @@
           <forkedProcessExitTimeoutInSeconds>600</forkedProcessExitTimeoutInSeconds>
           <!-- Not reusing forks lets us be more frugal with memory. We have a lot of tests, and they need a lot of metadata -->
           <reuseForks>false</reuseForks>
+          <forkCount>1C</forkCount>
           <systemProperties>
             <sample>nosample</sample>
           </systemProperties>
diff --git a/src/test/java/io/netty/buffer/api/BufferBulkAccessTest.java b/src/test/java/io/netty/buffer/api/BufferBulkAccessTest.java
index 90e9bba..0469369 100644
--- a/src/test/java/io/netty/buffer/api/BufferBulkAccessTest.java
+++ b/src/test/java/io/netty/buffer/api/BufferBulkAccessTest.java
@@ -303,60 +303,6 @@ public class BufferBulkAccessTest extends BufferTestSupport {
         }
     }
 
-    private static final Memoize<Fixture[]> OTHER_FIXTURES = new Memoize<Fixture[]>(
-            () -> Arrays.stream(allocators()).filter(filterOfTheDay(10)).toArray(Fixture[]::new));
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    public void writeBytesMustTransferDataAndUpdateOffsets(Fixture fixture) {
-        try (BufferAllocator alloc1 = fixture.createAllocator()) {
-            // Only test 10% of available combinations. Otherwise, this takes too long.
-            Fixture[] allocators = OTHER_FIXTURES.get();
-            Arrays.stream(allocators).parallel().forEach(otherFixture -> {
-                try (BufferAllocator alloc2 = otherFixture.createAllocator();
-                     Buffer target = alloc1.allocate(37);
-                     Buffer source = alloc2.allocate(35)) {
-                    // BE to BE
-                    target.order(BIG_ENDIAN);
-                    source.order(BIG_ENDIAN);
-                    verifyWriteBytes(target, source);
-
-                    // LE to BE
-                    target.fill((byte) 0).reset().order(BIG_ENDIAN);
-                    source.fill((byte) 0).reset().order(LITTLE_ENDIAN);
-                    verifyWriteBytes(target, source);
-
-                    // BE to LE
-                    target.fill((byte) 0).reset().order(LITTLE_ENDIAN);
-                    source.fill((byte) 0).reset().order(BIG_ENDIAN);
-                    verifyWriteBytes(target, source);
-
-                    // LE to LE
-                    target.fill((byte) 0).reset().order(LITTLE_ENDIAN);
-                    source.fill((byte) 0).reset().order(BIG_ENDIAN);
-                    verifyWriteBytes(target, source);
-                } catch (Exception e) {
-                    e.addSuppressed(new RuntimeException("other fixture was: " + otherFixture));
-                    throw e;
-                }
-            });
-        }
-    }
-
-    private static void verifyWriteBytes(Buffer target, Buffer source) {
-        for (int i = 0; i < 35; i++) {
-            source.writeByte((byte) (i + 1));
-        }
-        target.writeBytes(source);
-        assertThat(target.readerOffset()).isZero();
-        assertThat(target.writerOffset()).isEqualTo(35);
-        assertThat(source.readerOffset()).isEqualTo(35);
-        assertThat(source.writerOffset()).isEqualTo(35);
-        try (Buffer readableSlice = target.slice()) {
-            assertEquals(source, readableSlice);
-        }
-    }
-
     @ParameterizedTest
     @MethodSource("allocators")
     public void writeBytesMustWriteAllBytesFromByteArray(Fixture fixture) {
diff --git a/src/test/java/io/netty/buffer/api/BufferByteOffsettedAccessorsTest.java b/src/test/java/io/netty/buffer/api/BufferByteOffsettedAccessorsTest.java
new file mode 100644
index 0000000..f0d1542
--- /dev/null
+++ b/src/test/java/io/netty/buffer/api/BufferByteOffsettedAccessorsTest.java
@@ -0,0 +1,341 @@
+/*
+ * Copyright 2021 The Netty Project
+ *
+ * The Netty Project licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package io.netty.buffer.api;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BufferByteOffsettedAccessorsTest extends BufferTestSupport {
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfByteMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getByte(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfByteReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getByte(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfByteMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            byte value = 0x01;
+            buf.writeByte(value);
+            assertEquals(value, buf.getByte(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfByteMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            byte value = 0x01;
+            buf.writeByte(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(0x10, buf.getByte(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfByteMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            byte value = 0x01;
+            buf.writeByte(value);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getByte(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfByteReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            byte value = 0x01;
+            buf.writeByte(value);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getByte(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfByteMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getByte(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfByteMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getByte(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfByteReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getByte(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfByteReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getByte(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedByte(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedByte(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x01;
+            buf.writeUnsignedByte(value);
+            assertEquals(value, buf.getUnsignedByte(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            int value = 0x01;
+            buf.writeUnsignedByte(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(0x10, buf.getUnsignedByte(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x01;
+            buf.writeUnsignedByte(value);
+            buf.getUnsignedByte(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedByte(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(
+            Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x01;
+            buf.writeUnsignedByte(value);
+            buf.readOnly(true).getUnsignedByte(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(
+            Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedByte(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getUnsignedByte(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedByte(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getUnsignedByte(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedByteReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedByte(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfByteMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            byte value = 0x01;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setByte(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfByteMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            byte value = 0x01;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setByte(8, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfByteMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            byte value = 0x01;
+            buf.setByte(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedByteMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            int value = 0x01;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedByte(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedByteMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            int value = 0x01;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedByte(8, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedByteMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            int value = 0x01;
+            buf.setUnsignedByte(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+        }
+    }
+}
diff --git a/src/test/java/io/netty/buffer/api/BufferCharOffsettedAccessorsTest.java b/src/test/java/io/netty/buffer/api/BufferCharOffsettedAccessorsTest.java
new file mode 100644
index 0000000..dedb510
--- /dev/null
+++ b/src/test/java/io/netty/buffer/api/BufferCharOffsettedAccessorsTest.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright 2021 The Netty Project
+ *
+ * The Netty Project licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package io.netty.buffer.api;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BufferCharOffsettedAccessorsTest extends BufferTestSupport {
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getChar(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getChar(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            char value = 0x0102;
+            buf.writeChar(value);
+            assertEquals(value, buf.getChar(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            char value = 0x0102;
+            buf.writeChar(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(0x1002, buf.getChar(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            char value = 0x0102;
+            buf.writeChar(value);
+            buf.getChar(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getChar(7));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            char value = 0x0102;
+            buf.writeChar(value);
+            buf.readOnly(true).getChar(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getChar(7));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getChar(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getChar(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getChar(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfCharReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getChar(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfCharMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            char value = 0x0102;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setChar(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfCharMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            char value = 0x0102;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setChar(7, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfCharMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            char value = 0x0102;
+            buf.setChar(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x02, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+        }
+    }
+}
diff --git a/src/test/java/io/netty/buffer/api/BufferDoubleOffsettedAccessorsTest.java b/src/test/java/io/netty/buffer/api/BufferDoubleOffsettedAccessorsTest.java
new file mode 100644
index 0000000..47fd37f
--- /dev/null
+++ b/src/test/java/io/netty/buffer/api/BufferDoubleOffsettedAccessorsTest.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2021 The Netty Project
+ *
+ * The Netty Project licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package io.netty.buffer.api;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BufferDoubleOffsettedAccessorsTest extends BufferTestSupport {
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfDoubleMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getDouble(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfDoubleReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getDouble(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfDoubleMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            double value = Double.longBitsToDouble(0x0102030405060708L);
+            buf.writeDouble(value);
+            assertEquals(value, buf.getDouble(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfDoubleMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            double value = Double.longBitsToDouble(0x0102030405060708L);
+            buf.writeDouble(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(Double.longBitsToDouble(0x1002030405060708L), buf.getDouble(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfDoubleMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            double value = Double.longBitsToDouble(0x0102030405060708L);
+            buf.writeDouble(value);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getDouble(1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfDoubleReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            double value = Double.longBitsToDouble(0x0102030405060708L);
+            buf.writeDouble(value);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getDouble(1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfDoubleMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getDouble(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfDoubleMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getDouble(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfDoubleReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getDouble(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfDoubleReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getDouble(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfDoubleMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            double value = Double.longBitsToDouble(0x0102030405060708L);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setDouble(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfDoubleMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            double value = Double.longBitsToDouble(0x0102030405060708L);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setDouble(1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfDoubleMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            double value = Double.longBitsToDouble(0x0102030405060708L);
+            buf.setDouble(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x02, buf.readByte());
+            assertEquals((byte) 0x03, buf.readByte());
+            assertEquals((byte) 0x04, buf.readByte());
+            assertEquals((byte) 0x05, buf.readByte());
+            assertEquals((byte) 0x06, buf.readByte());
+            assertEquals((byte) 0x07, buf.readByte());
+            assertEquals((byte) 0x08, buf.readByte());
+        }
+    }
+}
diff --git a/src/test/java/io/netty/buffer/api/BufferFloatOffsettedAccessorsTest.java b/src/test/java/io/netty/buffer/api/BufferFloatOffsettedAccessorsTest.java
new file mode 100644
index 0000000..9fc6b2f
--- /dev/null
+++ b/src/test/java/io/netty/buffer/api/BufferFloatOffsettedAccessorsTest.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright 2021 The Netty Project
+ *
+ * The Netty Project licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package io.netty.buffer.api;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BufferFloatOffsettedAccessorsTest extends BufferTestSupport {
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getFloat(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getFloat(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            float value = Float.intBitsToFloat(0x01020304);
+            buf.writeFloat(value);
+            assertEquals(value, buf.getFloat(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            float value = Float.intBitsToFloat(0x01020304);
+            buf.writeFloat(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(Float.intBitsToFloat(0x10020304), buf.getFloat(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            float value = Float.intBitsToFloat(0x01020304);
+            buf.writeFloat(value);
+            buf.getFloat(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getFloat(7));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            float value = Float.intBitsToFloat(0x01020304);
+            buf.writeFloat(value);
+            buf.readOnly(true).getFloat(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getFloat(5));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getFloat(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getFloat(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getFloat(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfFloatReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThan(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getFloat(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfFloatMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            float value = Float.intBitsToFloat(0x01020304);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setFloat(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfFloatMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            float value = Float.intBitsToFloat(0x01020304);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setFloat(5, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfFloatMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            float value = Float.intBitsToFloat(0x01020304);
+            buf.setFloat(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x02, buf.readByte());
+            assertEquals((byte) 0x03, buf.readByte());
+            assertEquals((byte) 0x04, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+        }
+    }
+}
diff --git a/src/test/java/io/netty/buffer/api/BufferIntOffsettedAccessorsTest.java b/src/test/java/io/netty/buffer/api/BufferIntOffsettedAccessorsTest.java
new file mode 100644
index 0000000..5a83cc1
--- /dev/null
+++ b/src/test/java/io/netty/buffer/api/BufferIntOffsettedAccessorsTest.java
@@ -0,0 +1,340 @@
+/*
+ * Copyright 2021 The Netty Project
+ *
+ * The Netty Project licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package io.netty.buffer.api;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BufferIntOffsettedAccessorsTest extends BufferTestSupport {
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfIntMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getInt(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfIntReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getInt(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfIntMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x01020304;
+            buf.writeInt(value);
+            assertEquals(value, buf.getInt(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfIntMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            int value = 0x01020304;
+            buf.writeInt(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(0x10020304, buf.getInt(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfIntMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x01020304;
+            buf.writeInt(value);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getInt(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfIntReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x01020304;
+            buf.writeInt(value);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getInt(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfIntMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getInt(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfIntMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getInt(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfIntReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getInt(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfIntReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getInt(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedInt(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedInt(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            long value = 0x01020304;
+            buf.writeUnsignedInt(value);
+            assertEquals(value, buf.getUnsignedInt(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            long value = 0x01020304;
+            buf.writeUnsignedInt(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(0x10020304, buf.getUnsignedInt(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            long value = 0x01020304;
+            buf.writeUnsignedInt(value);
+            buf.getUnsignedInt(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedInt(5));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(
+            Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            long value = 0x01020304;
+            buf.writeUnsignedInt(value);
+            buf.readOnly(true).getUnsignedInt(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(
+            Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedInt(5));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getUnsignedInt(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedInt(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getUnsignedInt(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedIntReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedInt(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfIntMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            int value = 0x01020304;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setInt(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfIntMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            int value = 0x01020304;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setInt(5, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfIntMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            int value = 0x01020304;
+            buf.setInt(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x02, buf.readByte());
+            assertEquals((byte) 0x03, buf.readByte());
+            assertEquals((byte) 0x04, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedIntMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            long value = 0x01020304;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedInt(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedIntMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            long value = 0x01020304;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedInt(5, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedIntMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            long value = 0x01020304;
+            buf.setUnsignedInt(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x02, buf.readByte());
+            assertEquals((byte) 0x03, buf.readByte());
+            assertEquals((byte) 0x04, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+        }
+    }
+}
diff --git a/src/test/java/io/netty/buffer/api/BufferLongOffsettedAccessorsTest.java b/src/test/java/io/netty/buffer/api/BufferLongOffsettedAccessorsTest.java
new file mode 100644
index 0000000..af67f8f
--- /dev/null
+++ b/src/test/java/io/netty/buffer/api/BufferLongOffsettedAccessorsTest.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2021 The Netty Project
+ *
+ * The Netty Project licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package io.netty.buffer.api;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BufferLongOffsettedAccessorsTest extends BufferTestSupport {
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfLongMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getLong(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfLongReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getLong(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfLongMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            long value = 0x0102030405060708L;
+            buf.writeLong(value);
+            assertEquals(value, buf.getLong(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfLongMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            long value = 0x0102030405060708L;
+            buf.writeLong(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(0x1002030405060708L, buf.getLong(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfLongMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            long value = 0x0102030405060708L;
+            buf.writeLong(value);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getLong(1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfLongReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            long value = 0x0102030405060708L;
+            buf.writeLong(value);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getLong(1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfLongMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getLong(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfLongMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getLong(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfLongReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getLong(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfLongReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getLong(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfLongMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            long value = 0x0102030405060708L;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setLong(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfLongMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            long value = 0x0102030405060708L;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setLong(1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfLongMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            long value = 0x0102030405060708L;
+            buf.setLong(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x02, buf.readByte());
+            assertEquals((byte) 0x03, buf.readByte());
+            assertEquals((byte) 0x04, buf.readByte());
+            assertEquals((byte) 0x05, buf.readByte());
+            assertEquals((byte) 0x06, buf.readByte());
+            assertEquals((byte) 0x07, buf.readByte());
+            assertEquals((byte) 0x08, buf.readByte());
+        }
+    }
+}
diff --git a/src/test/java/io/netty/buffer/api/BufferMediumOffsettedAccessorsTest.java b/src/test/java/io/netty/buffer/api/BufferMediumOffsettedAccessorsTest.java
new file mode 100644
index 0000000..4b45f37
--- /dev/null
+++ b/src/test/java/io/netty/buffer/api/BufferMediumOffsettedAccessorsTest.java
@@ -0,0 +1,360 @@
+/*
+ * Copyright 2021 The Netty Project
+ *
+ * The Netty Project licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package io.netty.buffer.api;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BufferMediumOffsettedAccessorsTest extends BufferTestSupport {
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getMedium(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getMedium(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x010203;
+            buf.writeMedium(value);
+            assertEquals(value, buf.getMedium(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            int value = 0x010203;
+            buf.writeMedium(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(0x100203, buf.getMedium(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x010203;
+            buf.writeMedium(value);
+            buf.getMedium(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x010203;
+            buf.writeMedium(value);
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getMedium(6));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x010203;
+            buf.writeMedium(value);
+            buf.readOnly(true).getMedium(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getMedium(6));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getMedium(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getMedium(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getMedium(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfMediumReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getMedium(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedMedium(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedMedium(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x010203;
+            buf.writeUnsignedMedium(value);
+            assertEquals(value, buf.getUnsignedMedium(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            int value = 0x010203;
+            buf.writeUnsignedMedium(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(0x100203, buf.getUnsignedMedium(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x010203;
+            buf.writeUnsignedMedium(value);
+            buf.getUnsignedMedium(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedMedium(6));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(
+            Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x010203;
+            buf.writeUnsignedMedium(value);
+            buf.readOnly(true).getUnsignedMedium(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(
+            Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedMedium(6));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getUnsignedMedium(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedMedium(6));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getUnsignedMedium(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedMediumReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedMedium(8));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfMediumMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            int value = 0x010203;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setMedium(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfMediumMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            int value = 0x010203;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setMedium(6, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfMediumMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            int value = 0x010203;
+            buf.setMedium(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x02, buf.readByte());
+            assertEquals((byte) 0x03, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedMediumMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            int value = 0x010203;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedMedium(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedMediumMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            int value = 0x010203;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedMedium(6, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedMediumMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            int value = 0x010203;
+            buf.setUnsignedMedium(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x02, buf.readByte());
+            assertEquals((byte) 0x03, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+        }
+    }
+}
diff --git a/src/test/java/io/netty/buffer/api/BufferPrimitiveOffsettedAccessorsTest.java b/src/test/java/io/netty/buffer/api/BufferPrimitiveOffsettedAccessorsTest.java
deleted file mode 100644
index fbbf4b4..0000000
--- a/src/test/java/io/netty/buffer/api/BufferPrimitiveOffsettedAccessorsTest.java
+++ /dev/null
@@ -1,1955 +0,0 @@
-/*
- * Copyright 2021 The Netty Project
- *
- * The Netty Project licenses this file to you under the Apache License,
- * version 2.0 (the "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at:
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- */
-package io.netty.buffer.api;
-
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.MethodSource;
-
-import static java.nio.ByteOrder.BIG_ENDIAN;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-public class BufferPrimitiveOffsettedAccessorsTest extends BufferTestSupport {
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfByteMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getByte(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfByteReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getByte(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfByteMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            byte value = 0x01;
-            buf.writeByte(value);
-            assertEquals(value, buf.getByte(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfByteMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            byte value = 0x01;
-            buf.writeByte(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(0x10, buf.getByte(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfByteMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            byte value = 0x01;
-            buf.writeByte(value);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getByte(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfByteReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            byte value = 0x01;
-            buf.writeByte(value);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getByte(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfByteMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getByte(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfByteMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getByte(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfByteReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getByte(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfByteReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getByte(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedByte(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedByte(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x01;
-            buf.writeUnsignedByte(value);
-            assertEquals(value, buf.getUnsignedByte(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            int value = 0x01;
-            buf.writeUnsignedByte(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(0x10, buf.getUnsignedByte(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x01;
-            buf.writeUnsignedByte(value);
-            buf.getUnsignedByte(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedByte(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(
-            Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x01;
-            buf.writeUnsignedByte(value);
-            buf.readOnly(true).getUnsignedByte(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(
-            Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedByte(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getUnsignedByte(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedByte(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getUnsignedByte(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedByteReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedByte(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfByteMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            byte value = 0x01;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setByte(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfByteMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            byte value = 0x01;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setByte(8, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfByteMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            byte value = 0x01;
-            buf.setByte(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedByteMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            int value = 0x01;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedByte(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedByteMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            int value = 0x01;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedByte(8, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedByteMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            int value = 0x01;
-            buf.setUnsignedByte(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getChar(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getChar(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            char value = 0x0102;
-            buf.writeChar(value);
-            assertEquals(value, buf.getChar(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            char value = 0x0102;
-            buf.writeChar(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(0x1002, buf.getChar(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            char value = 0x0102;
-            buf.writeChar(value);
-            buf.getChar(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getChar(7));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            char value = 0x0102;
-            buf.writeChar(value);
-            buf.readOnly(true).getChar(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getChar(7));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getChar(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getChar(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getChar(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfCharReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getChar(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfCharMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            char value = 0x0102;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setChar(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfCharMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            char value = 0x0102;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setChar(7, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfCharMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            char value = 0x0102;
-            buf.setChar(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x02, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getShort(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getShort(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            short value = 0x0102;
-            buf.writeShort(value);
-            assertEquals(value, buf.getShort(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            short value = 0x0102;
-            buf.writeShort(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(0x1002, buf.getShort(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            short value = 0x0102;
-            buf.writeShort(value);
-            buf.getShort(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getShort(7));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            short value = 0x0102;
-            buf.writeShort(value);
-            buf.readOnly(true).getShort(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getShort(7));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getShort(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getShort(7));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getShort(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfShortReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getShort(7));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedShort(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedShort(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x0102;
-            buf.writeUnsignedShort(value);
-            assertEquals(value, buf.getUnsignedShort(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            int value = 0x0102;
-            buf.writeUnsignedShort(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(0x1002, buf.getUnsignedShort(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x0102;
-            buf.writeUnsignedShort(value);
-            buf.getUnsignedShort(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedShort(7));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(
-            Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x0102;
-            buf.writeUnsignedShort(value);
-            buf.readOnly(true).getUnsignedShort(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(
-            Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedShort(7));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getUnsignedShort(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedShort(7));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getUnsignedShort(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedShortReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedShort(7));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfShortMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            short value = 0x0102;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setShort(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfShortMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            short value = 0x0102;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setShort(7, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfShortMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            short value = 0x0102;
-            buf.setShort(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x02, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedShortMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            int value = 0x0102;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedShort(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedShortMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            int value = 0x0102;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedShort(7, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedShortMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            int value = 0x0102;
-            buf.setUnsignedShort(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x02, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getMedium(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getMedium(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x010203;
-            buf.writeMedium(value);
-            assertEquals(value, buf.getMedium(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            int value = 0x010203;
-            buf.writeMedium(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(0x100203, buf.getMedium(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x010203;
-            buf.writeMedium(value);
-            buf.getMedium(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x010203;
-            buf.writeMedium(value);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getMedium(6));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x010203;
-            buf.writeMedium(value);
-            buf.readOnly(true).getMedium(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getMedium(6));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getMedium(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getMedium(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getMedium(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfMediumReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getMedium(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedMedium(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedMedium(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x010203;
-            buf.writeUnsignedMedium(value);
-            assertEquals(value, buf.getUnsignedMedium(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            int value = 0x010203;
-            buf.writeUnsignedMedium(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(0x100203, buf.getUnsignedMedium(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x010203;
-            buf.writeUnsignedMedium(value);
-            buf.getUnsignedMedium(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedMedium(6));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(
-            Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x010203;
-            buf.writeUnsignedMedium(value);
-            buf.readOnly(true).getUnsignedMedium(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(
-            Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedMedium(6));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getUnsignedMedium(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedMedium(6));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getUnsignedMedium(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedMediumReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedMedium(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfMediumMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            int value = 0x010203;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setMedium(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfMediumMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            int value = 0x010203;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setMedium(6, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfMediumMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            int value = 0x010203;
-            buf.setMedium(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x02, buf.readByte());
-            assertEquals((byte) 0x03, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedMediumMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            int value = 0x010203;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedMedium(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedMediumMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            int value = 0x010203;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedMedium(6, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedMediumMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            int value = 0x010203;
-            buf.setUnsignedMedium(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x02, buf.readByte());
-            assertEquals((byte) 0x03, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfIntMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getInt(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfIntReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getInt(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfIntMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x01020304;
-            buf.writeInt(value);
-            assertEquals(value, buf.getInt(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfIntMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            int value = 0x01020304;
-            buf.writeInt(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(0x10020304, buf.getInt(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfIntMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x01020304;
-            buf.writeInt(value);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getInt(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfIntReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            int value = 0x01020304;
-            buf.writeInt(value);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getInt(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfIntMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getInt(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfIntMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getInt(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfIntReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getInt(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfIntReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getInt(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedInt(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedInt(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            long value = 0x01020304;
-            buf.writeUnsignedInt(value);
-            assertEquals(value, buf.getUnsignedInt(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            long value = 0x01020304;
-            buf.writeUnsignedInt(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(0x10020304, buf.getUnsignedInt(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            long value = 0x01020304;
-            buf.writeUnsignedInt(value);
-            buf.getUnsignedInt(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedInt(5));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(
-            Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            long value = 0x01020304;
-            buf.writeUnsignedInt(value);
-            buf.readOnly(true).getUnsignedInt(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(
-            Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedInt(5));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getUnsignedInt(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedInt(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getUnsignedInt(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfUnsignedIntReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedInt(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfIntMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            int value = 0x01020304;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setInt(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfIntMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            int value = 0x01020304;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setInt(5, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfIntMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            int value = 0x01020304;
-            buf.setInt(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x02, buf.readByte());
-            assertEquals((byte) 0x03, buf.readByte());
-            assertEquals((byte) 0x04, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedIntMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            long value = 0x01020304;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedInt(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedIntMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            long value = 0x01020304;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedInt(5, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfUnsignedIntMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            long value = 0x01020304;
-            buf.setUnsignedInt(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x02, buf.readByte());
-            assertEquals((byte) 0x03, buf.readByte());
-            assertEquals((byte) 0x04, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getFloat(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getFloat(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            float value = Float.intBitsToFloat(0x01020304);
-            buf.writeFloat(value);
-            assertEquals(value, buf.getFloat(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            float value = Float.intBitsToFloat(0x01020304);
-            buf.writeFloat(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(Float.intBitsToFloat(0x10020304), buf.getFloat(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            float value = Float.intBitsToFloat(0x01020304);
-            buf.writeFloat(value);
-            buf.getFloat(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getFloat(7));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            float value = Float.intBitsToFloat(0x01020304);
-            buf.writeFloat(value);
-            buf.readOnly(true).getFloat(1);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getFloat(5));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getFloat(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getFloat(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getFloat(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfFloatReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThan(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getFloat(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfFloatMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            float value = Float.intBitsToFloat(0x01020304);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setFloat(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfFloatMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            float value = Float.intBitsToFloat(0x01020304);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setFloat(5, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfFloatMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            float value = Float.intBitsToFloat(0x01020304);
-            buf.setFloat(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x02, buf.readByte());
-            assertEquals((byte) 0x03, buf.readByte());
-            assertEquals((byte) 0x04, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-            assertEquals((byte) 0x00, buf.readByte());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfLongMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getLong(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfLongReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getLong(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfLongMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            long value = 0x0102030405060708L;
-            buf.writeLong(value);
-            assertEquals(value, buf.getLong(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfLongMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            long value = 0x0102030405060708L;
-            buf.writeLong(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(0x1002030405060708L, buf.getLong(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfLongMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            long value = 0x0102030405060708L;
-            buf.writeLong(value);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getLong(1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfLongReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            long value = 0x0102030405060708L;
-            buf.writeLong(value);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getLong(1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfLongMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getLong(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfLongMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getLong(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfLongReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getLong(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfLongReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getLong(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfLongMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            long value = 0x0102030405060708L;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setLong(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfLongMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            long value = 0x0102030405060708L;
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setLong(1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfLongMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            long value = 0x0102030405060708L;
-            buf.setLong(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x02, buf.readByte());
-            assertEquals((byte) 0x03, buf.readByte());
-            assertEquals((byte) 0x04, buf.readByte());
-            assertEquals((byte) 0x05, buf.readByte());
-            assertEquals((byte) 0x06, buf.readByte());
-            assertEquals((byte) 0x07, buf.readByte());
-            assertEquals((byte) 0x08, buf.readByte());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfDoubleMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getDouble(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfDoubleReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getDouble(-1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfDoubleMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            double value = Double.longBitsToDouble(0x0102030405060708L);
-            buf.writeDouble(value);
-            assertEquals(value, buf.getDouble(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfDoubleMustReadWithDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            double value = Double.longBitsToDouble(0x0102030405060708L);
-            buf.writeDouble(value);
-            buf.setByte(0, (byte) 0x10);
-            assertEquals(Double.longBitsToDouble(0x1002030405060708L), buf.getDouble(0));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfDoubleMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            double value = Double.longBitsToDouble(0x0102030405060708L);
-            buf.writeDouble(value);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getDouble(1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfDoubleReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            double value = Double.longBitsToDouble(0x0102030405060708L);
-            buf.writeDouble(value);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getDouble(1));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfDoubleMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.getDouble(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfDoubleMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.getDouble(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfDoubleReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.readOnly(true).getDouble(0);
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedGetOfDoubleReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getDouble(8));
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfDoubleMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            double value = Double.longBitsToDouble(0x0102030405060708L);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setDouble(-1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfDoubleMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            assertEquals(Long.BYTES, buf.capacity());
-            double value = Double.longBitsToDouble(0x0102030405060708L);
-            assertThrows(IndexOutOfBoundsException.class, () -> buf.setDouble(1, value));
-            buf.writerOffset(Long.BYTES);
-            // Verify contents are unchanged.
-            assertEquals(0, buf.readLong());
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("allocators")
-    void offsettedSetOfDoubleMustHaveDefaultEndianByteOrder(Fixture fixture) {
-        try (BufferAllocator allocator = fixture.createAllocator();
-             Buffer buf = allocator.allocate(8)) {
-            buf.order(BIG_ENDIAN);
-            double value = Double.longBitsToDouble(0x0102030405060708L);
-            buf.setDouble(0, value);
-            buf.writerOffset(Long.BYTES);
-            assertEquals((byte) 0x01, buf.readByte());
-            assertEquals((byte) 0x02, buf.readByte());
-            assertEquals((byte) 0x03, buf.readByte());
-            assertEquals((byte) 0x04, buf.readByte());
-            assertEquals((byte) 0x05, buf.readByte());
-            assertEquals((byte) 0x06, buf.readByte());
-            assertEquals((byte) 0x07, buf.readByte());
-            assertEquals((byte) 0x08, buf.readByte());
-        }
-    }
-}
diff --git a/src/test/java/io/netty/buffer/api/BufferShortOffsettedAccessorsTest.java b/src/test/java/io/netty/buffer/api/BufferShortOffsettedAccessorsTest.java
new file mode 100644
index 0000000..7b6c691
--- /dev/null
+++ b/src/test/java/io/netty/buffer/api/BufferShortOffsettedAccessorsTest.java
@@ -0,0 +1,358 @@
+/*
+ * Copyright 2021 The Netty Project
+ *
+ * The Netty Project licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package io.netty.buffer.api;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BufferShortOffsettedAccessorsTest extends BufferTestSupport {
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getShort(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getShort(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            short value = 0x0102;
+            buf.writeShort(value);
+            assertEquals(value, buf.getShort(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            short value = 0x0102;
+            buf.writeShort(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(0x1002, buf.getShort(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            short value = 0x0102;
+            buf.writeShort(value);
+            buf.getShort(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getShort(7));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            short value = 0x0102;
+            buf.writeShort(value);
+            buf.readOnly(true).getShort(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getShort(7));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getShort(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getShort(7));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getShort(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfShortReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getShort(7));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedShort(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortReadOnlyMustBoundsCheckOnNegativeOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedShort(-1));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x0102;
+            buf.writeUnsignedShort(value);
+            assertEquals(value, buf.getUnsignedShort(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortMustReadWithDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            int value = 0x0102;
+            buf.writeUnsignedShort(value);
+            buf.setByte(0, (byte) 0x10);
+            assertEquals(0x1002, buf.getUnsignedShort(0));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x0102;
+            buf.writeUnsignedShort(value);
+            buf.getUnsignedShort(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedShort(7));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortReadOnlyMustNotBoundsCheckWhenReadOffsetAndSizeIsGreaterThanWriteOffset(
+            Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            int value = 0x0102;
+            buf.writeUnsignedShort(value);
+            buf.readOnly(true).getUnsignedShort(1);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsGreaterThanCapacity(
+            Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedShort(7));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.getUnsignedShort(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.getUnsignedShort(7));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortReadOnlyMustNotBoundsCheckWhenReadOffsetIsGreaterThanWriteOffset(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.readOnly(true).getUnsignedShort(0);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedGetOfUnsignedShortReadOnlyMustBoundsCheckWhenReadOffsetIsGreaterThanCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).getUnsignedShort(7));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfShortMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            short value = 0x0102;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setShort(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfShortMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            short value = 0x0102;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setShort(7, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfShortMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            short value = 0x0102;
+            buf.setShort(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x02, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedShortMustBoundsCheckWhenWriteOffsetIsNegative(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            int value = 0x0102;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedShort(-1, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedShortMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            assertEquals(Long.BYTES, buf.capacity());
+            int value = 0x0102;
+            assertThrows(IndexOutOfBoundsException.class, () -> buf.setUnsignedShort(7, value));
+            buf.writerOffset(Long.BYTES);
+            // Verify contents are unchanged.
+            assertEquals(0, buf.readLong());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    void offsettedSetOfUnsignedShortMustHaveDefaultEndianByteOrder(Fixture fixture) {
+        try (BufferAllocator allocator = fixture.createAllocator();
+             Buffer buf = allocator.allocate(8)) {
+            buf.order(BIG_ENDIAN);
+            int value = 0x0102;
+            buf.setUnsignedShort(0, value);
+            buf.writerOffset(Long.BYTES);
+            assertEquals((byte) 0x01, buf.readByte());
+            assertEquals((byte) 0x02, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+            assertEquals((byte) 0x00, buf.readByte());
+        }
+    }
+}
diff --git a/src/test/java/io/netty/buffer/api/BufferWriteBytesCombinationsTest.java b/src/test/java/io/netty/buffer/api/BufferWriteBytesCombinationsTest.java
new file mode 100644
index 0000000..0d10e96
--- /dev/null
+++ b/src/test/java/io/netty/buffer/api/BufferWriteBytesCombinationsTest.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2021 The Netty Project
+ *
+ * The Netty Project licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package io.netty.buffer.api;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.Arrays;
+
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import static java.nio.ByteOrder.LITTLE_ENDIAN;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BufferWriteBytesCombinationsTest extends BufferTestSupport {
+    private static final Memoize<Fixture[]> OTHER_FIXTURES = new Memoize<Fixture[]>(
+            () -> Arrays.stream(allocators()).filter(filterOfTheDay(10)).toArray(Fixture[]::new));
+
+    @ParameterizedTest
+    @MethodSource("allocators")
+    public void writeBytesMustTransferDataAndUpdateOffsets(Fixture fixture) {
+        try (BufferAllocator alloc1 = fixture.createAllocator()) {
+            // Only test 10% of available combinations. Otherwise, this takes too long.
+            Fixture[] allocators = OTHER_FIXTURES.get();
+            Arrays.stream(allocators).parallel().forEach(otherFixture -> {
+                try (BufferAllocator alloc2 = otherFixture.createAllocator();
+                     Buffer target = alloc1.allocate(37);
+                     Buffer source = alloc2.allocate(35)) {
+                    // BE to BE
+                    target.order(BIG_ENDIAN);
+                    source.order(BIG_ENDIAN);
+                    verifyWriteBytes(target, source);
+
+                    // LE to BE
+                    target.fill((byte) 0).reset().order(BIG_ENDIAN);
+                    source.fill((byte) 0).reset().order(LITTLE_ENDIAN);
+                    verifyWriteBytes(target, source);
+
+                    // BE to LE
+                    target.fill((byte) 0).reset().order(LITTLE_ENDIAN);
+                    source.fill((byte) 0).reset().order(BIG_ENDIAN);
+                    verifyWriteBytes(target, source);
+
+                    // LE to LE
+                    target.fill((byte) 0).reset().order(LITTLE_ENDIAN);
+                    source.fill((byte) 0).reset().order(BIG_ENDIAN);
+                    verifyWriteBytes(target, source);
+                } catch (Exception e) {
+                    e.addSuppressed(new RuntimeException("other fixture was: " + otherFixture));
+                    throw e;
+                }
+            });
+        }
+    }
+
+    private static void verifyWriteBytes(Buffer target, Buffer source) {
+        for (int i = 0; i < 35; i++) {
+            source.writeByte((byte) (i + 1));
+        }
+        target.writeBytes(source);
+        assertThat(target.readerOffset()).isZero();
+        assertThat(target.writerOffset()).isEqualTo(35);
+        assertThat(source.readerOffset()).isEqualTo(35);
+        assertThat(source.writerOffset()).isEqualTo(35);
+        try (Buffer readableSlice = target.slice()) {
+            assertEquals(source, readableSlice);
+        }
+    }
+}