@Test
public void testParse65536ByteBinaryCase1_2_7() {
int length = 65536;
ByteBuffer expected = ByteBuffer.allocate(length + 11);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= 0x7F;
expected.put(b);
expected.put(new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00});
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
expected.flip();
WebSocketPolicy policy = new WebSocketPolicy(WebSocketBehavior.SERVER);
policy.setMaxMessageSize(length);
Parser parser = new UnitParser(policy);
IncomingFramesCapture capture = new IncomingFramesCapture();
parser.setIncomingFramesHandler(capture);
parser.parse(expected);
capture.assertNoErrors();
capture.assertHasFrame(OpCode.BINARY, 1);
Frame pActual = capture.getFrames().get(0);
Assert.assertThat("BinaryFrame.payloadLength", pActual.getPayloadLength(), is(length));
// Assert.assertEquals("BinaryFrame.payload",length,pActual.getPayloadData().length);
}
@Test
public void testParserAndGenerator() throws Exception {
WebSocketPolicy policy = WebSocketPolicy.newServerPolicy();
ByteBufferPool bufferPool = new MappedByteBufferPool();
Generator gen = new Generator(policy, bufferPool);
Parser parser = new Parser(policy, bufferPool);
IncomingFramesCapture capture = new IncomingFramesCapture();
parser.setIncomingFramesHandler(capture);
String message = "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";
ByteBuffer out = bufferPool.acquire(8192, false);
try {
// Generate Buffer
BufferUtil.flipToFill(out);
WebSocketFrame frame = WebSocketFrame.text(message);
out = gen.generate(frame);
// Parse Buffer
parser.parse(out);
} finally {
bufferPool.release(out);
}
// Validate
capture.assertNoErrors();
capture.assertHasFrame(OpCode.TEXT, 1);
WebSocketFrame txt = capture.getFrames().get(0);
Assert.assertThat("Text parsed", txt.getPayloadAsUTF8(), is(message));
}
/** Incoming PING (Control Frame) should pass through extension unmodified */
@Test
public void testIncomingPing() {
IncomingFramesCapture capture = new IncomingFramesCapture();
FragmentExtension ext = new FragmentExtension();
ext.setBufferPool(new MappedByteBufferPool());
ext.setPolicy(WebSocketPolicy.newServerPolicy());
ExtensionConfig config = ExtensionConfig.parse("fragment;maxLength=4");
ext.setConfig(config);
ext.setNextIncomingFrames(capture);
String payload = "Are you there?";
Frame ping = WebSocketFrame.ping().setPayload(payload);
ext.incomingFrame(ping);
capture.assertFrameCount(1);
capture.assertHasFrame(OpCode.PING, 1);
WebSocketFrame actual = capture.getFrames().getFirst();
Assert.assertThat("Frame.opcode", actual.getOpCode(), is(OpCode.PING));
Assert.assertThat("Frame.fin", actual.isFin(), is(true));
Assert.assertThat("Frame.rsv1", actual.isRsv1(), is(false));
Assert.assertThat("Frame.rsv2", actual.isRsv2(), is(false));
Assert.assertThat("Frame.rsv3", actual.isRsv3(), is(false));
ByteBuffer expected = BufferUtil.toBuffer(payload, StringUtil.__UTF8_CHARSET);
Assert.assertThat("Frame.payloadLength", actual.getPayloadLength(), is(expected.remaining()));
ByteBufferAssert.assertEquals("Frame.payload", expected, actual.getPayload().slice());
}
/** Open/Activate the session */
public void open() {
if (LOG_OPEN.isDebugEnabled())
LOG_OPEN.debug("[{}] {}.open()", policy.getBehavior(), this.getClass().getSimpleName());
if (remote != null) {
// already opened
return;
}
try (ThreadClassLoaderScope scope = new ThreadClassLoaderScope(classLoader)) {
// Upgrade success
connection.getIOState().onConnected();
// Connect remote
remote = new WebSocketRemoteEndpoint(connection, outgoingHandler, getBatchMode());
if (LOG_OPEN.isDebugEnabled())
LOG_OPEN.debug(
"[{}] {}.open() remote={}",
policy.getBehavior(),
this.getClass().getSimpleName(),
remote);
// Open WebSocket
websocket.openSession(this);
// Open connection
connection.getIOState().onOpened();
if (LOG.isDebugEnabled()) {
LOG.debug("open -> {}", dump());
}
} catch (CloseException ce) {
LOG.warn(ce);
close(ce.getStatusCode(), ce.getMessage());
} catch (Throwable t) {
LOG.warn(t);
// Exception on end-user WS-Endpoint.
// Fast-fail & close connection with reason.
int statusCode = StatusCode.SERVER_ERROR;
if (policy.getBehavior() == WebSocketBehavior.CLIENT) {
statusCode = StatusCode.POLICY_VIOLATION;
}
close(statusCode, t.getMessage());
}
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("WebSocketSession[");
builder.append("websocket=").append(websocket);
builder.append(",behavior=").append(policy.getBehavior());
builder.append(",connection=").append(connection);
builder.append(",remote=").append(remote);
builder.append(",incoming=").append(incomingHandler);
builder.append(",outgoing=").append(outgoingHandler);
builder.append("]");
return builder.toString();
}
@Override
public RemoteEndpoint getRemote() {
if (LOG_OPEN.isDebugEnabled())
LOG_OPEN.debug("[{}] {}.getRemote()", policy.getBehavior(), this.getClass().getSimpleName());
ConnectionState state = connection.getIOState().getConnectionState();
if ((state == ConnectionState.OPEN) || (state == ConnectionState.CONNECTED)) {
return remote;
}
throw new WebSocketException(
"RemoteEndpoint unavailable, current state [" + state + "], expecting [OPEN or CONNECTED]");
}
private void unhandled(Throwable t) {
TARGET_LOG.warn("Unhandled Error (closing connection)", t);
onError(t);
// Unhandled Error, close the connection.
switch (policy.getBehavior()) {
case SERVER:
terminateConnection(StatusCode.SERVER_ERROR, t.getClass().getSimpleName());
break;
case CLIENT:
terminateConnection(StatusCode.POLICY_VIOLATION, t.getClass().getSimpleName());
break;
}
}
/** Verify that incoming frames are passed thru without modification */
@Test
public void testIncomingFrames() {
IncomingFramesCapture capture = new IncomingFramesCapture();
FragmentExtension ext = new FragmentExtension();
ext.setBufferPool(new MappedByteBufferPool());
ext.setPolicy(WebSocketPolicy.newClientPolicy());
ExtensionConfig config = ExtensionConfig.parse("fragment;maxLength=4");
ext.setConfig(config);
ext.setNextIncomingFrames(capture);
// Quote
List<String> quote = new ArrayList<>();
quote.add("No amount of experimentation can ever prove me right;");
quote.add("a single experiment can prove me wrong.");
quote.add("-- Albert Einstein");
// Manually create frame and pass into extension
for (String q : quote) {
Frame frame = WebSocketFrame.text(q);
ext.incomingFrame(frame);
}
int len = quote.size();
capture.assertFrameCount(len);
capture.assertHasFrame(OpCode.TEXT, len);
String prefix;
for (int i = 0; i < len; i++) {
prefix = "Frame[" + i + "]";
WebSocketFrame actual = capture.getFrames().get(i);
Assert.assertThat(prefix + ".opcode", actual.getOpCode(), is(OpCode.TEXT));
Assert.assertThat(prefix + ".fin", actual.isFin(), is(true));
Assert.assertThat(prefix + ".rsv1", actual.isRsv1(), is(false));
Assert.assertThat(prefix + ".rsv2", actual.isRsv2(), is(false));
Assert.assertThat(prefix + ".rsv3", actual.isRsv3(), is(false));
ByteBuffer expected = BufferUtil.toBuffer(quote.get(i), StringUtil.__UTF8_CHARSET);
Assert.assertThat(
prefix + ".payloadLength", actual.getPayloadLength(), is(expected.remaining()));
ByteBufferAssert.assertEquals(prefix + ".payload", expected, actual.getPayload().slice());
}
}
private void assertIncoming(byte[] raw, String... expectedTextDatas) {
WebSocketPolicy policy = WebSocketPolicy.newClientPolicy();
DeflateFrameExtension ext = new DeflateFrameExtension();
ext.setBufferPool(bufferPool);
ext.setPolicy(policy);
ExtensionConfig config = ExtensionConfig.parse("deflate-frame");
ext.setConfig(config);
// Setup capture of incoming frames
IncomingFramesCapture capture = new IncomingFramesCapture();
// Wire up stack
ext.setNextIncomingFrames(capture);
Parser parser = new UnitParser(policy);
parser.configureFromExtensions(Collections.singletonList(ext));
parser.setIncomingFramesHandler(ext);
parser.parse(ByteBuffer.wrap(raw));
int len = expectedTextDatas.length;
capture.assertFrameCount(len);
capture.assertHasFrame(OpCode.TEXT, len);
int i = 0;
for (WebSocketFrame actual : capture.getFrames()) {
String prefix = "Frame[" + i + "]";
Assert.assertThat(prefix + ".opcode", actual.getOpCode(), is(OpCode.TEXT));
Assert.assertThat(prefix + ".fin", actual.isFin(), is(true));
Assert.assertThat(
prefix + ".rsv1", actual.isRsv1(), is(false)); // RSV1 should be unset at this point
Assert.assertThat(prefix + ".rsv2", actual.isRsv2(), is(false));
Assert.assertThat(prefix + ".rsv3", actual.isRsv3(), is(false));
ByteBuffer expected = BufferUtil.toBuffer(expectedTextDatas[i], StandardCharsets.UTF_8);
Assert.assertThat(
prefix + ".payloadLength", actual.getPayloadLength(), is(expected.remaining()));
ByteBufferAssert.assertEquals(prefix + ".payload", expected, actual.getPayload().slice());
i++;
}
}
@Test
public void testGeneratedTwoFrames() throws IOException {
WebSocketPolicy policy = WebSocketPolicy.newClientPolicy();
DeflateFrameExtension ext = new DeflateFrameExtension();
ext.setBufferPool(bufferPool);
ext.setPolicy(policy);
ext.setConfig(new ExtensionConfig(ext.getName()));
boolean validating = true;
Generator generator = new Generator(policy, bufferPool, validating);
generator.configureFromExtensions(Collections.singletonList(ext));
OutgoingNetworkBytesCapture capture = new OutgoingNetworkBytesCapture(generator);
ext.setNextOutgoingFrames(capture);
ext.outgoingFrame(new TextFrame().setPayload("Hello"), null);
ext.outgoingFrame(new TextFrame().setPayload("There"), null);
capture.assertBytes(0, "c107f248cdc9c90700");
}
private void assertOutgoing(String text, String expectedHex) throws IOException {
WebSocketPolicy policy = WebSocketPolicy.newClientPolicy();
DeflateFrameExtension ext = new DeflateFrameExtension();
ext.setBufferPool(bufferPool);
ext.setPolicy(policy);
ExtensionConfig config = ExtensionConfig.parse("deflate-frame");
ext.setConfig(config);
boolean validating = true;
Generator generator = new Generator(policy, bufferPool, validating);
generator.configureFromExtensions(Collections.singletonList(ext));
OutgoingNetworkBytesCapture capture = new OutgoingNetworkBytesCapture(generator);
ext.setNextOutgoingFrames(capture);
Frame frame = new TextFrame().setPayload(text);
ext.outgoingFrame(frame, null);
capture.assertBytes(0, expectedHex);
}
/** Verify that outgoing text frames are fragmented by default configuration */
@Test
public void testOutgoingFramesDefaultConfig() throws IOException {
OutgoingFramesCapture capture = new OutgoingFramesCapture();
FragmentExtension ext = new FragmentExtension();
ext.setBufferPool(new MappedByteBufferPool());
ext.setPolicy(WebSocketPolicy.newServerPolicy());
ExtensionConfig config = ExtensionConfig.parse("fragment");
ext.setConfig(config);
ext.setNextOutgoingFrames(capture);
// Quote
List<String> quote = new ArrayList<>();
quote.add("No amount of experimentation can ever prove me right;");
quote.add("a single experiment can prove me wrong.");
quote.add("-- Albert Einstein");
// Write quote as separate frames
for (String section : quote) {
Frame frame = WebSocketFrame.text(section);
ext.outgoingFrame(frame, null);
}
// Expected Frames
List<WebSocketFrame> expectedFrames = new ArrayList<>();
expectedFrames.add(
new WebSocketFrame(OpCode.TEXT)
.setPayload("No amount of experimentation can ever prove me right;"));
expectedFrames.add(
new WebSocketFrame(OpCode.TEXT).setPayload("a single experiment can prove me wrong."));
expectedFrames.add(new WebSocketFrame(OpCode.TEXT).setPayload("-- Albert Einstein"));
// capture.dump();
int len = expectedFrames.size();
capture.assertFrameCount(len);
String prefix;
LinkedList<WebSocketFrame> frames = capture.getFrames();
for (int i = 0; i < len; i++) {
prefix = "Frame[" + i + "]";
WebSocketFrame actualFrame = frames.get(i);
WebSocketFrame expectedFrame = expectedFrames.get(i);
// Validate Frame
Assert.assertThat(prefix + ".opcode", actualFrame.getOpCode(), is(expectedFrame.getOpCode()));
Assert.assertThat(prefix + ".fin", actualFrame.isFin(), is(expectedFrame.isFin()));
Assert.assertThat(prefix + ".rsv1", actualFrame.isRsv1(), is(expectedFrame.isRsv1()));
Assert.assertThat(prefix + ".rsv2", actualFrame.isRsv2(), is(expectedFrame.isRsv2()));
Assert.assertThat(prefix + ".rsv3", actualFrame.isRsv3(), is(expectedFrame.isRsv3()));
// Validate Payload
ByteBuffer expectedData = expectedFrame.getPayload().slice();
ByteBuffer actualData = actualFrame.getPayload().slice();
Assert.assertThat(
prefix + ".payloadLength", actualData.remaining(), is(expectedData.remaining()));
ByteBufferAssert.assertEquals(prefix + ".payload", expectedData, actualData);
}
}
public DummyMuxAddServer() {
this.policy = WebSocketPolicy.newServerPolicy();
this.eventDriverFactory = new EventDriverFactory(policy);
this.echo = new AdapterEchoSocket();
}
/** Binary Message Spec testing the {@link Generator} and {@link Parser} */
public class TestABCase1_2 {
private WebSocketPolicy policy = WebSocketPolicy.newServerPolicy();
@Test
public void testGenerate125ByteBinaryCase1_2_2() {
int length = 125;
ByteBuffer bb = ByteBuffer.allocate(length);
for (int i = 0; i < length; ++i) {
bb.put("*".getBytes());
}
bb.flip();
WebSocketFrame binaryFrame = WebSocketFrame.binary().setPayload(bb);
Generator generator = new UnitGenerator();
ByteBuffer actual = generator.generate(binaryFrame);
ByteBuffer expected = ByteBuffer.allocate(length + 5);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= length & 0x7F;
expected.put(b);
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
BufferUtil.flipToFlush(expected, 0);
ByteBufferAssert.assertEquals("buffers do not match", expected, actual);
}
@Test
public void testGenerate126ByteBinaryCase1_2_3() {
int length = 126;
ByteBuffer bb = ByteBuffer.allocate(length);
for (int i = 0; i < length; ++i) {
bb.put("*".getBytes());
}
bb.flip();
WebSocketFrame binaryFrame = WebSocketFrame.binary().setPayload(bb);
Generator generator = new UnitGenerator();
ByteBuffer actual = generator.generate(binaryFrame);
ByteBuffer expected = ByteBuffer.allocate(length + 5);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= length & 0x7E;
expected.put(b);
// expected.put((byte)((length>>8) & 0xFF));
// expected.put((byte)(length & 0xFF));
expected.putShort((short) length);
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
BufferUtil.flipToFlush(expected, 0);
ByteBufferAssert.assertEquals("buffers do not match", expected, actual);
}
@Test
public void testGenerate127ByteBinaryCase1_2_4() {
int length = 127;
ByteBuffer bb = ByteBuffer.allocate(length);
for (int i = 0; i < length; ++i) {
bb.put("*".getBytes());
}
bb.flip();
WebSocketFrame binaryFrame = WebSocketFrame.binary().setPayload(bb);
Generator generator = new UnitGenerator();
ByteBuffer actual = generator.generate(binaryFrame);
ByteBuffer expected = ByteBuffer.allocate(length + 5);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= length & 0x7E;
expected.put(b);
// expected.put((byte)((length>>8) & 0xFF));
// expected.put((byte)(length & 0xFF));
expected.putShort((short) length);
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
BufferUtil.flipToFlush(expected, 0);
ByteBufferAssert.assertEquals("buffers do not match", expected, actual);
}
@Test
public void testGenerate128ByteBinaryCase1_2_5() {
int length = 128;
ByteBuffer bb = ByteBuffer.allocate(length);
for (int i = 0; i < length; ++i) {
bb.put("*".getBytes());
}
bb.flip();
WebSocketFrame binaryFrame = WebSocketFrame.binary().setPayload(bb);
Generator generator = new UnitGenerator();
ByteBuffer actual = generator.generate(binaryFrame);
ByteBuffer expected = ByteBuffer.allocate(length + 5);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= 0x7E;
expected.put(b);
expected.put((byte) (length >> 8));
expected.put((byte) (length & 0xFF));
// expected.putShort((short)length);
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
BufferUtil.flipToFlush(expected, 0);
ByteBufferAssert.assertEquals("buffers do not match", expected, actual);
}
@Test
public void testGenerate65535ByteBinaryCase1_2_6() {
int length = 65535;
ByteBuffer bb = ByteBuffer.allocate(length);
for (int i = 0; i < length; ++i) {
bb.put("*".getBytes());
}
bb.flip();
WebSocketFrame binaryFrame = WebSocketFrame.binary().setPayload(bb);
Generator generator = new UnitGenerator();
ByteBuffer actual = generator.generate(binaryFrame);
ByteBuffer expected = ByteBuffer.allocate(length + 5);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= 0x7E;
expected.put(b);
expected.put(new byte[] {(byte) 0xff, (byte) 0xff});
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
BufferUtil.flipToFlush(expected, 0);
ByteBufferAssert.assertEquals("buffers do not match", expected, actual);
}
@Test
public void testGenerate65536ByteBinaryCase1_2_7() {
int length = 65536;
ByteBuffer bb = ByteBuffer.allocate(length);
for (int i = 0; i < length; ++i) {
bb.put("*".getBytes());
}
bb.flip();
WebSocketFrame binaryFrame = WebSocketFrame.binary().setPayload(bb);
Generator generator = new UnitGenerator();
ByteBuffer actual = generator.generate(binaryFrame);
ByteBuffer expected = ByteBuffer.allocate(length + 11);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= 0x7F;
expected.put(b);
expected.put(new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00});
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
BufferUtil.flipToFlush(expected, 0);
ByteBufferAssert.assertEquals("buffers do not match", expected, actual);
}
@Test
public void testGenerateEmptyBinaryCase1_2_1() {
WebSocketFrame binaryFrame = WebSocketFrame.binary(new byte[] {});
Generator generator = new UnitGenerator();
ByteBuffer actual = generator.generate(binaryFrame);
ByteBuffer expected = ByteBuffer.allocate(5);
expected.put(new byte[] {(byte) 0x82, (byte) 0x00});
BufferUtil.flipToFlush(expected, 0);
ByteBufferAssert.assertEquals("buffers do not match", expected, actual);
}
@Test
public void testParse125ByteBinaryCase1_2_2() {
int length = 125;
ByteBuffer expected = ByteBuffer.allocate(length + 5);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= length & 0x7F;
expected.put(b);
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
expected.flip();
Parser parser = new UnitParser(policy);
IncomingFramesCapture capture = new IncomingFramesCapture();
parser.setIncomingFramesHandler(capture);
parser.parse(expected);
capture.assertNoErrors();
capture.assertHasFrame(OpCode.BINARY, 1);
Frame pActual = capture.getFrames().get(0);
Assert.assertThat("BinaryFrame.payloadLength", pActual.getPayloadLength(), is(length));
// Assert.assertEquals("BinaryFrame.payload",length,pActual.getPayloadData().length);
}
@Test
public void testParse126ByteBinaryCase1_2_3() {
int length = 126;
ByteBuffer expected = ByteBuffer.allocate(length + 5);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= length & 0x7E;
expected.put(b);
expected.putShort((short) length);
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
expected.flip();
Parser parser = new UnitParser(policy);
IncomingFramesCapture capture = new IncomingFramesCapture();
parser.setIncomingFramesHandler(capture);
parser.parse(expected);
capture.assertNoErrors();
capture.assertHasFrame(OpCode.BINARY, 1);
Frame pActual = capture.getFrames().get(0);
Assert.assertThat("BinaryFrame.payloadLength", pActual.getPayloadLength(), is(length));
// Assert.assertEquals("BinaryFrame.payload",length,pActual.getPayloadData().length);
}
@Test
public void testParse127ByteBinaryCase1_2_4() {
int length = 127;
ByteBuffer expected = ByteBuffer.allocate(length + 5);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= length & 0x7E;
expected.put(b);
expected.putShort((short) length);
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
expected.flip();
Parser parser = new UnitParser(policy);
IncomingFramesCapture capture = new IncomingFramesCapture();
parser.setIncomingFramesHandler(capture);
parser.parse(expected);
capture.assertNoErrors();
capture.assertHasFrame(OpCode.BINARY, 1);
Frame pActual = capture.getFrames().get(0);
Assert.assertThat("BinaryFrame.payloadLength", pActual.getPayloadLength(), is(length));
// .assertEquals("BinaryFrame.payload",length,pActual.getPayloadData().length);
}
@Test
public void testParse128ByteBinaryCase1_2_5() {
int length = 128;
ByteBuffer expected = ByteBuffer.allocate(length + 5);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= 0x7E;
expected.put(b);
expected.putShort((short) length);
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
expected.flip();
Parser parser = new UnitParser(policy);
IncomingFramesCapture capture = new IncomingFramesCapture();
parser.setIncomingFramesHandler(capture);
parser.parse(expected);
capture.assertNoErrors();
capture.assertHasFrame(OpCode.BINARY, 1);
Frame pActual = capture.getFrames().get(0);
Assert.assertThat("BinaryFrame.payloadLength", pActual.getPayloadLength(), is(length));
// Assert.assertEquals("BinaryFrame.payload",length,pActual.getPayloadData().length);
}
@Test
public void testParse65535ByteBinaryCase1_2_6() {
int length = 65535;
ByteBuffer expected = ByteBuffer.allocate(length + 5);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= 0x7E;
expected.put(b);
expected.put(new byte[] {(byte) 0xff, (byte) 0xff});
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
expected.flip();
WebSocketPolicy policy = new WebSocketPolicy(WebSocketBehavior.SERVER);
policy.setMaxMessageSize(length);
Parser parser = new UnitParser(policy);
IncomingFramesCapture capture = new IncomingFramesCapture();
parser.setIncomingFramesHandler(capture);
parser.parse(expected);
capture.assertNoErrors();
capture.assertHasFrame(OpCode.BINARY, 1);
Frame pActual = capture.getFrames().get(0);
Assert.assertThat("BinaryFrame.payloadLength", pActual.getPayloadLength(), is(length));
// Assert.assertEquals("BinaryFrame.payload",length,pActual.getPayloadData().length);
}
@Test
public void testParse65536ByteBinaryCase1_2_7() {
int length = 65536;
ByteBuffer expected = ByteBuffer.allocate(length + 11);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= 0x7F;
expected.put(b);
expected.put(new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00});
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
expected.flip();
WebSocketPolicy policy = new WebSocketPolicy(WebSocketBehavior.SERVER);
policy.setMaxMessageSize(length);
Parser parser = new UnitParser(policy);
IncomingFramesCapture capture = new IncomingFramesCapture();
parser.setIncomingFramesHandler(capture);
parser.parse(expected);
capture.assertNoErrors();
capture.assertHasFrame(OpCode.BINARY, 1);
Frame pActual = capture.getFrames().get(0);
Assert.assertThat("BinaryFrame.payloadLength", pActual.getPayloadLength(), is(length));
// Assert.assertEquals("BinaryFrame.payload",length,pActual.getPayloadData().length);
}
@Test
public void testParseEmptyBinaryCase1_2_1() {
ByteBuffer expected = ByteBuffer.allocate(5);
expected.put(new byte[] {(byte) 0x82, (byte) 0x00});
expected.flip();
Parser parser = new UnitParser(policy);
IncomingFramesCapture capture = new IncomingFramesCapture();
parser.setIncomingFramesHandler(capture);
parser.parse(expected);
capture.assertNoErrors();
capture.assertHasFrame(OpCode.BINARY, 1);
Frame pActual = capture.getFrames().get(0);
Assert.assertThat("BinaryFrame.payloadLength", pActual.getPayloadLength(), is(0));
// Assert.assertNull("BinaryFrame.payload",pActual.getPayloadData());
}
}
@Override
public void onOpened(Connection connection) {
if (LOG_OPEN.isDebugEnabled())
LOG_OPEN.debug("[{}] {}.onOpened()", policy.getBehavior(), this.getClass().getSimpleName());
open();
}