Merge pull request #84 from capnproto/maven

sbt -> maven, scalatest -> junit
This commit is contained in:
David Renshaw 2020-05-12 20:31:20 -04:00 committed by GitHub
commit e89dfd9f74
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
22 changed files with 1913 additions and 1794 deletions

View file

@ -28,7 +28,6 @@ jdk:
- openjdk8 - openjdk8
script: script:
- make CC=gcc-7 CXX=g++-7 - make CC=gcc-7 CXX=g++-7
- make CC=gcc-7 CXX=g++-7 addressbook - mvn compile
- sbt test - mvn test
- sbt doc

View file

@ -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++ MINGW_FLAGS=-O2 -DNDEBUG -I/usr/local/include -std=c++14 -static -static-libgcc -static-libstdc++
capnpc-java.exe : $(CAPNPC_JAVA_SOURCES) capnpc-java.exe : $(CAPNPC_JAVA_SOURCES)
$(MINGW_CXX) $(MINGW_FLAGS) $(CAPNPC_JAVA_SOURCES) $(MINGW_LIBS) -o capnpc-java.exe $(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

92
benchmark/pom.xml Normal file
View file

@ -0,0 +1,92 @@
<?xml version='1.0' encoding='UTF-8'?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<groupId>org.capnproto</groupId>
<artifactId>benchmark</artifactId>
<packaging>jar</packaging>
<description>capnproto-java benchmark</description>
<version>0.1.4</version>
<name>capnproto-java benchmark</name>
<organization>
<name>org.capnproto</name>
</organization>
<url>https://capnproto.org/</url>
<licenses>
<license>
<name>MIT</name>
<url>http://opensource.org/licenses/MIT</url>
<distribution>repo</distribution>
</license>
</licenses>
<scm>
<url>git@github.com:capnproto/capnproto-java.git</url>
<connection>scm:git@github.com:capnproto/capnproto-java.git</connection>
</scm>
<developers>
<developer>
<id>dwrensha</id>
<name>David Renshaw</name>
<url>https://github.com/dwrensha</url>
</developer>
</developers>
<dependencies>
<dependency>
<groupId>org.capnproto</groupId>
<artifactId>runtime</artifactId>
<version>0.1.4</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-antrun-plugin</artifactId>
<version>3.0.0</version>
<executions>
<execution>
<id>generate-sources</id>
<phase>generate-sources</phase>
<configuration>
<target>
<mkdir dir="src/main/generated"/>
<exec executable="capnp" failonerror="true">
<arg value="compile"/>
<arg value="-I"/>
<arg value="../compiler/src/main/schema/"/>
<arg value="--src-prefix=src/main/schema/"/>
<arg value="-o../capnpc-java:src/main/generated"/>
<arg value="src/main/schema/eval.capnp"/>
<arg value="src/main/schema/carsales.capnp"/>
<arg value="src/main/schema/catrank.capnp"/>
</exec>
</target>
</configuration>
<goals>
<goal>run</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<version>3.1.0</version>
<executions>
<execution>
<id>add-generated-sources</id>
<phase>generate-sources</phase>
<goals>
<goal>add-source</goal>
</goals>
<configuration>
<sources>
<source>src/main/generated</source>
</sources>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

98
compiler/pom.xml Normal file
View file

@ -0,0 +1,98 @@
<?xml version='1.0' encoding='UTF-8'?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<groupId>org.capnproto</groupId>
<artifactId>compiler</artifactId>
<packaging>jar</packaging>
<description>schema compiler plugin for java</description>
<version>0.1.4</version>
<name>capnpc-java</name>
<organization>
<name>org.capnproto</name>
</organization>
<url>https://capnproto.org/</url>
<licenses>
<license>
<name>MIT</name>
<url>http://opensource.org/licenses/MIT</url>
<distribution>repo</distribution>
</license>
</licenses>
<scm>
<url>git@github.com:capnproto/capnproto-java.git</url>
<connection>scm:git@github.com:capnproto/capnproto-java.git</connection>
</scm>
<developers>
<developer>
<id>dwrensha</id>
<name>David Renshaw</name>
<url>https://github.com/dwrensha</url>
</developer>
</developers>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.capnproto</groupId>
<artifactId>runtime</artifactId>
<version>0.1.4</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-antrun-plugin</artifactId>
<version>3.0.0</version>
<executions>
<execution>
<id>generate-test-sources</id>
<phase>generate-test-sources</phase>
<configuration>
<target>
<mkdir dir="src/test/generated"/>
<exec executable="capnp" failonerror="true">
<arg value="compile"/>
<arg value="-I"/>
<arg value="src/main/schema/"/>
<arg value="--src-prefix=src/test/schema/"/>
<arg value="-o../capnpc-java:src/test/generated"/>
<arg value="src/test/schema/test.capnp"/>
<arg value="src/test/schema/test-import.capnp"/>
</exec>
</target>
</configuration>
<goals>
<goal>run</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<version>3.1.0</version>
<executions>
<execution>
<id>add-generated-test-sources</id>
<phase>generate-test-sources</phase>
<goals>
<goal>add-test-source</goal>
</goals>
<configuration>
<sources>
<source>src/test/generated</source>
</sources>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

View file

@ -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<Test.TestAllTypes.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<Test.TestOldVersion.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<Test.TestOldVersion.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<Test.TestNewVersion.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<Test.TestOldVersion.Builder, Test.TestOldVersion.Reader> oldFactory =
new StructList.Factory(Test.TestOldVersion.factory);
StructList.Reader<Test.TestOldVersion.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<Test.TestNewVersion.Builder, Test.TestNewVersion.Reader> newFactory =
new StructList.Factory(Test.TestNewVersion.factory);
StructList.Builder<Test.TestNewVersion.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<Test.TestAllTypes.Builder> structList = allTypes.initStructList(2);
structList.get(0).setInt8Field((byte)5);
structList.get(1).setInt8Field((byte)9);
StructList.Reader<Test.TestAllTypes.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<Test.TestEnum> enumList = allTypes.initEnumList(3);
enumList.set(0, Test.TestEnum.FOO);
enumList.set(1, Test.TestEnum.BAR);
enumList.set(2, Test.TestEnum.BAZ);
EnumList.Reader<Test.TestEnum> 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<StructList.Builder<Test.TestAllTypes.Builder>> structListList = root.initStructListList(3);
StructList.Builder<Test.TestAllTypes.Builder> structList0 = structListList.init(0, 1);
structList0.get(0).setInt16Field((short)1);
// leave structList1 as default
StructList.Builder<Test.TestAllTypes.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<StructList.Reader<Test.TestAllTypes.Reader>> structListListReader =
structListList.asReader(new StructList.Factory(Test.TestAllTypes.factory));
Assert.assertEquals(structListListReader.size(), 3);
StructList.Reader<Test.TestAllTypes.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<Test.TestAllTypes.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<Test.TestAllTypes.Builder, Text.Builder> root = (Test.TestGenerics.Builder<Test.TestAllTypes.Builder, Text.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<Test.TestAllTypes.Reader, Text.Reader> rootReader = root.asReader(factory);
TestUtil.checkTestMessage(rootReader.getFoo());
Test.TestGenerics.Builder<Text.Builder, PrimitiveList.Byte.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<AnyPointer.Builder, AnyPointer.Reader, AnyPointer.Builder, AnyPointer.Reader> factory2 = Test.TestGenerics.newFactory(AnyPointer.factory, AnyPointer.factory);
Test.TestGenerics.Builder<AnyPointer.Builder, AnyPointer.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<PrimitiveList.Int.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<PrimitiveList.Int.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<Test.TestAllTypes.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<Test.TestAllTypes.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<StructList.Builder<Test.TestAllTypes.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<Text.Builder, Text.Reader, Test.TestAllTypes.Builder, Test.TestAllTypes.Reader> mapFactory
= new Test.GenericMap.Factory(Text.factory, Test.TestAllTypes.factory);
StructList.Factory<Test.GenericMap.Entry.Builder<Text.Builder, Test.TestAllTypes.Builder>,
Test.GenericMap.Entry.Reader<Text.Reader, Test.TestAllTypes.Reader>> entryFactory
= new StructList.Factory(new Test.GenericMap.Entry.Factory(Text.factory, Test.TestAllTypes.factory));
Test.GenericMap.Builder<Text.Builder, Test.TestAllTypes.Builder> root = builder.initRoot(mapFactory);
{
StructList.Builder<Test.GenericMap.Entry.Builder<Text.Builder, Test.TestAllTypes.Builder>> entries = root.initEntries(entryFactory, 3);
Test.GenericMap.Entry.Builder<Text.Builder, Test.TestAllTypes.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<Text.Builder, Test.TestAllTypes.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<Text.Builder, Test.TestAllTypes.Builder> entry2 = entries.get(2);
entry2.setKey(Text.factory, new Text.Reader("baz"));
Test.TestAllTypes.Builder value2 = entry2.initValue();
value2.setInt64Field(303);
}
{
StructList.Reader<Test.GenericMap.Entry.Reader<Text.Reader, Test.TestAllTypes.Reader>> entries =
root.asReader(mapFactory).getEntries(entryFactory);
Test.GenericMap.Entry.Reader<Text.Reader, Test.TestAllTypes.Reader> entry0 = entries.get(0);
Assert.assertEquals(entry0.getKey().toString(), "foo");
Assert.assertEquals(entry0.getValue().getInt64Field(), 101);
Test.GenericMap.Entry.Reader<Text.Reader, Test.TestAllTypes.Reader> entry1 = entries.get(1);
Assert.assertEquals(entry1.getKey().toString(), "bar");
Assert.assertEquals(entry1.getValue().getInt64Field(), 202);
Test.GenericMap.Entry.Reader<Text.Reader, Test.TestAllTypes.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<Test.TestAllTypes.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<Test.TestAllTypes.Reader> listReader = list.asReader(Test.TestAllTypes.factory);
Assert.assertEquals(listReader.get(0).getInt8Field(), 11);
TestUtil.checkTestMessage(listReader.get(1));
}
}

View file

@ -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<Test.TestAllTypes.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<Test.TestEnum> 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<Test.TestAllTypes.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<Test.TestEnum> 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<Test.TestAllTypes.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<Test.TestEnum> 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);
}
}

