@Test
public void testToLengthTwoBytes() {
assertEquals(messageLength.bytesToLength(new byte[] {3, 6}), 774);
}
@Test
public void testToLengthTwoBytesLastNegative() {
assertEquals(messageLength.bytesToLength(new byte[] {3, -24}), 1000);
}
@Test
public void testToBytesTwoBytes() {
assertArrayEquals(messageLength.lengthToBytes(774), new byte[] {3, 6});
}
@Test(expected = IllegalStateException.class)
public void testToLengthTooLong() {
messageLength.bytesToLength(new byte[] {-56});
}
@Test
public void testToBytesTwoBytesLastNegative() {
assertArrayEquals(messageLength.lengthToBytes(1000), new byte[] {3, -24});
}
@Test
public void testToBytesTwoBytesFirstNegative() {
assertArrayEquals(messageLength.lengthToBytes(51209), new byte[] {-56, 9});
}
@Test(expected = IllegalStateException.class)
public void testToBytesNegative() {
messageLength.lengthToBytes(-1);
}
@Test
public void testToLengthForSingleNegative() {
assertEquals(messageLength.bytesToLength(new byte[] {0, -1}), 255);
}
@Test
public void testToBytes() {
assertArrayEquals(messageLength.lengthToBytes(34), new byte[] {0, 34});
}
@Test
public void testMaxLength() {
assertEquals(messageLength.maxLength(), 65535);
}
@Test
public void testToBytesForSingleNegative() {
assertArrayEquals(messageLength.lengthToBytes(255), new byte[] {0, -1});
}
@Test
public void testByteLength() {
assertEquals(messageLength.byteLength(), 2);
}
@Test(expected = NullPointerException.class)
public void testToLengthNull() {
messageLength.bytesToLength(null);
}
@Test(expected = IllegalStateException.class)
public void testToLengthShort() {
messageLength.bytesToLength(new byte[] {-56, 9, 1});
}
@Test
public void testToBytesTwoBytesBothNegative() {
assertArrayEquals(messageLength.lengthToBytes(44444), new byte[] {-83, -100});
}
@Test
public void testToLength() {
assertEquals(messageLength.bytesToLength(new byte[] {0, 34}), 34);
}
@Test
public void testToLengthTwoBytesBothNegative() {
assertEquals(messageLength.bytesToLength(new byte[] {-83, -100}), 44444);
}
@Test
public void testToBytesZero() {
assertArrayEquals(messageLength.lengthToBytes(0), new byte[] {0, 0});
}
@Test
public void testToLengthTwoBytesFirstNegative() {
assertEquals(messageLength.bytesToLength(new byte[] {-56, 9}), 51209);
}
@Test
public void testToLengthZero() {
assertEquals(messageLength.bytesToLength(new byte[] {0, 0}), 0);
}
@Test(expected = IllegalStateException.class)
public void testToBytesToBig() {
messageLength.lengthToBytes(151209);
}
private void readMessage(SelectionKey sk, SocketChannel readChannel, TcpAddress incomingAddress)
throws IOException {
// note that socket has been used
SocketEntry entry = (SocketEntry) sockets.get(incomingAddress);
if (entry != null) {
entry.used();
ByteBuffer readBuffer = entry.getReadBuffer();
if (readBuffer != null) {
readChannel.read(readBuffer);
if (readBuffer.hasRemaining()) {
readChannel.register(selector, SelectionKey.OP_READ, entry);
} else {
dispatchMessage(incomingAddress, readBuffer, readBuffer.capacity());
}
return;
}
}
ByteBuffer byteBuffer = ByteBuffer.wrap(buf);
byteBuffer.limit(messageLengthDecoder.getMinHeaderLength());
long bytesRead = readChannel.read(byteBuffer);
if (logger.isDebugEnabled()) {
logger.debug("Reading header " + bytesRead + " bytes from " + incomingAddress);
}
MessageLength messageLength = new MessageLength(0, Integer.MIN_VALUE);
if (bytesRead == messageLengthDecoder.getMinHeaderLength()) {
messageLength = messageLengthDecoder.getMessageLength(ByteBuffer.wrap(buf));
if (logger.isDebugEnabled()) {
logger.debug("Message length is " + messageLength);
}
if ((messageLength.getMessageLength() > getMaxInboundMessageSize())
|| (messageLength.getMessageLength() <= 0)) {
logger.error(
"Received message length "
+ messageLength
+ " is greater than inboundBufferSize "
+ getMaxInboundMessageSize());
synchronized (entry) {
entry.getSocket().close();
logger.info("Socket to " + entry.getPeerAddress() + " closed due to an error");
}
} else {
byteBuffer.limit(messageLength.getMessageLength());
bytesRead += readChannel.read(byteBuffer);
if (bytesRead == messageLength.getMessageLength()) {
dispatchMessage(incomingAddress, byteBuffer, bytesRead);
} else {
byte[] message = new byte[byteBuffer.limit()];
byteBuffer.flip();
byteBuffer.get(message, 0, byteBuffer.limit() - byteBuffer.remaining());
entry.setReadBuffer(ByteBuffer.wrap(message));
}
readChannel.register(selector, SelectionKey.OP_READ, entry);
}
} else if (bytesRead < 0) {
logger.debug("Socket closed remotely");
sk.cancel();
readChannel.close();
TransportStateEvent e =
new TransportStateEvent(
DefaultTcpTransportMapping.this,
incomingAddress,
TransportStateEvent.STATE_DISCONNECTED_REMOTELY,
null);
fireConnectionStateChanged(e);
}
}
