@Test
  public void shouldEncodeAndDecodeClientMessageCorrectly_withPayLoadData_multipleMessages()
      throws UnsupportedEncodingException {
    SafeBuffer byteBuffer = new SafeBuffer(new byte[1024]);
    ClientMessage cmEncode = TestClientMessage.createForEncode(byteBuffer, 0);
    cmEncode
        .setMessageType(7)
        .setVersion((short) 3)
        .addFlag(ClientMessage.BEGIN_AND_END_FLAGS)
        .setCorrelationId(1)
        .setPartitionId(77);
    cmEncode.set(BYTE_DATA);
    cmEncode.updateFrameLength();
    final int calculatedFrame1Size =
        ClientMessage.HEADER_SIZE + ParameterUtil.calculateByteArrayDataSize(BYTE_DATA);

    final int nexMessageOffset = cmEncode.getFrameLength();
    ClientMessage cmEncode2 = TestClientMessage.createForEncode(byteBuffer, nexMessageOffset);

    cmEncode2
        .setMessageType(7)
        .setVersion((short) 3)
        .addFlag(ClientMessage.BEGIN_AND_END_FLAGS)
        .setCorrelationId(2)
        .setPartitionId(77);
    cmEncode2.set(BYTE_DATA);
    cmEncode2.updateFrameLength();
    final int calculatedFrame2Size =
        ClientMessage.HEADER_SIZE + ParameterUtil.calculateByteArrayDataSize(BYTE_DATA);

    ClientMessage cmDecode1 = ClientMessage.createForDecode(byteBuffer, 0);

    final byte[] cmDecodeVarData = cmDecode1.getByteArray();

    assertEquals(7, cmDecode1.getMessageType());
    assertEquals(3, cmDecode1.getVersion());
    assertEquals(ClientMessage.BEGIN_AND_END_FLAGS, cmDecode1.getFlags());
    assertEquals(1, cmDecode1.getCorrelationId());
    assertEquals(77, cmDecode1.getPartitionId());
    assertEquals(calculatedFrame1Size, cmDecode1.getFrameLength());
    assertArrayEquals(cmDecodeVarData, BYTE_DATA);

    ClientMessage cmDecode2 = ClientMessage.createForDecode(byteBuffer, cmDecode1.getFrameLength());
    byte[] cmDecodeVarData2 = cmDecode2.getByteArray();

    assertEquals(7, cmDecode2.getMessageType());
    assertEquals(3, cmDecode2.getVersion());
    assertEquals(ClientMessage.BEGIN_AND_END_FLAGS, cmDecode2.getFlags());
    assertEquals(2, cmDecode2.getCorrelationId());
    assertEquals(77, cmDecode2.getPartitionId());
    assertEquals(calculatedFrame2Size, cmDecode2.getFrameLength());
    assertArrayEquals(cmDecodeVarData2, BYTE_DATA);
  }
  @Test
  public void shouldEncodeWithNewVersionAndDecodeWithOldVersionCorrectly_withPayLoadData()
      throws UnsupportedEncodingException {
    SafeBuffer byteBuffer = new SafeBuffer(new byte[1024]);

    FutureClientMessage cmEncode = new FutureClientMessage();
    cmEncode.wrapForEncode(byteBuffer, 0);

    cmEncode
        .theNewField(999)
        .setMessageType(7)
        .setVersion((short) 3)
        .addFlag(ClientMessage.BEGIN_AND_END_FLAGS)
        .setCorrelationId(66)
        .setPartitionId(77);

    final int calculatedFrameSize =
        FutureClientMessage.THE_NEW_HEADER_SIZE
            + ParameterUtil.calculateByteArrayDataSize(BYTE_DATA);
    cmEncode.set(BYTE_DATA);
    cmEncode.updateFrameLength();

    ClientMessage cmDecode = ClientMessage.createForDecode(byteBuffer, 0);

    final byte[] cmDecodeVarData1 = cmDecode.getByteArray();

    assertEquals(7, cmDecode.getMessageType());
    assertEquals(3, cmDecode.getVersion());
    assertEquals(ClientMessage.BEGIN_AND_END_FLAGS, cmDecode.getFlags());
    assertEquals(66, cmDecode.getCorrelationId());
    assertEquals(77, cmDecode.getPartitionId());
    assertEquals(calculatedFrameSize, cmDecode.getFrameLength());
    assertArrayEquals(cmDecodeVarData1, BYTE_DATA);
  }
  @Test
  public void shouldEncodeAndDecodeClientMessageCorrectly_withPayLoadData_fromOffset()
      throws UnsupportedEncodingException {
    SafeBuffer byteBuffer = new SafeBuffer(new byte[150]);
    int offset = 100;

    ClientMessage cmEncode = TestClientMessage.createForEncode(byteBuffer, offset);

    cmEncode
        .setMessageType(7)
        .setVersion((short) 3)
        .addFlag(ClientMessage.BEGIN_AND_END_FLAGS)
        .setCorrelationId(66)
        .setPartitionId(77);

    byte[] bytes = VAR_DATA_STR_1.getBytes();
    final int calculatedFrameSize =
        ClientMessage.HEADER_SIZE
            + Bits.INT_SIZE_IN_BYTES
            + ParameterUtil.calculateByteArrayDataSize(bytes);
    cmEncode.set(1);
    cmEncode.set(bytes);
    cmEncode.updateFrameLength();

    ClientMessage cmDecode = ClientMessage.createForDecode(byteBuffer, offset);

    assertEquals(1, cmDecode.getInt());
    assertArrayEquals(bytes, cmDecode.getByteArray());

    assertEquals(calculatedFrameSize, cmDecode.getFrameLength());
  }
  @Test
  public void shouldEncodeAndDecodeClientMessageCorrectly_withPayLoadData()
      throws UnsupportedEncodingException {
    SafeBuffer byteBuffer = new SafeBuffer(new byte[1024]);

    ClientMessage cmEncode = TestClientMessage.createForEncode(byteBuffer, 0);

    cmEncode
        .setMessageType(7)
        .setVersion((short) 3)
        .addFlag(ClientMessage.BEGIN_AND_END_FLAGS)
        .setCorrelationId(66)
        .setPartitionId(77);

    final byte[] data1 = VAR_DATA_STR_1.getBytes(DEFAULT_ENCODING);
    final int calculatedFrameSize =
        ClientMessage.HEADER_SIZE + ParameterUtil.calculateByteArrayDataSize(data1);
    cmEncode.set(data1);
    cmEncode.updateFrameLength();

    ClientMessage cmDecode = ClientMessage.createForDecode(byteBuffer, 0);

    byte[] cmDecodeVarData1 = cmDecode.getByteArray();

    assertEquals(calculatedFrameSize, cmDecode.getFrameLength());
    assertArrayEquals(cmDecodeVarData1, data1);
  }
  @Test
  public void shouldEncodeDecodeCorrectly_PUT() {
    final int calculatedSize =
        MapPutCodec.RequestParameters.calculateDataSize(NAME, DATA, DATA, THE_LONG, THE_LONG);
    ClientMessage cmEncode = MapPutCodec.encodeRequest(NAME, DATA, DATA, THE_LONG, THE_LONG);
    cmEncode
        .setVersion((short) 3)
        .addFlag(ClientMessage.BEGIN_AND_END_FLAGS)
        .setCorrelationId(Long.MAX_VALUE)
        .setPartitionId(77);

    assertTrue(calculatedSize > cmEncode.getFrameLength());
    byteBuffer = cmEncode.buffer();

    ClientMessage cmDecode = ClientMessage.createForDecode(byteBuffer, 0);
    MapPutCodec.RequestParameters decodeParams = MapPutCodec.decodeRequest(cmDecode);

    assertEquals(MapPutCodec.REQUEST_TYPE.id(), cmDecode.getMessageType());
    assertEquals(3, cmDecode.getVersion());
    assertEquals(ClientMessage.BEGIN_AND_END_FLAGS, cmDecode.getFlags());
    assertEquals(Long.MAX_VALUE, cmDecode.getCorrelationId());
    assertEquals(77, cmDecode.getPartitionId());

    assertEquals(NAME, decodeParams.name);
    assertEquals(DATA, decodeParams.key);
    assertEquals(DATA, decodeParams.value);
    assertEquals(THE_LONG, decodeParams.threadId);
    assertEquals(THE_LONG, decodeParams.ttl);
  }
  @Test
  public void testUnsignedFields() throws IOException {
    ClientProtocolBuffer buffer = new SafeBuffer(new byte[18]);

    ClientMessage cmEncode = ClientMessage.createForEncode(buffer, 0);

    cmEncode.setVersion((short) (Byte.MAX_VALUE + 10));
    cmEncode.setMessageType(Short.MAX_VALUE + 10);
    cmEncode.setDataOffset((int) Short.MAX_VALUE + 10);
    cmEncode.setCorrelationId(Short.MAX_VALUE + 10);

    ClientMessage cmDecode = ClientMessage.createForDecode(buffer, 0);

    assertEquals(Byte.MAX_VALUE + 10, cmDecode.getVersion());
    assertEquals(Short.MAX_VALUE + 10, cmDecode.getMessageType());
    assertEquals((int) Short.MAX_VALUE + 10, cmDecode.getDataOffset());
  }
  @Test
  public void shouldEncodeAndDecodeClientMessageCorrectly() {
    SafeBuffer byteBuffer = new SafeBuffer(new byte[512]);

    ClientMessage cmEncode = TestClientMessage.createForEncode(byteBuffer, 0);

    cmEncode
        .setMessageType(7)
        .setVersion((short) 3)
        .addFlag(ClientMessage.BEGIN_AND_END_FLAGS)
        .setCorrelationId(66)
        .setPartitionId(77);

    ClientMessage cmDecode = ClientMessage.createForDecode(byteBuffer, 0);

    assertEquals(7, cmDecode.getMessageType());
    assertEquals(3, cmDecode.getVersion());
    assertEquals(ClientMessage.BEGIN_AND_END_FLAGS, cmDecode.getFlags());
    assertEquals(66, cmDecode.getCorrelationId());
    assertEquals(77, cmDecode.getPartitionId());
    assertEquals(ClientMessage.HEADER_SIZE, cmDecode.getFrameLength());
  }
 @Test
 public void test_wrapForDecode_withLargeBuffer() {
   ClientMessage.createForDecode(new SafeBuffer(new byte[100]), 10);
 }
 @Test
 public void test_wrapForDecode_withHeaderSizeBuffer() {
   ClientMessage.createForDecode(new SafeBuffer(new byte[ClientMessage.HEADER_SIZE]), 0);
 }
 @Test(expected = IndexOutOfBoundsException.class)
 public void test_wrapForDecode_withSmallBuffer() {
   ClientMessage.createForDecode(new SafeBuffer(new byte[10]), 1);
 }