View file

@ -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)
}

View file

@ -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)
}
}

90
examples/pom.xml Normal file
View file

@ -0,0 +1,90 @@
<?xml version='1.0' encoding='UTF-8'?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<groupId>org.capnproto</groupId>
<artifactId>examples</artifactId>
<packaging>jar</packaging>
<description>capnproto-java examples</description>
<version>0.1.4</version>
<name>capnproto-java examples</name>
<organization>
<name>org.capnproto</name>
</organization>
<url>https://capnproto.org/</url>
<licenses>
<license>
<name>MIT</name>
<url>http://opensource.org/licenses/MIT</url>
<distribution>repo</distribution>
</license>
</licenses>
<scm>
<url>git@github.com:capnproto/capnproto-java.git</url>
<connection>scm:git@github.com:capnproto/capnproto-java.git</connection>
</scm>
<developers>
<developer>
<id>dwrensha</id>
<name>David Renshaw</name>
<url>https://github.com/dwrensha</url>
</developer>
</developers>
<dependencies>
<dependency>
<groupId>org.capnproto</groupId>
<artifactId>runtime</artifactId>
<version>0.1.4</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-antrun-plugin</artifactId>
<version>3.0.0</version>
<executions>
<execution>
<id>generate-sources</id>
<phase>generate-sources</phase>
<configuration>
<target>
<mkdir dir="src/main/generated"/>
<exec executable="capnp" failonerror="true">
<arg value="compile"/>
<arg value="-I"/>
<arg value="../compiler/src/main/schema/"/>
<arg value="--src-prefix=src/main/schema/"/>
<arg value="-o../capnpc-java:src/main/generated"/>
<arg value="src/main/schema/addressbook.capnp"/>
</exec>
</target>
</configuration>
<goals>
<goal>run</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<version>3.1.0</version>
<executions>
<execution>
<id>add-generated-sources</id>
<phase>generate-sources</phase>
<goals>
<goal>add-source</goal>
</goals>
<configuration>
<sources>
<source>src/main/generated</source>
</sources>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

