diff --git a/compiler/src/test/scala/org/capnproto/EncodingSuite.scala b/compiler/src/test/scala/org/capnproto/EncodingSuite.scala
index ec5a6e2..4519058 100644
--- a/compiler/src/test/scala/org/capnproto/EncodingSuite.scala
+++ b/compiler/src/test/scala/org/capnproto/EncodingSuite.scala
@@ -19,68 +19,68 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-package org.capnproto;
+package org.capnproto
 
-import org.capnproto.test.Test._;
+import org.capnproto.test.Test._
 import org.scalatest.FunSuite
-import org.scalatest.Matchers._;
+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());
+    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);
+    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());
+    TestUtil.checkTestMessage(allTypes)
+    TestUtil.checkTestMessage(allTypes.asReader())
   }
 
   test("Setters") {
-    val message = new MessageBuilder();
-    val allTypes = message.initRoot(TestAllTypes.factory);
-    TestUtil.initTestMessage(allTypes);
+    val message = new MessageBuilder()
+    val allTypes = message.initRoot(TestAllTypes.factory)
+    TestUtil.initTestMessage(allTypes)
 
-    val message2 = new MessageBuilder();
-    val allTypes2 = message2.initRoot(TestAllTypes.factory);
+    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);
+    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 message = new MessageBuilder()
+    val allTypes = message.initRoot(TestAllTypes.factory)
 
-    val structList = allTypes.initStructList(3);
-    TestUtil.initTestMessage(structList.get(0));
+    val structList = allTypes.initStructList(3)
+    TestUtil.initTestMessage(structList.get(0))
 
-    val structField = allTypes.initStructField();
-    TestUtil.initTestMessage(structField);
+    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.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());
+    TestUtil.checkTestMessage(allTypes.getStructField())
+    val allTypesReader = allTypes.asReader()
+    TestUtil.checkTestMessage(allTypesReader.getStructField())
 
-    val any = message.initRoot(AnyPointer.factory);
-    val segments = message.getSegmentsForOutput();
+    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);
+        segment.get(jj) should equal (0)
       }
     }
   }
@@ -88,476 +88,484 @@ class EncodingSuite extends FunSuite {
   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);
+                            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);
+    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("UpgradeStructInBuilder") {
-    val builder = new MessageBuilder();
-    val root = builder.initRoot(TestAnyPointer.factory);
+    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 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");
+      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");
+      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");
+      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);
+    val message = new MessageBuilder()
+    val root = message.initRoot(TestAnyPointer.factory)
+    val any = root.getAnyPointerField()
 
-      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");
+      val longs = any.initAs(PrimitiveList.Long.factory, 3)
+      longs.set(0, 123)
+      longs.set(1, 456)
+      longs.set(2, 789)
+    }
 
-      news.get(1).getOld1() should equal (456);
-      news.get(1).getOld2().toString() should equal ("one");
+    {
+      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)
+    }
 
-      news.get(2).getOld1() should equal (789);
-      news.get(2).getOld2().toString() should equal ("two");
+    {
+      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("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 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);
-    var boolList = revBar.initBoolList(2);
-    boolList.set(0, false);
-    boolList.set(1, true);
+    revBar.setInt8Field(111)
+    var 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);
+    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"));
+    val message = new MessageBuilder()
+    val root = message.initRoot(TestUseGenerics.factory)
 
-      root.setUnspecified(factory2, root2.asReader(factory2));
+    {
+      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");
+    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());
+    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("Groups") {
-    val builder = new MessageBuilder();
-    val root = builder.initRoot(TestGroups.factory);
+    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"));
+      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());
+      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);
+      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());
+      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"));
+      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());
+      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 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 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);
+      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(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(-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);
+    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.TEXT_CONST.toString()) should equal ("foo")
+    (TestConstants.DATA_CONST.toArray()) should equal (TestUtil.data("bar"))
+
+    (TestConstants.ENUM_CONST) should equal (TestEnum.CORGE)
 
-    (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");
+      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);
+    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.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.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");
+      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);
+    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 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);
+      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);
+    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);
+                            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 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);
+    val root = message.getRoot(TestAnyPointer.factory)
     // TODO add this after we impelement totalSize():
-    //root.totalSize();
+    //root.totalSize()
 
     a [DecodeException] should be thrownBy
-      root.getAnyPointerField.getAs(new StructList.Factory(TestAllTypes.factory));
+      root.getAnyPointerField.getAs(new StructList.Factory(TestAllTypes.factory))
 
