コード例 #1
0
  @Test
  public void testUnsigned() throws IOException {
    writer.writeUnsigned(1, 1);
    writer.writeUnsigned(2, 2);
    writer.writeUnsigned(3, 3);
    writer.writeUnsigned(4, 4);

    try {
      writer.writeUnsigned(8, 8);
      fail("No exception on bad argument");
    } catch (IllegalArgumentException e) {
      assertEquals("Unsupported byte count for unsigned: 8", e.getMessage());
    }

    BinaryReader reader = getReader();

    try {
      reader.expectUnsigned(8);
      fail("No exception on bad argument");
    } catch (IllegalArgumentException e) {
      assertEquals("Unsupported byte count for unsigned: 8", e.getMessage());
    }

    assertEquals(1, reader.expectUnsigned(1));
    assertEquals(2, reader.expectUnsigned(2));
    assertEquals(3, reader.expectUnsigned(3));
    assertEquals(4, reader.expectUnsigned(4));
  }
コード例 #2
0
  @Test
  public void testWrite() throws IOException {
    writer.write(new byte[] {1, 2, 3, 4}, 1, 2);
    writer.write(0x7f);

    byte[] tmp = new byte[4];
    assertEquals(3, getReader().read(tmp));
    assertArrayEquals(new byte[] {2, 3, 0x7f, 0}, tmp);
  }
コード例 #3
0
  @Test
  public void testExpectUnsigned() throws IOException {
    writer.writeUInt8(1);
    writer.writeUInt16(2);
    writer.writeUInt24(3);
    writer.writeUInt32(4);

    BinaryReader reader = getReader();

    assertEquals(1, reader.expectUInt8());
    assertEquals(2, reader.expectUInt16());
    assertEquals(3, reader.expectUInt24());
    assertEquals(4, reader.expectUInt32());
  }
コード例 #4
0
  @Test
  public void testShort() throws IOException {
    // test writing and reading shorts.
    writer.writeShort((short) 1);
    writer.writeShort((short) 0xffff);
    writer.writeShort((short) -12345);
    writer.writeShort((short) 0);

    BinaryReader reader = getReader();

    assertEquals((short) 1, reader.expectShort());
    assertEquals((short) 0xffff, reader.expectShort());
    assertEquals((short) -12345, reader.expectShort());
    assertEquals((short) 0, reader.expectShort());
  }
コード例 #5
0
 private void testVarint(long value, int bytes) throws IOException {
   out.reset();
   writer.writeVarint(value);
   assertEquals(bytes, out.size());
   BinaryReader reader = getReader();
   assertEquals(value, reader.readLongVarint());
 }
コード例 #6
0
 private void testZigzag(int value, int bytes) throws IOException {
   out.reset();
   writer.writeZigzag(value);
   assertEquals(bytes, out.size());
   BinaryReader reader = getReader();
   assertEquals(value, reader.readIntZigzag());
 }
コード例 #7
0
  @Test
  public void testDouble() throws IOException {
    // test writing and reading shorts.
    writer.writeDouble(1);
    writer.writeDouble(6.62607004E-34);
    writer.writeDouble(299792458);
    writer.writeDouble(-123456.123456);
    writer.writeDouble(0.0);

    BinaryReader reader = getReader();

    assertEquals(1.0, reader.expectDouble(), 0.0);
    assertEquals(6.62607004E-34, reader.expectDouble(), 0.0);
    assertEquals(299792458, reader.expectDouble(), 0.0);
    assertEquals(-123456.123456, reader.expectDouble(), 0.0);
    assertEquals(0.0, reader.expectDouble(), 0.0);
  }
コード例 #8
0
  @Test
  public void testLong() throws IOException {
    // test writing and reading shorts.
    writer.writeLong(1);
    writer.writeLong(0xdeadbeefcafebabeL);
    writer.writeLong(0xffffffffffffffffL);
    writer.writeLong(-1234567890123456789L);
    writer.writeLong(0);

    BinaryReader reader = getReader();

    assertEquals(1, reader.expectLong());
    assertEquals(0xdeadbeefcafebabeL, reader.expectLong());
    assertEquals(0xffffffffffffffffL, reader.expectLong());
    assertEquals(-1234567890123456789L, reader.expectLong());
    assertEquals(0, reader.expectLong());
  }
コード例 #9
0
  @Test
  public void testInt() throws IOException {
    // test writing and reading shorts.
    writer.writeInt(1);
    writer.writeInt(0xdeadbeef);
    writer.writeInt(0xffffffff);
    writer.writeInt(-1234567890);
    writer.writeInt(0);

    BinaryReader reader = getReader();

    assertEquals(1, reader.expectInt());
    assertEquals(0xdeadbeef, reader.expectInt());
    assertEquals(0xffffffff, reader.expectInt());
    assertEquals(-1234567890, reader.expectInt());
    assertEquals(0, reader.expectInt());
  }