34
pom.xml Normal file
View file

@ -0,0 +1,34 @@
<?xml version='1.0' encoding='UTF-8'?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<groupId>org.capnproto</groupId>
<artifactId>capnproto-java</artifactId>
<packaging>pom</packaging>
<version>0.1.4</version>
<name>Cap'n Proto for Java</name>
<url>https://capnproto.org/</url>
<modules>
<module>runtime</module>
<module>compiler</module>
<module>examples</module>
<module>benchmark</module>
</modules>
<licenses>
<license>
<name>MIT</name>
<url>http://opensource.org/licenses/MIT</url>
<distribution>repo</distribution>
</license>
</licenses>
<scm>
<url>git@github.com:capnproto/capnproto-java.git</url>
<connection>scm:git@github.com:capnproto/capnproto-java.git</connection>
</scm>
<developers>
<developer>
<id>dwrensha</id>
<name>David Renshaw</name>
<url>https://github.com/dwrensha</url>
</developer>
</developers>
</project>

View file

@ -1 +0,0 @@
sbt.version=0.13.2

View file

@ -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 _<scala-version> 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 _<scala-version> 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 _<scala-version> 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 := (
<url>https://capnproto.org/</url>
<licenses>
<license>
<name>MIT</name>
<url>http://opensource.org/licenses/MIT</url>
<distribution>repo</distribution>
</license>
</licenses>
<scm>
<url>git@github.com:capnproto/capnproto-java.git</url>
<connection>scm:git@github.com:capnproto/capnproto-java.git</connection>
</scm>
<developers>
<developer>
<id>dwrensha</id>
<name>David Renshaw</name>
<url>https://github.com/dwrensha</url>
</developer>
</developers>
)
)
}
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*/
)
}
}
}

