@Test
public void shouldUnmarshalNumberWithColour() throws Exception {
ByteArrayBitStreamWriter writer = new ByteArrayBitStreamWriter();
writer.writeByte(22);
writer.writeByte(14);
writer.close();
byte[] bytes = writer.toByteArray();
assertThat(bytes.length, is(2));
Unmarshaller parser = dadlContext.createUnmarshaller();
NumberWithColour nwc = parser.unmarshal(bytes, NumberWithColour.class);
assertThat(nwc, is(notNullValue()));
assertThat(nwc.getI1(), is(22));
assertThat(nwc.getC(), is(Colour.YELLOW));
}
@Test
public void shouldUnmarshalList() throws Exception {
ByteArrayBitStreamWriter writer = new ByteArrayBitStreamWriter();
writer.writeByte(3);
writer.writeInt(16);
writer.writeInt(25);
writer.writeInt(36);
writer.close();
byte[] bytes = writer.toByteArray();
assertThat(bytes.length, is(13));
Unmarshaller unmarshaller = dadlContext.createUnmarshaller();
NumberList numberList = unmarshaller.unmarshal(writer.toByteArray(), NumberList.class);
assertThat(numberList.getNumItems(), is(3));
assertThat(numberList.getItems(), contains(16, 25, 36));
}
@Test
public void shouldUnmarshalTaggedString() throws Exception {
ByteArrayBitStreamWriter writer = new ByteArrayBitStreamWriter();
String text = "Hello DADL!";
writer.writeByte(0x0A);
writer.writeByte(2 + text.length());
writer.writeByte(22);
writer.writeByte(14);
writer.writeBytes(text);
writer.close();
byte[] bytes = writer.toByteArray();
assertThat(bytes.length, is(15));
Unmarshaller unmarshaller = dadlContext.createUnmarshaller();
TaggedString taggedString = unmarshaller.unmarshal(bytes, TaggedString.class);
assertThat(taggedString.getText(), is(text));
}
@Test
public void shouldUnmarshalSequenceWithOptionalElements() throws IOException {
ByteArrayBitStreamWriter writer = new ByteArrayBitStreamWriter();
writer.writeBits(0x0B, 8);
writer.writeBits(7, 8);
writer.writeBits(42, 24);
writer.writeBits(12345678, 32);
writer.close();
byte[] bytes = writer.toByteArray();
assertThat(bytes.length, is(9));
Unmarshaller parser = dadlContext.createUnmarshaller();
SequenceWithOptional choice = parser.unmarshal(bytes, SequenceWithOptional.class);
assertThat(choice, is(notNullValue()));
assertThat(choice.getOpt1(), is(nullValue()));
assertThat(choice.getOpt2(), is(notNullValue()));
assertThat(choice.getOpt2().getI21(), is(42));
assertThat(choice.getOpt2().getI22(), is(12345678));
}
@Test
public void shouldUnmarshalTaggedListWithSuffix() throws IOException {
ByteArrayBitStreamWriter writer = new ByteArrayBitStreamWriter();
writer.writeByte(0x8C);
writer.writeByte(8);
writer.writeShort(500);
writer.writeShort(600);
writer.writeShort(700);
writer.writeShort(800);
writer.writeInt(999);
writer.close();
byte[] bytes = writer.toByteArray();
assertThat(bytes.length, is(14));
Unmarshaller unmarshaller = dadlContext.createUnmarshaller();
TaggedListWithSuffix tlws = unmarshaller.unmarshal(bytes, TaggedListWithSuffix.class);
assertThat(tlws, is(notNullValue()));
TaggedList tl = tlws.getTaggedList();
assertThat(tl.getIndexes().size(), is(4));
assertThat(tl.getIndexes(), contains(500, 600, 700, 800));
assertThat(tlws.getSuffix(), is(999));
}
@Test
public void shouldUnmarshalBcdSequence() throws Exception {
ByteArrayBitStreamWriter writer = new ByteArrayBitStreamWriter();
writer.writeShort(4096);
writer.writeBits(1, 4);
writer.writeBits(2, 4);
writer.writeBits(3, 4);
writer.writeBits(4, 4);
writer.close();
byte[] bytes = writer.toByteArray();
assertThat(bytes.length, is(4));
Unmarshaller unmarshaller = dadlContext.createUnmarshaller();
BcdSequence bcdSequence = unmarshaller.unmarshal(bytes, BcdSequence.class);
assertThat(bcdSequence.getI16(), is(4096));
assertThat(bcdSequence.getBcd(), is(1234));
}
@Test
public void shouldUnmarshalBitField() throws Exception {
ByteArrayBitStreamWriter writer = new ByteArrayBitStreamWriter();
writer.writeBits(3, 2);
writer.writeBits(6, 3);
writer.writeBits(11, 4);
writer.writeBits(125, 7);
writer.close();
byte[] bytes = writer.toByteArray();
assertThat(bytes.length, is(2));
Unmarshaller unmarshaller = dadlContext.createUnmarshaller();
BitField bitField = unmarshaller.unmarshal(bytes, BitField.class);
assertThat(bitField.getB2(), is(3));
assertThat(bitField.getB3(), is(6));
assertThat(bitField.getB4(), is(11));
assertThat(bitField.getB7(), is(125));
}
@Test
public void shouldUnmarshalChoiceWithDiscriminator() throws Exception {
ByteArrayBitStreamWriter writer = new ByteArrayBitStreamWriter();
writer.writeBits(40, 8);
writer.writeBits(42, 24);
writer.writeBits(12345678, 32);
writer.close();
byte[] bytes = writer.toByteArray();
assertThat(bytes.length, is(8));
Unmarshaller parser = dadlContext.createUnmarshaller();
ChoiceWithDiscriminator choice = parser.unmarshal(bytes, ChoiceWithDiscriminator.class);
assertThat(choice, is(notNullValue()));
assertThat(choice.getOpt3(), is(nullValue()));
assertThat(choice.getOpt4(), is(notNullValue()));
assertThat(choice.getOpt4().getI41(), is(42));
assertThat(choice.getOpt4().getI42(), is(12345678));
}
@Test
public void shouldUnmarshalSeqMinLengthSuffix() throws Exception {
ByteArrayBitStreamWriter writer = new ByteArrayBitStreamWriter();
writer.writeByte(2);
writer.writeInt(17);
writer.writeInt(39);
for (int i = 0; i < 11; i++) {
writer.write(0);
}
writer.writeByte(99);
writer.close();
byte[] bytes = writer.toByteArray();
assertThat(bytes.length, is(21));
Unmarshaller unmarshaller = dadlContext.createUnmarshaller();
SeqMinLengthSuffix seqMinLength = unmarshaller.unmarshal(bytes, SeqMinLengthSuffix.class);
NumberList list = seqMinLength.getSml().getNumberList();
assertThat(list.getNumItems(), is(2));
assertThat(list.getItems().get(0), is(17));
assertThat(list.getItems().get(1), is(39));
assertThat(seqMinLength.getSuffix(), is(99));
}
@Test
public void shouldUnmarshalOpaqueContainer() throws Exception {
ByteArrayBitStreamWriter writer = new ByteArrayBitStreamWriter();
writer.writeInt(4);
writer.writeByte(20);
writer.writeByte(22);
writer.writeByte(24);
writer.writeByte(26);
writer.close();
byte[] bytes = writer.toByteArray();
assertThat(bytes.length, is(8));
Unmarshaller parser = dadlContext.createUnmarshaller();
OpaqueContainer oc = parser.unmarshal(bytes, OpaqueContainer.class);
assertThat(oc, is(notNullValue()));
assertThat(oc.getLength(), is(4));
assertThat(oc.getContent().length, is(oc.getLength()));
assertThat(oc.getContent()[0], is((byte) 20));
assertThat(oc.getContent()[1], is((byte) 22));
assertThat(oc.getContent()[2], is((byte) 24));
assertThat(oc.getContent()[3], is((byte) 26));
}
@Test
public void shouldParseAllNumbers() throws IOException {
ByteArrayBitStreamWriter writer = new ByteArrayBitStreamWriter();
writer.writeBits(5, 8);
writer.writeBits(200, 8);
writer.writeBits(1000, 16);
writer.writeBits(50000, 16);
writer.writeBits(5_000_000L, 24);
writer.writeBits(10_000_000L, 24);
writer.writeInt(-100000);
writer.writeUnsignedInt(3_000_000_000L);
writer.close();
byte[] bytes = writer.toByteArray();
assertThat(bytes.length, is(20));
Unmarshaller parser = dadlContext.createUnmarshaller();
AllNumbers an = parser.unmarshal(bytes, AllNumbers.class);
assertThat(an, is(notNullValue()));
ShortNumbers sn = an.getShortNumbers();
assertThat(sn, is(notNullValue()));
assertThat(sn.getI8(), is(5));
assertThat(sn.getU8(), is(200));
assertThat(sn.getI16(), is(1000));
assertThat(sn.getU16(), is(50000));
LongNumbers ln = an.getLongNumbers();
assertThat(ln, is(notNullValue()));
assertThat(ln.getI24(), is(5_000_000));
assertThat(ln.getU24(), is(10_000_000));
assertThat(ln.getI32(), is(-100_000));
assertThat(ln.getU32(), is(3_000_000_000L));
}