fdc59cc43c
Then run those tests in independent surefire forks. This should allow Maven to hold on to less test metadata, and cope better with the large number of tests.
1245 lines
52 KiB
Java
1245 lines
52 KiB
Java
/*
|
|
* 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 BufferPrimitiveRelativeAccessorsTest extends BufferTestSupport {
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfByteMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
byte value = 0x01;
|
|
buf.writeByte(value);
|
|
assertEquals(1, buf.readableBytes());
|
|
assertEquals(7, buf.writableBytes());
|
|
assertEquals(value, buf.readByte());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfByteMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
byte value = 0x01;
|
|
buf.writeByte(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(1, buf.readableBytes());
|
|
assertEquals(7, buf.writableBytes());
|
|
assertEquals(0x10, buf.readByte());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfByteMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
byte value = 0x01;
|
|
buf.writeByte(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(7, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, buf::readByte);
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedByteMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x01;
|
|
buf.writeUnsignedByte(value);
|
|
assertEquals(1, buf.readableBytes());
|
|
assertEquals(7, buf.writableBytes());
|
|
assertEquals(value, buf.readUnsignedByte());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedByteMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x01;
|
|
buf.writeUnsignedByte(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(1, buf.readableBytes());
|
|
assertEquals(7, buf.writableBytes());
|
|
assertEquals(0x10, buf.readUnsignedByte());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedByteMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x01;
|
|
buf.writeUnsignedByte(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(7, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readUnsignedByte());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedByteReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x01;
|
|
buf.writeUnsignedByte(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(7, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).readUnsignedByte());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfByteMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(8);
|
|
byte value = 0x01;
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeByte(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfByteMustHaveDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
byte value = 0x01;
|
|
buf.writeByte(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 relativeWriteOfUnsignedByteMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(8);
|
|
int value = 0x01;
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeUnsignedByte(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfUnsignedByteMustHaveDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
int value = 0x01;
|
|
buf.writeUnsignedByte(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 relativeReadOfCharMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
char value = 0x0102;
|
|
buf.writeChar(value);
|
|
assertEquals(2, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertEquals(value, buf.readChar());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfCharMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
char value = 0x0102;
|
|
buf.writeChar(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(2, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertEquals(0x1002, buf.readChar());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfCharMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
char value = 0x0102;
|
|
buf.writeChar(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(1, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, buf::readChar);
|
|
assertEquals(1, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfCharReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
char value = 0x0102;
|
|
buf.writeChar(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(1, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).readChar());
|
|
assertEquals(1, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfCharMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(7);
|
|
char value = 0x0102;
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeChar(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfCharMustHaveDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
char value = 0x0102;
|
|
buf.writeChar(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 relativeReadOfShortMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
short value = 0x0102;
|
|
buf.writeShort(value);
|
|
assertEquals(2, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertEquals(value, buf.readShort());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfShortMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
short value = 0x0102;
|
|
buf.writeShort(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(2, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertEquals(0x1002, buf.readShort());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfShortMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
short value = 0x0102;
|
|
buf.writeShort(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(1, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, buf::readShort);
|
|
assertEquals(1, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfShortReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
short value = 0x0102;
|
|
buf.writeShort(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(1, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).readShort());
|
|
assertEquals(1, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedShortMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x0102;
|
|
buf.writeUnsignedShort(value);
|
|
assertEquals(2, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertEquals(value, buf.readUnsignedShort());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedShortMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x0102;
|
|
buf.writeUnsignedShort(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(2, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertEquals(0x1002, buf.readUnsignedShort());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedShortMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x0102;
|
|
buf.writeUnsignedShort(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(1, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, buf::readUnsignedShort);
|
|
assertEquals(1, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedShortReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x0102;
|
|
buf.writeUnsignedShort(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(1, buf.readableBytes());
|
|
assertEquals(6, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).readUnsignedShort());
|
|
assertEquals(1, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfShortMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(7);
|
|
short value = 0x0102;
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeShort(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfShortMustHaveDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
short value = 0x0102;
|
|
buf.writeShort(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 relativeWriteOfUnsignedShortMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(7);
|
|
int value = 0x0102;
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeUnsignedShort(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfUnsignedShortMustHaveDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
int value = 0x0102;
|
|
buf.writeUnsignedShort(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 relativeReadOfMediumMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x010203;
|
|
buf.writeMedium(value);
|
|
assertEquals(3, buf.readableBytes());
|
|
assertEquals(5, buf.writableBytes());
|
|
assertEquals(value, buf.readMedium());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfMediumMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x010203;
|
|
buf.writeMedium(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(3, buf.readableBytes());
|
|
assertEquals(5, buf.writableBytes());
|
|
assertEquals(0x100203, buf.readMedium());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfMediumMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x010203;
|
|
buf.writeMedium(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(2, buf.readableBytes());
|
|
assertEquals(5, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, buf::readMedium);
|
|
assertEquals(2, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfMediumReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x010203;
|
|
buf.writeMedium(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(2, buf.readableBytes());
|
|
assertEquals(5, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).readMedium());
|
|
assertEquals(2, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedMediumMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x010203;
|
|
buf.writeUnsignedMedium(value);
|
|
assertEquals(3, buf.readableBytes());
|
|
assertEquals(5, buf.writableBytes());
|
|
assertEquals(value, buf.readUnsignedMedium());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedMediumMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x010203;
|
|
buf.writeUnsignedMedium(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(3, buf.readableBytes());
|
|
assertEquals(5, buf.writableBytes());
|
|
assertEquals(0x100203, buf.readUnsignedMedium());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedMediumMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x010203;
|
|
buf.writeUnsignedMedium(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(2, buf.readableBytes());
|
|
assertEquals(5, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, buf::readUnsignedMedium);
|
|
assertEquals(2, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedMediumReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x010203;
|
|
buf.writeUnsignedMedium(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(2, buf.readableBytes());
|
|
assertEquals(5, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).readUnsignedMedium());
|
|
assertEquals(2, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfMediumMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(6);
|
|
int value = 0x010203;
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeMedium(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfMediumMustHaveDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
int value = 0x010203;
|
|
buf.writeMedium(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 relativeWriteOfUnsignedMediumMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(6);
|
|
int value = 0x010203;
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeUnsignedMedium(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfUnsignedMediumMustHaveDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
int value = 0x010203;
|
|
buf.writeUnsignedMedium(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 relativeReadOfIntMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x01020304;
|
|
buf.writeInt(value);
|
|
assertEquals(4, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertEquals(value, buf.readInt());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfIntMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x01020304;
|
|
buf.writeInt(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(4, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertEquals(0x10020304, buf.readInt());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfIntMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x01020304;
|
|
buf.writeInt(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(3, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, buf::readInt);
|
|
assertEquals(3, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfIntReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
int value = 0x01020304;
|
|
buf.writeInt(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(3, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).readInt());
|
|
assertEquals(3, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedIntMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
long value = 0x01020304;
|
|
buf.writeUnsignedInt(value);
|
|
assertEquals(4, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertEquals(value, buf.readUnsignedInt());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedIntMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
long value = 0x01020304;
|
|
buf.writeUnsignedInt(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(4, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertEquals(0x10020304, buf.readUnsignedInt());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedIntMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
long value = 0x01020304;
|
|
buf.writeUnsignedInt(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(3, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, buf::readUnsignedInt);
|
|
assertEquals(3, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfUnsignedIntReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
long value = 0x01020304;
|
|
buf.writeUnsignedInt(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(3, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).readUnsignedInt());
|
|
assertEquals(3, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfIntMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(5);
|
|
int value = 0x01020304;
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeInt(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfIntMustHaveDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
int value = 0x01020304;
|
|
buf.writeInt(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 relativeWriteOfUnsignedIntMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(5);
|
|
long value = 0x01020304;
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeUnsignedInt(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfUnsignedIntMustHaveDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
long value = 0x01020304;
|
|
buf.writeUnsignedInt(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 relativeReadOfFloatMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
float value = Float.intBitsToFloat(0x01020304);
|
|
buf.writeFloat(value);
|
|
assertEquals(4, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertEquals(value, buf.readFloat());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfFloatMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
float value = Float.intBitsToFloat(0x01020304);
|
|
buf.writeFloat(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(4, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertEquals(Float.intBitsToFloat(0x10020304), buf.readFloat());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfFloatMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
float value = Float.intBitsToFloat(0x01020304);
|
|
buf.writeFloat(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(3, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, buf::readFloat);
|
|
assertEquals(3, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfFloatReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
float value = Float.intBitsToFloat(0x01020304);
|
|
buf.writeFloat(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(3, buf.readableBytes());
|
|
assertEquals(4, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).readFloat());
|
|
assertEquals(3, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfFloatMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(5);
|
|
float value = Float.intBitsToFloat(0x01020304);
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeFloat(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfFloatMustHaveDefaultEndianByteOrder(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.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 relativeReadOfLongMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
long value = 0x0102030405060708L;
|
|
buf.writeLong(value);
|
|
assertEquals(8, buf.readableBytes());
|
|
assertEquals(0, buf.writableBytes());
|
|
assertEquals(value, buf.readLong());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfLongMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
long value = 0x0102030405060708L;
|
|
buf.writeLong(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(8, buf.readableBytes());
|
|
assertEquals(0, buf.writableBytes());
|
|
assertEquals(0x1002030405060708L, buf.readLong());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfLongMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
long value = 0x0102030405060708L;
|
|
buf.writeLong(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(7, buf.readableBytes());
|
|
assertEquals(0, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, buf::readLong);
|
|
assertEquals(7, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfLongReadOnlyMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
long value = 0x0102030405060708L;
|
|
buf.writeLong(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(7, buf.readableBytes());
|
|
assertEquals(0, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).readLong());
|
|
assertEquals(7, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfLongMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(1);
|
|
long value = 0x0102030405060708L;
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeLong(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfLongMustHaveDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
long value = 0x0102030405060708L;
|
|
buf.writeLong(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 relativeReadOfDoubleMustNotBoundsCheckWhenReadOffsetAndSizeIsEqualToWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
double value = Double.longBitsToDouble(0x0102030405060708L);
|
|
buf.writeDouble(value);
|
|
assertEquals(8, buf.readableBytes());
|
|
assertEquals(0, buf.writableBytes());
|
|
assertEquals(value, buf.readDouble());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfDoubleMustReadWithDefaultEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
buf.order(BIG_ENDIAN);
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
double value = Double.longBitsToDouble(0x0102030405060708L);
|
|
buf.writeDouble(value);
|
|
buf.setByte(0, (byte) 0x10);
|
|
assertEquals(8, buf.readableBytes());
|
|
assertEquals(0, buf.writableBytes());
|
|
assertEquals(Double.longBitsToDouble(0x1002030405060708L), buf.readDouble());
|
|
assertEquals(0, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfDoubleMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
double value = Double.longBitsToDouble(0x0102030405060708L);
|
|
buf.writeDouble(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(7, buf.readableBytes());
|
|
assertEquals(0, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, buf::readDouble);
|
|
assertEquals(7, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeReadOfDoubleReadOnllyMustBoundsCheckWhenReadOffsetAndSizeIsBeyondWriteOffset(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(0, buf.readableBytes());
|
|
assertEquals(Long.BYTES, buf.writableBytes());
|
|
double value = Double.longBitsToDouble(0x0102030405060708L);
|
|
buf.writeDouble(value);
|
|
buf.readerOffset(1);
|
|
assertEquals(7, buf.readableBytes());
|
|
assertEquals(0, buf.writableBytes());
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.readOnly(true).readDouble());
|
|
assertEquals(7, buf.readableBytes());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfDoubleMustBoundsCheckWhenWriteOffsetAndSizeIsBeyondCapacity(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator();
|
|
Buffer buf = allocator.allocate(8)) {
|
|
assertEquals(Long.BYTES, buf.capacity());
|
|
buf.writerOffset(1);
|
|
double value = Double.longBitsToDouble(0x0102030405060708L);
|
|
assertThrows(IndexOutOfBoundsException.class, () -> buf.writeDouble(value));
|
|
buf.writerOffset(Long.BYTES);
|
|
// Verify contents are unchanged.
|
|
assertEquals(0, buf.readLong());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
void relativeWriteOfDoubleMustHaveDefaultEndianByteOrder(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.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());
|
|
}
|
|
}
|
|
}
|