-    val messageBuilder = new MessageBuilder();
-    val builderRoot = messageBuilder.initRoot(TestAnyPointer.factory);
+    val messageBuilder = new MessageBuilder()
+    val builderRoot = messageBuilder.initRoot(TestAnyPointer.factory)
     a [DecodeException] should be thrownBy
-      builderRoot.getAnyPointerField.setAs(TestAnyPointer.factory, root);
+      builderRoot.getAnyPointerField.setAs(TestAnyPointer.factory, root)
 
   }
 
   test("VoidListAmplification") {
-    val builder = new MessageBuilder();
-    builder.initRoot(TestAnyPointer.factory).getAnyPointerField().initAs(PrimitiveList.Void.factory, 1 << 28);
+    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 segments = builder.getSegmentsForOutput()
+    segments.length should equal (1)
 
-    val reader = new MessageReader(segments, ReaderOptions.DEFAULT_READER_OPTIONS);
-    val root = reader.getRoot(TestAnyPointer.factory);
+    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));
+       root.getAnyPointerField().getAs(new StructList.Factory(TestAllTypes.factory))
   }
 
   test("EmptyStructListAmplification") {
-    val builder = new MessageBuilder();
+    val builder = new MessageBuilder()
     builder.initRoot(TestAnyPointer.factory).getAnyPointerField()
-           .initAs(new StructList.Factory(TestEmptyStruct.factory), (1 << 29) - 1);
+           .initAs(new StructList.Factory(TestEmptyStruct.factory), (1 << 29) - 1)
 
-    val segments = builder.getSegmentsForOutput();
-    segments.length should equal (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);
+    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));
+       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);
+      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);
+      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);
+      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);
+      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);
+      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);
+      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);
+      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");
+      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);
+      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)
     }
   }
 
 
   // to debug, do this:
   //Serialize.write((new java.io.FileOutputStream("/Users/dwrensha/Desktop/test.dat")).getChannel(),
-  //                 message);
+  //                 message)
 
 }
diff --git a/compiler/src/test/scala/org/capnproto/TestUtil.scala b/compiler/src/test/scala/org/capnproto/TestUtil.scala
index 2ae28d8..2080c0f 100644
--- a/compiler/src/test/scala/org/capnproto/TestUtil.scala
+++ b/compiler/src/test/scala/org/capnproto/TestUtil.scala
@@ -19,356 +19,361 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-package org.capnproto;
+package org.capnproto
 
 import org.capnproto.Text.Reader
-import org.scalatest.Matchers._;
-import org.capnproto.test.Test._;
+import org.scalatest.Matchers._
+import org.capnproto.test.Test._
 
 
 object TestUtil {
 
   def data(str : String) : Array[Byte] = {
     try {
-      return str.getBytes("ISO_8859-1");
+      return str.getBytes("ISO_8859-1")
     } catch {
-      case e: Exception => throw new Error("could not decode");
+      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);
+    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 boolList = subBuilder.initBoolList(5);
-      boolList.set(0, false);
-      boolList.set(1, true);
-      boolList.set(2, false);
-      boolList.set(3, true);
-      boolList.set(4, true);
+    {
+      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);
+    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 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 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 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 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);
+    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");
+    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 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();
+        val subSubBuilder = subBuilder.getStructField()
         assert(subSubBuilder.getTextField().toString() == "nested")
       }
 
-      subBuilder.getEnumField() should equal (TestEnum.BAZ);
+      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);
+      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);
+    builder.getEnumField() should equal (TestEnum.CORGE)
 
-    assert(builder.getVoidList().size() == 6);
+    assert(builder.getVoidList().size() == 6)
 
-    val boolList = builder.getBoolList();
-    assert(boolList.get(0) == true);
-    assert(boolList.get(1) == false);
-    assert(boolList.get(2) == false);
-    assert(boolList.get(3) == true);
+    val boolList = builder.getBoolList()
+    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);
+    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 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());
+    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);
+    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");
+    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 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();
+        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);
+      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);
+    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 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);
+    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 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());
+    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);
+    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.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));
+    (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));
+    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);
+      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");
+      subReader.getTextField().toString() should equal ("baz")
 
       {
-        val subSubReader = subReader.getStructField();
-        subSubReader.getTextField().toString() should equal ("nested");
+        val subSubReader = subReader.getStructField()
+        subSubReader.getTextField().toString() should equal ("nested")
       }
 
     }
 
-    reader.getEnumField() should equal (TestEnum.CORGE);
+    reader.getEnumField() should equal (TestEnum.CORGE)
+
+    reader.getVoidList().size() should equal (6)
 
