java.nio.ReadOnlyBufferException Java Examples

private void testGetReadOnlyDst(boolean direct) {
    byte[] bytes = { 'a', 'b', 'c', 'd' };

    ByteBuf buffer = newBuffer(bytes.length);
    buffer.writeBytes(bytes);

    ByteBuffer dst = direct ? ByteBuffer.allocateDirect(bytes.length) : ByteBuffer.allocate(bytes.length);
    ByteBuffer readOnlyDst = dst.asReadOnlyBuffer();
    try {
        buffer.getBytes(0, readOnlyDst);
        fail();
    } catch (ReadOnlyBufferException e) {
        // expected
    }
    assertEquals(0, readOnlyDst.position());
    buffer.release();
}
 

/**
 * @param buf the ByteBuffer to receive the results of the read operation.
 * @return the number of bytes read, possibly zero, or -1 if
 *         reach end-of-stream
 * @throws IOException if there is some error performing the read
 */
@Override
public int read(ByteBuffer buf) throws IOException {
  if (buf.isReadOnly()){
    throw new ReadOnlyBufferException();
  }

  int readLen = Math.min(buf.remaining(), available());

  int bytesRead;
  if (buf.hasArray()) {
    int pos = buf.position();
    bytesRead = read(buf.array(), pos, readLen);
    if (bytesRead > 0) {
      buf.position(pos + bytesRead);
    }
  } else {
    byte[] readData = new byte[readLen];
    bytesRead = read(readData, 0, readLen);
    if (bytesRead > 0) {
      buf.put(readData);
    }
  }

  return bytesRead;
}
 

@Test(expected = ReadOnlyBufferException.class)
public void testSetMedium() throws IOException {
    ByteBuf buf = newBuffer(wrappedBuffer(new byte[8]));
    try {
        buf.setMedium(0, 1);
    } finally {
        buf.release();
    }
}
 

@Test(expected = ReadOnlyBufferException.class)
public void testSetBoolean() {
    ByteBuf buf = newBuffer(wrappedBuffer(new byte[8]));
    try {
        buf.setBoolean(0, true);
    } finally {
        buf.release();
    }
}
 

@Override
public ByteBuf ensureWritable(int minWritableBytes) {
	// note: ReadOnlyByteBuf allows this but in most cases this does not make sense
	if (minWritableBytes != 0) {
		throw new ReadOnlyBufferException();
	}
	return this;
}
 

@Test(expected = ReadOnlyBufferException.class)
public void testSetByte() {
    ByteBuf buf = newBuffer(wrappedBuffer(new byte[8]));
    try {
        buf.setByte(0, 1);
    } finally {
        buf.release();
    }
}
 

@Test(expected = ReadOnlyBufferException.class)
public void testSetBytesWithByteBuf() {
    ByteBuf buf = newBuffer(wrappedBuffer(new byte[8]));
    ByteBuf src = wrappedBuffer(new byte[4]);
    try {
        buf.setBytes(0, src);
    } finally {
        buf.release();
        src.release();
    }
}
 

@Test(expected = ReadOnlyBufferException.class)
public void testSetBytesViaArray() {
    ByteBuf buf = buffer(allocate(8).asReadOnlyBuffer());
    try {
        buf.setBytes(0, "test".getBytes());
    } finally {
        buf.release();
    }
}
 

@Test(expected = ReadOnlyBufferException.class)
public void test_get_immutable() {
    final String key = "test.key";
    final ByteBuffer value = ByteBuffer.wrap("test.value".getBytes());

    connectionAttributes.put(key, value);

    final Optional<ByteBuffer> returnValue1 = connectionAttributes.get(key);
    assertTrue(returnValue1.isPresent());
    assertEquals(value, returnValue1.get());

    returnValue1.get().put(0, (byte) 10);

}
 

public static <T> void writeArgs(DataBuffer<T> buffer, int arrayLength, int offset, int length) {
  if (length > buffer.size()) {
    throw new BufferOverflowException();
  }
  if (buffer.isReadOnly()) {
    throw new ReadOnlyBufferException();
  }
  arrayArgs(arrayLength, offset, length);
}
 

