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()); }
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()); }
@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)); }
private void assertBadExpectUnsigned(String message, byte[] data, int bytes) { ByteArrayInputStream bais = new ByteArrayInputStream(data); try { BinaryReader reader = new BigEndianBinaryReader(bais); reader.expectUnsigned(bytes); fail("No exception on bad short"); } catch (IOException e) { assertEquals(message, e.getMessage()); } }
@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); }
@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); }
@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()); }
@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()); }
@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()); } }
@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()); }
@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()); }
@Test public void testRead() throws IOException { out.write(new byte[] {1, 2, 3, 4}); BinaryReader reader = getReader(); assertEquals(1, reader.read()); byte[] tmp = new byte[10]; assertEquals(3, reader.read(tmp, 2, 8)); assertArrayEquals(new byte[] {0, 0, 2, 3, 4, 0, 0, 0, 0, 0}, tmp); try { reader.read(tmp, 5, 6); } catch (IllegalArgumentException e) { assertEquals("Illegal arguments for read: byte[10], off:5, len:6", e.getMessage()); } }
@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()); } }
@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()); } }
@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)); }
public Record(BinaryReader binaryReader, ChunkHeader chunkHeader) throws IOException { super(binaryReader, chunkHeader.getOffset() + binaryReader.getPosition()); magicNumber = NumberUtil.intValueExpected(binaryReader.readDWord(), 10794, "Invalid magic number."); size = NumberUtil.intValueMax(binaryReader.readDWord(), 0x10000, "Invalid size."); recordNum = binaryReader.readQWord(); timestamp = binaryReader.readFileTime(); rootNode = new RootNode(binaryReader, chunkHeader, null); int desiredPosition = getInitialPosition() + size - 4; int skipAmount = desiredPosition - binaryReader.getPosition(); if (skipAmount > 0) { binaryReader.skip(skipAmount); } size2 = NumberUtil.intValueExpected(binaryReader.readDWord(), size, "Size 2 doesn't match."); }
@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); }