View file

@ -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")

40
runtime/pom.xml Normal file
View file

@ -0,0 +1,40 @@
<?xml version='1.0' encoding='UTF-8'?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<groupId>org.capnproto</groupId>
<artifactId>runtime</artifactId>
<packaging>jar</packaging>
<description>runtime</description>
<version>0.1.4</version>
<name>Cap'n Proto runtime library</name>
<organization>
<name>org.capnproto</name>
</organization>
<url>https://capnproto.org/</url>
<licenses>
<license>
<name>MIT</name>
<url>http://opensource.org/licenses/MIT</url>
<distribution>repo</distribution>
</license>
</licenses>
<scm>
<url>git@github.com:capnproto/capnproto-java.git</url>
<connection>scm:git@github.com:capnproto/capnproto-java.git</connection>
</scm>
<developers>
<developer>
<id>dwrensha</id>
<name>David Renshaw</name>
<url>https://github.com/dwrensha</url>
</developer>
</developers>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

View file

@ -19,27 +19,30 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE. // THE SOFTWARE.
package org.capnproto package org.capnproto;
import java.nio.ByteBuffer import org.junit.Assert;
import org.scalatest.FunSuite import org.junit.Test;
import org.scalatest.Matchers._
class ArrayInputStreamSuite extends FunSuite { import java.nio.ByteBuffer;
test("EmptyArray") {
val stream = new ArrayInputStream(ByteBuffer.allocate(0)) public class ArrayInputStreamTest {
val dst = ByteBuffer.allocate(10) @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 // read() should return -1 at the end of the stream
// https://docs.oracle.com/javase/7/docs/api/java/nio/channels/ReadableByteChannel.html // 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") { @Test
val oneByte: Array[Byte] = Array(42) public void testRequestMoreBytesThanArePresent() throws java.io.IOException {
val stream = new ArrayInputStream(ByteBuffer.wrap(oneByte)) byte[] oneByte = new byte[]{42};
val dst = ByteBuffer.allocate(10) ArrayInputStream stream = new ArrayInputStream(ByteBuffer.wrap(oneByte));
stream.read(dst) should equal (1) ByteBuffer dst = ByteBuffer.allocate(10);
stream.read(dst) should equal (-1) // end of stream Assert.assertEquals(stream.read(dst), 1);
Assert.assertEquals(stream.read(dst), -1); // end of stream
} }
} }

View file

@ -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<StructReader> {
@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<StructBuilder> {
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));
}
}

View file

@ -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));
}
}
}

View file

@ -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
});
}
}

View file

@ -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)
}
}

View file

@ -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)))
}
}

View file

@ -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
))
}
}

View file

@ -1 +0,0 @@
version in ThisBuild := "0.1.0"