Java ReleasableBytesStreamOutput.writeByte方法代码示例

import org.elasticsearch.common.io.stream.ReleasableBytesStreamOutput; //导入方法依赖的package包/类
private BytesReference getRandomizedBytesReference(int length) throws IOException {
    // we know bytes stream output always creates a paged bytes reference, we use it to create randomized content
    ReleasableBytesStreamOutput out = new ReleasableBytesStreamOutput(length, bigarrays);
    for (int i = 0; i < length; i++) {
        out.writeByte((byte) random().nextInt(1 << 8));
    }
    assertEquals(out.size(), length);
    BytesReference ref = out.bytes();
    assertEquals(ref.length(), length);
    if (randomBoolean()) {
        return new BytesArray(ref.toBytesRef());
    } else if (randomBoolean()) {
        BytesRef bytesRef = ref.toBytesRef();
        return Netty4Utils.toBytesReference(Unpooled.wrappedBuffer(bytesRef.bytes, bytesRef.offset,
            bytesRef.length));
    } else {
        return ref;
    }
}
 

import org.elasticsearch.common.io.stream.ReleasableBytesStreamOutput; //导入方法依赖的package包/类
@Override
protected BytesReference newBytesReference(int length) throws IOException {
    ReleasableBytesStreamOutput out = new ReleasableBytesStreamOutput(length, bigarrays);
    for (int i = 0; i < length; i++) {
        out.writeByte((byte) random().nextInt(1 << 8));
    }
    assertEquals(out.size(), length);
    BytesReference ref = out.bytes();
    assertEquals(ref.length(), length);
    BytesRef bytesRef = ref.toBytesRef();
    final ByteBuf buffer = Unpooled.wrappedBuffer(bytesRef.bytes, bytesRef.offset, bytesRef.length);
    return Netty4Utils.toBytesReference(buffer);
}
 

import org.elasticsearch.common.io.stream.ReleasableBytesStreamOutput; //导入方法依赖的package包/类
protected BytesReference newBytesReference(int length) throws IOException {
    // we know bytes stream output always creates a paged bytes reference, we use it to create randomized content
    ReleasableBytesStreamOutput out = new ReleasableBytesStreamOutput(length, bigarrays);
    for (int i = 0; i < length; i++) {
        out.writeByte((byte) random().nextInt(1 << 8));
    }
    assertThat(out.size(), Matchers.equalTo(length));
    BytesReference ref = out.bytes();
    assertThat(ref.length(), Matchers.equalTo(length));
    assertThat(ref, Matchers.instanceOf(PagedBytesReference.class));
    return ref;
}
 

import org.elasticsearch.common.io.stream.ReleasableBytesStreamOutput; //导入方法依赖的package包/类
private List<BytesReference> newRefList(int length) throws IOException {
    List<BytesReference> referenceList = new ArrayList<>();
    for (int i = 0; i < length;) {
        int remaining = length-i;
        int sliceLength = randomIntBetween(1, remaining);
        ReleasableBytesStreamOutput out = new ReleasableBytesStreamOutput(sliceLength, bigarrays);
        for (int j = 0; j < sliceLength; j++) {
            out.writeByte((byte) random().nextInt(1 << 8));
        }
        assertEquals(sliceLength, out.size());
        referenceList.add(out.bytes());
        i+=sliceLength;
    }
    return referenceList;
}
 

import org.elasticsearch.common.io.stream.ReleasableBytesStreamOutput; //导入方法依赖的package包/类
public void testCompareTo() throws IOException {
    final int iters = randomIntBetween(5, 10);
    for (int i = 0; i < iters; i++) {
        int length = randomIntBetween(10, PAGE_SIZE * randomIntBetween(2, 8));
        BytesReference bytesReference = newBytesReference(length);
        assertTrue(bytesReference.compareTo(new BytesArray("")) > 0);
        assertTrue(new BytesArray("").compareTo(bytesReference) < 0);


        assertEquals(0, bytesReference.compareTo(bytesReference));
        int sliceFrom = randomIntBetween(0, bytesReference.length());
        int sliceLength = randomIntBetween(0, bytesReference.length() - sliceFrom);
        BytesReference slice = bytesReference.slice(sliceFrom, sliceLength);

        assertEquals(bytesReference.toBytesRef().compareTo(slice.toBytesRef()),
            new BytesArray(bytesReference.toBytesRef(), true).compareTo(new BytesArray(slice.toBytesRef(), true)));

        assertEquals(bytesReference.toBytesRef().compareTo(slice.toBytesRef()),
            bytesReference.compareTo(slice));
        assertEquals(slice.toBytesRef().compareTo(bytesReference.toBytesRef()),
            slice.compareTo(bytesReference));

        assertEquals(0, slice.compareTo(new BytesArray(slice.toBytesRef())));
        assertEquals(0, new BytesArray(slice.toBytesRef()).compareTo(slice));

        final int crazyLength = length + randomIntBetween(10, PAGE_SIZE * randomIntBetween(2, 8));
        ReleasableBytesStreamOutput crazyStream = new ReleasableBytesStreamOutput(length, bigarrays);
        final int offset = randomIntBetween(0, crazyLength - length);
        for (int j = 0; j < offset; j++) {
            crazyStream.writeByte((byte) random().nextInt(1 << 8));
        }
        bytesReference.writeTo(crazyStream);
        for (int j = crazyStream.size(); j < crazyLength; j++) {
            crazyStream.writeByte((byte) random().nextInt(1 << 8));
        }
        PagedBytesReference crazyReference = crazyStream.bytes();

        assertFalse(crazyReference.compareTo(bytesReference) == 0);
        assertEquals(0, crazyReference.slice(offset, length).compareTo(
            bytesReference));
        assertEquals(0, bytesReference.compareTo(
            crazyReference.slice(offset, length)));
    }
}