@Test(expected = ReadOnlyBufferException.class)
public void testSetLong() {
    ByteBuf buf = newBuffer(wrappedBuffer(new byte[8]));
    try {
        buf.setLong(0, 1);
    } finally {
        buf.release();
    }
}
 

@Test(expected = ReadOnlyBufferException.class)
public void testSetLong() {
    ByteBuf buf = buffer(allocate(8).asReadOnlyBuffer());
    try {
        buf.setLong(0, 1);
    } finally {
        buf.release();
    }
}
 

@Test(expected = ReadOnlyBufferException.class)
public void testSetBytesWithInputStream() throws IOException {
    ByteBuf buf = newBuffer(wrappedBuffer(new byte[8]));
    try {
        buf.setBytes(0, new ByteArrayInputStream(new byte[4]), 4);
    } finally {
        buf.release();
    }
}
 

@Test(expected = ReadOnlyBufferException.class)
public void testSetMedium() {
    ByteBuf buf = buffer(allocate(8).asReadOnlyBuffer());
    try {
        buf.setMedium(0, 1);
    } finally {
        buf.release();
    }
}
 

@Test
public void test_getAll_immutable() {
    final ImmutableMap<String, ByteBuffer> values = ImmutableMap.of(
            "test.key1", ByteBuffer.wrap("test.value1".getBytes()),
            "test.key2", ByteBuffer.wrap("test.value2".getBytes()));

    for (final Map.Entry<String, ByteBuffer> value : values.entrySet()) {
        connectionAttributes.put(value.getKey(), value.getValue());
    }

    final Optional<Map<String, ByteBuffer>> returnValues1 = connectionAttributes.getAll();

    assertTrue(returnValues1.isPresent());
    assertAllEquals(values, returnValues1.get());

    final AtomicInteger exceptions = new AtomicInteger(0);

    for (final String key : values.keySet()) {
        try {
            returnValues1.get().get(key).put(0, (byte) 10);
        } catch (final ReadOnlyBufferException e) {
            exceptions.incrementAndGet();
        }
    }

    final Optional<Map<String, ByteBuffer>> returnValues2 = connectionAttributes.getAll();

    assertTrue(returnValues2.isPresent());
    assertAllEquals(values, returnValues2.get());
    assertEquals(values.size(), exceptions.get());
}
 

@Test(expected = ReadOnlyBufferException.class)
public void testSetFloat() throws IOException {
    ByteBuf buf = newBuffer(wrappedBuffer(new byte[8]));
    try {
        buf.setFloat(0, 1);
    } finally {
        buf.release();
    }
}
 

@Test(expected = ReadOnlyBufferException.class)
public void testSetBytesViaBuffer() {
    ByteBuf buf = buffer(allocate(8).asReadOnlyBuffer());
    ByteBuf copy = Unpooled.copyInt(1);
    try {
        buf.setBytes(0, copy);
    } finally {
        buf.release();
        copy.release();
    }
}
 

@Override
public ByteBuf setBytes(int index, ByteBuffer src) {
    throw new ReadOnlyBufferException();
}
 

@Override
protected void _setMedium(int index, int value) {
    throw new ReadOnlyBufferException();
}
 

@Override
public ByteBuf setMedium(int index, int value) {
    throw new ReadOnlyBufferException();
}
 

@Override
protected void _setShortLE(int index, int value) {
    throw new ReadOnlyBufferException();
}
 

@Override
public int setBytes(int index, InputStream in, int length) {
    throw new ReadOnlyBufferException();
}
 

@Override
public ByteBuf setShortLE(int index, int value) {
    throw new ReadOnlyBufferException();
}
 

@Override
protected void _setShort(int index, int value) {
    throw new ReadOnlyBufferException();
}
 

@Override
public ByteBuf setShort(int index, int value) {
    throw new ReadOnlyBufferException();
}
 

@Override
protected void _setByte(int index, int value) {
    throw new ReadOnlyBufferException();
}
 

@Override
public ByteBuf setByte(int index, int value) {
    throw new ReadOnlyBufferException();
}
 

@Override
public ByteBuf setMediumLE(int index, int value) {
    throw new ReadOnlyBufferException();
}
 

@Override
public int setBytes(int index, FileChannel in, long position, int length) {
    throw new ReadOnlyBufferException();
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) {
    throw new ReadOnlyBufferException();
}