andreacavalli/netty-incubator-buffer-api
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Align the remaining exception expectations and fix MemSegBuffer and CompositeBuffer to throw the correct exceptions

Browse Source
This commit is contained in:
Chris Vest 2021-06-01 12:04:57 +02:00
parent 289c9ebba1
commit d0d929bc55
4 changed files with 41 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
buffer-api/src/main/java/io/netty/buffer/api/CompositeBuffer.java
View File

@ -808,8 +808,11 @@ public final class CompositeBuffer extends ResourceSupport<Buffer, CompositeBuff
public void extendWith(Send<Buffer> extension) { public void extendWith(Send<Buffer> extension) {
Objects.requireNonNull(extension, "Extension buffer cannot be null."); Objects.requireNonNull(extension, "Extension buffer cannot be null.");
Buffer buffer = extension.receive(); Buffer buffer = extension.receive();
if (!isOwned()) { if (!isAccessible() || !isOwned()) {
buffer.close(); buffer.close();
if (!isAccessible()) {
throw bufferIsClosed(this);
}
throw new IllegalStateException("This buffer cannot be extended because it is not in an owned state."); throw new IllegalStateException("This buffer cannot be extended because it is not in an owned state.");
} }
if (bufs.length > 0 && buffer.order() != order()) { if (bufs.length > 0 && buffer.order() != order()) {

6
buffer-memseg/src/main/java/io/netty/buffer/api/memseg/MemSegBuffer.java
View File

@ -214,6 +214,9 @@ class MemSegBuffer extends ResourceSupport<Buffer, MemSegBuffer> implements Buff
@Override @Override
public Buffer fill(byte value) { public Buffer fill(byte value) {
if (!isAccessible()) {
throw bufferIsClosed(this);
}
checkSet(0, capacity()); checkSet(0, capacity());
seg.fill(value); seg.fill(value);
return this; return this;
@ -288,6 +291,9 @@ class MemSegBuffer extends ResourceSupport<Buffer, MemSegBuffer> implements Buff
@Override @Override
public long nativeAddress() { public long nativeAddress() {
if (!isAccessible()) {
throw bufferIsClosed(this);
}
if (seg.isNative()) { if (seg.isNative()) {
return seg.address().toRawLongValue(); return seg.address().toRawLongValue();
} }

7
buffer-tests/src/test/java/io/netty/buffer/api/tests/BufferCompositionTest.java
View File

@ -17,6 +17,7 @@ package io.netty.buffer.api.tests;
import io.netty.buffer.api.Buffer; import io.netty.buffer.api.Buffer;
import io.netty.buffer.api.BufferAllocator; import io.netty.buffer.api.BufferAllocator;
import io.netty.buffer.api.BufferClosedException;
import io.netty.buffer.api.BufferReadOnlyException; import io.netty.buffer.api.BufferReadOnlyException;
import io.netty.buffer.api.CompositeBuffer; import io.netty.buffer.api.CompositeBuffer;
import io.netty.buffer.api.Send; import io.netty.buffer.api.Send;
@ -69,7 +70,7 @@ public class BufferCompositionTest extends BufferTestSupport {
CompositeBuffer bufA = CompositeBuffer.compose(allocator, allocator.allocate(4).send()); CompositeBuffer bufA = CompositeBuffer.compose(allocator, allocator.allocate(4).send());
Send<Buffer> sendA = bufA.send(); Send<Buffer> sendA = bufA.send();
try { try {
assertThrows(IllegalStateException.class, () -> bufA.extendWith(sendA)); assertThrows(BufferClosedException.class, () -> bufA.extendWith(sendA));
} finally { } finally {
sendA.discard(); sendA.discard();
} }
@ -151,9 +152,7 @@ public class BufferCompositionTest extends BufferTestSupport {
composite = CompositeBuffer.compose(allocator, a.send()); composite = CompositeBuffer.compose(allocator, a.send());
} }
try (composite) { try (composite) {
var exc = assertThrows(IllegalStateException.class, assertThrows(BufferClosedException.class, () -> composite.extendWith(composite.send()));
() -> composite.extendWith(composite.send()));
assertThat(exc).hasMessageContaining("cannot be extended");
} }
} }
} }

58
buffer-tests/src/test/java/io/netty/buffer/api/tests/BufferTestSupport.java
View File

@ -332,15 +332,14 @@ public abstract class BufferTestSupport {
assertThrows(BufferClosedException.class, () -> buf.copyInto(0, new byte[1], 0, 1)); assertThrows(BufferClosedException.class, () -> buf.copyInto(0, new byte[1], 0, 1));
assertThrows(BufferClosedException.class, () -> buf.copyInto(0, ByteBuffer.allocate(1), 0, 1)); assertThrows(BufferClosedException.class, () -> buf.copyInto(0, ByteBuffer.allocate(1), 0, 1));
if (CompositeBuffer.isComposite(buf)) { if (CompositeBuffer.isComposite(buf)) {
assertThrows(IllegalStateException.class, () -> ((CompositeBuffer) buf).extendWith(target.send())); assertThrows(BufferClosedException.class, () -> ((CompositeBuffer) buf).extendWith(target.send()));
} }
} }
assertThrows(BufferClosedException.class, () -> buf.split()); assertThrows(BufferClosedException.class, () -> buf.split());
assertThrows(BufferClosedException.class, () -> buf.send()); assertThrows(BufferClosedException.class, () -> buf.send());
assertThrows(UnsupportedOperationException.class, () -> acquire((ResourceSupport<?, ?>) buf)); assertThrows(BufferClosedException.class, () -> acquire((ResourceSupport<?, ?>) buf));
final RuntimeException c1e = assertThrows(RuntimeException.class, () -> buf.copy()); assertThrows(BufferClosedException.class, () -> buf.copy());
assertTrue(c1e instanceof UnsupportedOperationException || c1e instanceof IllegalStateException);
assertThrows(BufferClosedException.class, () -> buf.openCursor()); assertThrows(BufferClosedException.class, () -> buf.openCursor());
assertThrows(BufferClosedException.class, () -> buf.openCursor(0, 0)); assertThrows(BufferClosedException.class, () -> buf.openCursor(0, 0));
assertThrows(BufferClosedException.class, () -> buf.openReverseCursor()); assertThrows(BufferClosedException.class, () -> buf.openReverseCursor());
@ -348,31 +347,31 @@ public abstract class BufferTestSupport {
} }
public static void verifyReadInaccessible(Buffer buf) { public static void verifyReadInaccessible(Buffer buf) {
assertThrows(UnsupportedOperationException.class, () -> buf.readByte()); assertThrows(BufferClosedException.class, () -> buf.readByte());
assertThrows(UnsupportedOperationException.class, () -> buf.readUnsignedByte()); assertThrows(BufferClosedException.class, () -> buf.readUnsignedByte());
assertThrows(UnsupportedOperationException.class, () -> buf.readChar()); assertThrows(BufferClosedException.class, () -> buf.readChar());
assertThrows(UnsupportedOperationException.class, () -> buf.readShort()); assertThrows(BufferClosedException.class, () -> buf.readShort());
assertThrows(UnsupportedOperationException.class, () -> buf.readUnsignedShort()); assertThrows(BufferClosedException.class, () -> buf.readUnsignedShort());
assertThrows(UnsupportedOperationException.class, () -> buf.readMedium()); assertThrows(BufferClosedException.class, () -> buf.readMedium());
assertThrows(UnsupportedOperationException.class, () -> buf.readUnsignedMedium()); assertThrows(BufferClosedException.class, () -> buf.readUnsignedMedium());
assertThrows(UnsupportedOperationException.class, () -> buf.readInt()); assertThrows(BufferClosedException.class, () -> buf.readInt());
assertThrows(UnsupportedOperationException.class, () -> buf.readUnsignedInt()); assertThrows(BufferClosedException.class, () -> buf.readUnsignedInt());
assertThrows(UnsupportedOperationException.class, () -> buf.readFloat()); assertThrows(BufferClosedException.class, () -> buf.readFloat());
assertThrows(UnsupportedOperationException.class, () -> buf.readLong()); assertThrows(BufferClosedException.class, () -> buf.readLong());
assertThrows(UnsupportedOperationException.class, () -> buf.readDouble()); assertThrows(BufferClosedException.class, () -> buf.readDouble());
assertThrows(UnsupportedOperationException.class, () -> buf.getByte(0)); assertThrows(BufferClosedException.class, () -> buf.getByte(0));
assertThrows(UnsupportedOperationException.class, () -> buf.getUnsignedByte(0)); assertThrows(BufferClosedException.class, () -> buf.getUnsignedByte(0));
assertThrows(UnsupportedOperationException.class, () -> buf.getChar(0)); assertThrows(BufferClosedException.class, () -> buf.getChar(0));
assertThrows(UnsupportedOperationException.class, () -> buf.getShort(0)); assertThrows(BufferClosedException.class, () -> buf.getShort(0));
assertThrows(UnsupportedOperationException.class, () -> buf.getUnsignedShort(0)); assertThrows(BufferClosedException.class, () -> buf.getUnsignedShort(0));
assertThrows(UnsupportedOperationException.class, () -> buf.getMedium(0)); assertThrows(BufferClosedException.class, () -> buf.getMedium(0));
assertThrows(UnsupportedOperationException.class, () -> buf.getUnsignedMedium(0)); assertThrows(BufferClosedException.class, () -> buf.getUnsignedMedium(0));
assertThrows(UnsupportedOperationException.class, () -> buf.getInt(0)); assertThrows(BufferClosedException.class, () -> buf.getInt(0));
assertThrows(UnsupportedOperationException.class, () -> buf.getUnsignedInt(0)); assertThrows(BufferClosedException.class, () -> buf.getUnsignedInt(0));
assertThrows(UnsupportedOperationException.class, () -> buf.getFloat(0)); assertThrows(BufferClosedException.class, () -> buf.getFloat(0));
assertThrows(UnsupportedOperationException.class, () -> buf.getLong(0)); assertThrows(BufferClosedException.class, () -> buf.getLong(0));
assertThrows(UnsupportedOperationException.class, () -> buf.getDouble(0)); assertThrows(BufferClosedException.class, () -> buf.getDouble(0));
} }
public static void verifyWriteInaccessible(Buffer buf, Class<? extends RuntimeException> expected) { public static void verifyWriteInaccessible(Buffer buf, Class<? extends RuntimeException> expected) {
@ -403,8 +402,7 @@ public abstract class BufferTestSupport {
assertThrows(expected, () -> buf.setDouble(0, 32)); assertThrows(expected, () -> buf.setDouble(0, 32));
assertThrows(expected, () -> buf.ensureWritable(1)); assertThrows(expected, () -> buf.ensureWritable(1));
final RuntimeException f1e = assertThrows(RuntimeException.class, () -> buf.fill((byte) 0)); assertThrows(expected, () -> buf.fill((byte) 0));
assertTrue(f1e instanceof IllegalStateException || f1e instanceof UnsupportedOperationException);
try (BufferAllocator allocator = BufferAllocator.heap(); try (BufferAllocator allocator = BufferAllocator.heap();
Buffer source = allocator.allocate(8)) { Buffer source = allocator.allocate(8)) {
assertThrows(expected, () -> source.copyInto(0, buf, 0, 1)); assertThrows(expected, () -> source.copyInto(0, buf, 0, 1));