diff --git a/.travis.yml b/.travis.yml index add81f7..fef94bd 100644 --- a/.travis.yml +++ b/.travis.yml @@ -28,7 +28,6 @@ jdk: - openjdk8 script: - make CC=gcc-7 CXX=g++-7 - - make CC=gcc-7 CXX=g++-7 addressbook - - sbt test - - sbt doc + - mvn compile + - mvn test diff --git a/Makefile b/Makefile index 1c3ef13..1e041a5 100644 --- a/Makefile +++ b/Makefile @@ -28,8 +28,3 @@ MINGW_CXX=i686-w64-mingw32-g++ MINGW_FLAGS=-O2 -DNDEBUG -I/usr/local/include -std=c++14 -static -static-libgcc -static-libstdc++ capnpc-java.exe : $(CAPNPC_JAVA_SOURCES) $(MINGW_CXX) $(MINGW_FLAGS) $(CAPNPC_JAVA_SOURCES) $(MINGW_LIBS) -o capnpc-java.exe - -addressbook : capnpc-java - PWD=pwd - mkdir -p examples/src/main/generated - capnp compile -I$(PWD)/compiler/src/main/schema --src-prefix=examples/src/main/schema -o./capnpc-java:examples/src/main/generated examples/src/main/schema/addressbook.capnp diff --git a/benchmark/pom.xml b/benchmark/pom.xml new file mode 100644 index 0000000..474d7ff --- /dev/null +++ b/benchmark/pom.xml @@ -0,0 +1,92 @@ + + + 4.0.0 + org.capnproto + benchmark + jar + capnproto-java benchmark + 0.1.4 + capnproto-java benchmark + + org.capnproto + + https://capnproto.org/ + + + MIT + http://opensource.org/licenses/MIT + repo + + + + git@github.com:capnproto/capnproto-java.git + scm:git@github.com:capnproto/capnproto-java.git + + + + dwrensha + David Renshaw + https://github.com/dwrensha + + + + + org.capnproto + runtime + 0.1.4 + + + + + + + maven-antrun-plugin + 3.0.0 + + + generate-sources + generate-sources + + + + + + + + + + + + + + + + + run + + + + + + + org.codehaus.mojo + build-helper-maven-plugin + 3.1.0 + + + add-generated-sources + generate-sources + + add-source + + + + src/main/generated + + + + + + + + diff --git a/compiler/pom.xml b/compiler/pom.xml new file mode 100644 index 0000000..4cbede3 --- /dev/null +++ b/compiler/pom.xml @@ -0,0 +1,98 @@ + + + 4.0.0 + org.capnproto + compiler + jar + schema compiler plugin for java + 0.1.4 + capnpc-java + + org.capnproto + + https://capnproto.org/ + + + MIT + http://opensource.org/licenses/MIT + repo + + + + git@github.com:capnproto/capnproto-java.git + scm:git@github.com:capnproto/capnproto-java.git + + + + dwrensha + David Renshaw + https://github.com/dwrensha + + + + + junit + junit + 4.12 + test + + + + org.capnproto + runtime + 0.1.4 + + + + + + + maven-antrun-plugin + 3.0.0 + + + generate-test-sources + generate-test-sources + + + + + + + + + + + + + + + + run + + + + + + + org.codehaus.mojo + build-helper-maven-plugin + 3.1.0 + + + add-generated-test-sources + generate-test-sources + + add-test-source + + + + src/test/generated + + + + + + + + diff --git a/compiler/src/test/java/org/capnproto/EncodingTest.java b/compiler/src/test/java/org/capnproto/EncodingTest.java new file mode 100644 index 0000000..ca1a702 --- /dev/null +++ b/compiler/src/test/java/org/capnproto/EncodingTest.java @@ -0,0 +1,851 @@ +package org.capnproto.test; + +import org.capnproto.*; +import org.capnproto.Void; +import org.junit.Assert; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +public class EncodingTest { + @org.junit.Test + public void testAllTypes() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + TestUtil.initTestMessage(allTypes); + TestUtil.checkTestMessage(allTypes); + TestUtil.checkTestMessage(allTypes.asReader()); + } + + @org.junit.Test + public void testAllTypesMultiSegment() { + MessageBuilder message = new MessageBuilder(5, BuilderArena.AllocationStrategy.FIXED_SIZE); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + TestUtil.initTestMessage(allTypes); + + TestUtil.checkTestMessage(allTypes); + TestUtil.checkTestMessage(allTypes.asReader()); + } + + @org.junit.Test + public void testSetters() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + TestUtil.initTestMessage(allTypes); + + MessageBuilder message2 = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes2 = message2.initRoot(Test.TestAllTypes.factory); + + allTypes2.setStructField(allTypes.asReader()); + TestUtil.checkTestMessage(allTypes2.getStructField()); + + Test.TestAllTypes.Reader reader = allTypes2.asReader().getStructField(); + TestUtil.checkTestMessage(reader); + } + + @org.junit.Test + public void testZeroing() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + + StructList.Builder structList = allTypes.initStructList(3); + TestUtil.initTestMessage(structList.get(0)); + + Test.TestAllTypes.Builder structField = allTypes.initStructField(); + TestUtil.initTestMessage(structField); + + TestUtil.initTestMessage(structList.get(1)); + TestUtil.initTestMessage(structList.get(2)); + TestUtil.checkTestMessage(structList.get(0)); + allTypes.initStructList(0); + + TestUtil.checkTestMessage(allTypes.getStructField()); + Test.TestAllTypes.Reader allTypesReader = allTypes.asReader(); + TestUtil.checkTestMessage(allTypesReader.getStructField()); + + AnyPointer.Builder any = message.initRoot(AnyPointer.factory); + ByteBuffer[] segments = message.getSegmentsForOutput(); + for (ByteBuffer segment : segments) { + for (int j = 0; j < segment.limit(); j++) { + Assert.assertEquals(segment.get(j), 0); + } + } + } + + @org.junit.Test + public void testDoubleFarPointers() throws IOException { + byte[] bytes = new byte[]{2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, + 6, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 1, 7, -1, 127, 0, 0, 0, 0}; + + ArrayInputStream input = new ArrayInputStream(java.nio.ByteBuffer.wrap(bytes)); + MessageReader message = org.capnproto.Serialize.read(input); + Test.TestAllTypes.Reader root = message.getRoot(Test.TestAllTypes.factory); + + Assert.assertTrue(root.getBoolField()); + Assert.assertEquals(root.getInt8Field(), 7); + Assert.assertEquals(root.getInt16Field(), 32767); + } + + @org.junit.Test + public void testUpgradeStruct() { + MessageBuilder builder = new MessageBuilder(); + Test.TestAnyPointer.Builder root = builder.initRoot(Test.TestAnyPointer.factory); + + { + Test.TestOldVersion.Builder oldVersion = root.getAnyPointerField().initAs(Test.TestOldVersion.factory); + oldVersion.setOld1(123); + oldVersion.setOld2("foo"); + Test.TestOldVersion.Builder sub = oldVersion.initOld3(); + sub.setOld1(456); + sub.setOld2("bar"); + } + + { + Test.TestNewVersion.Reader newVersion = root.getAnyPointerField().asReader().getAs(Test.TestNewVersion.factory); + Assert.assertEquals(newVersion.getOld1(), 123); + Assert.assertEquals(newVersion.getOld2().toString(), "foo"); + Assert.assertEquals(newVersion.getNew2().toString(), "baz"); + Assert.assertEquals(newVersion.hasNew2(), false); + Assert.assertEquals(newVersion.hasNew3(), false); + } + } + + @org.junit.Test + public void testUpgradeStructInBuilder() { + MessageBuilder builder = new MessageBuilder(); + Test.TestAnyPointer.Builder root = builder.initRoot(Test.TestAnyPointer.factory); + + { + Test.TestOldVersion.Builder oldVersion = root.getAnyPointerField().initAs(Test.TestOldVersion.factory); + oldVersion.setOld1(123); + oldVersion.setOld2("foo"); + Test.TestOldVersion.Builder sub = oldVersion.initOld3(); + sub.setOld1(456); + sub.setOld2("bar"); + } + { + Test.TestNewVersion.Builder newVersion = root.getAnyPointerField().getAs(Test.TestNewVersion.factory); + Assert.assertEquals(newVersion.getOld1(), 123); + Assert.assertEquals(newVersion.getOld2().toString(), "foo"); + Assert.assertEquals(newVersion.getNew1(), 987); + Assert.assertEquals(newVersion.getNew2().toString(), "baz"); + Test.TestNewVersion.Builder sub = newVersion.getOld3(); + Assert.assertEquals(sub.getOld1(), 456); + Assert.assertEquals(sub.getOld2().toString(), "bar"); + + newVersion.setOld1(234); + newVersion.setOld2("qux"); + newVersion.setNew1(654); + newVersion.setNew2("quux"); + } + { + Test.TestOldVersion.Builder oldVersion = root.getAnyPointerField().getAs(Test.TestOldVersion.factory); + Assert.assertEquals(oldVersion.getOld1(), 234); + Assert.assertEquals(oldVersion.getOld2().toString(), "qux"); + } + } + + @org.junit.Test + public void testStructListUpgrade() { + MessageBuilder message = new MessageBuilder(); + Test.TestAnyPointer.Builder root = message.initRoot(Test.TestAnyPointer.factory); + AnyPointer.Builder any = root.getAnyPointerField(); + + { + PrimitiveList.Long.Builder longs = any.initAs(PrimitiveList.Long.factory, 3); + longs.set(0, 123); + longs.set(1, 456); + longs.set(2, 789); + } + { + StructList.Reader olds = any.asReader().getAs(Test.TestOldVersion.listFactory); + Assert.assertEquals(olds.get(0).getOld1(), 123); + Assert.assertEquals(olds.get(1).getOld1(), 456); + Assert.assertEquals(olds.get(2).getOld1(), 789); + } + { + StructList.Builder olds = any.getAs(Test.TestOldVersion.listFactory); + Assert.assertEquals(olds.size(), 3); + Assert.assertEquals(olds.get(0).getOld1(), 123); + Assert.assertEquals(olds.get(1).getOld1(), 456); + Assert.assertEquals(olds.get(2).getOld1(), 789); + + olds.get(0).setOld2("zero"); + olds.get(1).setOld2("one"); + olds.get(2).setOld2("two"); + } + { + StructList.Builder news = any.getAs(Test.TestNewVersion.listFactory); + Assert.assertEquals(news.size(), 3); + Assert.assertEquals(news.get(0).getOld1(), 123); + Assert.assertEquals(news.get(0).getOld2().toString(), "zero"); + + Assert.assertEquals(news.get(1).getOld1(), 456); + Assert.assertEquals(news.get(1).getOld2().toString(), "one"); + + Assert.assertEquals(news.get(2).getOld1(), 789); + Assert.assertEquals(news.get(2).getOld2().toString(), "two"); + } + } + + @org.junit.Test + public void testStructListUpgradeDoubleFar() { + byte[] bytes = new byte[]{ + 1,0,0,0,0x1f,0,0,0, // list, inline composite, 3 words + 4, 0, 0, 0, 1, 0, 2, 0, // struct tag. 1 element, 1 word data, 2 pointers. + 91,0,0,0,0,0,0,0, // data: 91 + 0x05,0,0,0, 0x42,0,0,0, // list pointer, offset 1, type = BYTE, length 8. + 0,0,0,0,0,0,0,0, // null pointer + 0x68,0x65,0x6c,0x6c,0x6f,0x21,0x21,0}; // "hello!!" + + ByteBuffer segment = java.nio.ByteBuffer.wrap(bytes); + segment.order(java.nio.ByteOrder.LITTLE_ENDIAN); + MessageReader messageReader = new MessageReader(new ByteBuffer[]{segment}, ReaderOptions.DEFAULT_READER_OPTIONS); + + StructList.Factory oldFactory = + new StructList.Factory(Test.TestOldVersion.factory); + StructList.Reader oldVersion = messageReader.getRoot(oldFactory); + + Assert.assertEquals(oldVersion.size(), 1); + Assert.assertEquals(oldVersion.get(0).getOld1(), 91); + Assert.assertEquals(oldVersion.get(0).getOld2().toString(), "hello!!"); + + // Make the first segment exactly large enough to fit the original message. + // This leaves no room for a far pointer landing pad in the first segment. + MessageBuilder message = new MessageBuilder(6); + message.setRoot(oldFactory, oldVersion); + + ByteBuffer[] segments = message.getSegmentsForOutput(); + Assert.assertEquals(segments.length, 1); + Assert.assertEquals(segments[0].limit(), 6 * 8); + + StructList.Factory newFactory = + new StructList.Factory(Test.TestNewVersion.factory); + StructList.Builder newVersion = message.getRoot(newFactory); + Assert.assertEquals(newVersion.size(), 1); + Assert.assertEquals(newVersion.get(0).getOld1(), 91); + Assert.assertEquals(newVersion.get(0).getOld2().toString(), "hello!!"); + + ByteBuffer[] segments1 = message.getSegmentsForOutput(); + Assert.assertEquals(segments[0].limit(), 6 * 8); + for (int ii = 8; ii < (5 * 8) - 1; ++ii) { + // Check the the old list, including the tag, was zeroed. + Assert.assertEquals(segments[0].get(ii), 0); + } + } + + @org.junit.Test + public void testListBuilderAsReader() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + + allTypes.initVoidList(10); + Assert.assertEquals(allTypes.getVoidList().asReader().size(), 10); + + PrimitiveList.Boolean.Builder boolList = allTypes.initBoolList(7); + boolList.set(3, true); + PrimitiveList.Boolean.Reader boolListReader = boolList.asReader(); + Assert.assertEquals(boolListReader.size(), 7); + Assert.assertEquals(boolListReader.get(0), false); + Assert.assertEquals(boolListReader.get(1), false); + Assert.assertEquals(boolListReader.get(2), false); + Assert.assertEquals(boolListReader.get(3), true); + Assert.assertEquals(boolListReader.get(4), false); + + PrimitiveList.Byte.Builder int8List = allTypes.initInt8List(9); + int8List.set(4, (byte)100); + int8List.set(8, (byte)11); + PrimitiveList.Byte.Reader int8ListReader = int8List.asReader(); + Assert.assertEquals(int8ListReader.size(), 9); + Assert.assertEquals(int8ListReader.get(0), 0); + Assert.assertEquals(int8ListReader.get(4), 100); + Assert.assertEquals(int8ListReader.get(8), 11); + + PrimitiveList.Short.Builder int16List = allTypes.initInt16List(2); + int16List.set(0, (short)1); + PrimitiveList.Short.Reader int16ListReader = int16List.asReader(); + Assert.assertEquals(int16ListReader.size(), 2); + Assert.assertEquals(int16ListReader.get(0), 1); + Assert.assertEquals(int16ListReader.get(1), 0); + + // TODO other primitive lists + + TextList.Builder textList = allTypes.initTextList(1); + textList.set(0, new Text.Reader("abcdefg")); + TextList.Reader textListReader = textList.asReader(); + Assert.assertEquals(textListReader.size(), 1); + Assert.assertEquals(textListReader.get(0).toString(), "abcdefg"); + + DataList.Builder dataList = allTypes.initDataList(1); + dataList.set(0, new Data.Reader(new byte[]{1,2,3,4})); + DataList.Reader dataListReader = dataList.asReader(); + Assert.assertEquals(dataListReader.size(), 1); + Assert.assertTrue(java.util.Arrays.equals(dataListReader.get(0).toArray(), new byte[]{1,2,3,4})); + + StructList.Builder structList = allTypes.initStructList(2); + structList.get(0).setInt8Field((byte)5); + structList.get(1).setInt8Field((byte)9); + StructList.Reader structListReader = structList.asReader(Test.TestAllTypes.factory); + Assert.assertEquals(structListReader.size(), 2); + Assert.assertEquals(structListReader.get(0).getInt8Field(), 5); + Assert.assertEquals(structListReader.get(1).getInt8Field(), 9); + + EnumList.Builder enumList = allTypes.initEnumList(3); + enumList.set(0, Test.TestEnum.FOO); + enumList.set(1, Test.TestEnum.BAR); + enumList.set(2, Test.TestEnum.BAZ); + EnumList.Reader enumListReader = enumList.asReader(); + Assert.assertEquals(enumListReader.size(), 3); + Assert.assertEquals(enumListReader.get(0), Test.TestEnum.FOO); + Assert.assertEquals(enumListReader.get(1), Test.TestEnum.BAR); + Assert.assertEquals(enumListReader.get(2), Test.TestEnum.BAZ); + } + + @org.junit.Test + public void testNestedListBuilderAsReader() { + MessageBuilder builder = new MessageBuilder(); + Test.TestLists.Builder root = builder.initRoot(Test.TestLists.factory); + + ListList.Builder> structListList = root.initStructListList(3); + StructList.Builder structList0 = structListList.init(0, 1); + structList0.get(0).setInt16Field((short)1); + // leave structList1 as default + StructList.Builder structList2 = structListList.init(2, 3); + structList2.get(0).setInt16Field((short)22); + structList2.get(1).setInt16Field((short)333); + structList2.get(2).setInt16Field((short)4444); + + ListList.Reader> structListListReader = + structListList.asReader(new StructList.Factory(Test.TestAllTypes.factory)); + Assert.assertEquals(structListListReader.size(), 3); + StructList.Reader structList0Reader = structListListReader.get(0); + Assert.assertEquals(structList0Reader.size(), 1); + Assert.assertEquals(structList0Reader.get(0).getInt16Field(), 1); + Assert.assertEquals(structListListReader.get(1).size(), 0); + StructList.Reader structList2Reader = structListListReader.get(2); + Assert.assertEquals(structList2Reader.size(), 3); + Assert.assertEquals(structList2Reader.get(0).getInt16Field(), 22); + Assert.assertEquals(structList2Reader.get(1).getInt16Field(), 333); + Assert.assertEquals(structList2Reader.get(2).getInt16Field(), 4444); + } + + @org.junit.Test + public void testGenerics() { + MessageBuilder message = new MessageBuilder(); + Test.TestGenerics.Factory factory = Test.TestGenerics.newFactory(Test.TestAllTypes.factory, Text.factory); + + Test.TestGenerics.Builder root = (Test.TestGenerics.Builder) message.initRoot(factory); + TestUtil.initTestMessage(root.getFoo()); + root.getDub().setFoo(Text.factory, new Text.Reader("Hello")); + + PrimitiveList.Byte.Builder bar = root.getDub().initBar(1); + bar.set(0, (byte) 11); + Test.TestAllTypes.Builder revBar = root.getRev().getBar(); + revBar.setInt8Field((byte) 111); + PrimitiveList.Boolean.Builder boolList = revBar.initBoolList(2); + boolList.set(0, false); + boolList.set(1, true); + + TestUtil.checkTestMessage(root.getFoo()); + Test.TestGenerics.Reader rootReader = root.asReader(factory); + TestUtil.checkTestMessage(rootReader.getFoo()); + Test.TestGenerics.Builder dubReader = root.getDub(); + Assert.assertEquals(dubReader.getFoo().toString(), "Hello"); + PrimitiveList.Byte.Builder barReader = dubReader.getBar(); + Assert.assertEquals(1, barReader.size()); + Assert.assertEquals(11, barReader.get(0)); + } + + @org.junit.Test + public void testUseGenerics() { + MessageBuilder message = new MessageBuilder(); + Test.TestUseGenerics.Builder root = message.initRoot(Test.TestUseGenerics.factory); + { + MessageBuilder message2 = new MessageBuilder(); + Test.TestGenerics.Factory factory2 = Test.TestGenerics.newFactory(AnyPointer.factory, AnyPointer.factory); + Test.TestGenerics.Builder root2 = message2.initRoot(factory2); + root2.initDub().setFoo(Text.factory, new Text.Reader("foobar")); + + root.setUnspecified(factory2, root2.asReader(factory2)); + } + + Assert.assertEquals("foobar", root.getUnspecified().getDub().getFoo().toString()); + } + + @org.junit.Test + public void testDefaults() { + MessageBuilder message = new MessageBuilder(); + Test.TestDefaults.Builder defaults = message.initRoot(Test.TestDefaults.factory); + TestUtil.checkDefaultMessage(defaults); + TestUtil.checkDefaultMessage(defaults.asReader()); + TestUtil.setDefaultMessage(defaults); + TestUtil.checkSettedDefaultMessage(defaults.asReader()); + } + + @org.junit.Test + public void testUnions() { + MessageBuilder builder = new MessageBuilder(); + Test.TestUnion.Builder root = builder.initRoot(Test.TestUnion.factory); + Test.TestUnion.Union0.Builder u0 = root.initUnion0(); + u0.initU0f1sp(10); + Assert.assertEquals(u0.which(), Test.TestUnion.Union0.Which.U0F1SP); + + u0.initPrimitiveList(10); + Assert.assertEquals(u0.which(), Test.TestUnion.Union0.Which.PRIMITIVE_LIST); + } + + @org.junit.Test + public void testGroups() { + MessageBuilder builder = new MessageBuilder(); + Test.TestGroups.Builder root = builder.initRoot(Test.TestGroups.factory); + { + Test.TestGroups.Groups.Foo.Builder foo = root.getGroups().initFoo(); + foo.setCorge(12345678); + foo.setGrault(123456789012345L); + foo.setGarply(new Text.Reader("foobar")); + + Assert.assertEquals(12345678, foo.getCorge()); + Assert.assertEquals(123456789012345L, foo.getGrault()); + Assert.assertEquals("foobar", foo.getGarply().toString()); + } + { + Test.TestGroups.Groups.Bar.Builder bar = root.getGroups().initBar(); + bar.setCorge(23456789); + bar.setGrault(new Text.Reader("barbaz")); + bar.setGarply(234567890123456L); + + Assert.assertEquals(23456789, bar.getCorge()); + Assert.assertEquals("barbaz", bar.getGrault().toString()); + Assert.assertEquals(234567890123456L, bar.getGarply()); + } + { + Test.TestGroups.Groups.Baz.Builder baz = root.getGroups().initBaz(); + baz.setCorge(34567890); + baz.setGrault(new Text.Reader("bazqux")); + baz.setGarply(new Text.Reader("quxquux")); + + Assert.assertEquals(34567890, baz.getCorge()); + Assert.assertEquals("bazqux", baz.getGrault().toString()); + Assert.assertEquals("quxquux", baz.getGarply().toString()); + } + } + + @org.junit.Test + public void testNestedLists() { + MessageBuilder builder = new MessageBuilder(); + Test.TestLists.Builder root = builder.initRoot(Test.TestLists.factory); + { + ListList.Builder intListList = root.initInt32ListList(2); + PrimitiveList.Int.Builder intList0 = intListList.init(0, 4); + intList0.set(0, 1); + intList0.set(1, 2); + intList0.set(2, 3); + intList0.set(3, 4); + PrimitiveList.Int.Builder intList1 = intListList.init(1, 1); + intList1.set(0, 100); + } + { + Test.TestLists.Reader reader = root.asReader(); + ListList.Reader intListList = reader.getInt32ListList(); + Assert.assertEquals(2, intListList.size()); + PrimitiveList.Int.Reader intList0 = intListList.get(0); + Assert.assertEquals(4, intList0.size()); + Assert.assertEquals(1, intList0.get(0)); + Assert.assertEquals(2, intList0.get(1)); + Assert.assertEquals(3, intList0.get(2)); + Assert.assertEquals(4, intList0.get(3)); + PrimitiveList.Int.Reader intList1 = intListList.get(1); + Assert.assertEquals(1, intList1.size()); + Assert.assertEquals(100, intList1.get(0)); + } + } + + @org.junit.Test + public void testConstants() { + Assert.assertEquals(Void.VOID, Test.TestConstants.VOID_CONST); + Assert.assertEquals(true, Test.TestConstants.BOOL_CONST); + Assert.assertEquals(-123, Test.TestConstants.INT8_CONST); + Assert.assertEquals(-12345, Test.TestConstants.INT16_CONST); + Assert.assertEquals(-12345678, Test.TestConstants.INT32_CONST); + Assert.assertEquals(-123456789012345L, Test.TestConstants.INT64_CONST); + + Assert.assertEquals(-22, Test.TestConstants.UINT8_CONST); + Assert.assertEquals(-19858, Test.TestConstants.UINT16_CONST); + Assert.assertEquals(-838178284, Test.TestConstants.UINT32_CONST); + Assert.assertEquals(-6101065172474983726L, Test.TestConstants.UINT64_CONST); + + Assert.assertEquals(1234.5f, Test.TestConstants.FLOAT32_CONST, TestUtil.DELTA); + Assert.assertEquals(-123e45, Test.TestConstants.FLOAT64_CONST, TestUtil.DELTA); + + Assert.assertEquals("foo", Test.TestConstants.TEXT_CONST.toString()); + Assert.assertArrayEquals(TestUtil.data("bar"), Test.TestConstants.DATA_CONST.toArray()); + + Assert.assertEquals(Test.TestEnum.CORGE, Test.TestConstants.ENUM_CONST); + { + Test.TestAllTypes.Reader subReader = Test.TestConstants.STRUCT_CONST; + Assert.assertEquals(subReader.getBoolField(), true); + Assert.assertEquals(subReader.getInt8Field(), -12); + Assert.assertEquals(subReader.getInt16Field(), 3456); + Assert.assertEquals(subReader.getInt32Field(), -78901234); + Assert.assertEquals(subReader.getInt64Field(), 56789012345678L); + Assert.assertEquals(subReader.getUInt8Field(), 90); + Assert.assertEquals(subReader.getUInt16Field(), 1234); + Assert.assertEquals(subReader.getUInt32Field(), 56789012); + Assert.assertEquals(subReader.getUInt64Field(), 345678901234567890L); + Assert.assertEquals(subReader.getFloat32Field(), -1.25e-10f, TestUtil.DELTA); + Assert.assertEquals(subReader.getFloat64Field(), 345, TestUtil.DELTA); + Assert.assertEquals(subReader.getTextField().toString(), "baz"); + } + + Assert.assertEquals(6, Test.TestConstants.VOID_LIST_CONST.size()); + + { + PrimitiveList.Boolean.Reader listReader = Test.TestConstants.BOOL_LIST_CONST; + Assert.assertEquals(4, listReader.size()); + Assert.assertEquals(true, listReader.get(0)); + Assert.assertEquals(false, listReader.get(1)); + Assert.assertEquals(false, listReader.get(2)); + Assert.assertEquals(true, listReader.get(3)); + } + + { + TextList.Reader listReader = Test.TestConstants.TEXT_LIST_CONST; + Assert.assertEquals(3, listReader.size()); + Assert.assertEquals("plugh", listReader.get(0).toString()); + Assert.assertEquals("xyzzy", listReader.get(1).toString()); + Assert.assertEquals("thud", listReader.get(2).toString()); + } + + { + StructList.Reader listReader = Test.TestConstants.STRUCT_LIST_CONST; + Assert.assertEquals(3, listReader.size()); + Assert.assertEquals("structlist 1", listReader.get(0).getTextField().toString()); + Assert.assertEquals("structlist 2", listReader.get(1).getTextField().toString()); + Assert.assertEquals("structlist 3", listReader.get(2).getTextField().toString()); + } + } + + @org.junit.Test + public void testGlobalConstants() { + Assert.assertEquals(Test.GLOBAL_INT, 12345); + } + + @org.junit.Test + public void testEmptyStruct() { + MessageBuilder builder = new MessageBuilder(); + Test.TestAnyPointer.Builder root = builder.initRoot(Test.TestAnyPointer.factory); + + Assert.assertFalse(root.hasAnyPointerField()); + + AnyPointer.Builder any = root.getAnyPointerField(); + Assert.assertTrue(any.isNull()); + any.initAs(Test.TestEmptyStruct.factory); + Assert.assertFalse(any.isNull()); + Assert.assertTrue(root.hasAnyPointerField()); + + { + Test.TestAnyPointer.Reader reader = root.asReader(); + Assert.assertTrue(reader.hasAnyPointerField()); + Assert.assertNotNull(reader.getAnyPointerField()); + } + } + + @org.junit.Test(expected=DecodeException.class) + public void testTextBuilderIntUnderflow() { + MessageBuilder builder = new MessageBuilder(); + Test.TestAnyPointer.Builder root = builder.initRoot(Test.TestAnyPointer.factory); + root.getAnyPointerField().initAs(Data.factory, 0); + root.getAnyPointerField().getAs(Text.factory); + } + + @org.junit.Test(expected=DecodeException.class) + public void testInlineCompositeListIntOverflow() throws DecodeException { + + byte[] bytes = new byte[]{0,0,0,0, 0,0,1,0, 1,0,0,0, 0x17,0,0,0, 0,0,0,-128, 16,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0}; + + ByteBuffer segment = ByteBuffer.wrap(bytes); + segment.order(ByteOrder.LITTLE_ENDIAN); + MessageReader message = new MessageReader(new ByteBuffer[]{segment}, ReaderOptions.DEFAULT_READER_OPTIONS); + + Test.TestAnyPointer.Reader root = message.getRoot(Test.TestAnyPointer.factory); + root.getAnyPointerField().getAs(new StructList.Factory(Test.TestAllTypes.factory)); + } + + @org.junit.Test(expected=DecodeException.class) + public void testInlineCompositeListIntOverflow2() throws DecodeException { + + byte[] bytes = new byte[]{0,0,0,0, 0,0,1,0, 1,0,0,0, 0x17,0,0,0, 0,0,0,-128, 16,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0}; + + ByteBuffer segment = ByteBuffer.wrap(bytes); + segment.order(ByteOrder.LITTLE_ENDIAN); + MessageReader message = new MessageReader(new ByteBuffer[]{segment}, ReaderOptions.DEFAULT_READER_OPTIONS); + + Test.TestAnyPointer.Reader root = message.getRoot(Test.TestAnyPointer.factory); + + MessageBuilder messageBuilder = new MessageBuilder(); + Test.TestAnyPointer.Builder builderRoot = messageBuilder.initRoot(Test.TestAnyPointer.factory); + builderRoot.getAnyPointerField().setAs(Test.TestAnyPointer.factory, root); + } + + @org.junit.Test(expected=DecodeException.class) + public void testVoidListAmplification() throws DecodeException { + MessageBuilder builder = new MessageBuilder(); + builder.initRoot(Test.TestAnyPointer.factory).getAnyPointerField().initAs(PrimitiveList.Void.factory, 1 << 28); + + ByteBuffer[] segments = builder.getSegmentsForOutput(); + Assert.assertEquals(1, segments.length); + + MessageReader reader = new MessageReader(segments, ReaderOptions.DEFAULT_READER_OPTIONS); + Test.TestAnyPointer.Reader root = reader.getRoot(Test.TestAnyPointer.factory); + root.getAnyPointerField().getAs(new StructList.Factory(Test.TestAllTypes.factory)); + } + + @org.junit.Test(expected=DecodeException.class) + public void testEmptyStructListAmplification() { + MessageBuilder builder = new MessageBuilder(); + builder.initRoot(Test.TestAnyPointer.factory).getAnyPointerField() + .initAs(new StructList.Factory(Test.TestEmptyStruct.factory), (1 << 29) - 1); + + ByteBuffer[] segments = builder.getSegmentsForOutput(); + Assert.assertEquals(1, segments.length); + + MessageReader reader = new MessageReader(segments, ReaderOptions.DEFAULT_READER_OPTIONS); + Test.TestAnyPointer.Reader root = reader.getRoot(Test.TestAnyPointer.factory); + root.getAnyPointerField().getAs(new StructList.Factory(Test.TestAllTypes.factory)); + } + + @org.junit.Test + public void testLongUint8List() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + int length = (1 << 28) + 1; + PrimitiveList.Byte.Builder list = allTypes.initUInt8List(length); + Assert.assertEquals(list.size(), length); + list.set(length - 1, (byte)3); + Assert.assertEquals(list.get(length - 1), 3); + Assert.assertEquals(allTypes.asReader().getUInt8List().get(length - 1), 3); + } + + @org.junit.Test + public void testLongUint16List() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + int length = (1 << 27) + 1; + PrimitiveList.Short.Builder list = allTypes.initUInt16List(length); + Assert.assertEquals(list.size(), length); + list.set(length - 1, (short)3); + Assert.assertEquals(list.get(length - 1), 3); + Assert.assertEquals(allTypes.asReader().getUInt16List().get(length - 1), 3); + } + + @org.junit.Test + public void testLongUint32List() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + int length = (1 << 26) + 1; + PrimitiveList.Int.Builder list = allTypes.initUInt32List(length); + Assert.assertEquals(list.size(), length); + list.set(length - 1, 3); + Assert.assertEquals(list.get(length - 1), 3); + Assert.assertEquals(allTypes.asReader().getUInt32List().get(length - 1), 3); + } + + @org.junit.Test + public void testLongUint64List() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + int length = (1 << 25) + 1; + PrimitiveList.Long.Builder list = allTypes.initUInt64List(length); + Assert.assertEquals(list.size(), length); + list.set(length - 1, 3); + Assert.assertEquals(list.get(length - 1), 3); + Assert.assertEquals(allTypes.asReader().getUInt64List().get(length - 1), 3); + } + + @org.junit.Test + public void testLongFloat32List() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + int length = (1 << 26) + 1; + PrimitiveList.Float.Builder list = allTypes.initFloat32List(length); + Assert.assertEquals(list.size(), length); + list.set(length - 1, 3.14f); + Assert.assertEquals(list.get(length - 1), 3.14f, 0.0f); + Assert.assertEquals(allTypes.asReader().getFloat32List().get(length - 1), 3.14f, 0.0f); + } + + @org.junit.Test + public void testLongFloat64List() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + int length = (1 << 25) + 1; + PrimitiveList.Double.Builder list = allTypes.initFloat64List(length); + Assert.assertEquals(list.size(), length); + list.set(length - 1, 3.14); + Assert.assertEquals(list.get(length - 1), 3.14, 0.0); + Assert.assertEquals(allTypes.asReader().getFloat64List().get(length - 1), 3.14, 0.0); + } + + @org.junit.Test + public void testLongStructList() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + int length = (1 << 21) + 1; + StructList.Builder list = allTypes.initStructList(length); + Assert.assertEquals(list.size(), length); + list.get(length - 1).setUInt8Field((byte)3); + Assert.assertEquals(list.get(length - 1).getUInt8Field(), 3); + Assert.assertEquals(allTypes.asReader().getStructList().get(length - 1).getUInt8Field(), 3); + } + + @org.junit.Test + public void testLongTextList() { + MessageBuilder message = new MessageBuilder(); + Test.TestAllTypes.Builder allTypes = message.initRoot(Test.TestAllTypes.factory); + int length = (1 << 25) + 1; + TextList.Builder list = allTypes.initTextList(length); + Assert.assertEquals(list.size(), length); + list.set(length - 1, new Text.Reader("foo")); + Assert.assertEquals(list.get(length - 1).toString(), "foo"); + Assert.assertEquals(allTypes.asReader().getTextList().get(length - 1).toString(), "foo"); + } + + @org.junit.Test + public void testLongListList() { + MessageBuilder message = new MessageBuilder(); + Test.TestLists.Builder root = message.initRoot(Test.TestLists.factory); + int length = (1 << 25) + 1; + ListList.Builder> list = root.initStructListList(length); + Assert.assertEquals(list.size(), length); + list.init(length - 1, 3); + Assert.assertEquals(list.get(length - 1).size(), 3); + Assert.assertEquals(root.asReader().getStructListList().get(length - 1).size(), 3); + } + + @org.junit.Test + public void testStructSetters() { + MessageBuilder builder = new MessageBuilder(); + Test.TestAllTypes.Builder root = builder.initRoot(Test.TestAllTypes.factory); + TestUtil.initTestMessage(root); + + { + MessageBuilder builder2 = new MessageBuilder(); + builder2.setRoot(Test.TestAllTypes.factory, root.asReader()); + TestUtil.checkTestMessage(builder2.getRoot(Test.TestAllTypes.factory)); + } + + { + MessageBuilder builder2 = new MessageBuilder(); + Test.TestAllTypes.Builder root2 = builder2.getRoot(Test.TestAllTypes.factory); + root2.setStructField(root.asReader()); + TestUtil.checkTestMessage(root2.getStructField()); + } + + { + MessageBuilder builder2 = new MessageBuilder(); + Test.TestAnyPointer.Builder root2 = builder2.getRoot(Test.TestAnyPointer.factory); + root2.getAnyPointerField().setAs(Test.TestAllTypes.factory, root.asReader()); + TestUtil.checkTestMessage(root2.getAnyPointerField().getAs(Test.TestAllTypes.factory)); + } + } + + @org.junit.Test + public void testSerializedSize() { + MessageBuilder builder = new MessageBuilder(); + Test.TestAnyPointer.Builder root = builder.initRoot(Test.TestAnyPointer.factory); + root.getAnyPointerField().setAs(Text.factory, new Text.Reader("12345")); + + // one word for segment table, one for the root pointer, + // one for the body of the TestAnyPointer struct, + // and one for the body of the Text. + Assert.assertEquals(Serialize.computeSerializedSizeInWords(builder), 4); + } + + @org.junit.Test + public void testImport() { + MessageBuilder builder = new MessageBuilder(); + org.capnproto.testimport.TestImport.Foo.Builder root = builder.initRoot(org.capnproto.testimport.TestImport.Foo.factory); + Test.TestAllTypes.Builder field = root.initImportedStruct(); + TestUtil.initTestMessage(field); + TestUtil.checkTestMessage(field); + TestUtil.checkTestMessage(field.asReader()); + } + + @org.junit.Test + public void testGenericMap() { + MessageBuilder builder = new MessageBuilder(); + Test.GenericMap.Factory mapFactory + = new Test.GenericMap.Factory(Text.factory, Test.TestAllTypes.factory); + + StructList.Factory, + Test.GenericMap.Entry.Reader> entryFactory + = new StructList.Factory(new Test.GenericMap.Entry.Factory(Text.factory, Test.TestAllTypes.factory)); + + Test.GenericMap.Builder root = builder.initRoot(mapFactory); + + { + StructList.Builder> entries = root.initEntries(entryFactory, 3); + + Test.GenericMap.Entry.Builder entry0 = entries.get(0); + entry0.setKey(Text.factory, new Text.Reader("foo")); + Test.TestAllTypes.Builder value0 = entry0.initValue(); + value0.setInt64Field(101); + + Test.GenericMap.Entry.Builder entry1 = entries.get(1); + entry1.setKey(Text.factory, new Text.Reader("bar")); + Test.TestAllTypes.Builder value1 = entry1.initValue(); + value1.setInt64Field(202); + + Test.GenericMap.Entry.Builder entry2 = entries.get(2); + entry2.setKey(Text.factory, new Text.Reader("baz")); + Test.TestAllTypes.Builder value2 = entry2.initValue(); + value2.setInt64Field(303); + } + + { + StructList.Reader> entries = + root.asReader(mapFactory).getEntries(entryFactory); + + Test.GenericMap.Entry.Reader entry0 = entries.get(0); + Assert.assertEquals(entry0.getKey().toString(), "foo"); + Assert.assertEquals(entry0.getValue().getInt64Field(), 101); + + Test.GenericMap.Entry.Reader entry1 = entries.get(1); + Assert.assertEquals(entry1.getKey().toString(), "bar"); + Assert.assertEquals(entry1.getValue().getInt64Field(), 202); + + Test.GenericMap.Entry.Reader entry2 = entries.get(2); + Assert.assertEquals(entry2.getKey().toString(), "baz"); + Assert.assertEquals(entry2.getValue().getInt64Field(), 303); + } + } + + @org.junit.Test + public void testSetWithCaveats() { + MessageBuilder builder = new MessageBuilder(); + Test.TestAllTypes.Builder root = builder.initRoot(Test.TestAllTypes.factory); + StructList.Builder list = root.initStructList(2); + + { + MessageBuilder message1 = new MessageBuilder(); + Test.TestAllTypes.Builder root1 = message1.initRoot(Test.TestAllTypes.factory); + root1.setInt8Field((byte)11); + list.setWithCaveats(Test.TestAllTypes.factory, 0, root1.asReader()); + } + + { + MessageBuilder message2 = new MessageBuilder(); + Test.TestAllTypes.Builder root2 = message2.initRoot(Test.TestAllTypes.factory); + TestUtil.initTestMessage(root2); + list.setWithCaveats(Test.TestAllTypes.factory, 1, root2.asReader()); + } + + StructList.Reader listReader = list.asReader(Test.TestAllTypes.factory); + Assert.assertEquals(listReader.get(0).getInt8Field(), 11); + TestUtil.checkTestMessage(listReader.get(1)); + } +} + + diff --git a/compiler/src/test/java/org/capnproto/TestUtil.java b/compiler/src/test/java/org/capnproto/TestUtil.java new file mode 100644 index 0000000..5128451 --- /dev/null +++ b/compiler/src/test/java/org/capnproto/TestUtil.java @@ -0,0 +1,348 @@ +package org.capnproto.test; + +import org.capnproto.*; +import org.junit.Assert; + +import java.io.UnsupportedEncodingException; + +public class TestUtil { + public static byte[] data(String string) { + try { + return string.getBytes("ISO_8859-1"); + } catch (UnsupportedEncodingException e) { + Assert.fail("Could not decode"); + return null; + } + } + + public static final double DELTA = 1e-15; + + public static void initTestMessage(Test.TestAllTypes.Builder builder) { + builder.setVoidField(org.capnproto.Void.VOID); + builder.setBoolField(true); + builder.setInt8Field((byte) -123); + builder.setInt16Field((short) -12345); + builder.setInt32Field(-12345678); + builder.setInt64Field(-123456789012345L); + builder.setUInt8Field((byte) 0xea); + builder.setUInt16Field((short) 0x4567); + builder.setUInt32Field(0x34567890); + builder.setUInt64Field(0x1234567890123456L); + builder.setFloat32Field(1234.5f); + builder.setFloat64Field(-123e45); + builder.setTextField("foo"); + builder.setDataField(data("bar")); + { + Test.TestAllTypes.Builder subBuilder = builder.initStructField(); + subBuilder.setVoidField(org.capnproto.Void.VOID); + subBuilder.setBoolField(true); + subBuilder.setInt8Field((byte) -12); + subBuilder.setInt16Field((short) 3456); + subBuilder.setInt32Field(-78901234); + subBuilder.setInt64Field(56789012345678L); + subBuilder.setUInt8Field((byte) 90); + subBuilder.setUInt16Field((short) 1234); + subBuilder.setUInt32Field(56789012); + subBuilder.setUInt64Field(345678901234567890L); + subBuilder.setFloat32Field(-1.25e-10f); + subBuilder.setFloat64Field(345); + subBuilder.setTextField(new Text.Reader("baz")); + subBuilder.setDataField(data("qux")); + { + Test.TestAllTypes.Builder subSubBuilder = subBuilder.initStructField(); + subSubBuilder.setTextField(new Text.Reader("nested")); + subSubBuilder.initStructField().setTextField(new Text.Reader("really nested")); + } + subBuilder.setEnumField(Test.TestEnum.BAZ); + + PrimitiveList.Boolean.Builder boolList = subBuilder.initBoolList(5); + boolList.set(0, false); + boolList.set(1, true); + boolList.set(2, false); + boolList.set(3, true); + boolList.set(4, true); + } + + builder.setEnumField(Test.TestEnum.CORGE); + builder.initVoidList(6); + + PrimitiveList.Boolean.Builder boolList = builder.initBoolList(4); + boolList.set(0, true); + boolList.set(1, false); + boolList.set(2, false); + boolList.set(3, true); + + PrimitiveList.Double.Builder float64List = builder.initFloat64List(4); + float64List.set(0, 7777.75); + float64List.set(1, Double.POSITIVE_INFINITY); + float64List.set(2, Double.NEGATIVE_INFINITY); + float64List.set(3, Double.NaN); + + TextList.Builder textList = builder.initTextList(3); + textList.set(0, new Text.Reader("plugh")); + textList.set(1, new Text.Reader("xyzzy")); + textList.set(2, new Text.Reader("thud")); + + StructList.Builder structList = builder.initStructList(3); + structList.get(0).setTextField(new Text.Reader("structlist 1")); + structList.get(1).setTextField(new Text.Reader("structlist 2")); + structList.get(2).setTextField(new Text.Reader("structlist 3")); + + EnumList.Builder enumList = builder.initEnumList(2); + enumList.set(0, Test.TestEnum.FOO); + enumList.set(1, Test.TestEnum.GARPLY); + } + + public static void checkTestMessage(Test.TestAllTypes.Builder builder) { + builder.getVoidField(); + Assert.assertEquals(builder.getBoolField(), true); + Assert.assertEquals(builder.getInt8Field(), -123); + Assert.assertEquals(builder.getInt16Field(), -12345); + Assert.assertEquals(builder.getInt32Field(), -12345678); + Assert.assertEquals(builder.getInt64Field(), -123456789012345L); + Assert.assertEquals(builder.getUInt8Field(), (byte) 0xea); + Assert.assertEquals(builder.getUInt16Field(), 0x4567); + Assert.assertEquals(builder.getUInt32Field(), 0x34567890); + Assert.assertEquals(builder.getUInt64Field(), 0x1234567890123456L); + Assert.assertEquals(builder.getFloat32Field(), 1234.5f, DELTA); + Assert.assertEquals(builder.getFloat64Field(), -123e45, DELTA); + Assert.assertEquals(builder.getTextField().toString(), "foo"); + + { + Test.TestAllTypes.Builder subBuilder = builder.getStructField(); + subBuilder.getVoidField(); + Assert.assertEquals(subBuilder.getBoolField(), true); + Assert.assertEquals(subBuilder.getInt8Field(), -12); + Assert.assertEquals(subBuilder.getInt16Field(), 3456); + Assert.assertEquals(subBuilder.getInt32Field(), -78901234); + Assert.assertEquals(subBuilder.getInt64Field(), 56789012345678L); + Assert.assertEquals(subBuilder.getUInt8Field(), 90); + Assert.assertEquals(subBuilder.getUInt16Field(), 1234); + Assert.assertEquals(subBuilder.getUInt32Field(), 56789012); + Assert.assertEquals(subBuilder.getUInt64Field(), 345678901234567890L); + Assert.assertEquals(subBuilder.getFloat32Field(), -1.25e-10f, DELTA); + Assert.assertEquals(subBuilder.getFloat64Field(), 345, DELTA); + + { + Test.TestAllTypes.Builder subSubBuilder = subBuilder.getStructField(); + Assert.assertEquals(subSubBuilder.getTextField().toString(), "nested"); + } + + Assert.assertEquals(subBuilder.getEnumField(), Test.TestEnum.BAZ); + + PrimitiveList.Boolean.Builder boolList = subBuilder.getBoolList(); + Assert.assertEquals(boolList.get(0), false); + Assert.assertEquals(boolList.get(1), true); + Assert.assertEquals(boolList.get(2), false); + Assert.assertEquals(boolList.get(3), true); + Assert.assertEquals(boolList.get(4), true); + + } + Assert.assertEquals(builder.getEnumField(), Test.TestEnum.CORGE); + + Assert.assertEquals(builder.getVoidList().size(), 6); + + PrimitiveList.Boolean.Builder boolList = builder.getBoolList(); + Assert.assertEquals(boolList.get(0), true); + Assert.assertEquals(boolList.get(1), false); + Assert.assertEquals(boolList.get(2), false); + Assert.assertEquals(boolList.get(3), true); + + PrimitiveList.Double.Builder float64List = builder.getFloat64List(); + Assert.assertEquals(float64List.get(0), 7777.75, DELTA); + Assert.assertEquals(float64List.get(1), Double.POSITIVE_INFINITY, DELTA); + Assert.assertEquals(float64List.get(2), Double.NEGATIVE_INFINITY, DELTA); + Assert.assertEquals(float64List.get(3), Double.NaN, DELTA); + + TextList.Builder textList = builder.getTextList(); + Assert.assertEquals(textList.size(), 3); + Assert.assertEquals(textList.get(0).toString(), "plugh"); + Assert.assertEquals(textList.get(1).toString(), "xyzzy"); + Assert.assertEquals(textList.get(2).toString(), "thud"); + + StructList.Builder structList = builder.getStructList(); + Assert.assertEquals(3, structList.size()); + Assert.assertEquals(structList.get(0).getTextField().toString(), "structlist 1"); + Assert.assertEquals(structList.get(1).getTextField().toString(), "structlist 2"); + Assert.assertEquals(structList.get(2).getTextField().toString(), "structlist 3"); + + EnumList.Builder enumList = builder.getEnumList(); + Assert.assertEquals(enumList.get(0), Test.TestEnum.FOO); + Assert.assertEquals(enumList.get(1), Test.TestEnum.GARPLY); + } + + public static void checkTestMessage(Test.TestAllTypes.Reader reader) { + reader.getVoidField(); + Assert.assertEquals(reader.getBoolField(), true); + Assert.assertEquals(reader.getInt8Field(), -123); + Assert.assertEquals(reader.getInt16Field(), -12345); + Assert.assertEquals(reader.getInt32Field(), -12345678); + Assert.assertEquals(reader.getInt64Field(), -123456789012345L); + Assert.assertEquals(reader.getUInt8Field(), (byte)0xea); + Assert.assertEquals(reader.getUInt16Field(), 0x4567); + Assert.assertEquals(reader.getUInt32Field(), 0x34567890); + Assert.assertEquals(reader.getUInt64Field(), 0x1234567890123456L); + Assert.assertEquals(reader.getFloat32Field(), 1234.5f, DELTA); + Assert.assertEquals(reader.getFloat64Field(), -123e45, DELTA); + Assert.assertEquals(reader.getTextField().toString(), "foo"); + + { + Test.TestAllTypes.Reader subReader = reader.getStructField(); + subReader.getVoidField(); + Assert.assertEquals(subReader.getBoolField(), true); + Assert.assertEquals(subReader.getInt8Field(), -12); + Assert.assertEquals(subReader.getInt16Field(), 3456); + Assert.assertEquals(subReader.getInt32Field(), -78901234); + Assert.assertEquals(subReader.getInt64Field(), 56789012345678L); + Assert.assertEquals(subReader.getUInt8Field(), 90); + Assert.assertEquals(subReader.getUInt16Field(), 1234); + Assert.assertEquals(subReader.getUInt32Field(), 56789012); + Assert.assertEquals(subReader.getUInt64Field(), 345678901234567890L); + Assert.assertEquals(subReader.getFloat32Field(), -1.25e-10f, DELTA); + Assert.assertEquals(subReader.getFloat64Field(), 345, DELTA); + + { + Test.TestAllTypes.Reader subSubReader = subReader.getStructField(); + Assert.assertEquals(subSubReader.getTextField().toString(), "nested"); + } + PrimitiveList.Boolean.Reader boolList = subReader.getBoolList(); + Assert.assertEquals(boolList.get(0), false); + Assert.assertEquals(boolList.get(1), true); + Assert.assertEquals(boolList.get(2), false); + Assert.assertEquals(boolList.get(3), true); + Assert.assertEquals(boolList.get(4), true); + + } + + Assert.assertEquals(reader.getVoidList().size(), 6); + + PrimitiveList.Boolean.Reader boolList = reader.getBoolList(); + Assert.assertEquals(boolList.get(0), true); + Assert.assertEquals(boolList.get(1), false); + Assert.assertEquals(boolList.get(2), false); + Assert.assertEquals(boolList.get(3), true); + + PrimitiveList.Double.Reader float64List = reader.getFloat64List(); + Assert.assertEquals(float64List.get(0), 7777.75, DELTA); + Assert.assertEquals(float64List.get(1), Double.POSITIVE_INFINITY, DELTA); + Assert.assertEquals(float64List.get(2), Double.NEGATIVE_INFINITY, DELTA); + Assert.assertEquals(float64List.get(3), Double.NaN, DELTA); + + TextList.Reader textList = reader.getTextList(); + Assert.assertEquals(textList.size(), 3); + Assert.assertEquals(textList.get(0).toString(), "plugh"); + Assert.assertEquals(textList.get(1).toString(), "xyzzy"); + Assert.assertEquals(textList.get(2).toString(), "thud"); + StructList.Reader structList = reader.getStructList(); + Assert.assertEquals(3, structList.size()); + Assert.assertEquals(structList.get(0).getTextField().toString(), "structlist 1"); + Assert.assertEquals(structList.get(1).getTextField().toString(), "structlist 2"); + Assert.assertEquals(structList.get(2).getTextField().toString(), "structlist 3"); + + EnumList.Reader enumList = reader.getEnumList(); + Assert.assertEquals(enumList.get(0), Test.TestEnum.FOO); + Assert.assertEquals(enumList.get(1), Test.TestEnum.GARPLY); + } + + public static void checkDefaultMessage(Test.TestDefaults.Builder builder) { + builder.getVoidField(); + Assert.assertTrue(builder.getBoolField()); + Assert.assertEquals(builder.getInt8Field(), -123); + Assert.assertEquals(builder.getInt16Field(), -12345); + Assert.assertEquals(builder.getInt32Field(), -12345678); + Assert.assertEquals(builder.getInt64Field(), -123456789012345L); + Assert.assertEquals(builder.getUInt8Field(), (byte)0xea); + Assert.assertEquals(builder.getUInt16Field(), (short)45678); + Assert.assertEquals(builder.getUInt32Field(), 0xce0a6a14); + Assert.assertEquals(builder.getUInt64Field(), 0xab54a98ceb1f0ad2L); + Assert.assertEquals(builder.getFloat32Field(), 1234.5f, DELTA); + Assert.assertEquals(builder.getFloat64Field(), -123e45, DELTA); + Assert.assertEquals(builder.getEnumField(), Test.TestEnum.CORGE); + + Assert.assertEquals(builder.getTextField().toString(), "foo"); + Assert.assertArrayEquals(builder.getDataField().toArray(), new byte[]{0x62, 0x61, 0x72}); + } + + public static void checkDefaultMessage(Test.TestDefaults.Reader reader) { + reader.getVoidField(); + Assert.assertEquals(reader.getBoolField(), true); + Assert.assertEquals(reader.getInt8Field(), -123); + Assert.assertEquals(reader.getInt16Field(), -12345); + Assert.assertEquals(reader.getInt32Field(), -12345678); + Assert.assertEquals(reader.getInt64Field(), -123456789012345L); + Assert.assertEquals(reader.getUInt8Field(), (byte)0xea); + Assert.assertEquals(reader.getUInt16Field(), (short)45678); + Assert.assertEquals(reader.getUInt32Field(), 0xce0a6a14); + Assert.assertEquals(reader.getUInt64Field(), 0xab54a98ceb1f0ad2L); + Assert.assertEquals(reader.getFloat32Field(), 1234.5f, DELTA); + Assert.assertEquals(reader.getFloat64Field(), -123e45, DELTA); + Assert.assertEquals(reader.getTextField().toString(), "foo"); + Assert.assertArrayEquals(reader.getDataField().toArray(), new byte[]{0x62, 0x61, 0x72}); + { + Test.TestAllTypes.Reader subReader = reader.getStructField(); + subReader.getVoidField(); + Assert.assertTrue(subReader.getBoolField()); + Assert.assertEquals(subReader.getInt8Field(), -12); + Assert.assertEquals(subReader.getInt16Field(), 3456); + Assert.assertEquals(subReader.getInt32Field(), -78901234); + // ... + Assert.assertEquals(subReader.getTextField().toString(), "baz"); + + { + Test.TestAllTypes.Reader subSubReader = subReader.getStructField(); + Assert.assertEquals(subSubReader.getTextField().toString(), "nested"); + } + + } + + Assert.assertEquals(reader.getEnumField(), Test.TestEnum.CORGE); + Assert.assertEquals(reader.getVoidList().size(), 6); + + { + PrimitiveList.Boolean.Reader listReader = reader.getBoolList(); + Assert.assertEquals(listReader.size(), 4); + Assert.assertTrue(listReader.get(0)); + Assert.assertFalse(listReader.get(1)); + Assert.assertFalse(listReader.get(2)); + Assert.assertTrue(listReader.get(3)); + } + + { + PrimitiveList.Byte.Reader listReader = reader.getInt8List(); + Assert.assertEquals(listReader.size(), 2); + Assert.assertEquals(listReader.get(0), 111); + Assert.assertEquals(listReader.get(1), -111); + } + } + + public static void setDefaultMessage(Test.TestDefaults.Builder builder) { + builder.setBoolField(false); + builder.setInt8Field((byte) -122); + builder.setInt16Field((short) -12344); + builder.setInt32Field(-12345677); + builder.setInt64Field(-123456789012344L); + builder.setUInt8Field((byte) 0xe9); + builder.setUInt16Field((short) 45677); + builder.setUInt32Field(0xce0a6a13); + builder.setUInt64Field(0xab54a98ceb1f0ad1L); + builder.setFloat32Field(1234.4f); + builder.setFloat64Field(-123e44); + builder.setTextField(new Text.Reader("bar")); + builder.setEnumField(Test.TestEnum.QUX); + } + + public static void checkSettedDefaultMessage(Test.TestDefaults.Reader reader) { + Assert.assertEquals(reader.getBoolField(), false); + Assert.assertEquals(reader.getInt8Field(), -122); + Assert.assertEquals(reader.getInt16Field(), -12344); + Assert.assertEquals(reader.getInt32Field(), -12345677); + Assert.assertEquals(reader.getInt64Field(), -123456789012344L); + Assert.assertEquals(reader.getUInt8Field(), (byte) 0xe9); + Assert.assertEquals(reader.getUInt16Field(), (short) 45677); + Assert.assertEquals(reader.getUInt32Field(), 0xce0a6a13); + Assert.assertEquals(reader.getUInt64Field(), 0xab54a98ceb1f0ad1L); + Assert.assertEquals(reader.getFloat32Field(), 1234.4f, DELTA); + Assert.assertEquals(reader.getFloat64Field(), -123e44, DELTA); + Assert.assertEquals(reader.getEnumField(), Test.TestEnum.QUX); + } +} diff --git a/compiler/src/test/scala/org/capnproto/EncodingSuite.scala b/compiler/src/test/scala/org/capnproto/EncodingSuite.scala deleted file mode 100644 index 42b6cc3..0000000 --- a/compiler/src/test/scala/org/capnproto/EncodingSuite.scala +++ /dev/null @@ -1,848 +0,0 @@ -// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors -// Licensed under the MIT License: -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -package org.capnproto - -import org.capnproto.test.Test._ -import org.scalatest.FunSuite -import org.scalatest.Matchers._ - -class EncodingSuite extends FunSuite { - test("AllTypes") { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - TestUtil.initTestMessage(allTypes) - TestUtil.checkTestMessage(allTypes) - TestUtil.checkTestMessage(allTypes.asReader()) - } - - test("AllTypesMultiSegment") { - val message = new MessageBuilder(5, BuilderArena.AllocationStrategy.FIXED_SIZE) - val allTypes = message.initRoot(TestAllTypes.factory) - TestUtil.initTestMessage(allTypes) - - TestUtil.checkTestMessage(allTypes) - TestUtil.checkTestMessage(allTypes.asReader()) - } - - test("Setters") { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - TestUtil.initTestMessage(allTypes) - - val message2 = new MessageBuilder() - val allTypes2 = message2.initRoot(TestAllTypes.factory) - - allTypes2.setStructField(allTypes.asReader()) - TestUtil.checkTestMessage(allTypes2.getStructField()) - val reader = allTypes2.asReader().getStructField() - TestUtil.checkTestMessage(reader) - } - - test("Zeroing") { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - - val structList = allTypes.initStructList(3) - TestUtil.initTestMessage(structList.get(0)) - - val structField = allTypes.initStructField() - TestUtil.initTestMessage(structField) - - TestUtil.initTestMessage(structList.get(1)) - TestUtil.initTestMessage(structList.get(2)) - TestUtil.checkTestMessage(structList.get(0)) - allTypes.initStructList(0) - - TestUtil.checkTestMessage(allTypes.getStructField()) - val allTypesReader = allTypes.asReader() - TestUtil.checkTestMessage(allTypesReader.getStructField()) - - val any = message.initRoot(AnyPointer.factory) - val segments = message.getSegmentsForOutput() - for (segment <- segments) { - for (jj <- 0 to segment.limit - 1) { - segment.get(jj) should equal (0) - } - } - } - - test("DoubleFarPointers") { - val bytes = Array[Byte](2,0,0,0, 1,0,0,0, 2,0,0,0, 1,0,0,0, - 6,0,0,0, 1,0,0,0, 2,0,0,0, 2,0,0,0, - 0,0,0,0, 1,0,0,0, 1,7, -1, 127, 0,0,0,0) - - val input = new ArrayInputStream (java.nio.ByteBuffer.wrap(bytes)) - val message = org.capnproto.Serialize.read(input) - val root = message.getRoot(TestAllTypes.factory) - root.getBoolField() should equal (true) - root.getInt8Field() should equal (7) - root.getInt16Field() should equal (32767) - } - - test("UpgradeStruct") { - val builder = new MessageBuilder() - val root = builder.initRoot(TestAnyPointer.factory) - - { - val oldVersion = root.getAnyPointerField().initAs(TestOldVersion.factory) - oldVersion.setOld1(123) - oldVersion.setOld2("foo") - val sub = oldVersion.initOld3() - sub.setOld1(456) - sub.setOld2("bar") - } - - { - val newVersion = root.getAnyPointerField().asReader().getAs(TestNewVersion.factory) - newVersion.getOld1() should equal (123) - newVersion.getOld2().toString() should equal ("foo") - newVersion.getNew2().toString() should equal ("baz") - newVersion.hasNew2() should equal (false) - newVersion.hasNew3() should equal (false) - } - } - - test("UpgradeStructInBuilder") { - val builder = new MessageBuilder() - val root = builder.initRoot(TestAnyPointer.factory) - - { - val oldVersion = root.getAnyPointerField().initAs(TestOldVersion.factory) - oldVersion.setOld1(123) - oldVersion.setOld2("foo") - val sub = oldVersion.initOld3() - sub.setOld1(456) - sub.setOld2("bar") - } - - { - val newVersion = root.getAnyPointerField().getAs(TestNewVersion.factory) - newVersion.getOld1() should equal (123) - newVersion.getOld2().toString() should equal ("foo") - newVersion.getNew1() should equal (987) - newVersion.getNew2().toString() should equal ("baz") - val sub = newVersion.getOld3() - sub.getOld1() should equal (456) - sub.getOld2().toString() should equal ("bar") - - newVersion.setOld1(234) - newVersion.setOld2("qux") - newVersion.setNew1(654) - newVersion.setNew2("quux") - - } - - { - val oldVersion = root.getAnyPointerField().getAs(TestOldVersion.factory) - oldVersion.getOld1() should equal (234) - oldVersion.getOld2.toString() should equal ("qux") - } - } - - test("StructListUpgrade") { - val message = new MessageBuilder() - val root = message.initRoot(TestAnyPointer.factory) - val any = root.getAnyPointerField() - - { - val longs = any.initAs(PrimitiveList.Long.factory, 3) - longs.set(0, 123) - longs.set(1, 456) - longs.set(2, 789) - } - - { - val olds = any.asReader().getAs(TestOldVersion.listFactory) - olds.get(0).getOld1() should equal (123) - olds.get(1).getOld1() should equal (456) - olds.get(2).getOld1() should equal (789) - } - - { - val olds = any.getAs(TestOldVersion.listFactory) - olds.size() should equal (3) - olds.get(0).getOld1() should equal (123) - olds.get(1).getOld1() should equal (456) - olds.get(2).getOld1() should equal (789) - - olds.get(0).setOld2("zero") - olds.get(1).setOld2("one") - olds.get(2).setOld2("two") - } - - { - val news = any.getAs(TestNewVersion.listFactory) - news.size() should equal (3) - news.get(0).getOld1() should equal (123) - news.get(0).getOld2().toString() should equal ("zero") - - news.get(1).getOld1() should equal (456) - news.get(1).getOld2().toString() should equal ("one") - - news.get(2).getOld1() should equal (789) - news.get(2).getOld2().toString() should equal ("two") - } - } - - test("StructListUpgradeDoubleFar") { - val bytes = Array[Byte]( - 1,0,0,0,0x1f,0,0,0, // list, inline composite, 3 words - 4, 0, 0, 0, 1, 0, 2, 0, // struct tag. 1 element, 1 word data, 2 pointers. - 91,0,0,0,0,0,0,0, // data: 91 - 0x05,0,0,0, 0x42,0,0,0, // list pointer, offset 1, type = BYTE, length 8. - 0,0,0,0,0,0,0,0, // null pointer - 0x68,0x65,0x6c,0x6c,0x6f,0x21,0x21,0) // "hello!!" - - val segment = java.nio.ByteBuffer.wrap(bytes) - segment.order(java.nio.ByteOrder.LITTLE_ENDIAN) - val messageReader = new MessageReader(Array(segment), ReaderOptions.DEFAULT_READER_OPTIONS) - - val oldFactory = new StructList.Factory(TestOldVersion.factory) - val oldVersion = messageReader.getRoot(oldFactory) - - oldVersion.size() should equal (1) - oldVersion.get(0).getOld1() should equal (91) - oldVersion.get(0).getOld2().toString() should equal ("hello!!") - - // Make the first segment exactly large enough to fit the original message. - // This leaves no room for a far pointer landing pad in the first segment. - val message = new MessageBuilder(6) - message.setRoot(oldFactory, oldVersion) - - val segments = message.getSegmentsForOutput() - segments.length should equal (1) - segments(0).limit() should equal (6 * 8) - - val newVersion = message.getRoot(new StructList.Factory(TestNewVersion.factory)) - newVersion.size() should equal (1) - newVersion.get(0).getOld1() should equal (91) - newVersion.get(0).getOld2().toString() should equal ("hello!!") - - val segments1 = message.getSegmentsForOutput() - segments(0).limit() should equal (6 * 8) - for (ii <- 8 to (5 * 8) - 1) { - // Check the the old list, including the tag, was zeroed. - segments(0).get(ii) should equal (0) - } - } - - test("ListBuilderAsReader") { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - - allTypes.initVoidList(10) - allTypes.getVoidList().asReader().size() should equal (10) - - val boolList = allTypes.initBoolList(7) - boolList.set(3, true) - val boolListReader = boolList.asReader() - boolListReader.size() should equal (7) - boolListReader.get(0) should equal (false) - boolListReader.get(1) should equal (false) - boolListReader.get(2) should equal (false) - boolListReader.get(3) should equal (true) - boolListReader.get(4) should equal (false) - - val int8List = allTypes.initInt8List(9) - int8List.set(4, 100) - int8List.set(8, 11) - val int8ListReader = int8List.asReader() - int8ListReader.size() should equal (9) - int8ListReader.get(0) should equal (0) - int8ListReader.get(4) should equal (100) - int8ListReader.get(8) should equal (11) - - val int16List = allTypes.initInt16List(2) - int16List.set(0, 1) - val int16ListReader = int16List.asReader() - int16ListReader.size() should equal (2) - int16ListReader.get(0) should equal (1) - int16ListReader.get(1) should equal (0) - - // TODO other primitive lists - - val textList = allTypes.initTextList(1) - textList.set(0, new Text.Reader("abcdefg")) - val textListReader = textList.asReader() - textListReader.size() should equal (1) - textListReader.get(0).toString() should equal ("abcdefg") - - val dataList = allTypes.initDataList(1) - dataList.set(0, new Data.Reader(Array(1,2,3,4))) - val dataListReader = dataList.asReader() - dataListReader.size() should equal (1) - dataListReader.get(0).toArray() should equal (Array(1,2,3,4)) - - val structList = allTypes.initStructList(2) - structList.get(0).setInt8Field(5) - structList.get(1).setInt8Field(9) - val structListReader = structList.asReader(TestAllTypes.factory) - structListReader.size() should equal (2) - structListReader.get(0).getInt8Field() should equal (5) - structListReader.get(1).getInt8Field() should equal (9) - - val enumList = allTypes.initEnumList(3) - enumList.set(0, TestEnum.FOO) - enumList.set(1, TestEnum.BAR) - enumList.set(2, TestEnum.BAZ) - val enumListReader = enumList.asReader() - enumListReader.size() should equal (3) - enumListReader.get(0) should equal (TestEnum.FOO) - enumListReader.get(1) should equal (TestEnum.BAR) - enumListReader.get(2) should equal (TestEnum.BAZ) - } - - test("NestedListBuilderAsReader") { - val builder = new MessageBuilder() - val root = builder.initRoot(TestLists.factory) - - val structListList = root.initStructListList(3) - val structList0 = structListList.init(0, 1) - structList0.get(0).setInt16Field(1) - // leave structList1 as default - val structList2 = structListList.init(2, 3) - structList2.get(0).setInt16Field(22) - structList2.get(1).setInt16Field(333) - structList2.get(2).setInt16Field(4444) - - val structListListReader = structListList.asReader(new StructList.Factory(TestAllTypes.factory)) - structListListReader.size() should equal (3) - val structList0Reader = structListListReader.get(0) - structList0Reader.size() should equal(1) - structList0Reader.get(0).getInt16Field() should equal (1) - structListListReader.get(1).size() should equal (0) - val structList2Reader = structListListReader.get(2) - structList2Reader.size() should equal (3) - structList2Reader.get(0).getInt16Field() should equal (22) - structList2Reader.get(1).getInt16Field() should equal (333) - structList2Reader.get(2).getInt16Field() should equal (4444) - } - - test("Generics") { - val message = new MessageBuilder() - val factory = TestGenerics.newFactory(TestAllTypes.factory, Text.factory) - val root = message.initRoot(factory) - TestUtil.initTestMessage(root.getFoo()) - root.getDub().setFoo(Text.factory, new Text.Reader("Hello")) - val bar = root.getDub().initBar(1) - bar.set(0, 11) - val revBar = root.getRev().getBar() - revBar.setInt8Field(111) - val boolList = revBar.initBoolList(2) - boolList.set(0, false) - boolList.set(1, true) - - TestUtil.checkTestMessage(root.getFoo()) - val rootReader = root.asReader(factory) - TestUtil.checkTestMessage(rootReader.getFoo()) - val dubReader = root.getDub() - dubReader.getFoo().toString() should equal ("Hello") - val barReader = dubReader.getBar() - barReader.size() should equal (1) - barReader.get(0) should equal (11) - } - - test("UseGenerics") { - val message = new MessageBuilder() - val root = message.initRoot(TestUseGenerics.factory) - - { - val message2 = new MessageBuilder() - val factory2 = TestGenerics.newFactory(AnyPointer.factory, AnyPointer.factory) - val root2 = message2.initRoot(factory2) - val dub2 = root2.initDub().setFoo(Text.factory, new Text.Reader("foobar")) - - root.setUnspecified(factory2, root2.asReader(factory2)) - } - - val rootReader = root.asReader() - root.getUnspecified().getDub().getFoo().toString() should equal ("foobar") - } - - test("Defaults") { - val message = new MessageBuilder() - val defaults = message.initRoot(TestDefaults.factory) - TestUtil.checkDefaultMessage(defaults) - TestUtil.checkDefaultMessage(defaults.asReader()) - TestUtil.setDefaultMessage(defaults) - TestUtil.checkSettedDefaultMessage(defaults.asReader()) - } - - test("Unions") { - val builder = new MessageBuilder() - val root = builder.initRoot(TestUnion.factory) - val u0 = root.initUnion0() - u0.initU0f1sp(10) - assert(u0.which() == TestUnion.Union0.Which.U0F1SP) - - u0.initPrimitiveList(10) - assert(u0.which() == TestUnion.Union0.Which.PRIMITIVE_LIST) - } - - test("Groups") { - val builder = new MessageBuilder() - val root = builder.initRoot(TestGroups.factory) - - { - val foo = root.getGroups().initFoo() - foo.setCorge(12345678) - foo.setGrault(123456789012345L) - foo.setGarply(new Text.Reader("foobar")) - - assert(12345678 == foo.getCorge()) - assert(123456789012345L == foo.getGrault()) - assert("foobar" == foo.getGarply().toString()) - } - - { - val bar = root.getGroups.initBar() - bar.setCorge(23456789) - bar.setGrault(new Text.Reader("barbaz")) - bar.setGarply(234567890123456L) - - assert(23456789 == bar.getCorge()) - assert("barbaz" == bar.getGrault().toString()) - assert(234567890123456L == bar.getGarply()) - } - - { - val baz = root.getGroups().initBaz() - baz.setCorge(34567890) - baz.setGrault(new Text.Reader("bazqux")) - baz.setGarply(new Text.Reader("quxquux")) - - assert(34567890 == baz.getCorge()) - assert("bazqux" == baz.getGrault().toString()) - assert("quxquux" == baz.getGarply().toString()) - } - } - - test("NestedLists") { - val builder = new MessageBuilder() - val root = builder.initRoot(TestLists.factory) - - { - val intListList = root.initInt32ListList(2) - val intList0 = intListList.init(0, 4) - intList0.set(0, 1) - intList0.set(1, 2) - intList0.set(2, 3) - intList0.set(3, 4) - val intList1 = intListList.init(1, 1) - intList1.set(0, 100) - } - - { - val reader = root.asReader() - val intListList = root.getInt32ListList() - intListList.size() should equal (2) - val intList0 = intListList.get(0) - intList0.size() should equal (4) - intList0.get(0) should equal (1) - intList0.get(1) should equal (2) - intList0.get(2) should equal (3) - intList0.get(3) should equal (4) - val intList1 = intListList.get(1) - intList1.size() should equal (1) - intList1.get(0) should equal(100) - } - } - - test("Constants") { - assert(Void.VOID == TestConstants.VOID_CONST) - assert(true == TestConstants.BOOL_CONST) - assert(-123 == TestConstants.INT8_CONST) - assert(-12345 == TestConstants.INT16_CONST) - assert(-12345678 == TestConstants.INT32_CONST) - assert(-123456789012345L == TestConstants.INT64_CONST) - - assert(-22 == TestConstants.UINT8_CONST) - assert(-19858 == TestConstants.UINT16_CONST) - assert(-838178284 == TestConstants.UINT32_CONST) - assert(-6101065172474983726L == TestConstants.UINT64_CONST) - - assert(1234.5f == TestConstants.FLOAT32_CONST) - (-123e45) should equal (TestConstants.FLOAT64_CONST) - - (TestConstants.TEXT_CONST.toString()) should equal ("foo") - (TestConstants.DATA_CONST.toArray()) should equal (TestUtil.data("bar")) - - (TestConstants.ENUM_CONST) should equal (TestEnum.CORGE) - - { - val subReader = TestConstants.STRUCT_CONST - subReader.getBoolField() should equal (true) - subReader.getInt8Field() should equal (-12) - subReader.getInt16Field() should equal(3456) - subReader.getInt32Field() should equal (-78901234) - subReader.getInt64Field() should equal (56789012345678L) - subReader.getUInt8Field() should equal (90) - subReader.getUInt16Field should equal (1234) - subReader.getUInt32Field() should equal (56789012) - subReader.getUInt64Field() should equal (345678901234567890L) - subReader.getFloat32Field() should equal (-1.25e-10f) - subReader.getFloat64Field() should equal (345) - subReader.getTextField().toString() should equal ("baz") - // ... - } - - TestConstants.VOID_LIST_CONST.size() should equal (6) - - { - val listReader = TestConstants.BOOL_LIST_CONST - listReader.size() should equal (4) - listReader.get(0) should equal (true) - listReader.get(1) should equal (false) - listReader.get(2) should equal (false) - listReader.get(3) should equal (true) - } - - // ... - { - val listReader = TestConstants.TEXT_LIST_CONST - listReader.size() should equal(3) - listReader.get(0).toString() should equal ("plugh") - listReader.get(1).toString() should equal ("xyzzy") - listReader.get(2).toString() should equal ("thud") - } - - { - val listReader = TestConstants.STRUCT_LIST_CONST - listReader.size() should equal(3) - listReader.get(0).getTextField().toString() should equal ("structlist 1") - listReader.get(1).getTextField().toString() should equal ("structlist 2") - listReader.get(2).getTextField().toString() should equal ("structlist 3") - } - - } - - test("GlobalConstants") { - assert(12345 == GLOBAL_INT) - } - - test("EmptyStruct") { - val builder = new MessageBuilder() - val root = builder.initRoot(TestAnyPointer.factory) - root.hasAnyPointerField() should equal (false) - val any = root.getAnyPointerField() - any.isNull() should equal (true) - any.initAs(TestEmptyStruct.factory) - any.isNull() should equal (false) - root.hasAnyPointerField() should equal (true) - - { - val rootReader = root.asReader() - rootReader.hasAnyPointerField() should equal (true) - rootReader.getAnyPointerField().isNull() should equal (false) - } - } - - test("TextBuilderIntUnderflow") { - val message = new MessageBuilder() - val root = message.initRoot(TestAnyPointer.factory) - root.getAnyPointerField.initAs(org.capnproto.Data.factory, 0) - a [DecodeException] should be thrownBy root.getAnyPointerField.getAs(org.capnproto.Text.factory) - } - - test("InlineCompositeListIntOverflow") { - val bytes = Array[Byte](0,0,0,0, 0,0,1,0, - 1,0,0,0, 0x17,0,0,0, 0,0,0,-128, 16,0,0,0, - 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0) - - val segment = java.nio.ByteBuffer.wrap(bytes) - segment.order(java.nio.ByteOrder.LITTLE_ENDIAN) - val message = new MessageReader(Array(segment), ReaderOptions.DEFAULT_READER_OPTIONS) - - val root = message.getRoot(TestAnyPointer.factory) - // TODO add this after we impelement totalSize(): - //root.totalSize() - - a [DecodeException] should be thrownBy - root.getAnyPointerField.getAs(new StructList.Factory(TestAllTypes.factory)) - - val messageBuilder = new MessageBuilder() - val builderRoot = messageBuilder.initRoot(TestAnyPointer.factory) - a [DecodeException] should be thrownBy - builderRoot.getAnyPointerField.setAs(TestAnyPointer.factory, root) - - } - - test("VoidListAmplification") { - val builder = new MessageBuilder() - builder.initRoot(TestAnyPointer.factory).getAnyPointerField().initAs(PrimitiveList.Void.factory, 1 << 28) - - val segments = builder.getSegmentsForOutput() - segments.length should equal (1) - - val reader = new MessageReader(segments, ReaderOptions.DEFAULT_READER_OPTIONS) - val root = reader.getRoot(TestAnyPointer.factory) - a [DecodeException] should be thrownBy - root.getAnyPointerField().getAs(new StructList.Factory(TestAllTypes.factory)) - } - - test("EmptyStructListAmplification") { - val builder = new MessageBuilder() - builder.initRoot(TestAnyPointer.factory).getAnyPointerField() - .initAs(new StructList.Factory(TestEmptyStruct.factory), (1 << 29) - 1) - - val segments = builder.getSegmentsForOutput() - segments.length should equal (1) - - val reader = new MessageReader(segments, ReaderOptions.DEFAULT_READER_OPTIONS) - val root = reader.getRoot(TestAnyPointer.factory) - a [DecodeException] should be thrownBy - root.getAnyPointerField().getAs(new StructList.Factory(TestAllTypes.factory)) - } - - test("LongUint8List") { - { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - val length = (1 << 28) + 1 - val list = allTypes.initUInt8List(length) - list.size() should equal (length) - list.set(length - 1, 3) - list.get(length - 1) should equal (3) - allTypes.asReader().getUInt8List().get(length - 1) should equal (3) - } - } - - - test("LongUint16List") { - { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - val length = (1 << 27) + 1 - val list = allTypes.initUInt16List(length) - list.size() should equal (length) - list.set(length - 1, 3) - list.get(length - 1) should equal (3) - allTypes.asReader().getUInt16List().get(length - 1) should equal (3) - } - } - - test("LongUint32List") { - { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - val length = (1 << 26) + 1 - val list = allTypes.initUInt32List(length) - list.size() should equal (length) - list.set(length - 1, 3) - list.get(length - 1) should equal (3) - allTypes.asReader().getUInt32List().get(length - 1) should equal (3) - } - } - - test("LongUint64List") { - { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - val length = (1 << 25) + 1 - val list = allTypes.initUInt64List(length) - list.size() should equal (length) - list.set(length - 1, 3) - list.get(length - 1) should equal (3) - allTypes.asReader().getUInt64List().get(length - 1) should equal (3) - } - } - - test("LongFloat32List") { - { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - val length = (1 << 26) + 1 - val list = allTypes.initFloat32List(length) - list.size() should equal (length) - list.set(length - 1, 3.14f) - list.get(length - 1) should equal (3.14f) - allTypes.asReader().getFloat32List().get(length - 1) should equal (3.14f) - } - } - - test("LongFloat64List") { - { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - val length = (1 << 25) + 1 - val list = allTypes.initFloat64List(length) - list.size() should equal (length) - list.set(length - 1, 3.14) - list.get(length - 1) should equal (3.14) - allTypes.asReader().getFloat64List().get(length - 1) should equal (3.14) - } - } - - test("LongStructList") { - { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - val length = (1 << 21) + 1 - val list = allTypes.initStructList(length) - list.size() should equal (length) - list.get(length - 1).setUInt8Field(3) - allTypes.asReader().getStructList().get(length - 1).getUInt8Field() should equal (3) - } - } - - test("LongTextList") { - { - val message = new MessageBuilder() - val allTypes = message.initRoot(TestAllTypes.factory) - val length = (1 << 25) + 1 - val list = allTypes.initTextList(length) - list.size() should equal (length) - list.set(length - 1, new Text.Reader("foo")) - allTypes.asReader().getTextList().get(length - 1).toString() should equal ("foo") - } - } - - - test("LongListList") { - { - val message = new MessageBuilder() - val root = message.initRoot(TestLists.factory) - val length = (1 << 25) + 1 - val list = root.initStructListList(length) - list.size() should equal (length) - list.init(length - 1, 3) - list.get(length - 1).size() should equal (3) - root.asReader().getStructListList().get(length - 1).size() should equal (3) - } - } - - test("StructSetters") { - val builder = new MessageBuilder() - val root = builder.initRoot(TestAllTypes.factory) - TestUtil.initTestMessage(root) - - { - val builder2 = new MessageBuilder() - builder2.setRoot(TestAllTypes.factory, root.asReader()) - TestUtil.checkTestMessage(builder2.getRoot(TestAllTypes.factory)) - } - - { - val builder2 = new MessageBuilder() - val root2 = builder2.getRoot(TestAllTypes.factory) - root2.setStructField(root.asReader()) - TestUtil.checkTestMessage(root2.getStructField()) - } - - { - val builder2 = new MessageBuilder() - val root2 = builder2.getRoot(TestAnyPointer.factory) - root2.getAnyPointerField().setAs(TestAllTypes.factory, root.asReader()) - TestUtil.checkTestMessage(root2.getAnyPointerField.getAs(TestAllTypes.factory)) - } - } - - test("SerializedSize") { - val builder = new MessageBuilder() - val root = builder.initRoot(TestAnyPointer.factory) - root.getAnyPointerField().setAs(Text.factory, new Text.Reader("12345")) - - // one word for segment table, one for the root pointer, - // one for the body of the TestAnyPointer struct, - // and one for the body of the Text. - Serialize.computeSerializedSizeInWords(builder) should equal (4) - } - - test("Import") { - val builder = new MessageBuilder() - val root = builder.initRoot(org.capnproto.testimport.TestImport.Foo.factory) - val field = root.initImportedStruct() - TestUtil.initTestMessage(field) - TestUtil.checkTestMessage(field) - TestUtil.checkTestMessage(field.asReader()) - } - - test("GenericMap") { - val builder = new MessageBuilder() - val mapFactory = new GenericMap.Factory(Text.factory, TestAllTypes.factory) - val entryFactory = new StructList.Factory(new GenericMap.Entry.Factory(Text.factory, TestAllTypes.factory)); - val root = builder.initRoot(mapFactory) - - { - val entries = root.initEntries(entryFactory, 3); - - val entry0 = entries.get(0) - entry0.setKey(Text.factory, new Text.Reader("foo")) - val value0 = entry0.initValue() - value0.setInt64Field(101); - - val entry1 = entries.get(1) - entry1.setKey(Text.factory, new Text.Reader("bar")) - val value1 = entry1.initValue() - value1.setInt64Field(202); - - val entry2 = entries.get(2) - entry2.setKey(Text.factory, new Text.Reader("baz")) - val value2 = entry2.initValue() - value2.setInt64Field(303); - } - - { - val entries = root.asReader(mapFactory).getEntries(entryFactory) - val entry0 = entries.get(0) - assert(entry0.getKey().toString() == "foo") - assert(entry0.getValue().getInt64Field() == 101) - - val entry1 = entries.get(1) - assert(entry1.getKey().toString() == "bar") - assert(entry1.getValue().getInt64Field() == 202) - - val entry2 = entries.get(2) - assert(entry2.getKey().toString() == "baz") - assert(entry2.getValue().getInt64Field == 303) - } - } - - test("setWithCaveats") { - val builder = new MessageBuilder() - val root = builder.initRoot(TestAllTypes.factory) - val list = root.initStructList(2) - - { - val message1 = new MessageBuilder() - val root1 = message1.initRoot(TestAllTypes.factory) - root1.setInt8Field(11) - list.setWithCaveats(TestAllTypes.factory, 0, root1.asReader()) - } - - { - val message2 = new MessageBuilder() - val root2 = message2.initRoot(TestAllTypes.factory) - TestUtil.initTestMessage(root2) - list.setWithCaveats(TestAllTypes.factory, 1, root2.asReader()) - } - - val listReader = list.asReader(TestAllTypes.factory) - listReader.get(0).getInt8Field() should equal (11) - TestUtil.checkTestMessage(listReader.get(1)) - } - - // to debug, do this: - //Serialize.write((new java.io.FileOutputStream("/Users/dwrensha/Desktop/test.dat")).getChannel(), - // message) - -} diff --git a/compiler/src/test/scala/org/capnproto/TestUtil.scala b/compiler/src/test/scala/org/capnproto/TestUtil.scala deleted file mode 100644 index 1f9ee0e..0000000 --- a/compiler/src/test/scala/org/capnproto/TestUtil.scala +++ /dev/null @@ -1,379 +0,0 @@ -// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors -// Licensed under the MIT License: -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -package org.capnproto - -import org.capnproto.Text.Reader -import org.scalatest.Matchers._ -import org.capnproto.test.Test._ - - -object TestUtil { - - def data(str : String) : Array[Byte] = { - try { - str.getBytes("ISO_8859-1") - } catch { - case e: Exception => throw new Error("could not decode") - } - } - - def initTestMessage(builder : TestAllTypes.Builder) { - builder.setVoidField(org.capnproto.Void.VOID) - builder.setBoolField(true) - builder.setInt8Field(-123) - builder.setInt16Field(-12345) - builder.setInt32Field(-12345678) - builder.setInt64Field(-123456789012345L) - builder.setUInt8Field(0xea.toByte) - builder.setUInt16Field(0x4567) - builder.setUInt32Field(0x34567890) - builder.setUInt64Field(0x1234567890123456L) - builder.setFloat32Field(1234.5f) - builder.setFloat64Field(-123e45) - builder.setTextField("foo") - builder.setDataField(data("bar")) - - { - val subBuilder = builder.initStructField() - subBuilder.setVoidField(org.capnproto.Void.VOID) - subBuilder.setBoolField(true) - subBuilder.setInt8Field(-12) - subBuilder.setInt16Field(3456) - subBuilder.setInt32Field(-78901234) - subBuilder.setInt64Field(56789012345678L) - subBuilder.setUInt8Field(90) - subBuilder.setUInt16Field(1234) - subBuilder.setUInt32Field(56789012) - subBuilder.setUInt64Field(345678901234567890L) - subBuilder.setFloat32Field(-1.25e-10f) - subBuilder.setFloat64Field(345) - subBuilder.setTextField(new Text.Reader("baz")) - subBuilder.setDataField(data("qux")) - - { - val subSubBuilder = subBuilder.initStructField() - subSubBuilder.setTextField(new Text.Reader("nested")) - subSubBuilder.initStructField().setTextField(new Text.Reader("really nested")) - } - - subBuilder.setEnumField(TestEnum.BAZ) - - val boolList = subBuilder.initBoolList(5) - boolList.set(0, false) - boolList.set(1, true) - boolList.set(2, false) - boolList.set(3, true) - boolList.set(4, true) - } - - builder.setEnumField(TestEnum.CORGE) - builder.initVoidList(6) - - val boolList = builder.initBoolList(4) - boolList.set(0, true) - boolList.set(1, false) - boolList.set(2, false) - boolList.set(3, true) - - val float64List = builder.initFloat64List(4) - float64List.set(0, 7777.75) - float64List.set(1, Double.PositiveInfinity) - float64List.set(2, Double.NegativeInfinity) - float64List.set(3, Double.NaN) - - val textList = builder.initTextList(3) - textList.set(0, new Text.Reader("plugh")) - textList.set(1, new Text.Reader("xyzzy")) - textList.set(2, new Text.Reader("thud")) - - val structList = builder.initStructList(3) - structList.get(0).setTextField(new Text.Reader("structlist 1")) - structList.get(1).setTextField(new Text.Reader("structlist 2")) - structList.get(2).setTextField(new Text.Reader("structlist 3")) - - - val enumList = builder.initEnumList(2) - enumList.set(0, TestEnum.FOO) - enumList.set(1, TestEnum.GARPLY) - } - - def checkTestMessage(builder : TestAllTypes.Builder) { - builder.getVoidField() - assert(builder.getBoolField() == true) - assert(builder.getInt8Field() == -123) - assert(builder.getInt16Field() == -12345) - assert(builder.getInt32Field() == -12345678) - assert(builder.getInt64Field() == -123456789012345L) - assert(builder.getUInt8Field() == 0xea.toByte) - assert(builder.getUInt16Field() == 0x4567) - assert(builder.getUInt32Field() == 0x34567890) - assert(builder.getUInt64Field() == 0x1234567890123456L) - assert(builder.getFloat32Field() == 1234.5f) - assert(builder.getFloat64Field() == -123e45) - assert(builder.getTextField().toString() == "foo") - - { - val subBuilder = builder.getStructField() - subBuilder.getVoidField() - assert(subBuilder.getBoolField() == true) - assert(subBuilder.getInt8Field() == -12) - assert(subBuilder.getInt16Field() == 3456) - assert(subBuilder.getInt32Field() == -78901234) - assert(subBuilder.getInt64Field() == 56789012345678L) - assert(subBuilder.getUInt8Field() == 90) - assert(subBuilder.getUInt16Field() == 1234) - assert(subBuilder.getUInt32Field() == 56789012) - assert(subBuilder.getUInt64Field() == 345678901234567890L) - assert(subBuilder.getFloat32Field() == -1.25e-10f) - assert(subBuilder.getFloat64Field() == 345) - - { - val subSubBuilder = subBuilder.getStructField() - assert(subSubBuilder.getTextField().toString() == "nested") - } - - subBuilder.getEnumField() should equal (TestEnum.BAZ) - - val boolList = subBuilder.getBoolList() - assert(boolList.get(0) == false) - assert(boolList.get(1) == true) - assert(boolList.get(2) == false) - assert(boolList.get(3) == true) - assert(boolList.get(4) == true) - - } - builder.getEnumField() should equal (TestEnum.CORGE) - - assert(builder.getVoidList().size() == 6) - - val boolList = builder.getBoolList() - assert(boolList.size() == 4) - assert(boolList.get(0) == true) - assert(boolList.get(1) == false) - assert(boolList.get(2) == false) - assert(boolList.get(3) == true) - - val float64List = builder.getFloat64List() - assert(float64List.get(0) == 7777.75) - assert(float64List.get(1) == Double.PositiveInfinity) - assert(float64List.get(2) == Double.NegativeInfinity) - assert(float64List.get(3) != float64List.get(3)); // NaN - - val textList = builder.getTextList() - assert(textList.size() == 3) - assert(textList.get(0).toString() == "plugh") - assert(textList.get(1).toString() == "xyzzy") - assert(textList.get(2).toString() == "thud") - - val structList = builder.getStructList() - assert(3 == structList.size()) - assert(structList.get(0).getTextField().toString() == "structlist 1") - assert(structList.get(1).getTextField().toString() == "structlist 2") - assert(structList.get(2).getTextField().toString() == "structlist 3") - - val enumList = builder.getEnumList() - (enumList.get(0)) should equal (TestEnum.FOO) - (enumList.get(1)) should equal (TestEnum.GARPLY) - } - - def checkTestMessage(reader : TestAllTypes.Reader) { - reader.getVoidField() - assert(reader.getBoolField() == true) - assert(reader.getInt8Field() == -123) - assert(reader.getInt16Field() == -12345) - assert(reader.getInt32Field() == -12345678) - assert(reader.getInt64Field() == -123456789012345L) - assert(reader.getUInt8Field() == 0xea.toByte) - assert(reader.getUInt16Field() == 0x4567) - assert(reader.getUInt32Field() == 0x34567890) - assert(reader.getUInt64Field() == 0x1234567890123456L) - assert(reader.getFloat32Field() == 1234.5f) - assert(reader.getFloat64Field() == -123e45) - assert(reader.getTextField().toString() == "foo") - - { - val subReader = reader.getStructField() - subReader.getVoidField() - assert(subReader.getBoolField() == true) - assert(subReader.getInt8Field() == -12) - assert(subReader.getInt16Field() == 3456) - assert(subReader.getInt32Field() == -78901234) - assert(subReader.getInt64Field() == 56789012345678L) - assert(subReader.getUInt8Field() == 90) - assert(subReader.getUInt16Field() == 1234) - assert(subReader.getUInt32Field() == 56789012) - assert(subReader.getUInt64Field() == 345678901234567890L) - assert(subReader.getFloat32Field() == -1.25e-10f) - assert(subReader.getFloat64Field() == 345) - - { - val subSubReader = subReader.getStructField() - assert(subSubReader.getTextField().toString() == "nested") - } - val boolList = subReader.getBoolList() - assert(boolList.get(0) == false) - assert(boolList.get(1) == true) - assert(boolList.get(2) == false) - assert(boolList.get(3) == true) - assert(boolList.get(4) == true) - - } - - assert(reader.getVoidList().size() == 6) - - val boolList = reader.getBoolList() - assert(boolList.get(0) == true) - assert(boolList.get(1) == false) - assert(boolList.get(2) == false) - assert(boolList.get(3) == true) - - val float64List = reader.getFloat64List() - assert(float64List.get(0) == 7777.75) - assert(float64List.get(1) == Double.PositiveInfinity) - assert(float64List.get(2) == Double.NegativeInfinity) - assert(float64List.get(3) != float64List.get(3)); // NaN - - val textList = reader.getTextList() - assert(textList.size() == 3) - assert(textList.get(0).toString() == "plugh") - assert(textList.get(1).toString() == "xyzzy") - assert(textList.get(2).toString() == "thud") - - - val structList = reader.getStructList() - assert(3 == structList.size()) - assert(structList.get(0).getTextField().toString() == "structlist 1") - assert(structList.get(1).getTextField().toString() == "structlist 2") - assert(structList.get(2).getTextField().toString() == "structlist 3") - - val enumList = reader.getEnumList() - (enumList.get(0)) should equal (TestEnum.FOO) - (enumList.get(1)) should equal (TestEnum.GARPLY) - - } - - def checkDefaultMessage(builder : TestDefaults.Builder) { - builder.getVoidField() - assert(builder.getBoolField() == true) - assert(builder.getInt8Field() == -123) - assert(builder.getInt16Field() == -12345) - assert(builder.getInt32Field() == -12345678) - assert(builder.getInt64Field() == -123456789012345L) - assert(builder.getUInt8Field() == 0xea.toByte) - assert(builder.getUInt16Field() == 45678.toShort) - assert(builder.getUInt32Field() == 0xce0a6a14) - assert(builder.getUInt64Field() == 0xab54a98ceb1f0ad2L) - assert(builder.getFloat32Field() == 1234.5f) - assert(builder.getFloat64Field() == -123e45) - assert(builder.getEnumField() == TestEnum.CORGE) - - (builder.getTextField().toString()) should equal ("foo") - (builder.getDataField().toArray()) should equal (Array(0x62,0x61,0x72)) - } - - def checkDefaultMessage(reader : TestDefaults.Reader) { - reader.getVoidField() - assert(reader.getBoolField() == true) - assert(reader.getInt8Field() == -123) - assert(reader.getInt16Field() == -12345) - assert(reader.getInt32Field() == -12345678) - assert(reader.getInt64Field() == -123456789012345L) - assert(reader.getUInt8Field() == 0xea.toByte) - assert(reader.getUInt16Field() == 45678.toShort) - assert(reader.getUInt32Field() == 0xce0a6a14) - assert(reader.getUInt64Field() == 0xab54a98ceb1f0ad2L) - assert(reader.getFloat32Field() == 1234.5f) - assert(reader.getFloat64Field() == -123e45) - (reader.getTextField().toString()) should equal ("foo") - (reader.getDataField().toArray()) should equal (Array(0x62,0x61,0x72)) - - { - val subReader = reader.getStructField() - subReader.getVoidField() - subReader.getBoolField() should equal (true) - subReader.getInt8Field() should equal (-12) - subReader.getInt16Field() should equal (3456) - subReader.getInt32Field() should equal (-78901234) - // ... - subReader.getTextField().toString() should equal ("baz") - - { - val subSubReader = subReader.getStructField() - subSubReader.getTextField().toString() should equal ("nested") - } - - } - - reader.getEnumField() should equal (TestEnum.CORGE) - - reader.getVoidList().size() should equal (6) - - { - val listReader = reader.getBoolList() - listReader.size() should equal (4) - listReader.get(0) should equal (true) - listReader.get(1) should equal (false) - listReader.get(2) should equal (false) - listReader.get(3) should equal (true) - } - - { - val listReader = reader.getInt8List() - listReader.size() should equal (2) - listReader.get(0) should equal (111) - listReader.get(1) should equal (-111) - } - - } - - - def setDefaultMessage(builder : TestDefaults.Builder) { - builder.setBoolField(false) - builder.setInt8Field(-122) - builder.setInt16Field(-12344) - builder.setInt32Field(-12345677) - builder.setInt64Field(-123456789012344L) - builder.setUInt8Field(0xe9.toByte) - builder.setUInt16Field(45677.toShort) - builder.setUInt32Field(0xce0a6a13) - builder.setUInt64Field(0xab54a98ceb1f0ad1L) - builder.setFloat32Field(1234.4f) - builder.setFloat64Field(-123e44) - builder.setTextField(new Reader("bar")) - builder.setEnumField(TestEnum.QUX) - } - - def checkSettedDefaultMessage(reader : TestDefaults.Reader) { - assert(reader.getBoolField() == false) - assert(reader.getInt8Field() == -122) - assert(reader.getInt16Field() == -12344) - assert(reader.getInt32Field() == -12345677) - assert(reader.getInt64Field() == -123456789012344L) - assert(reader.getUInt8Field() == 0xe9.toByte) - assert(reader.getUInt16Field() == 45677.toShort) - assert(reader.getUInt32Field() == 0xce0a6a13) - assert(reader.getUInt64Field() == 0xab54a98ceb1f0ad1L) - assert(reader.getFloat32Field() == 1234.4f) - assert(reader.getFloat64Field() == -123e44) - assert(reader.getEnumField() == TestEnum.QUX) - } -} diff --git a/examples/pom.xml b/examples/pom.xml new file mode 100644 index 0000000..462450a --- /dev/null +++ b/examples/pom.xml @@ -0,0 +1,90 @@ + + + 4.0.0 + org.capnproto + examples + jar + capnproto-java examples + 0.1.4 + capnproto-java examples + + org.capnproto + + https://capnproto.org/ + + + MIT + http://opensource.org/licenses/MIT + repo + + + + git@github.com:capnproto/capnproto-java.git + scm:git@github.com:capnproto/capnproto-java.git + + + + dwrensha + David Renshaw + https://github.com/dwrensha + + + + + org.capnproto + runtime + 0.1.4 + + + + + + + maven-antrun-plugin + 3.0.0 + + + generate-sources + generate-sources + + + + + + + + + + + + + + + run + + + + + + + org.codehaus.mojo + build-helper-maven-plugin + 3.1.0 + + + add-generated-sources + generate-sources + + add-source + + + + src/main/generated + + + + + + + + diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..0e14bd2 --- /dev/null +++ b/pom.xml @@ -0,0 +1,34 @@ + + + 4.0.0 + org.capnproto + capnproto-java + pom + 0.1.4 + Cap'n Proto for Java + https://capnproto.org/ + + runtime + compiler + examples + benchmark + + + + MIT + http://opensource.org/licenses/MIT + repo + + + + git@github.com:capnproto/capnproto-java.git + scm:git@github.com:capnproto/capnproto-java.git + + + + dwrensha + David Renshaw + https://github.com/dwrensha + + + diff --git a/project/build.properties b/project/build.properties deleted file mode 100644 index 8ac605a..0000000 --- a/project/build.properties +++ /dev/null @@ -1 +0,0 @@ -sbt.version=0.13.2 diff --git a/project/build.scala b/project/build.scala deleted file mode 100644 index 03f468d..0000000 --- a/project/build.scala +++ /dev/null @@ -1,179 +0,0 @@ -import sbt.Keys._ -import sbt._ - -object Build extends sbt.Build { - - lazy val root = - project( - id = "capnproto-java", - base = file(".") - ).aggregate(compiler, runtime, examples) - .settings(cleanFiles <+= baseDirectory { base => base / "capnpc-java"}) - - lazy val compiler = - project( - id = "compiler", - base = file("compiler") - ).dependsOn(runtime) - .settings(makeCppTask) - .settings(compile <<= compile in Compile dependsOn makeCpp) - .settings(compileTestSchemaTask) - .settings(test <<= test in Test dependsOn compileTestSchema) - .settings(unmanagedSourceDirectories in Test += sourceDirectory.value / "test" / "generated") - .settings(cleanFiles += sourceDirectory.value / "test" / "generated") - - lazy val runtime = - project( - id = "runtime", - base = file("runtime") - ).settings(publishArtifact := true) - .settings(crossPaths := false) // disable outputting the _ suffix - - lazy val examples = - project( - id = "examples", - base = file("examples") - ).dependsOn(runtime, compiler) - .settings(makeExamplesTask) - .settings(test <<= test in Test dependsOn makeExamples) - .settings(compile <<= compile in Compile dependsOn makeExamples) - .settings(unmanagedSourceDirectories in Compile += sourceDirectory.value / "main" / "generated") - .settings(cleanFiles += sourceDirectory.value / "main" / "generated") - .settings(crossPaths := false) // disable outputting the _ suffix - - lazy val benchmark = - project( - id = "benchmark", - base = file("benchmark") - ).dependsOn(runtime, compiler) - .settings(compileBenchmarkSchemaTask) - .settings(compile <<= compile in Compile dependsOn compileBenchmarkSchema) - .settings(unmanagedSourceDirectories in Compile += sourceDirectory.value / "main" / "generated") - .settings(cleanFiles += sourceDirectory.value / "main" / "generated") - .settings(crossPaths := false) // disable outputting the _ suffix - - def project(id: String, base: File) = - Project( - id = id, - base = base, - settings = - Project.defaultSettings ++ - Shared.settings ++ - Seq(libraryDependencies ++= Shared.testDeps) - ).configs(IntegrationTest) - - val compileTestSchema = taskKey[Unit]("Run capnpc-java on test schema") - val compileTestSchemaTask = compileTestSchema := { - val result0 = "mkdir -p compiler/src/test/generated".!! - val result = "capnp compile -I compiler/src/main/schema/ --src-prefix=compiler/src/test/schema/ -o./capnpc-java:compiler/src/test/generated compiler/src/test/schema/test.capnp compiler/src/test/schema/test-import.capnp".!! - println(s"**** CodeGen for test.capnp started\n$result\n**** CodeGen complete."); - } - - val makeCpp = taskKey[Unit]("Run make against the C++ code to create the Java code generator") - val makeCppTask = makeCpp := { - val makeResult = "make capnpc-java".!! - println(s"**** C++ Build Started\n$makeResult\n**** C++ Build Complete") - } - - val makeExamples = taskKey[Unit]("Run capnpc-java compiler against the addressbook schema") - val makeExamplesTask = makeExamples := { - Thread.sleep(1000) - val makeResult = "make addressbook".!! - println(s"**** CodeGen for Addressbook Started\n$makeResult\n**** CodeGen for Addressbook Complete") - } - - val compileBenchmarkSchema = taskKey[Unit]("Run capnpc-java on benchmark schema") - val compileBenchmarkSchemaTask = compileBenchmarkSchema := { - val result0 = "mkdir -p benchmark/src/main/generated".!! - val result = "capnp compile -I compiler/src/main/schema/ --src-prefix=benchmark/src/main/schema/ -o./capnpc-java:benchmark/src/main/generated benchmark/src/main/schema/eval.capnp benchmark/src/main/schema/carsales.capnp benchmark/src/main/schema/catrank.capnp".!! - println(s"**** CodeGen for benchmark started\n$result\n**** CodeGen complete."); - } - -} - -object Shared { - - val testDeps = Seq( - "org.scalatest" %% "scalatest" % "2.1.6" % "it,test" -// "org.scalacheck" %% "scalacheck" % "1.11.4" % "it,test", - ) - - val settings = Seq( - scalaVersion := "2.11.0", - scalacOptions := Seq( - "-deprecation", - "-feature", - "-optimise", - "-Yinline-warnings", - "-unchecked", - "-feature" - ), - javacOptions in (Compile, compile) ++= Seq("-source", "1.7", "-target", "1.7"), - resolvers += Resolver.sonatypeRepo("snapshots"), - resolvers += Resolver.sonatypeRepo("releases"), - shellPrompt := ShellPrompt.buildShellPrompt, - organization := "org.capnproto", - publishArtifact := false, - publishTo := { - val nexus = "https://oss.sonatype.org/" - if (isSnapshot.value) - Some("snapshots" at nexus + "content/repositories/snapshots") - else - Some("releases" at nexus + "service/local/staging/deploy/maven2") - }, - credentials += Credentials(Path.userHome / ".ivy2" / ".credentials"), - publishMavenStyle := true, - version := "0.1.4", - autoScalaLibrary := false, - publishArtifact in Test := false, - autoScalaLibrary in test := false, - pomIncludeRepository := { x => false }, - pomExtra := ( - https://capnproto.org/ - - - MIT - http://opensource.org/licenses/MIT - repo - - - - git@github.com:capnproto/capnproto-java.git - scm:git@github.com:capnproto/capnproto-java.git - - - - dwrensha - David Renshaw - https://github.com/dwrensha - - - ) - - ) - -} - -object ShellPrompt { - object devnull extends ProcessLogger { - def info(s: => String) {} - def error(s: => String) {} - def buffer[T](f: => T): T = f - } - - def currBranch = ( - ("git status -sb" lines_! devnull headOption) - getOrElse "-" stripPrefix "## " - ) - - val buildShellPrompt = { - (state: State) => { - val currProject = Project.extract(state).currentProject.id - "[%s](%s)$ ".format( - currProject, currBranch /*, BuildSettings.buildVersion*/ - ) - } - } -} - - diff --git a/project/plugins.sbt b/project/plugins.sbt deleted file mode 100644 index 368f9d8..0000000 --- a/project/plugins.sbt +++ /dev/null @@ -1,7 +0,0 @@ -addSbtPlugin("com.github.mpeltonen" % "sbt-idea" % "1.5.2") - -addSbtPlugin("net.virtual-void" % "sbt-dependency-graph" % "0.7.4") - -resolvers += Resolver.url("scalasbt", new URL("http://scalasbt.artifactoryonline.com/scalasbt/sbt-plugin-releases")) (Resolver.ivyStylePatterns) - -addSbtPlugin("com.typesafe.sbt" % "sbt-pgp" % "0.8.3") diff --git a/runtime/pom.xml b/runtime/pom.xml new file mode 100644 index 0000000..1f34c56 --- /dev/null +++ b/runtime/pom.xml @@ -0,0 +1,40 @@ + + + 4.0.0 + org.capnproto + runtime + jar + runtime + 0.1.4 + Cap'n Proto runtime library + + org.capnproto + + https://capnproto.org/ + + + MIT + http://opensource.org/licenses/MIT + repo + + + + git@github.com:capnproto/capnproto-java.git + scm:git@github.com:capnproto/capnproto-java.git + + + + dwrensha + David Renshaw + https://github.com/dwrensha + + + + + junit + junit + 4.12 + test + + + diff --git a/runtime/src/test/scala/org/capnproto/ArrayInputStreamSuite.scala b/runtime/src/test/java/org/capnproto/ArrayInputStreamTest.java similarity index 64% rename from runtime/src/test/scala/org/capnproto/ArrayInputStreamSuite.scala rename to runtime/src/test/java/org/capnproto/ArrayInputStreamTest.java index 18da8d9..57c61e9 100644 --- a/runtime/src/test/scala/org/capnproto/ArrayInputStreamSuite.scala +++ b/runtime/src/test/java/org/capnproto/ArrayInputStreamTest.java @@ -19,27 +19,30 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. -package org.capnproto +package org.capnproto; -import java.nio.ByteBuffer -import org.scalatest.FunSuite -import org.scalatest.Matchers._ +import org.junit.Assert; +import org.junit.Test; -class ArrayInputStreamSuite extends FunSuite { - test("EmptyArray") { - val stream = new ArrayInputStream(ByteBuffer.allocate(0)) - val dst = ByteBuffer.allocate(10) +import java.nio.ByteBuffer; + +public class ArrayInputStreamTest { + @Test + public void testEmptyArray() throws java.io.IOException { + ArrayInputStream stream = new ArrayInputStream(ByteBuffer.allocate(0)); + ByteBuffer dst = ByteBuffer.allocate(10); // read() should return -1 at the end of the stream // https://docs.oracle.com/javase/7/docs/api/java/nio/channels/ReadableByteChannel.html - stream.read(dst) should equal (-1) + Assert.assertEquals(stream.read(dst), -1); } - test("Request more bytes than are present") { - val oneByte: Array[Byte] = Array(42) - val stream = new ArrayInputStream(ByteBuffer.wrap(oneByte)) - val dst = ByteBuffer.allocate(10) - stream.read(dst) should equal (1) - stream.read(dst) should equal (-1) // end of stream + @Test + public void testRequestMoreBytesThanArePresent() throws java.io.IOException { + byte[] oneByte = new byte[]{42}; + ArrayInputStream stream = new ArrayInputStream(ByteBuffer.wrap(oneByte)); + ByteBuffer dst = ByteBuffer.allocate(10); + Assert.assertEquals(stream.read(dst), 1); + Assert.assertEquals(stream.read(dst), -1); // end of stream } } diff --git a/runtime/src/test/java/org/capnproto/LayoutTest.java b/runtime/src/test/java/org/capnproto/LayoutTest.java new file mode 100644 index 0000000..4ed6042 --- /dev/null +++ b/runtime/src/test/java/org/capnproto/LayoutTest.java @@ -0,0 +1,127 @@ +package org.capnproto; + +import org.junit.Assert; +import org.junit.Test; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +public class LayoutTest { + private class BareStructReader implements StructReader.Factory { + @Override + public StructReader constructReader(SegmentReader segment, int data, int pointers, int dataSize, short pointerCount, int nestingLimit) { + return new StructReader(segment, data, pointers, dataSize, pointerCount, nestingLimit); + } + } + + @Test + public void testSimpleRawDataStruct() { + byte[] data = new byte[] { + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x23, 0x45, (byte)0x467, (byte)0x89, (byte)0xab, (byte)0xcd, (byte)0xef + }; + + ByteBuffer buffer = ByteBuffer.wrap(data); + buffer.order(ByteOrder.LITTLE_ENDIAN); + + ReaderArena arena = new ReaderArena(new ByteBuffer[]{ buffer }, 0x7fffffffffffffffL); + + StructReader reader = WireHelpers.readStructPointer(new BareStructReader(), arena.tryGetSegment(0), 0, null, 0, 0x7fffffff); + + Assert.assertEquals(reader._getLongField(0), 0xefcdab8967452301L); + Assert.assertEquals(reader._getLongField(1), 0L); + + Assert.assertEquals(reader._getIntField(0), 0x67452301); + Assert.assertEquals(reader._getIntField(1), 0xefcdab89); + Assert.assertEquals(reader._getIntField(2), 0); + + Assert.assertEquals(reader._getShortField(0), (short)0x2301); + Assert.assertEquals(reader._getShortField(1), (short)0x6745); + Assert.assertEquals(reader._getShortField(2), (short)0xab89); + Assert.assertEquals(reader._getShortField(3), (short)0xefcd); + Assert.assertEquals(reader._getShortField(4), (short)0); + + Assert.assertEquals(reader._getBooleanField(0), true); + Assert.assertEquals(reader._getBooleanField(1), false); + Assert.assertEquals(reader._getBooleanField(2), false); + + Assert.assertEquals(reader._getBooleanField(3), false); + Assert.assertEquals(reader._getBooleanField(4), false); + Assert.assertEquals(reader._getBooleanField(5), false); + Assert.assertEquals(reader._getBooleanField(6), false); + Assert.assertEquals(reader._getBooleanField(7), false); + + Assert.assertEquals(reader._getBooleanField(8), true); + Assert.assertEquals(reader._getBooleanField(9), true); + Assert.assertEquals(reader._getBooleanField(10), false); + Assert.assertEquals(reader._getBooleanField(11), false); + Assert.assertEquals(reader._getBooleanField(12), false); + Assert.assertEquals(reader._getBooleanField(13), true); + Assert.assertEquals(reader._getBooleanField(14), false); + Assert.assertEquals(reader._getBooleanField(15), false); + + Assert.assertEquals(reader._getBooleanField(63), true); + Assert.assertEquals(reader._getBooleanField(64), false); + } + + private class BareStructBuilder implements StructBuilder.Factory { + private StructSize structSize; + + public BareStructBuilder(StructSize structSize) { + this.structSize = structSize; + } + + @Override + public StructBuilder constructBuilder(SegmentBuilder segment, int data, int pointers, int dataSize, short pointerCount) { + return new StructBuilder(segment, data, pointers, dataSize, pointerCount); + } + + @Override + public StructSize structSize() { + return this.structSize; + } + } + + @Test + public void testStructRoundTripOneSegment() { + ByteBuffer buffer = ByteBuffer.allocate(1024*8); + buffer.order(ByteOrder.LITTLE_ENDIAN); + + SegmentBuilder segment = new SegmentBuilder(buffer, new BuilderArena(BuilderArena.SUGGESTED_FIRST_SEGMENT_WORDS, + BuilderArena.SUGGESTED_ALLOCATION_STRATEGY)); + BareStructBuilder factory = new BareStructBuilder(new StructSize((short) 2, (short) 4)); + StructBuilder builder = WireHelpers.initStructPointer(factory, 0, segment, factory.structSize()); + + setUpStruct(builder); + checkStruct(builder); + } + + private void setUpStruct(StructBuilder builder) { + builder._setLongField(0, 0x1011121314151617L); + builder._setIntField(2, 0x20212223); + builder._setShortField(6, (short)0x3031); + builder._setByteField(14, (byte)0x40); + builder._setBooleanField(120, false); + builder._setBooleanField(121, false); + builder._setBooleanField(122, true); + builder._setBooleanField(123, false); + builder._setBooleanField(124, true); + builder._setBooleanField(125, true); + builder._setBooleanField(126, true); + builder._setBooleanField(127, false); + } + + private void checkStruct(StructBuilder builder) { + Assert.assertEquals(0x1011121314151617L, builder._getLongField(0)); + Assert.assertEquals(0x20212223, builder._getIntField(2)); + Assert.assertEquals(0x3031, builder._getShortField(6)); + Assert.assertEquals(0x40, builder._getByteField(14)); + Assert.assertEquals(false, builder._getBooleanField(120)); + Assert.assertEquals(false, builder._getBooleanField(121)); + Assert.assertEquals(true, builder._getBooleanField(122)); + Assert.assertEquals(false, builder._getBooleanField(123)); + Assert.assertEquals(true, builder._getBooleanField(124)); + Assert.assertEquals(true, builder._getBooleanField(125)); + Assert.assertEquals(true, builder._getBooleanField(126)); + Assert.assertEquals(false, builder._getBooleanField(127)); + } +} diff --git a/runtime/src/test/java/org/capnproto/SerializePackedTest.java b/runtime/src/test/java/org/capnproto/SerializePackedTest.java new file mode 100644 index 0000000..f4197f0 --- /dev/null +++ b/runtime/src/test/java/org/capnproto/SerializePackedTest.java @@ -0,0 +1,85 @@ +package org.capnproto; + +import org.junit.Assert; +import org.junit.Test; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.Arrays; + +public class SerializePackedTest { + + @Test + public void testSimplePacking() { + assertPacksTo(new byte[0], new byte[0]); + + assertPacksTo(new byte[]{0,0,0,0,0,0,0,0}, new byte[]{0,0}); + + assertPacksTo(new byte[]{0,0,12,0,0,34,0,0}, new byte[]{0x24,12,34}); + + assertPacksTo(new byte[]{1,3,2,4,5,7,6,8}, new byte[]{(byte)0xff,1,3,2,4,5,7,6,8,0}); + + assertPacksTo(new byte[]{0,0,0,0,0,0,0,0, 1,3,2,4,5,7,6,8}, + new byte[]{0,0,(byte)0xff,1,3,2,4,5,7,6,8,0}); + + assertPacksTo(new byte[]{0,0,12,0,0,34,0,0, 1,3,2,4,5,7,6,8}, + new byte[]{0x24, 12, 34, (byte)0xff,1,3,2,4,5,7,6,8,0}); + + assertPacksTo(new byte[]{1,3,2,4,5,7,6,8, 8,6,7,4,5,2,3,1}, + new byte[]{(byte)0xff,1,3,2,4,5,7,6,8,1,8,6,7,4,5,2,3,1}); + + assertPacksTo(new byte[]{1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, 0,2,4,0,9,0,5,1}, + new byte[]{(byte)0xff,1,2,3,4,5,6,7,8, 3, 1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, + (byte)0xd6,2,4,9,5,1}); + + assertPacksTo(new byte[]{1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, 6,2,4,3,9,0,5,1, 1,2,3,4,5,6,7,8, 0,2,4,0,9,0,5,1}, + new byte[]{(byte)0xff,1,2,3,4,5,6,7,8, 3, 1,2,3,4,5,6,7,8, 6,2,4,3,9,0,5,1, 1,2,3,4,5,6,7,8, + (byte)0xd6,2,4,9,5,1}); + + assertPacksTo(new byte[]{8,0,100,6,0,1,1,2, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,1,0,2,0,3,1}, + new byte[]{(byte)0xed,8,100,6,1,1,2, 0,2, (byte)0xd4,1,2,3,1}); + + assertPacksTo(new byte[]{0,0,0,0,2,0,0,0, 0,0,0,0,0,0,1,0, 0,0,0,0,0,0,0,0}, + new byte[]{0x10,2, 0x40,1, 0,0}); + + assertPacksTo(new byte[8 * 200], new byte[]{0, (byte)199}); + + byte[] ones = new byte[8 * 200]; + Arrays.fill(ones, (byte)1); + byte[] packedOnes = new byte[10 + 8 * 199]; + Arrays.fill(packedOnes, (byte)1); + packedOnes[0] = (byte)255; + packedOnes[9] = (byte)199; + assertPacksTo(ones,packedOnes); + } + + private void assertPacksTo(byte[] unpacked, byte[] packed) { + { + byte[] bytes = new byte[packed.length]; + ArrayOutputStream writer = new ArrayOutputStream(ByteBuffer.wrap(bytes)); + PackedOutputStream packedOutputStream = new PackedOutputStream(writer); + try { + packedOutputStream.write(ByteBuffer.wrap(unpacked)); + } catch (IOException e) { + Assert.fail("Failed writing to PackedOutputStream"); + } + + Assert.assertTrue(Arrays.equals(bytes, packed)); + } + + { + ArrayInputStream reader = new ArrayInputStream(ByteBuffer.wrap(packed)); + PackedInputStream stream = new PackedInputStream(reader); + byte[] bytes = new byte[unpacked.length]; + int n = 0; + try { + n = stream.read(ByteBuffer.wrap(bytes)); + } catch (IOException e) { + Assert.fail("Failed reading from PackedInputStream"); + } + + Assert.assertEquals(n, unpacked.length); + Assert.assertTrue(Arrays.equals(bytes, unpacked)); + } + } +} diff --git a/runtime/src/test/java/org/capnproto/SerializeTest.java b/runtime/src/test/java/org/capnproto/SerializeTest.java new file mode 100644 index 0000000..5b5c5f4 --- /dev/null +++ b/runtime/src/test/java/org/capnproto/SerializeTest.java @@ -0,0 +1,128 @@ +// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors +// Licensed under the MIT License: +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package org.capnproto; + +import java.nio.ByteBuffer; + +import org.junit.Assert; +import org.junit.Test; + +public class SerializeTest { + + /** + * @param arena: segment `i` contains `i` words each set to `i` + */ + private void checkSegmentContents(int exampleSegmentCount, ReaderArena arena) { + Assert.assertEquals(arena.segments.size(), exampleSegmentCount); + for (int i = 0; i < exampleSegmentCount; ++i) { + SegmentReader segment = arena.segments.get(i); + java.nio.LongBuffer segmentWords = segment.buffer.asLongBuffer(); + + Assert.assertEquals(segmentWords.capacity(), i); + segmentWords.rewind(); + while (segmentWords.hasRemaining()) { + Assert.assertEquals(segmentWords.get(), i); + } + } + } + + /** + * @param exampleSegmentCount number of segments + * @param exampleBytes byte array containing `segmentCount` segments; segment `i` contains `i` words each set to `i` + */ + private void expectSerializesTo(int exampleSegmentCount, byte[] exampleBytes) throws java.io.IOException { + // ---- + // read via ReadableByteChannel + { + MessageReader messageReader = Serialize.read(new ArrayInputStream(ByteBuffer.wrap(exampleBytes))); + checkSegmentContents(exampleSegmentCount, messageReader.arena); + } + + // ------ + // read via ByteBuffer + { + MessageReader messageReader = Serialize.read(ByteBuffer.wrap(exampleBytes)); + checkSegmentContents(exampleSegmentCount, messageReader.arena); + } + } + + @Test + public void testSegmentReading() throws java.io.IOException { + // When transmitting over a stream, the following should be sent. All integers are unsigned and little-endian. + // - (4 bytes) The number of segments, minus one (since there is always at least one segment). + // - (N * 4 bytes) The size of each segment, in words. + // - (0 or 4 bytes) Padding up to the next word boundary. + // - The content of each segment, in order. + + expectSerializesTo(1, new byte[]{ + 0, 0, 0, 0, // 1 segment + 0, 0, 0, 0 // Segment 0 contains 0 bytes + // No padding + // Segment 0 (empty) + }); + + expectSerializesTo(2, new byte[]{ + 1, 0, 0, 0, // 2 segments + 0, 0, 0, 0, // Segment 0 contains 0 words + 1, 0, 0, 0, // Segment 1 contains 1 words + // Padding + 0, 0, 0, 0, + // Segment 0 (empty) + // Segment 1 + 1, 0, 0, 0, 0, 0, 0, 0 + }); + + expectSerializesTo(3, new byte[] { + 2, 0, 0, 0, // 3 segments + 0, 0, 0, 0, // Segment 0 contains 0 words + 1, 0, 0, 0, // Segment 1 contains 1 words + 2, 0, 0, 0, // Segment 2 contains 2 words + // No padding + // Segment 0 (empty) + // Segment 1 + 1, 0, 0, 0, 0, 0, 0, 0, + // Segment 2 + 2, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0 + }); + + expectSerializesTo(4, new byte[]{ + 3, 0, 0, 0, // 4 segments + 0, 0, 0, 0, // Segment 0 contains 0 words + 1, 0, 0, 0, // Segment 1 contains 1 words + 2, 0, 0, 0, // Segment 2 contains 2 words + 3, 0, 0, 0, // Segment 3 contains 3 words + // Padding + 0, 0, 0, 0, + // Segment 0 (empty) + // Segment 1 + 1, 0, 0, 0, 0, 0, 0, 0, + // Segment 2 + 2, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + // Segment 3 + 3, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0 + }); + } +} diff --git a/runtime/src/test/scala/org/capnproto/LayoutSuite.scala b/runtime/src/test/scala/org/capnproto/LayoutSuite.scala deleted file mode 100644 index 2a8f778..0000000 --- a/runtime/src/test/scala/org/capnproto/LayoutSuite.scala +++ /dev/null @@ -1,144 +0,0 @@ -// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors -// Licensed under the MIT License: -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -package org.capnproto - -import org.scalatest.FunSuite - - -class LayoutSuite extends FunSuite { - - class BareStructReader extends StructReader.Factory[StructReader] { - def constructReader(segment: org.capnproto.SegmentReader, data: Int, pointers: Int, - dataSize: Int, pointerCount: Short, nestingLimit:Int) : StructReader = { - new StructReader(segment,data,pointers,dataSize,pointerCount,nestingLimit) - } - } - - test("SimpleRawDataStruct") { - val data : Array[Byte] = - Array(0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x01, 0x23, 0x45, 0x67, 0x89.toByte, 0xab.toByte, - 0xcd.toByte, 0xef.toByte) - - val buffer = java.nio.ByteBuffer.wrap(data) - buffer.order(java.nio.ByteOrder.LITTLE_ENDIAN) - - val arena = new ReaderArena(Array(buffer), 0x7fffffffffffffffL) - - val reader = WireHelpers.readStructPointer(new BareStructReader(), - arena.tryGetSegment(0), - 0, null, 0, 0x7fffffff) - - assert(reader._getLongField(0) === 0xefcdab8967452301L) - assert(reader._getLongField(1) === 0L) - - assert(reader._getIntField(0) === 0x67452301) - assert(reader._getIntField(1) === 0xefcdab89) - assert(reader._getIntField(2) === 0) - assert(reader._getShortField(0) === 0x2301.toShort) - assert(reader._getShortField(1) === 0x6745.toShort) - assert(reader._getShortField(2) === 0xab89.toShort) - assert(reader._getShortField(3) === 0xefcd.toShort) - assert(reader._getShortField(4) === 0.toShort) - - // TODO masking - - assert(reader._getBooleanField(0) === true) - assert(reader._getBooleanField(1) === false) - assert(reader._getBooleanField(2) === false) - - assert(reader._getBooleanField(3) === false) - assert(reader._getBooleanField(4) === false) - assert(reader._getBooleanField(5) === false) - assert(reader._getBooleanField(6) === false) - assert(reader._getBooleanField(7) == false) - - assert(reader._getBooleanField(8) === true) - assert(reader._getBooleanField(9) === true) - assert(reader._getBooleanField(10) === false) - assert(reader._getBooleanField(11) === false) - assert(reader._getBooleanField(12) === false) - assert(reader._getBooleanField(13) === true) - assert(reader._getBooleanField(14) === false) - assert(reader._getBooleanField(15) === false) - - assert(reader._getBooleanField(63) === true) - assert(reader._getBooleanField(64) === false) - - // TODO masking - - } - - def setupStruct(builder : StructBuilder) = { - builder._setLongField(0, 0x1011121314151617L) - builder._setIntField(2, 0x20212223) - builder._setShortField(6, 0x3031.toShort) - builder._setByteField(14, 0x40) - builder._setBooleanField(120, false) - builder._setBooleanField(121, false) - builder._setBooleanField(122, true) - builder._setBooleanField(123, false) - builder._setBooleanField(124, true) - builder._setBooleanField(125, true) - builder._setBooleanField(126, true) - builder._setBooleanField(127, false) - } - - def checkStruct(builder : StructBuilder) { - assert(0x1011121314151617L === builder._getLongField(0)) - assert(0x20212223 == builder._getIntField(2)) - assert(0x3031 === builder._getShortField(6)) - assert(0x40 === builder._getByteField(14)) - assert(false === builder._getBooleanField(120)) - assert(false === builder._getBooleanField(121)) - assert(true === builder._getBooleanField(122)) - assert(false === builder._getBooleanField(123)) - assert(true === builder._getBooleanField(124)) - assert(true === builder._getBooleanField(125)) - assert(true === builder._getBooleanField(126)) - assert(false === builder._getBooleanField(127)) - } - - - class BareStructBuilder(val structSize : StructSize) extends StructBuilder.Factory[StructBuilder] { - - def constructBuilder(segment: org.capnproto.SegmentBuilder, data: Int, pointers: Int, - dataSize: Int, pointerCount: Short) : StructBuilder = { - new StructBuilder(segment,data,pointers,dataSize,pointerCount) - } - } - - - test("StructRoundTrip_OneSegment") { - val buffer = java.nio.ByteBuffer.allocate(1024 * 8) - buffer.order(java.nio.ByteOrder.LITTLE_ENDIAN) - - val segment = new SegmentBuilder(buffer, new BuilderArena(BuilderArena.SUGGESTED_FIRST_SEGMENT_WORDS, - BuilderArena.SUGGESTED_ALLOCATION_STRATEGY)) - val factory = new BareStructBuilder(new StructSize(2, 4)) - val builder = WireHelpers.initStructPointer(factory, 0, segment, factory.structSize) - setupStruct(builder) - checkStruct(builder) - } - -} - diff --git a/runtime/src/test/scala/org/capnproto/SerializePackedSuite.scala b/runtime/src/test/scala/org/capnproto/SerializePackedSuite.scala deleted file mode 100644 index 65247ba..0000000 --- a/runtime/src/test/scala/org/capnproto/SerializePackedSuite.scala +++ /dev/null @@ -1,89 +0,0 @@ -// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors -// Licensed under the MIT License: -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -package org.capnproto - -import org.scalatest.FunSuite -import org.scalatest.Matchers._ -import java.nio.ByteBuffer - -class SerializePackedSuite extends FunSuite { - - def expectPacksTo(unpacked : Array[Byte], packed : Array[Byte]) { - // ---- - // write - { - val bytes = new Array[Byte](packed.length) - val writer = new ArrayOutputStream(ByteBuffer.wrap(bytes)) - val packedOutputStream = new PackedOutputStream(writer) - packedOutputStream.write(ByteBuffer.wrap(unpacked)) - - (bytes) should equal (packed) - } - - // ------ - // read - { - val reader = new ArrayInputStream(ByteBuffer.wrap(packed)) - val packedInputStream = new PackedInputStream(reader) - val bytes = new Array[Byte](unpacked.length) - val n = packedInputStream.read(ByteBuffer.wrap(bytes)) - - (n) should equal (unpacked.length) - - (bytes) should equal (unpacked) - } - } - - test("SimplePacking") { - expectPacksTo(Array(), Array()) - expectPacksTo(Array(0,0,0,0,0,0,0,0), Array(0,0)) - expectPacksTo(Array(0,0,12,0,0,34,0,0), Array(0x24,12,34)) - expectPacksTo(Array(1,3,2,4,5,7,6,8), Array(0xff.toByte,1,3,2,4,5,7,6,8,0)) - expectPacksTo(Array(0,0,0,0,0,0,0,0, 1,3,2,4,5,7,6,8), - Array(0,0,0xff.toByte,1,3,2,4,5,7,6,8,0)) - expectPacksTo(Array(0,0,12,0,0,34,0,0, 1,3,2,4,5,7,6,8), - Array(0x24, 12, 34, 0xff.toByte,1,3,2,4,5,7,6,8,0)) - expectPacksTo(Array(1,3,2,4,5,7,6,8, 8,6,7,4,5,2,3,1), - Array(0xff.toByte,1,3,2,4,5,7,6,8,1,8,6,7,4,5,2,3,1)) - - expectPacksTo(Array(1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, 0,2,4,0,9,0,5,1), - Array(0xff.toByte,1,2,3,4,5,6,7,8, 3, 1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, - 0xd6.toByte,2,4,9,5,1)) - - expectPacksTo(Array(1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8, 6,2,4,3,9,0,5,1, 1,2,3,4,5,6,7,8, 0,2,4,0,9,0,5,1), - Array(0xff.toByte,1,2,3,4,5,6,7,8, 3, 1,2,3,4,5,6,7,8, 6,2,4,3,9,0,5,1, 1,2,3,4,5,6,7,8, - 0xd6.toByte,2,4,9,5,1)) - - expectPacksTo(Array(8,0,100,6,0,1,1,2, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,1,0,2,0,3,1), - Array(0xed.toByte,8,100,6,1,1,2, 0,2, 0xd4.toByte,1,2,3,1)) - - expectPacksTo(Array(0,0,0,0,2,0,0,0, 0,0,0,0,0,0,1,0, 0,0,0,0,0,0,0,0), - Array(0x10,2, 0x40,1, 0,0)) - - expectPacksTo(Array.tabulate[Byte](8 * 200)((n) => 0), - Array(0, 199.toByte)) - - expectPacksTo(Array.tabulate[Byte](8 * 200)((n) => 1), - Array.concat(Array(0xff.toByte, 1,1,1,1,1,1,1,1, 199.toByte), - Array.tabulate[Byte](8 * 199)((n) => 1))) - } -} diff --git a/runtime/src/test/scala/org/capnproto/SerializeSuite.scala b/runtime/src/test/scala/org/capnproto/SerializeSuite.scala deleted file mode 100644 index a1a1c6c..0000000 --- a/runtime/src/test/scala/org/capnproto/SerializeSuite.scala +++ /dev/null @@ -1,123 +0,0 @@ -// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors -// Licensed under the MIT License: -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -package org.capnproto - -import java.nio.ByteBuffer - -import org.scalatest.FunSuite -import org.scalatest.Matchers._ - -class SerializeSuite extends FunSuite { - /** - * @param exampleSegmentCount number of segments - * @param exampleBytes byte array containing `segmentCount` segments; segment `i` contains `i` words each set to `i` - */ - def expectSerializesTo(exampleSegmentCount: Int, exampleBytes: Array[Byte]): Unit = { - def checkSegmentContents(arena: ReaderArena): Unit = { - arena.segments should have length exampleSegmentCount - for (i <- 0 until exampleSegmentCount) { - val segment = arena.segments.get(i) - val segmentWords = segment.buffer.asLongBuffer() - - segmentWords.capacity should equal (i) - segmentWords.rewind() - while (segmentWords.hasRemaining) { - segmentWords.get should equal (i) - } - } - } - - // ---- - // read via ReadableByteChannel - { - val messageReader = Serialize.read(new ArrayInputStream(ByteBuffer.wrap(exampleBytes))) - checkSegmentContents(messageReader.arena) - } - - // ------ - // read via ByteBuffer - { - val messageReader = Serialize.read(ByteBuffer.wrap(exampleBytes)) - checkSegmentContents(messageReader.arena) - } - } - - test("SegmentReading") { - // When transmitting over a stream, the following should be sent. All integers are unsigned and little-endian. - // - (4 bytes) The number of segments, minus one (since there is always at least one segment). - // - (N * 4 bytes) The size of each segment, in words. - // - (0 or 4 bytes) Padding up to the next word boundary. - // - The content of each segment, in order. - - expectSerializesTo(1, Array[Byte]( - 0, 0, 0, 0, // 1 segment - 0, 0, 0, 0 // Segment 0 contains 0 bytes - // No padding - // Segment 0 (empty) - )) - - expectSerializesTo(2, Array[Byte]( - 1, 0, 0, 0, // 2 segments - 0, 0, 0, 0, // Segment 0 contains 0 words - 1, 0, 0, 0, // Segment 1 contains 1 words - // Padding - 0, 0, 0, 0, - // Segment 0 (empty) - // Segment 1 - 1, 0, 0, 0, 0, 0, 0, 0 - )) - - expectSerializesTo(3, Array[Byte]( - 2, 0, 0, 0, // 3 segments - 0, 0, 0, 0, // Segment 0 contains 0 words - 1, 0, 0, 0, // Segment 1 contains 1 words - 2, 0, 0, 0, // Segment 2 contains 2 words - // No padding - // Segment 0 (empty) - // Segment 1 - 1, 0, 0, 0, 0, 0, 0, 0, - // Segment 2 - 2, 0, 0, 0, 0, 0, 0, 0, - 2, 0, 0, 0, 0, 0, 0, 0 - )) - - expectSerializesTo(4, Array[Byte]( - 3, 0, 0, 0, // 4 segments - 0, 0, 0, 0, // Segment 0 contains 0 words - 1, 0, 0, 0, // Segment 1 contains 1 words - 2, 0, 0, 0, // Segment 2 contains 2 words - 3, 0, 0, 0, // Segment 3 contains 3 words - // Padding - 0, 0, 0, 0, - // Segment 0 (empty) - // Segment 1 - 1, 0, 0, 0, 0, 0, 0, 0, - // Segment 2 - 2, 0, 0, 0, 0, 0, 0, 0, - 2, 0, 0, 0, 0, 0, 0, 0, - // Segment 3 - 3, 0, 0, 0, 0, 0, 0, 0, - 3, 0, 0, 0, 0, 0, 0, 0, - 3, 0, 0, 0, 0, 0, 0, 0 - )) - } -} diff --git a/version.sbt b/version.sbt deleted file mode 100644 index e765444..0000000 --- a/version.sbt +++ /dev/null @@ -1 +0,0 @@ -version in ThisBuild := "0.1.0"