-    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.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);
+      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);
+    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.getBoolField() == false)
+    assert(reader.getInt8Field() == -122)
+    assert(reader.getInt16Field() == -12344)
+    assert(reader.getInt32Field() == -12345677)
+    assert(reader.getInt64Field() == -123456789012344L)
+    assert(reader.getUInt8Field() == 0xe9.toByte)
+    assert(reader.getUInt16Field() == 45677.toShort)
+    assert(reader.getUInt32Field() == 0xce0a6a13)
+    assert(reader.getUInt64Field() == 0xab54a98ceb1f0ad1L)
+    assert(reader.getFloat32Field() == 1234.4f)
+    assert(reader.getFloat64Field() == -123e44)
     assert(reader.getEnumField() == TestEnum.QUX)
   }
 }
diff --git a/runtime/src/test/scala/org/capnproto/LayoutSuite.scala b/runtime/src/test/scala/org/capnproto/LayoutSuite.scala
index 72185ad..cd922ed 100644
--- a/runtime/src/test/scala/org/capnproto/LayoutSuite.scala
+++ b/runtime/src/test/scala/org/capnproto/LayoutSuite.scala
@@ -19,7 +19,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-package org.capnproto;
+package org.capnproto
 
 import org.scalatest.FunSuite
 
@@ -29,7 +29,7 @@ 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 = {
-      return new StructReader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+      return new StructReader(segment,data,pointers,dataSize,pointerCount,nestingLimit)
     }
   }
 
@@ -37,85 +37,85 @@ class LayoutSuite extends FunSuite {
     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);
+            0xcd.toByte, 0xef.toByte)
 
-    val buffer = java.nio.ByteBuffer.wrap(data);
-    buffer.order(java.nio.ByteOrder.LITTLE_ENDIAN);
+    val buffer = java.nio.ByteBuffer.wrap(data)
+    buffer.order(java.nio.ByteOrder.LITTLE_ENDIAN)
 
-    val arena = new ReaderArena(Array(buffer), 0x7fffffffffffffffL);
+    val arena = new ReaderArena(Array(buffer), 0x7fffffffffffffffL)
 
     val reader = WireHelpers.readStructPointer(new BareStructReader(),
                                                arena.tryGetSegment(0),
-                                               0, null, 0, 0x7fffffff);
+                                               0, null, 0, 0x7fffffff)
 
-    assert(reader._getLongField(0) === 0xefcdab8967452301L);
-    assert(reader._getLongField(1) === 0L);
+    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);
+    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(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(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(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);
+    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);
+    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));
+    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))
   }
 
 
@@ -123,24 +123,24 @@ class LayoutSuite extends FunSuite {
 
     def constructBuilder(segment: org.capnproto.SegmentBuilder, data: Int, pointers: Int,
                           dataSize: Int, pointerCount: Short) : StructBuilder = {
-      return new StructBuilder(segment,data,pointers,dataSize,pointerCount);
+      return new StructBuilder(segment,data,pointers,dataSize,pointerCount)
     }
     def structSize() : StructSize = {
-      return structSize;
+      return structSize
     }
   }
 
 
   test("StructRoundTrip_OneSegment") {
-    val buffer = java.nio.ByteBuffer.allocate(1024 * 8);
-    buffer.order(java.nio.ByteOrder.LITTLE_ENDIAN);
+    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);
+    val factory = new BareStructBuilder(new StructSize(2, 4))
+    val builder =  WireHelpers.initStructPointer(factory, 0, segment, factory.structSize())
+    setupStruct(builder)
+    checkStruct(builder)
   }
 
 }
diff --git a/runtime/src/test/scala/org/capnproto/SerializePackedSuite.scala b/runtime/src/test/scala/org/capnproto/SerializePackedSuite.scala
index d9a9265..d2078bb 100644
--- a/runtime/src/test/scala/org/capnproto/SerializePackedSuite.scala
+++ b/runtime/src/test/scala/org/capnproto/SerializePackedSuite.scala
@@ -19,11 +19,11 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-package org.capnproto;
+package org.capnproto
 
-import org.scalatest.FunSuite;
-import org.scalatest.Matchers._;
-import java.nio.ByteBuffer;
+import org.scalatest.FunSuite
+import org.scalatest.Matchers._
+import java.nio.ByteBuffer
 
 class SerializePackedSuite extends FunSuite {
 
@@ -31,54 +31,54 @@ class SerializePackedSuite extends FunSuite {
     // ----
     // 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));
+      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);
+      (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));
+      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);
+      (n) should equal (unpacked.length)
 
-      (bytes) should equal (unpacked);
+      (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(), 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));
+                  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));
+                  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));
+                  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));
+                        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));
+                        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));
+                  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));
+                  Array(0x10,2, 0x40,1, 0,0))
   }
 }