765f8989ca
Motivation: In Netty 5 we wish to have a simpler, safe, future proof, and more consistent buffer API. We developed such an API in the incubating buffer repository, and taking it through multiple rounds of review and adjustments. This PR/commit bring the results of that work into the Netty 5 branch of the main Netty repository. Modifications: * `Buffer` is an interface, and all implementations are hidden behind it. There is no longer an inheritance hierarchy of abstract classes and implementations. * Reference counting is gone. After a buffer has been allocated, calling `close` on it will deallocate it. It is then up to users and integrators to ensure that the life-times of buffers are managed correctly. This is usually not a problem as buffers tend to flow through the pipeline to be released after a terminal IO operation. * Slice and duplicate methods are replaced with `split`. By removing slices, duplicate, and reference counting, there is no longer a possibility that a buffer and/or its memory can be shared and accessible through multiple routes. This solves the problem of data being accessed from multiple places in an uncoordinated way, and the problem of buffer memory being closed while being in use by some unsuspecting piece of code. Some adjustments will have to be made to other APIs, idioms, and usages, since `split` is not always a replacement for `slice` in some use cases. * The `split` has been added which allows memory to be shared among multiple buffers, but in non-overlapping regions. When the memory regions don't overlap, it will not be possible for the different buffers to interfere with each other. An internal, and completely transparent, reference counting system ensures that the backing memory is released once the last buffer view is closed. * A Send API has been introduced that can be used to enforce (in the type system) the transfer of buffer ownership. This is not expected to be used in the pipeline flow itself, but rather for other objects that wrap buffers and wish to avoid becoming "shared views" — the absence of "shared views" of memory is important for avoiding bugs in the absence of reference counting. * A new BufferAllocator API, where the choice of implementation determines factors like on-/off-heap, pooling or not. How access to the different allocators will be exposed to integrators will be decided later. Perhaps they'll be directly accessible on the `ChannelHandlerContext`. * The `PooledBufferAllocator` has been copied and modified to match the new allocator API. This includes unifying its implementation that was previously split across on-heap and off-heap. * The `PooledBufferAllocator` implementation has also been adjusted to allocate 4 MiB chunks by default, and a few changes have been made to the implementation to make a newly created, empty allocator use significantly less heap memory. * A `Resource` interface has been added, which defines the life-cycle methods and the `send` method. The `Buffer` interface extends this. * Analogues for `ByteBufHolder` has been added in the `BufferHolder` and `BufferRef` classes. * `ByteCursor` is added as a new way to iterate the data in buffers. The byte cursor API is designed to be more JIT friendly than an iterator, or the existing `ByteProcessor` interface. * `CompositeBuffer` no longer permit the same level of access to its internal components. The composite buffer enforces its ownership of its components via the `Send` API, and the components can only be individually accessed with the `forEachReadable` and `forEachWritable` methods. This keeps the API and behavioral differences between composite and non-composite buffers to a minimum. * Two implementations of the `Buffer` interface are provided with the API: One based on `ByteBuffer`, and one based on `sun.misc.Unsafe`. The `ByteBuffer` implementation is used by default. More implementations can be loaded from the classpath via service loading. The `MemorySegment` based implementation is left behind in the incubator repository. * An extensive and highly parameterised test suite has been added, to ensure that all implementations have consistent and correct behaviour, regardless of their configuration or composition. Result: We have a new buffer API that is simpler, better tested, more consistent in behaviour, and safer by design, than the existing `ByteBuf` API. The next legs of this journey will be about integrating this new API into Netty proper, and deprecate (and eventually remove) the `ByteBuf` API. This fixes #11024, #8601, #8543, #8542, #8534, #3358, and #3306.
567 lines
24 KiB
Java
567 lines
24 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.tests;
|
|
|
|
import io.netty.buffer.api.Buffer;
|
|
import io.netty.buffer.api.BufferAllocator;
|
|
import io.netty.buffer.api.BufferClosedException;
|
|
import io.netty.buffer.api.BufferReadOnlyException;
|
|
import io.netty.buffer.api.CompositeBuffer;
|
|
import io.netty.buffer.api.Send;
|
|
import io.netty.buffer.api.internal.ResourceSupport;
|
|
import org.junit.jupiter.api.Test;
|
|
import org.junit.jupiter.params.ParameterizedTest;
|
|
import org.junit.jupiter.params.provider.MethodSource;
|
|
|
|
import static io.netty.buffer.api.internal.Statics.acquire;
|
|
import static io.netty.buffer.api.internal.Statics.isOwned;
|
|
import static org.assertj.core.api.Assertions.assertThat;
|
|
import static org.junit.jupiter.api.Assertions.assertThrows;
|
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
|
|
|
public class BufferCompositionTest extends BufferTestSupport {
|
|
@Test
|
|
public void compositeBuffersCannotHaveDuplicateComponents() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
Send<Buffer> a = allocator.allocate(4).send();
|
|
var e = assertThrows(IllegalStateException.class, () -> CompositeBuffer.compose(allocator, a, a));
|
|
assertThat(e).hasMessageContaining("already been received");
|
|
|
|
Send<Buffer> b = allocator.allocate(4).send();
|
|
try (CompositeBuffer composite = CompositeBuffer.compose(allocator, b)) {
|
|
e = assertThrows(IllegalStateException.class, () -> composite.extendWith(b));
|
|
assertThat(e).hasMessageContaining("already been received");
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void compositeBufferFromSends() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
Buffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
assertEquals(24, composite.capacity());
|
|
assertTrue(isOwned((ResourceSupport<?, ?>) composite));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void compositeBufferMustNotBeAllowedToContainThemselves() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
CompositeBuffer bufA = CompositeBuffer.compose(allocator, allocator.allocate(4).send());
|
|
Send<Buffer> sendA = bufA.send();
|
|
try {
|
|
assertThrows(BufferClosedException.class, () -> bufA.extendWith(sendA));
|
|
} finally {
|
|
sendA.close();
|
|
}
|
|
|
|
CompositeBuffer bufB = CompositeBuffer.compose(allocator, allocator.allocate(4).send());
|
|
Send<Buffer> sendB = bufB.send();
|
|
try (CompositeBuffer compositeBuffer = CompositeBuffer.compose(allocator, sendB)) {
|
|
assertThrows(IllegalStateException.class, () -> compositeBuffer.extendWith(sendB));
|
|
} finally {
|
|
sendB.close();
|
|
}
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("allocators")
|
|
public void ensureWritableOnCompositeBuffersMustRespectExistingBigEndianByteOrder(Fixture fixture) {
|
|
try (BufferAllocator allocator = fixture.createAllocator()) {
|
|
Buffer composite;
|
|
try (Buffer a = allocator.allocate(4)) {
|
|
composite = CompositeBuffer.compose(allocator, a.send());
|
|
}
|
|
try (composite) {
|
|
composite.writeInt(0x01020304);
|
|
composite.ensureWritable(4);
|
|
composite.writeInt(0x05060708);
|
|
assertEquals(0x0102030405060708L, composite.readLong());
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void extendOnNonCompositeBufferMustThrow() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
Buffer a = allocator.allocate(8);
|
|
Buffer b = allocator.allocate(8)) {
|
|
assertThrows(ClassCastException.class, () -> ((CompositeBuffer) a).extendWith(b.send()));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void extendingNonOwnedCompositeBufferMustThrow() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
Buffer a = allocator.allocate(8);
|
|
Buffer b = allocator.allocate(8);
|
|
CompositeBuffer composed = CompositeBuffer.compose(allocator, a.send())) {
|
|
try (Buffer ignore = acquire(composed)) {
|
|
var exc = assertThrows(IllegalStateException.class, () -> composed.extendWith(b.send()));
|
|
assertThat(exc).hasMessageContaining("owned");
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void extendingCompositeBufferWithItselfMustThrow() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
CompositeBuffer composite;
|
|
try (Buffer a = allocator.allocate(8)) {
|
|
composite = CompositeBuffer.compose(allocator, a.send());
|
|
}
|
|
try (composite) {
|
|
assertThrows(BufferClosedException.class, () -> composite.extendWith(composite.send()));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void extendingWithZeroCapacityBufferHasNoEffect() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator)) {
|
|
composite.extendWith(CompositeBuffer.compose(allocator).send());
|
|
assertThat(composite.capacity()).isZero();
|
|
assertThat(composite.countComponents()).isZero();
|
|
}
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
Buffer a = allocator.allocate(1);
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator, a.send());
|
|
assertTrue(isOwned(composite));
|
|
assertThat(composite.capacity()).isOne();
|
|
assertThat(composite.countComponents()).isOne();
|
|
try (Buffer b = CompositeBuffer.compose(allocator)) {
|
|
composite.extendWith(b.send());
|
|
}
|
|
assertTrue(isOwned(composite));
|
|
assertThat(composite.capacity()).isOne();
|
|
assertThat(composite.countComponents()).isOne();
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void extendingCompositeBufferWithNullMustThrow() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator)) {
|
|
assertThrows(NullPointerException.class, () -> composite.extendWith(null));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void extendingCompositeBufferMustIncreaseCapacityByGivenBuffer() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator)) {
|
|
assertThat(composite.capacity()).isZero();
|
|
try (Buffer buf = allocator.allocate(8)) {
|
|
composite.extendWith(buf.send());
|
|
}
|
|
assertThat(composite.capacity()).isEqualTo(8);
|
|
composite.writeLong(0x0102030405060708L);
|
|
assertThat(composite.readLong()).isEqualTo(0x0102030405060708L);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void emptyCompositeBufferMustAllowExtendingWithBuffer() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
try (CompositeBuffer composite = CompositeBuffer.compose(allocator)) {
|
|
try (Buffer b = allocator.allocate(8)) {
|
|
composite.extendWith(b.send());
|
|
assertThat(composite.capacity()).isEqualTo(8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void emptyCompositeBufferMustAllowExtendingWithReadOnlyBuffer() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
try (CompositeBuffer composite = CompositeBuffer.compose(allocator)) {
|
|
try (Buffer b = allocator.allocate(8).makeReadOnly()) {
|
|
composite.extendWith(b.send());
|
|
assertTrue(composite.readOnly());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void whenExtendingCompositeBufferWithWriteOffsetAtCapacityExtensionWriteOffsetCanBeNonZero() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
CompositeBuffer composite;
|
|
try (Buffer a = allocator.allocate(8)) {
|
|
composite = CompositeBuffer.compose(allocator, a.send());
|
|
}
|
|
try (composite) {
|
|
composite.writeLong(0);
|
|
try (Buffer b = allocator.allocate(8)) {
|
|
b.writeInt(1);
|
|
composite.extendWith(b.send());
|
|
assertThat(composite.capacity()).isEqualTo(16);
|
|
assertThat(composite.writerOffset()).isEqualTo(12);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void whenExtendingCompositeBufferWithWriteOffsetLessThanCapacityExtensionWriteOffsetMustZero() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
CompositeBuffer composite;
|
|
try (Buffer a = allocator.allocate(8)) {
|
|
composite = CompositeBuffer.compose(allocator, a.send());
|
|
}
|
|
try (composite) {
|
|
composite.writeInt(0);
|
|
try (Buffer b = allocator.allocate(8)) {
|
|
b.writeInt(1);
|
|
var exc = assertThrows(IllegalArgumentException.class,
|
|
() -> composite.extendWith(b.send()));
|
|
assertThat(exc).hasMessageContaining("unwritten gap");
|
|
}
|
|
try (Buffer b = allocator.allocate(8)) {
|
|
b.setInt(0, 1);
|
|
composite.extendWith(b.send());
|
|
assertThat(composite.capacity()).isEqualTo(16);
|
|
assertThat(composite.writerOffset()).isEqualTo(4);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void whenExtendingCompositeBufferWithReadOffsetAtCapacityExtensionReadOffsetCanBeNonZero() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
CompositeBuffer composite;
|
|
try (Buffer a = allocator.allocate(8)) {
|
|
composite = CompositeBuffer.compose(allocator, a.send());
|
|
}
|
|
try (composite) {
|
|
composite.writeLong(0);
|
|
composite.readLong();
|
|
try (Buffer b = allocator.allocate(8)) {
|
|
b.writeInt(1);
|
|
b.readInt();
|
|
composite.extendWith(b.send());
|
|
assertThat(composite.capacity()).isEqualTo(16);
|
|
assertThat(composite.writerOffset()).isEqualTo(12);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void whenExtendingCompositeBufferWithReadOffsetLessThanCapacityExtensionReadOffsetMustZero() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator, allocator.allocate(8).send())) {
|
|
composite.writeLong(0);
|
|
composite.readInt();
|
|
|
|
Buffer b = allocator.allocate(8);
|
|
b.writeInt(1);
|
|
b.readInt();
|
|
var exc = assertThrows(IllegalArgumentException.class,
|
|
() -> composite.extendWith(b.send()));
|
|
assertThat(exc).hasMessageContaining("unread gap");
|
|
assertThat(composite.capacity()).isEqualTo(8);
|
|
assertThat(composite.writerOffset()).isEqualTo(8);
|
|
assertThat(composite.readerOffset()).isEqualTo(4);
|
|
|
|
composite.extendWith(allocator.allocate(8).writeInt(1).send());
|
|
assertThat(composite.capacity()).isEqualTo(16);
|
|
assertThat(composite.writerOffset()).isEqualTo(12);
|
|
assertThat(composite.readerOffset()).isEqualTo(4);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void composingReadOnlyBuffersMustCreateReadOnlyCompositeBuffer() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
Buffer a = allocator.allocate(4).makeReadOnly();
|
|
Buffer b = allocator.allocate(4).makeReadOnly();
|
|
Buffer composite = CompositeBuffer.compose(allocator, a.send(), b.send())) {
|
|
assertTrue(composite.readOnly());
|
|
verifyWriteInaccessible(composite, BufferReadOnlyException.class);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void composingReadOnlyAndWritableBuffersMustThrow() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
try (Buffer a = allocator.allocate(8).makeReadOnly();
|
|
Buffer b = allocator.allocate(8)) {
|
|
assertThrows(IllegalArgumentException.class,
|
|
() -> CompositeBuffer.compose(allocator, a.send(), b.send()));
|
|
}
|
|
try (Buffer a = allocator.allocate(8).makeReadOnly();
|
|
Buffer b = allocator.allocate(8)) {
|
|
assertThrows(IllegalArgumentException.class,
|
|
() -> CompositeBuffer.compose(allocator, b.send(), a.send()));
|
|
}
|
|
try (Buffer a = allocator.allocate(8).makeReadOnly();
|
|
Buffer b = allocator.allocate(8);
|
|
Buffer c = allocator.allocate(8).makeReadOnly()) {
|
|
assertThrows(IllegalArgumentException.class,
|
|
() -> CompositeBuffer.compose(allocator, a.send(), b.send(), c.send()));
|
|
}
|
|
try (Buffer a = allocator.allocate(8).makeReadOnly();
|
|
Buffer b = allocator.allocate(8);
|
|
Buffer c = allocator.allocate(8)) {
|
|
assertThrows(IllegalArgumentException.class,
|
|
() -> CompositeBuffer.compose(allocator, b.send(), a.send(), c.send()));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void compositeWritableBufferCannotBeExtendedWithReadOnlyBuffer() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
CompositeBuffer composite;
|
|
try (Buffer a = allocator.allocate(8)) {
|
|
composite = CompositeBuffer.compose(allocator, a.send());
|
|
}
|
|
try (composite; Buffer b = allocator.allocate(8).makeReadOnly()) {
|
|
assertThrows(IllegalArgumentException.class, () -> composite.extendWith(b.send()));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void compositeReadOnlyBufferCannotBeExtendedWithWritableBuffer() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
|
|
CompositeBuffer composite;
|
|
try (Buffer a = allocator.allocate(8).makeReadOnly()) {
|
|
composite = CompositeBuffer.compose(allocator, a.send());
|
|
}
|
|
try (composite; Buffer b = allocator.allocate(8)) {
|
|
assertThrows(IllegalArgumentException.class, () -> composite.extendWith(b.send()));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void splitComponentsFloorMustThrowOnOutOfBounds() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
assertThrows(IllegalArgumentException.class, () -> composite.splitComponentsFloor(-1));
|
|
assertThrows(IllegalArgumentException.class, () -> composite.splitComponentsFloor(17));
|
|
try (CompositeBuffer split = composite.splitComponentsFloor(16)) {
|
|
assertThat(split.capacity()).isEqualTo(16);
|
|
assertThat(composite.capacity()).isZero();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void splitComponentsCeilMustThrowOnOutOfBounds() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
assertThrows(IllegalArgumentException.class, () -> composite.splitComponentsCeil(-1));
|
|
assertThrows(IllegalArgumentException.class, () -> composite.splitComponentsCeil(17));
|
|
try (CompositeBuffer split = composite.splitComponentsCeil(16)) {
|
|
assertThat(split.capacity()).isEqualTo(16);
|
|
assertThat(composite.capacity()).isZero();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void splitComponentsFloorMustGiveEmptyBufferForOffsetInFirstComponent() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
try (CompositeBuffer split = composite.splitComponentsFloor(4)) {
|
|
assertTrue(isOwned(split));
|
|
assertTrue(split.isAccessible());
|
|
assertThat(split.capacity()).isZero();
|
|
|
|
assertTrue(isOwned(composite));
|
|
assertTrue(composite.isAccessible());
|
|
assertThat(composite.capacity()).isEqualTo(16);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void splitComponentsFloorMustGiveEmptyBufferForOffsetLastByteInFirstComponent() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
try (CompositeBuffer split = composite.splitComponentsFloor(7)) {
|
|
assertTrue(isOwned(split));
|
|
assertTrue(split.isAccessible());
|
|
assertThat(split.capacity()).isZero();
|
|
|
|
assertTrue(isOwned(composite));
|
|
assertTrue(composite.isAccessible());
|
|
assertThat(composite.capacity()).isEqualTo(16);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void splitComponentsFloorMustGiveBufferWithFirstComponentForOffsetInSecondComponent() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
try (CompositeBuffer split = composite.splitComponentsFloor(12)) {
|
|
assertTrue(isOwned(split));
|
|
assertTrue(split.isAccessible());
|
|
assertThat(split.capacity()).isEqualTo(8);
|
|
|
|
assertTrue(isOwned(composite));
|
|
assertTrue(composite.isAccessible());
|
|
assertThat(composite.capacity()).isEqualTo(8);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void splitComponentsFloorMustGiveBufferWithFirstComponentForOffsetOnFirstByteInSecondComponent() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
try (CompositeBuffer split = composite.splitComponentsFloor(8)) {
|
|
assertTrue(isOwned(split));
|
|
assertTrue(split.isAccessible());
|
|
assertThat(split.capacity()).isEqualTo(8);
|
|
|
|
assertTrue(isOwned(composite));
|
|
assertTrue(composite.isAccessible());
|
|
assertThat(composite.capacity()).isEqualTo(8);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void splitComponentsCeilMustGiveBufferWithFirstComponentForOffsetInFirstComponent() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
try (CompositeBuffer split = composite.splitComponentsCeil(4)) {
|
|
assertTrue(isOwned(split));
|
|
assertTrue(split.isAccessible());
|
|
assertThat(split.capacity()).isEqualTo(8);
|
|
|
|
assertTrue(isOwned(composite));
|
|
assertTrue(composite.isAccessible());
|
|
assertThat(composite.capacity()).isEqualTo(8);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void splitComponentsCeilMustGiveBufferWithFirstComponentFofOffsetOnLastByteInFirstComponent() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
try (CompositeBuffer split = composite.splitComponentsCeil(7)) {
|
|
assertTrue(isOwned(split));
|
|
assertTrue(split.isAccessible());
|
|
assertThat(split.capacity()).isEqualTo(8);
|
|
|
|
assertTrue(isOwned(composite));
|
|
assertTrue(composite.isAccessible());
|
|
assertThat(composite.capacity()).isEqualTo(8);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void splitComponentsCeilMustGiveBufferWithFirstAndSecondComponentForfOffsetInSecondComponent() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
try (CompositeBuffer split = composite.splitComponentsCeil(12)) {
|
|
assertTrue(isOwned(split));
|
|
assertTrue(split.isAccessible());
|
|
assertThat(split.capacity()).isEqualTo(16);
|
|
|
|
assertTrue(isOwned(composite));
|
|
assertTrue(composite.isAccessible());
|
|
assertThat(composite.capacity()).isEqualTo(0);
|
|
}
|
|
}
|
|
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
try (CompositeBuffer split = composite.splitComponentsCeil(12)) {
|
|
assertTrue(isOwned(split));
|
|
assertTrue(split.isAccessible());
|
|
assertThat(split.capacity()).isEqualTo(16);
|
|
|
|
assertTrue(isOwned(composite));
|
|
assertTrue(composite.isAccessible());
|
|
assertThat(composite.capacity()).isEqualTo(8);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void splitComponentsCeilMustGiveBufferWithFirstComponentForfOffsetOnFirstByteInSecondComponent() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
try (CompositeBuffer split = composite.splitComponentsCeil(7)) {
|
|
assertTrue(isOwned(split));
|
|
assertTrue(split.isAccessible());
|
|
assertThat(split.capacity()).isEqualTo(8);
|
|
|
|
assertTrue(isOwned(composite));
|
|
assertTrue(composite.isAccessible());
|
|
assertThat(composite.capacity()).isEqualTo(8);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void splitComponentsCeilMustGiveEmptyBufferForOffsetOnFirstByteInFirstComponent() {
|
|
try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
|
|
CompositeBuffer composite = CompositeBuffer.compose(allocator,
|
|
allocator.allocate(8).send(),
|
|
allocator.allocate(8).send())) {
|
|
try (CompositeBuffer split = composite.splitComponentsCeil(0)) {
|
|
assertTrue(isOwned(split));
|
|
assertTrue(split.isAccessible());
|
|
assertThat(split.capacity()).isZero();
|
|
|
|
assertTrue(isOwned(composite));
|
|
assertTrue(composite.isAccessible());
|
|
assertThat(composite.capacity()).isEqualTo(16);
|
|
}
|
|
}
|
|
}
|
|
}
|