public void testInheritanceProtobuf() throws IOException {
if (skipTests) {
System.err.println("RuntimeSchema.MORPH_NON_FINAL_POJOS was not enabled.");
return;
}
System.err.println("executing inheritance test for protobuf ... ");
Schema<InputSystem> schema = RuntimeSchema.getSchema(InputSystem.class);
InputSystem sys = new InputSystem();
KeyBoard kb = new KeyBoard();
Mouse ms = new Mouse();
kb.setName("Test");
kb.setNumberOfKeys(10);
ms.setName("Test1");
ms.setNumberOfButtons(2);
List<InputDevice> devices = new ArrayList<InputDevice>();
devices.add(ms);
devices.add(kb);
sys.setInputDevices(devices);
ByteArrayOutputStream out = new ByteArrayOutputStream();
ProtobufIOUtil.writeTo(out, sys, schema, buf());
byte[] listData = out.toByteArray();
InputSystem deserSystem = new InputSystem();
ByteArrayInputStream in = new ByteArrayInputStream(listData);
ProtobufIOUtil.mergeFrom(in, deserSystem, schema, buf());
assertEquals(sys, deserSystem);
}
/**
* HasHasBar wraps an object without a schema. That object will have to be serialized via the
* default java serialization and it will be delimited.
*
* <p>HasBar wraps a message {@link Bar}.
*/
public void testJavaSerializable() throws Exception {
Schema<HasHasBar> schema = RuntimeSchema.getSchema(HasHasBar.class);
HasHasBar hhbCompare = new HasHasBar("hhb", new HasBar(12345, "hb", SerializableObjects.bar));
HasHasBar dhhb = new HasHasBar();
int expectedSize = ComputedSizeOutput.getSize(hhbCompare, schema);
byte[] deferred = toByteArray(hhbCompare, schema);
assertTrue(deferred.length == expectedSize);
ProtostuffIOUtil.mergeFrom(deferred, dhhb, schema);
assertEquals(hhbCompare, dhhb);
}
public void testFoo() throws Exception {
Schema<Foo> schema = RuntimeSchema.getSchema(Foo.class);
Foo fooCompare = foo;
Foo dfoo = new Foo();
byte[] deferred = toByteArray(fooCompare, schema);
// ComputedSizeOutput is format compatible with protobuf
// E.g collections are not serialized ... only its members/elements are.
if (!RuntimeEnv.COLLECTION_SCHEMA_ON_REPEATED_FIELDS)
assertTrue(deferred.length == ComputedSizeOutput.getSize(fooCompare, schema));
ProtostuffIOUtil.mergeFrom(deferred, dfoo, schema);
SerializableObjects.assertEquals(fooCompare, dfoo);
}
public void testPojoWithArrayAndSet() throws Exception {
PojoWithArrayAndSet pojoCompare = filledPojoWithArrayAndSet();
Schema<PojoWithArrayAndSet> schema = RuntimeSchema.getSchema(PojoWithArrayAndSet.class);
PojoWithArrayAndSet dpojo = new PojoWithArrayAndSet();
int expectedSize = ComputedSizeOutput.getSize(pojoCompare, schema, true);
byte[] deferred = toByteArray(pojoCompare, schema);
assertTrue(deferred.length == expectedSize);
ProtostuffIOUtil.mergeFrom(deferred, dpojo, schema);
assertEquals(pojoCompare, dpojo);
// System.err.println(dpojo.getSomeEnumAsSet());
// System.err.println(dpojo.getSomeFloatAsSet());
}
public void testBaz() throws Exception {
Schema<Baz> schema = RuntimeSchema.getSchema(Baz.class);
for (Baz bazCompare : new Baz[] {baz, negativeBaz}) {
Baz dbaz = new Baz();
int expectedSize = ComputedSizeOutput.getSize(bazCompare, schema);
byte[] deferred = toByteArray(bazCompare, schema);
assertTrue(deferred.length == expectedSize);
ProtostuffIOUtil.mergeFrom(deferred, dbaz, schema);
SerializableObjects.assertEquals(bazCompare, dbaz);
// System.err.println(dbaz.getId());
// System.err.println(dbaz.getName());
// System.err.println(dbaz.getTimestamp());
}
}
public void testBar() throws Exception {
Schema<Bar> schema = RuntimeSchema.getSchema(Bar.class);
for (Bar barCompare : new Bar[] {bar, negativeBar}) {
Bar dbar = new Bar();
int expectedSize = ComputedSizeOutput.getSize(barCompare, schema);
byte[] deferred = toByteArray(barCompare, schema);
assertTrue(deferred.length == expectedSize);
ProtostuffIOUtil.mergeFrom(deferred, dbar, schema);
SerializableObjects.assertEquals(barCompare, dbar);
// System.err.println(dbar.getSomeInt());
// System.err.println(dbar.getSomeLong());
// System.err.println(dbar.getSomeFloat());
// System.err.println(dbar.getSomeDouble());
// System.err.println(dbar.getSomeBytes());
// System.err.println(dbar.getSomeString());
// System.err.println(dbar.getSomeEnum());
// System.err.println(dbar.getSomeBoolean());
}
}
public void testCollectionAndMapSchema() throws Exception {
if (!RuntimeEnv.COLLECTION_SCHEMA_ON_REPEATED_FIELDS) {
System.err.println("RuntimeSchema.COLLECTION_SCHEMA_ON_REPEATED_FIELDS was not enabled.");
return;
}
Schema<PojoFoo> schema = RuntimeSchema.getSchema(PojoFoo.class);
Pipe.Schema<PojoFoo> pipeSchema = ((MappedSchema<PojoFoo>) schema).pipeSchema;
PojoFoo p = new PojoFoo().fill();
byte[] data = toByteArray(p, schema);
PojoFoo pFromByteArray = new PojoFoo();
mergeFrom(data, 0, data.length, pFromByteArray, schema);
assertEquals(p, pFromByteArray);
PojoFoo pFromStream = new PojoFoo();
ByteArrayInputStream in = new ByteArrayInputStream(data);
mergeFrom(in, pFromStream, schema);
assertEquals(p, pFromByteArray);
roundTrip(p, schema, pipeSchema);
}