コード例 #10
0
  @Test
  public void testReadUnsigned() throws IOException {
    writer.writeUInt16(2);

    BinaryReader reader = getReader();

    assertEquals(2, reader.readUInt16());
    assertEquals(0, reader.readUInt16());

    writer.writeUInt8(5);
    reader = getReader();

    try {
      reader.readUInt16();
      fail("No exception in bad read");
    } catch (IOException e) {
      assertEquals("Missing byte 2 to read uint16", e.getMessage());
    }
  }
コード例 #11
0
  @Test
  public void testByte() throws IOException {
    // test writing and reading bytes.
    writer.writeByte((byte) 1);
    writer.writeByte((byte) 0xff);
    writer.writeByte((byte) '\"');
    writer.writeByte((byte) 0);

    BinaryReader reader = getReader();

    assertEquals((byte) 1, reader.expectByte());
    assertEquals((byte) 0xff, reader.expectByte());
    assertEquals((byte) '\"', reader.expectByte());
    assertEquals((byte) 0, reader.expectByte());

    try {
      reader.expectByte();
    } catch (IOException e) {
      assertEquals("Missing expected byte", e.getMessage());
    }
  }
コード例 #12
0
  @Test
  public void testWriteEndianNess() throws IOException {
    writer.writeShort((short) 4);
    assertArrayEquals(new byte[] {0, 4}, out.toByteArray());
    out.reset();

    writer.writeInt(4);
    assertArrayEquals(new byte[] {0, 0, 0, 4}, out.toByteArray());
    out.reset();

    writer.writeLong(4L);
    assertArrayEquals(new byte[] {0, 0, 0, 0, 0, 0, 0, 4}, out.toByteArray());
    out.reset();

    writer.writeUInt16(4);
    assertArrayEquals(new byte[] {0, 4}, out.toByteArray());
    out.reset();

    writer.writeUInt24(4);
    assertArrayEquals(new byte[] {0, 0, 4}, out.toByteArray());
    out.reset();

    writer.writeUInt32(4);
    assertArrayEquals(new byte[] {0, 0, 0, 4}, out.toByteArray());
    out.reset();
  }
コード例 #13
0
  @Test
  public void testBinary() throws IOException {
    Binary bytes =
        Binary.wrap(new byte[] {0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 7, 6, 5, 4, 3, 2, 1});
    // test writing and reading bytes.
    writer.writeBinary(bytes);

    BinaryReader reader = getReader();

    Binary read = reader.expectBinary(bytes.length());

    assertEquals(bytes, read);
  }
コード例 #14
0
  @Test
  public void testBytes() throws IOException {
    byte[] bytes = new byte[] {0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 7, 6, 5, 4, 3, 2, 1};
    // test writing and reading bytes.
    writer.write(bytes);

    BinaryReader reader = getReader();

    byte[] read = new byte[bytes.length];
    reader.read(read);

    assertArrayEquals(bytes, read);
  }
コード例 #15
0
  @Test
  public void testBadBinary() throws IOException {
    Binary bytes =
        Binary.wrap(new byte[] {0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 7, 6, 5, 4, 3, 2, 1});
    // test writing and reading bytes.
    writer.writeBinary(bytes);

    BinaryReader reader = getReader();

    try {
      reader.expectBinary(bytes.length() + 1);
      fail("No exception on bad binary data");
    } catch (IOException e) {
      assertEquals("Not enough data available on stream: 20 < 21", e.getMessage());
    }
  }
コード例 #16
0
  @Test
  public void testSigned() throws IOException {
    writer.writeSigned(-1, 1);
    writer.writeSigned(-2, 2);
    writer.writeSigned(-3, 4);
    writer.writeSigned(-4, 8);
    writer.writeSigned(-100L, 1);
    writer.writeSigned(-200L, 2);
    writer.writeSigned(-300L, 4);
    writer.writeSigned(-400L, 8);

    try {
      writer.writeSigned(-8, 3);
      fail("No exception on bad argument");
    } catch (IllegalArgumentException e) {
      assertEquals("Unsupported byte count for signed: 3", e.getMessage());
    }

    try {
      writer.writeSigned(-8L, 3);
      fail("No exception on bad argument");
    } catch (IllegalArgumentException e) {
      assertEquals("Unsupported byte count for signed: 3", e.getMessage());
    }

    BinaryReader reader = getReader();

    try {
      reader.expectSigned(3);
      fail("No exception on bad argument");
    } catch (IllegalArgumentException e) {
      assertEquals("Unsupported byte count for signed: 3", e.getMessage());
    }

    assertEquals(-1, reader.expectSigned(1));
    assertEquals(-2, reader.expectSigned(2));
    assertEquals(-3, reader.expectSigned(4));
    assertEquals(-4, reader.expectSigned(8));
  }