capnproto

orphan-test.c++ (53642B)

---

 // 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.
 
 #include "message.h"
 #include <kj/debug.h>
 #include <kj/compat/gtest.h>
 #include "test-util.h"
 
 namespace capnp {
 namespace _ {  // private
 namespace {
 
 TEST(Orphans, Structs) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   initTestMessage(root.initStructField());
   EXPECT_TRUE(root.hasStructField());
 
   Orphan<TestAllTypes> orphan = root.disownStructField();
   EXPECT_FALSE(orphan == nullptr);
 
   checkTestMessage(orphan.getReader());
   checkTestMessage(orphan.get());
   EXPECT_FALSE(root.hasStructField());
 
   root.adoptStructField(kj::mv(orphan));
   EXPECT_TRUE(orphan == nullptr);
   EXPECT_TRUE(root.hasStructField());
   checkTestMessage(root.asReader().getStructField());
 }
 
 TEST(Orphans, EmptyStruct) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
   auto anyPointer = root.getAnyPointerField();
   EXPECT_TRUE(anyPointer.isNull());
   auto orphan = builder.getOrphanage().newOrphan<test::TestEmptyStruct>();
   anyPointer.adopt(kj::mv(orphan));
   EXPECT_EQ(0, anyPointer.targetSize().wordCount);
   EXPECT_FALSE(anyPointer.isNull());
 }
 
 TEST(Orphans, EmptyStructOverwrite) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
   auto anyPointer = root.getAnyPointerField();
   EXPECT_TRUE(anyPointer.isNull());
   anyPointer.initAs<TestAllTypes>();
   auto orphan = builder.getOrphanage().newOrphan<test::TestEmptyStruct>();
   anyPointer.adopt(kj::mv(orphan));
   EXPECT_EQ(0, anyPointer.targetSize().wordCount);
   EXPECT_FALSE(anyPointer.isNull());
 }
 
 TEST(Orphans, AdoptNullStruct) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
   auto anyPointer = root.getAnyPointerField();
   EXPECT_TRUE(anyPointer.isNull());
   anyPointer.initAs<TestAllTypes>();
   anyPointer.adopt(Orphan<test::TestEmptyStruct>());
   EXPECT_EQ(0, anyPointer.targetSize().wordCount);
   EXPECT_TRUE(anyPointer.isNull());
 }
 
 TEST(Orphans, Lists) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   root.setUInt32List({12, 34, 56});
   EXPECT_TRUE(root.hasUInt32List());
 
   Orphan<List<uint32_t>> orphan = root.disownUInt32List();
   EXPECT_FALSE(orphan == nullptr);
 
   checkList(orphan.getReader(), {12u, 34u, 56u});
   checkList(orphan.get(), {12u, 34u, 56u});
   EXPECT_FALSE(root.hasUInt32List());
 
   root.adoptUInt32List(kj::mv(orphan));
   EXPECT_TRUE(orphan == nullptr);
   EXPECT_TRUE(root.hasUInt32List());
   checkList(root.asReader().getUInt32List(), {12u, 34u, 56u});
 }
 
 TEST(Orphans, StructLists) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   auto list = root.initStructList(2);
   list[0].setTextField("foo");
   list[1].setTextField("bar");
   EXPECT_TRUE(root.hasStructList());
 
   Orphan<List<TestAllTypes>> orphan = root.disownStructList();
   EXPECT_FALSE(orphan == nullptr);
 
   ASSERT_EQ(2u, orphan.getReader().size());
   EXPECT_EQ("foo", orphan.getReader()[0].getTextField());
   EXPECT_EQ("bar", orphan.getReader()[1].getTextField());
   ASSERT_EQ(2u, orphan.get().size());
   EXPECT_EQ("foo", orphan.get()[0].getTextField());
   EXPECT_EQ("bar", orphan.get()[1].getTextField());
   EXPECT_FALSE(root.hasStructList());
 
   root.adoptStructList(kj::mv(orphan));
   EXPECT_TRUE(orphan == nullptr);
   EXPECT_TRUE(root.hasStructList());
   ASSERT_EQ(2u, root.asReader().getStructList().size());
   EXPECT_EQ("foo", root.asReader().getStructList()[0].getTextField());
   EXPECT_EQ("bar", root.asReader().getStructList()[1].getTextField());
 }
 
 TEST(Orphans, Text) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   root.setTextField("foo");
   EXPECT_TRUE(root.hasTextField());
 
   Orphan<Text> orphan = root.disownTextField();
   EXPECT_FALSE(orphan == nullptr);
 
   EXPECT_EQ("foo", orphan.getReader());
   EXPECT_EQ("foo", orphan.get());
   EXPECT_FALSE(root.hasTextField());
 
   root.adoptTextField(kj::mv(orphan));
   EXPECT_TRUE(orphan == nullptr);
   EXPECT_TRUE(root.hasTextField());
   EXPECT_EQ("foo", root.getTextField());
 }
 
 TEST(Orphans, Data) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   root.setDataField(data("foo"));
   EXPECT_TRUE(root.hasDataField());
 
   Orphan<Data> orphan = root.disownDataField();
   EXPECT_FALSE(orphan == nullptr);
 
   EXPECT_EQ(data("foo"), orphan.getReader());
   EXPECT_EQ(data("foo"), orphan.get());
   EXPECT_FALSE(root.hasDataField());
 
   root.adoptDataField(kj::mv(orphan));
   EXPECT_TRUE(orphan == nullptr);
   EXPECT_TRUE(root.hasDataField());
   EXPECT_EQ(data("foo"), root.getDataField());
 }
 
 TEST(Orphans, NoCrossMessageTransfers) {
   MallocMessageBuilder builder1;
   MallocMessageBuilder builder2;
   auto root1 = builder1.initRoot<TestAllTypes>();
   auto root2 = builder2.initRoot<TestAllTypes>();
 
   initTestMessage(root1.initStructField());
 
   EXPECT_ANY_THROW(root2.adoptStructField(root1.disownStructField()));
 }
 
 TEST(Orphans, OrphanageStruct) {
   MallocMessageBuilder builder;
 
   Orphan<TestAllTypes> orphan = builder.getOrphanage().newOrphan<TestAllTypes>();
   initTestMessage(orphan.get());
   checkTestMessage(orphan.getReader());
 
   auto root = builder.initRoot<TestAllTypes>();
   root.adoptStructField(kj::mv(orphan));
 }
 
 TEST(Orphans, OrphanageList) {
   MallocMessageBuilder builder;
 
   Orphan<List<uint32_t>> orphan = builder.getOrphanage().newOrphan<List<uint32_t>>(2);
   orphan.get().set(0, 123);
   orphan.get().set(1, 456);
 
   List<uint32_t>::Reader reader = orphan.getReader();
   ASSERT_EQ(2u, reader.size());
   EXPECT_EQ(123u, reader[0]);
   EXPECT_EQ(456u, reader[1]);
 
   auto root = builder.initRoot<TestAllTypes>();
   root.adoptUInt32List(kj::mv(orphan));
 }
 
 TEST(Orphans, OrphanageText) {
   MallocMessageBuilder builder;
 
   Orphan<Text> orphan = builder.getOrphanage().newOrphan<Text>(8);
   ASSERT_EQ(8u, orphan.get().size());
   memcpy(orphan.get().begin(), "12345678", 8);
 
   auto root = builder.initRoot<TestAllTypes>();
   root.adoptTextField(kj::mv(orphan));
   EXPECT_EQ("12345678", root.getTextField());
 }
 
 TEST(Orphans, OrphanageData) {
   MallocMessageBuilder builder;
 
   Orphan<Data> orphan = builder.getOrphanage().newOrphan<Data>(2);
   ASSERT_EQ(2u, orphan.get().size());
   orphan.get()[0] = 123;
   orphan.get()[1] = 45;
 
   auto root = builder.initRoot<TestAllTypes>();
   root.adoptDataField(kj::mv(orphan));
   ASSERT_EQ(2u, root.getDataField().size());
   EXPECT_EQ(123u, root.getDataField()[0]);
   EXPECT_EQ(45u, root.getDataField()[1]);
 }
 
 TEST(Orphans, OrphanageStructCopy) {
   MallocMessageBuilder builder1;
   MallocMessageBuilder builder2;
 
   auto root1 = builder1.initRoot<TestAllTypes>();
   initTestMessage(root1);
 
   Orphan<TestAllTypes> orphan = builder2.getOrphanage().newOrphanCopy(root1.asReader());
   checkTestMessage(orphan.getReader());
 
   auto root2 = builder2.initRoot<TestAllTypes>();
   root2.adoptStructField(kj::mv(orphan));
 }
 
 TEST(Orphans, OrphanageListCopy) {
   MallocMessageBuilder builder1;
   MallocMessageBuilder builder2;
 
   auto root1 = builder1.initRoot<TestAllTypes>();
   root1.setUInt32List({12, 34, 56});
 
   Orphan<List<uint32_t>> orphan = builder2.getOrphanage().newOrphanCopy(
       root1.asReader().getUInt32List());
   checkList(orphan.getReader(), {12u, 34u, 56u});
 
   auto root2 = builder2.initRoot<TestAllTypes>();
   root2.adoptUInt32List(kj::mv(orphan));
 }
 
 TEST(Orphans, OrphanageTextCopy) {
   MallocMessageBuilder builder;
 
   Orphan<Text> orphan = builder.getOrphanage().newOrphanCopy(Text::Reader("foobarba"));
   EXPECT_EQ("foobarba", orphan.getReader());
 
   auto root = builder.initRoot<TestAllTypes>();
   root.adoptTextField(kj::mv(orphan));
 }
 
 TEST(Orphans, OrphanageDataCopy) {
   MallocMessageBuilder builder;
 
   Orphan<Data> orphan = builder.getOrphanage().newOrphanCopy(data("foo"));
   EXPECT_EQ(data("foo"), orphan.getReader());
 
   auto root = builder.initRoot<TestAllTypes>();
   root.adoptDataField(kj::mv(orphan));
 }
 
 TEST(Orphans, ZeroOut) {
   MallocMessageBuilder builder;
   TestAllTypes::Reader orphanReader;
 
   {
     Orphan<TestAllTypes> orphan = builder.getOrphanage().newOrphan<TestAllTypes>();
     orphanReader = orphan.getReader();
     initTestMessage(orphan.get());
     checkTestMessage(orphan.getReader());
   }
 
   // Once the Orphan destructor is called, the message should be zero'd out.
   checkTestMessageAllZero(orphanReader);
 }
 
 TEST(Orphans, StructAnyPointer) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
 
   initTestMessage(root.getAnyPointerField().initAs<TestAllTypes>());
   EXPECT_TRUE(root.hasAnyPointerField());
 
   Orphan<TestAllTypes> orphan = root.getAnyPointerField().disownAs<TestAllTypes>();
   EXPECT_FALSE(orphan == nullptr);
 
   checkTestMessage(orphan.getReader());
   EXPECT_FALSE(root.hasAnyPointerField());
 
   root.getAnyPointerField().adopt(kj::mv(orphan));
   EXPECT_TRUE(orphan == nullptr);
   EXPECT_TRUE(root.hasAnyPointerField());
   checkTestMessage(root.asReader().getAnyPointerField().getAs<TestAllTypes>());
 }
 
 TEST(Orphans, ListAnyPointer) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
 
   root.getAnyPointerField().setAs<List<uint32_t>>({12, 34, 56});
   EXPECT_TRUE(root.hasAnyPointerField());
 
   Orphan<List<uint32_t>> orphan = root.getAnyPointerField().disownAs<List<uint32_t>>();
   EXPECT_FALSE(orphan == nullptr);
 
   checkList(orphan.getReader(), {12u, 34u, 56u});
   EXPECT_FALSE(root.hasAnyPointerField());
 
   root.getAnyPointerField().adopt(kj::mv(orphan));
   EXPECT_TRUE(orphan == nullptr);
   EXPECT_TRUE(root.hasAnyPointerField());
   checkList(root.asReader().getAnyPointerField().getAs<List<uint32_t>>(), {12u, 34u, 56u});
 }
 
 #if !CAPNP_LITE
 TEST(Orphans, DynamicStruct) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
 
   initTestMessage(root.getAnyPointerField().initAs<TestAllTypes>());
   EXPECT_TRUE(root.hasAnyPointerField());
 
   Orphan<DynamicStruct> orphan =
       root.getAnyPointerField().disownAs<DynamicStruct>(Schema::from<TestAllTypes>());
   EXPECT_FALSE(orphan == nullptr);
 
   EXPECT_TRUE(orphan.get().getSchema() == Schema::from<TestAllTypes>());
   checkDynamicTestMessage(orphan.getReader());
   EXPECT_FALSE(root.hasAnyPointerField());
 
   root.getAnyPointerField().adopt(kj::mv(orphan));
   EXPECT_TRUE(orphan == nullptr);
   EXPECT_TRUE(root.hasAnyPointerField());
   checkTestMessage(root.asReader().getAnyPointerField().getAs<TestAllTypes>());
 
   Orphan<DynamicStruct> orphan2 = root.getAnyPointerField().disownAs<TestAllTypes>();
   EXPECT_FALSE(orphan2 == nullptr);
   EXPECT_TRUE(orphan2.get().getSchema() == Schema::from<TestAllTypes>());
   checkDynamicTestMessage(orphan2.getReader());
 }
 
 TEST(Orphans, DynamicList) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
 
   root.getAnyPointerField().setAs<List<uint32_t>>({12, 34, 56});
   EXPECT_TRUE(root.hasAnyPointerField());
 
   Orphan<DynamicList> orphan =
       root.getAnyPointerField().disownAs<DynamicList>(Schema::from<List<uint32_t>>());
   EXPECT_FALSE(orphan == nullptr);
 
   checkList<uint32_t>(orphan.getReader(), {12, 34, 56});
   EXPECT_FALSE(root.hasAnyPointerField());
 
   root.getAnyPointerField().adopt(kj::mv(orphan));
   EXPECT_TRUE(orphan == nullptr);
   EXPECT_TRUE(root.hasAnyPointerField());
   checkList(root.asReader().getAnyPointerField().getAs<List<uint32_t>>(), {12u, 34u, 56u});
 
   Orphan<DynamicList> orphan2 = root.getAnyPointerField().disownAs<List<uint32_t>>();
   EXPECT_FALSE(orphan2 == nullptr);
   checkList<uint32_t>(orphan2.getReader(), {12, 34, 56});
 }
 
 TEST(Orphans, DynamicStructList) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
 
   auto list = root.getAnyPointerField().initAs<List<TestAllTypes>>(2);
   list[0].setTextField("foo");
   list[1].setTextField("bar");
   EXPECT_TRUE(root.hasAnyPointerField());
 
   Orphan<DynamicList> orphan =
       root.getAnyPointerField().disownAs<DynamicList>(Schema::from<List<TestAllTypes>>());
   EXPECT_FALSE(orphan == nullptr);
 
   ASSERT_EQ(2u, orphan.get().size());
   EXPECT_EQ("foo", orphan.get()[0].as<TestAllTypes>().getTextField());
   EXPECT_EQ("bar", orphan.get()[1].as<TestAllTypes>().getTextField());
   EXPECT_FALSE(root.hasAnyPointerField());
 
   root.getAnyPointerField().adopt(kj::mv(orphan));
   EXPECT_TRUE(orphan == nullptr);
   EXPECT_TRUE(root.hasAnyPointerField());
   ASSERT_EQ(2u, root.asReader().getAnyPointerField().getAs<List<TestAllTypes>>().size());
   EXPECT_EQ("foo", root.asReader().getAnyPointerField()
                        .getAs<List<TestAllTypes>>()[0].getTextField());
   EXPECT_EQ("bar", root.asReader().getAnyPointerField()
                        .getAs<List<TestAllTypes>>()[1].getTextField());
 }
 
 TEST(Orphans, OrphanageDynamicStruct) {
   MallocMessageBuilder builder;
 
   Orphan<DynamicStruct> orphan = builder.getOrphanage().newOrphan(Schema::from<TestAllTypes>());
   initDynamicTestMessage(orphan.get());
   checkDynamicTestMessage(orphan.getReader());
 
   auto root = builder.initRoot<test::TestAnyPointer>();
   root.getAnyPointerField().adopt(kj::mv(orphan));
   checkTestMessage(root.asReader().getAnyPointerField().getAs<TestAllTypes>());
 }
 
 TEST(Orphans, OrphanageDynamicList) {
   MallocMessageBuilder builder;
 
   Orphan<DynamicList> orphan = builder.getOrphanage().newOrphan(Schema::from<List<uint32_t>>(), 2);
   orphan.get().set(0, 123);
   orphan.get().set(1, 456);
 
   checkList<uint32_t>(orphan.getReader(), {123, 456});
 
   auto root = builder.initRoot<test::TestAnyPointer>();
   root.getAnyPointerField().adopt(kj::mv(orphan));
   checkList(root.getAnyPointerField().getAs<List<uint32_t>>(), {123u, 456u});
 }
 
 TEST(Orphans, OrphanageDynamicStructCopy) {
   MallocMessageBuilder builder1;
   MallocMessageBuilder builder2;
 
   auto root1 = builder1.initRoot<test::TestAnyPointer>();
   initTestMessage(root1.getAnyPointerField().initAs<TestAllTypes>());
 
   Orphan<DynamicStruct> orphan = builder2.getOrphanage().newOrphanCopy(
       root1.asReader().getAnyPointerField().getAs<DynamicStruct>(Schema::from<TestAllTypes>()));
   checkDynamicTestMessage(orphan.getReader());
 
   auto root2 = builder2.initRoot<test::TestAnyPointer>();
   root2.getAnyPointerField().adopt(kj::mv(orphan));
   checkTestMessage(root2.asReader().getAnyPointerField().getAs<TestAllTypes>());
 }
 
 TEST(Orphans, OrphanageDynamicListCopy) {
   MallocMessageBuilder builder1;
   MallocMessageBuilder builder2;
 
   auto root1 = builder1.initRoot<test::TestAnyPointer>();
   root1.getAnyPointerField().setAs<List<uint32_t>>({12, 34, 56});
 
   Orphan<DynamicList> orphan = builder2.getOrphanage().newOrphanCopy(
       root1.asReader().getAnyPointerField().getAs<DynamicList>(Schema::from<List<uint32_t>>()));
   checkList<uint32_t>(orphan.getReader(), {12, 34, 56});
 
   auto root2 = builder2.initRoot<test::TestAnyPointer>();
   root2.getAnyPointerField().adopt(kj::mv(orphan));
   checkList(root2.getAnyPointerField().getAs<List<uint32_t>>(), {12u, 34u, 56u});
 }
 
 TEST(Orphans, DynamicStructAs) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
 
   initTestMessage(root.getAnyPointerField().initAs<TestAllTypes>());
   EXPECT_TRUE(root.hasAnyPointerField());
 
   Orphan<DynamicValue> orphan =
       root.getAnyPointerField().disownAs<DynamicStruct>(Schema::from<TestAllTypes>());
   EXPECT_EQ(DynamicValue::STRUCT, orphan.getType());
 
   checkTestMessage(orphan.getReader().as<TestAllTypes>());
   checkTestMessage(orphan.get().as<TestAllTypes>());
 
   {
     Orphan<DynamicStruct> structOrphan = orphan.releaseAs<DynamicStruct>();
     EXPECT_EQ(DynamicValue::UNKNOWN, orphan.getType());
     EXPECT_FALSE(structOrphan == nullptr);
     checkDynamicTestMessage(structOrphan.getReader());
     checkDynamicTestMessage(structOrphan.get());
     checkTestMessage(structOrphan.getReader().as<TestAllTypes>());
     checkTestMessage(structOrphan.get().as<TestAllTypes>());
 
     {
       Orphan<TestAllTypes> typedOrphan = structOrphan.releaseAs<TestAllTypes>();
       EXPECT_TRUE(structOrphan == nullptr);
       EXPECT_FALSE(typedOrphan == nullptr);
       checkTestMessage(typedOrphan.getReader());
       checkTestMessage(typedOrphan.get());
       orphan = kj::mv(typedOrphan);
       EXPECT_EQ(DynamicValue::STRUCT, orphan.getType());
       EXPECT_TRUE(typedOrphan == nullptr);
     }
   }
 
   {
     Orphan<TestAllTypes> typedOrphan = orphan.releaseAs<TestAllTypes>();
     checkTestMessage(typedOrphan.getReader());
     checkTestMessage(typedOrphan.get());
   }
 }
 
 TEST(Orphans, DynamicListAs) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
 
   root.getAnyPointerField().setAs<List<uint32_t>>({12, 34, 56});
   EXPECT_TRUE(root.hasAnyPointerField());
 
   Orphan<DynamicValue> orphan =
       root.getAnyPointerField().disownAs<DynamicList>(Schema::from<List<uint32_t>>());
   EXPECT_EQ(DynamicValue::LIST, orphan.getType());
 
   checkList(orphan.getReader().as<List<uint32_t>>(), {12, 34, 56});
   checkList(orphan.get().as<List<uint32_t>>(), {12, 34, 56});
 
   {
     Orphan<DynamicList> listOrphan = orphan.releaseAs<DynamicList>();
     EXPECT_EQ(DynamicValue::UNKNOWN, orphan.getType());
     EXPECT_FALSE(listOrphan == nullptr);
     checkList<uint32_t>(listOrphan.getReader(), {12, 34, 56});
     checkList<uint32_t>(listOrphan.get(), {12, 34, 56});
     checkList(listOrphan.getReader().as<List<uint32_t>>(), {12, 34, 56});
     checkList(listOrphan.get().as<List<uint32_t>>(), {12, 34, 56});
 
     {
       Orphan<List<uint32_t>> typedOrphan = listOrphan.releaseAs<List<uint32_t>>();
       EXPECT_TRUE(listOrphan == nullptr);
       EXPECT_FALSE(typedOrphan == nullptr);
       checkList(typedOrphan.getReader(), {12, 34, 56});
       checkList(typedOrphan.get(), {12, 34, 56});
       orphan = kj::mv(typedOrphan);
       EXPECT_EQ(DynamicValue::LIST, orphan.getType());
       EXPECT_TRUE(typedOrphan == nullptr);
     }
   }
 
   {
     Orphan<List<uint32_t>> typedOrphan = orphan.releaseAs<List<uint32_t>>();
     checkList(typedOrphan.getReader(), {12, 34, 56});
     checkList(typedOrphan.get(), {12, 34, 56});
   }
 }
 
 TEST(Orphans, DynamicAnyPointer) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
 
   initTestMessage(root.getAnyPointerField().initAs<TestAllTypes>());
   EXPECT_TRUE(root.hasAnyPointerField());
 
   Orphan<DynamicValue> orphan = root.getAnyPointerField().disown();
   EXPECT_EQ(DynamicValue::ANY_POINTER, orphan.getType());
 
   Orphan<AnyPointer> objectOrphan = orphan.releaseAs<AnyPointer>();
   checkTestMessage(objectOrphan.getAs<TestAllTypes>());
   checkDynamicTestMessage(objectOrphan.getAs<DynamicStruct>(Schema::from<TestAllTypes>()));
 }
 
 TEST(Orphans, DynamicDisown) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
   initTestMessage(root);
 
   Orphan<TestAllTypes> dstOrphan =
       Orphanage::getForMessageContaining(root).newOrphan<TestAllTypes>();
   auto dst = dstOrphan.get();
 
   DynamicStruct::Builder dynamic = root;
   DynamicStruct::Builder dynamicDst = dst;
 
   for (auto field: dynamic.getSchema().getFields()) {
     dynamicDst.adopt(field, dynamic.disown(field));
   }
 
   checkTestMessageAllZero(root.asReader());
   checkTestMessage(dst.asReader());
 
   for (auto field: dynamic.getSchema().getFields()) {
     dynamicDst.adopt(field, dynamic.disown(field));
   }
 
   checkTestMessageAllZero(root.asReader());
   checkTestMessageAllZero(dst.asReader());
 }
 
 TEST(Orphans, DynamicDisownGroup) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestGroups>();
 
   auto bar = root.initGroups().initBar();
   bar.setCorge(123);
   bar.setGrault("foo");
   bar.setGarply(9876543210987ll);
 
   Orphan<test::TestGroups> dstOrphan =
       Orphanage::getForMessageContaining(root).newOrphan<test::TestGroups>();
   auto dst = dstOrphan.get();
 
   toDynamic(dst).adopt("groups", toDynamic(root).disown("groups"));
 
   EXPECT_EQ(test::TestGroups::Groups::FOO, root.getGroups().which());
 
   EXPECT_EQ(test::TestGroups::Groups::BAR, dst.getGroups().which());
   auto newBar = dst.getGroups().getBar();
   EXPECT_EQ(123, newBar.getCorge());
   EXPECT_EQ("foo", newBar.getGrault());
   EXPECT_EQ(9876543210987ll, newBar.getGarply());
 }
 #endif  // !CAPNP_LITE
 
 TEST(Orphans, OrphanageFromBuilder) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   {
     Orphanage orphanage = Orphanage::getForMessageContaining(root);
     Orphan<TestAllTypes> orphan = orphanage.newOrphan<TestAllTypes>();
     initTestMessage(orphan.get());
     root.adoptStructField(kj::mv(orphan));
     checkTestMessage(root.asReader().getStructField());
   }
 
   {
     Orphanage orphanage = Orphanage::getForMessageContaining(root.initBoolList(3));
     Orphan<TestAllTypes> orphan = orphanage.newOrphan<TestAllTypes>();
     initTestMessage(orphan.get());
     root.adoptStructField(kj::mv(orphan));
     checkTestMessage(root.asReader().getStructField());
   }
 
 #if !CAPNP_LITE
   {
     Orphanage orphanage = Orphanage::getForMessageContaining(toDynamic(root));
     Orphan<TestAllTypes> orphan = orphanage.newOrphan<TestAllTypes>();
     initTestMessage(orphan.get());
     root.adoptStructField(kj::mv(orphan));
     checkTestMessage(root.asReader().getStructField());
   }
 
   {
     Orphanage orphanage = Orphanage::getForMessageContaining(toDynamic(root.initBoolList(3)));
     Orphan<TestAllTypes> orphan = orphanage.newOrphan<TestAllTypes>();
     initTestMessage(orphan.get());
     root.adoptStructField(kj::mv(orphan));
     checkTestMessage(root.asReader().getStructField());
   }
 #endif  // !CAPNP_LITE
 }
 
 static bool allZero(const word* begin, const word* end) {
   for (const byte* pos = reinterpret_cast<const byte*>(begin);
        pos < reinterpret_cast<const byte*>(end); ++pos) {
     if (*pos != 0) return false;
   }
   return true;
 }
 
 TEST(Orphans, StructsZerodAfterUse) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   const word* zerosStart = builder.getSegmentsForOutput()[0].end();
   initTestMessage(root.initStructField());
   const word* zerosEnd = builder.getSegmentsForOutput()[0].end();
 
   root.setTextField("foo");  // guard against overruns
 
   EXPECT_EQ(1u, builder.getSegmentsForOutput().size());  // otherwise test is invalid
 
   root.disownStructField();
 
   EXPECT_TRUE(allZero(zerosStart, zerosEnd));
 
   EXPECT_EQ("foo", root.getTextField());
 }
 
 TEST(Orphans, ListsZerodAfterUse) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   const word* zerosStart = builder.getSegmentsForOutput()[0].end();
   root.setUInt32List({12, 34, 56});
   const word* zerosEnd = builder.getSegmentsForOutput()[0].end();
 
   root.setTextField("foo");  // guard against overruns
 
   EXPECT_EQ(1u, builder.getSegmentsForOutput().size());  // otherwise test is invalid
 
   root.disownUInt32List();
 
   EXPECT_TRUE(allZero(zerosStart, zerosEnd));
 
   EXPECT_EQ("foo", root.getTextField());
 }
 
 TEST(Orphans, EmptyListsZerodAfterUse) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   const word* zerosStart = builder.getSegmentsForOutput()[0].end();
   root.initUInt32List(0);
   const word* zerosEnd = builder.getSegmentsForOutput()[0].end();
 
   root.setTextField("foo");  // guard against overruns
 
   EXPECT_EQ(1u, builder.getSegmentsForOutput().size());  // otherwise test is invalid
 
   root.disownUInt32List();
 
   EXPECT_TRUE(allZero(zerosStart, zerosEnd));
 
   EXPECT_EQ("foo", root.getTextField());
 }
 
 TEST(Orphans, StructListsZerodAfterUse) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   const word* zerosStart = builder.getSegmentsForOutput()[0].end();
   {
     auto list = root.initStructList(2);
     initTestMessage(list[0]);
     initTestMessage(list[1]);
   }
   const word* zerosEnd = builder.getSegmentsForOutput()[0].end();
 
   root.setTextField("foo");  // guard against overruns
 
   EXPECT_EQ(1u, builder.getSegmentsForOutput().size());  // otherwise test is invalid
 
   root.disownStructList();
 
   EXPECT_TRUE(allZero(zerosStart, zerosEnd));
 
   EXPECT_EQ("foo", root.getTextField());
 }
 
 TEST(Orphans, EmptyStructListsZerodAfterUse) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   const word* zerosStart = builder.getSegmentsForOutput()[0].end();
   root.initStructList(0);
   const word* zerosEnd = builder.getSegmentsForOutput()[0].end();
 
   root.setTextField("foo");  // guard against overruns
 
   EXPECT_EQ(1u, builder.getSegmentsForOutput().size());  // otherwise test is invalid
 
   root.disownStructList();
 
   EXPECT_TRUE(allZero(zerosStart, zerosEnd));
 
   EXPECT_EQ("foo", root.getTextField());
 }
 
 TEST(Orphans, TextZerodAfterUse) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   const word* zerosStart = builder.getSegmentsForOutput()[0].end();
   root.setTextField("abcd123");
   const word* zerosEnd = builder.getSegmentsForOutput()[0].end();
 
   root.setDataField(data("foo"));  // guard against overruns
 
   EXPECT_EQ(1u, builder.getSegmentsForOutput().size());  // otherwise test is invalid
 
   root.disownTextField();
 
   EXPECT_TRUE(allZero(zerosStart, zerosEnd));
 
   EXPECT_EQ(data("foo"), root.getDataField());
 }
 
 TEST(Orphans, DataZerodAfterUse) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   const word* zerosStart = builder.getSegmentsForOutput()[0].end();
   root.setDataField(data("abcd123"));
   const word* zerosEnd = builder.getSegmentsForOutput()[0].end();
 
   root.setTextField("foo");  // guard against overruns
 
   EXPECT_EQ(1u, builder.getSegmentsForOutput().size());  // otherwise test is invalid
 
   root.disownDataField();
 
   EXPECT_TRUE(allZero(zerosStart, zerosEnd));
 
   EXPECT_EQ("foo", root.getTextField());
 }
 
 TEST(Orphans, FarPointer) {
   MallocMessageBuilder builder(0, AllocationStrategy::FIXED_SIZE);
   auto root = builder.initRoot<TestAllTypes>();
   auto child = root.initStructField();
   initTestMessage(child);
 
   auto orphan = root.disownStructField();
   EXPECT_FALSE(root.hasStructField());
   EXPECT_TRUE(orphan != nullptr);
   EXPECT_FALSE(orphan == nullptr);
 
   checkTestMessage(orphan.getReader());
   checkTestMessage(orphan.get());
 }
 
 TEST(Orphans, UpgradeStruct) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
 
   auto old = root.getAnyPointerField().initAs<test::TestOldVersion>();
   old.setOld1(1234);
   old.setOld2("foo");
 
   auto orphan = root.getAnyPointerField().disownAs<test::TestNewVersion>();
 
   // Relocation has not occurred yet.
   old.setOld1(12345);
   EXPECT_EQ(12345, orphan.getReader().getOld1());
   EXPECT_EQ("foo", old.getOld2());
 
   // This will relocate the struct.
   auto newVersion = orphan.get();
 
   EXPECT_EQ(0, old.getOld1());
   EXPECT_EQ("", old.getOld2());
 
   EXPECT_EQ(12345, newVersion.getOld1());
   EXPECT_EQ("foo", newVersion.getOld2());
 }
 
 TEST(Orphans, UpgradeStructList) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<test::TestAnyPointer>();
 
   auto old = root.getAnyPointerField().initAs<List<test::TestOldVersion>>(2);
   old[0].setOld1(1234);
   old[0].setOld2("foo");
   old[1].setOld1(4321);
   old[1].setOld2("bar");
 
   auto orphan = root.getAnyPointerField().disownAs<List<test::TestNewVersion>>();
 
   // Relocation has not occurred yet.
   old[0].setOld1(12345);
   EXPECT_EQ(12345, orphan.getReader()[0].getOld1());
   EXPECT_EQ("foo", old[0].getOld2());
 
   // This will relocate the struct.
   auto newVersion = orphan.get();
 
   EXPECT_EQ(0, old[0].getOld1());
   EXPECT_EQ("", old[0].getOld2());
 
   EXPECT_EQ(12345, newVersion[0].getOld1());
   EXPECT_EQ("foo", newVersion[0].getOld2());
   EXPECT_EQ(4321, newVersion[1].getOld1());
   EXPECT_EQ("bar", newVersion[1].getOld2());
 }
 
 TEST(Orphans, DisownNull) {
   MallocMessageBuilder builder;
   auto root = builder.initRoot<TestAllTypes>();
 
   {
     Orphan<TestAllTypes> orphan = root.disownStructField();
     EXPECT_TRUE(orphan == nullptr);
 
     checkTestMessageAllZero(orphan.getReader());
     EXPECT_TRUE(orphan == nullptr);
 
     // get()ing the orphan allocates an object, for security reasons.
     checkTestMessageAllZero(orphan.get());
     EXPECT_FALSE(orphan == nullptr);
   }
 
   {
     Orphan<List<int32_t>> orphan = root.disownInt32List();
     EXPECT_TRUE(orphan == nullptr);
 
     EXPECT_EQ(0, orphan.getReader().size());
     EXPECT_TRUE(orphan == nullptr);
 
     EXPECT_EQ(0, orphan.get().size());
     EXPECT_TRUE(orphan == nullptr);
   }
 
   {
     Orphan<List<TestAllTypes>> orphan = root.disownStructList();
     EXPECT_TRUE(orphan == nullptr);
 
     EXPECT_EQ(0, orphan.getReader().size());
     EXPECT_TRUE(orphan == nullptr);
 
     EXPECT_EQ(0, orphan.get().size());
     EXPECT_TRUE(orphan == nullptr);
   }
 }
 
 TEST(Orphans, ReferenceExternalData) {
   MallocMessageBuilder builder;
 
   union {
     word align;
     byte data[50];
   };
 
   memset(data, 0x55, sizeof(data));
 
   auto orphan = builder.getOrphanage().referenceExternalData(Data::Builder(data, sizeof(data)));
 
   // Data was added as a new segment.
   {
     auto segments = builder.getSegmentsForOutput();
     ASSERT_EQ(2, segments.size());
     EXPECT_EQ(data, segments[1].asBytes().begin());
     EXPECT_EQ((sizeof(data) + 7) / 8, segments[1].size());
   }
 
   // Can't get builder because it's read-only.
   EXPECT_ANY_THROW(orphan.get());
 
   // Can get reader.
   {
     auto reader = orphan.getReader();
     EXPECT_EQ(data, reader.begin());
     EXPECT_EQ(sizeof(data), reader.size());
   }
 
   // Adopt into message tree.
   auto root = builder.getRoot<TestAllTypes>();
   root.adoptDataField(kj::mv(orphan));
 
   // Can't get child builder.
   EXPECT_ANY_THROW(root.getDataField());
 
   // Can get child reader.
   {
     auto reader = root.asReader().getDataField();
     EXPECT_EQ(data, reader.begin());
     EXPECT_EQ(sizeof(data), reader.size());
   }
 
   // Back to orphan.
   orphan = root.disownDataField();
 
   // Now the orphan may be pointing to a far pointer landing pad, so check that it still does the
   // right things.
 
   // Can't get builder because it's read-only.
   EXPECT_ANY_THROW(orphan.get());
 
   // Can get reader.
   {
     auto reader = orphan.getReader();
     EXPECT_EQ(data, reader.begin());
     EXPECT_EQ(sizeof(data), reader.size());
   }
 
   // Finally, let's abandon the orphan and check that this doesn't zero out the data.
   orphan = Orphan<Data>();
 
   for (byte b: data) {
     EXPECT_EQ(0x55, b);
   }
 }
 
 TEST(Orphans, ReferenceExternalData_NoZeroOnSet) {
   // Verify that an external blob is not zeroed by setFoo().
 
   union {
     word align;
     byte data[50];
   };
 
   memset(data, 0x55, sizeof(data));
 
   MallocMessageBuilder builder;
   auto root = builder.getRoot<TestAllTypes>();
   root.adoptDataField(builder.getOrphanage().referenceExternalData(
       Data::Builder(data, sizeof(data))));
 
   root.setDataField(Data::Builder());
 
   for (byte b: data) {
     EXPECT_EQ(0x55, b);
   }
 }
 
 TEST(Orphans, ReferenceExternalData_NoZeroImmediateAbandon) {
   // Verify that an external blob is not zeroed when abandoned immediately, without ever being
   // adopted.
 
   union {
     word align;
     byte data[50];
   };
 
   memset(data, 0x55, sizeof(data));
 
   MallocMessageBuilder builder;
   builder.getOrphanage().referenceExternalData(Data::Builder(data, sizeof(data)));
 
   for (byte b: data) {
     EXPECT_EQ(0x55, b);
   }
 }
 
 TEST(Orphans, TruncateData) {
   MallocMessageBuilder message;
   auto orphan = message.getOrphanage().newOrphan<Data>(17);
   auto builder = orphan.get();
   memset(builder.begin(), 123, builder.size());
 
   EXPECT_EQ(4, message.getSegmentsForOutput()[0].size());
   orphan.truncate(2);
   EXPECT_EQ(2, message.getSegmentsForOutput()[0].size());
 
   auto reader = orphan.getReader();
   EXPECT_EQ(2, reader.size());
   EXPECT_EQ(builder.begin(), reader.begin());
 
   EXPECT_EQ(123, builder[0]);
   EXPECT_EQ(123, builder[1]);
   EXPECT_EQ(0, builder[2]);
   EXPECT_EQ(0, builder[3]);
   EXPECT_EQ(0, builder[16]);
 }
 
 TEST(Orphans, ExtendData) {
   MallocMessageBuilder message;
   auto orphan = message.getOrphanage().newOrphan<Data>(17);
   auto builder = orphan.get();
   memset(builder.begin(), 123, builder.size());
 
   EXPECT_EQ(4, message.getSegmentsForOutput()[0].size());
   orphan.truncate(27);
   EXPECT_EQ(5, message.getSegmentsForOutput()[0].size());
 
   auto reader = orphan.getReader();
   EXPECT_EQ(27, reader.size());
   EXPECT_EQ(builder.begin(), reader.begin());
 
   for (uint i = 0; i < 17; i++) {
     EXPECT_EQ(123, reader[i]);
   }
   for (uint i = 17; i < 27; i++) {
     EXPECT_EQ(0, reader[i]);
   }
 }
 
 TEST(Orphans, ExtendDataCopy) {
   MallocMessageBuilder message;
   auto orphan = message.getOrphanage().newOrphan<Data>(17);
   auto builder = orphan.get();
   memset(builder.begin(), 123, builder.size());
 
   auto orphan2 = message.getOrphanage().newOrphan<Data>(1);
   orphan2.get()[0] = 32;
 
   orphan.truncate(27);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(27, reader.size());
   EXPECT_NE(builder.begin(), reader.begin());
 
   for (uint i = 0; i < 17; i++) {
     EXPECT_EQ(123, reader[i]);
     EXPECT_EQ(0, builder[i]);
   }
   for (uint i = 17; i < 27; i++) {
     EXPECT_EQ(0, reader[i]);
   }
 
   EXPECT_EQ(32, orphan2.getReader()[0]);
 }
 
 TEST(Orphans, ExtendDataFromEmpty) {
   MallocMessageBuilder message;
 
   auto orphan = message.initRoot<TestAllTypes>().disownDataField();
   orphan.truncate(3);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(3, reader.size());
 
   for (uint i = 0; i < 3; i++) {
     EXPECT_EQ(0, reader[i]);
   }
 }
 
 TEST(Orphans, TruncateText) {
   MallocMessageBuilder message;
   auto orphan = message.getOrphanage().newOrphan<Text>(17);
   auto builder = orphan.get();
   memset(builder.begin(), 'a', builder.size());
 
   EXPECT_EQ(4, message.getSegmentsForOutput()[0].size());
   orphan.truncate(2);
   EXPECT_EQ(2, message.getSegmentsForOutput()[0].size());
 
   auto reader = orphan.getReader();
   EXPECT_EQ(2, reader.size());
   EXPECT_EQ(builder.begin(), reader.begin());
 
   EXPECT_EQ('a', builder[0]);
   EXPECT_EQ('a', builder[1]);
   EXPECT_EQ('\0', builder[2]);
   EXPECT_EQ('\0', builder[3]);
   EXPECT_EQ('\0', builder[16]);
 }
 
 TEST(Orphans, ExtendText) {
   MallocMessageBuilder message;
   auto orphan = message.getOrphanage().newOrphan<Text>(17);
   auto builder = orphan.get();
   memset(builder.begin(), 'a', builder.size());
 
   EXPECT_EQ(4, message.getSegmentsForOutput()[0].size());
   orphan.truncate(27);
   EXPECT_EQ(5, message.getSegmentsForOutput()[0].size());
 
   auto reader = orphan.getReader();
   EXPECT_EQ(27, reader.size());
   EXPECT_EQ(builder.begin(), reader.begin());
 
   for (uint i = 0; i < 17; i++) {
     EXPECT_EQ('a', reader[i]);
   }
   for (uint i = 17; i < 27; i++) {
     EXPECT_EQ('\0', reader[i]);
   }
 }
 
 TEST(Orphans, ExtendTextCopy) {
   MallocMessageBuilder message;
   auto orphan = message.getOrphanage().newOrphan<Text>(17);
   auto builder = orphan.get();
   memset(builder.begin(), 'a', builder.size());
 
   auto orphan2 = message.getOrphanage().newOrphan<Data>(1);
   orphan2.get()[0] = 32;
 
   orphan.truncate(27);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(27, reader.size());
   EXPECT_NE(builder.begin(), reader.begin());
 
   for (uint i = 0; i < 17; i++) {
     EXPECT_EQ('a', reader[i]);
     EXPECT_EQ('\0', builder[i]);
   }
   for (uint i = 17; i < 27; i++) {
     EXPECT_EQ('\0', reader[i]);
   }
 
   EXPECT_EQ(32, orphan2.getReader()[0]);
 }
 
 TEST(Orphans, ExtendTextFromEmpty) {
   MallocMessageBuilder message;
 
   auto orphan = message.initRoot<TestAllTypes>().disownTextField();
   orphan.truncate(3);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(3, reader.size());
 
   for (uint i = 0; i < 3; i++) {
     EXPECT_EQ('\0', reader[i]);
   }
 }
 
 TEST(Orphans, TruncatePrimitiveList) {
   MallocMessageBuilder message;
   auto orphan = message.getOrphanage().newOrphan<List<uint32_t>>(7);
   auto builder = orphan.get();
   for (uint i = 0; i < 7; i++) {
     builder.set(i, 123456789 + i);
   }
 
   EXPECT_EQ(5, message.getSegmentsForOutput()[0].size());
   orphan.truncate(3);
   EXPECT_EQ(3, message.getSegmentsForOutput()[0].size());
 
   auto reader = orphan.getReader();
   EXPECT_EQ(3, reader.size());
 
   for (uint i = 0; i < 3; i++) {
     EXPECT_EQ(123456789 + i, builder[i]);
     EXPECT_EQ(123456789 + i, reader[i]);
   }
   for (uint i = 3; i < 7; i++) {
     EXPECT_EQ(0, builder[i]);
   }
 
   // Can't compare pointers directly, but we can check if builder modifications are visible using
   // the reader.
   builder.set(0, 321);
   EXPECT_EQ(321, reader[0]);
 }
 
 TEST(Orphans, ExtendPrimitiveList) {
   MallocMessageBuilder message;
   auto orphan = message.getOrphanage().newOrphan<List<uint32_t>>(7);
   auto builder = orphan.get();
   for (uint i = 0; i < 7; i++) {
     builder.set(i, 123456789 + i);
   }
 
   EXPECT_EQ(5, message.getSegmentsForOutput()[0].size());
   orphan.truncate(11);
   EXPECT_EQ(7, message.getSegmentsForOutput()[0].size());
 
   auto reader = orphan.getReader();
   EXPECT_EQ(11, reader.size());
 
   for (uint i = 0; i < 7; i++) {
     EXPECT_EQ(123456789 + i, reader[i]);
     EXPECT_EQ(123456789 + i, builder[i]);
   }
   for (uint i = 7; i < 11; i++) {
     EXPECT_EQ(0, reader[i]);
   }
 
   // Can't compare pointers directly, but we can check if builder modifications are visible using
   // the reader.
   builder.set(0, 321);
   EXPECT_EQ(321, reader[0]);
 }
 
 TEST(Orphans, ExtendPrimitiveListCopy) {
   MallocMessageBuilder message;
   auto orphan = message.getOrphanage().newOrphan<List<uint32_t>>(7);
   auto builder = orphan.get();
   for (uint i = 0; i < 7; i++) {
     builder.set(i, 123456789 + i);
   }
 
   auto orphan2 = message.getOrphanage().newOrphan<Data>(1);
   orphan2.get()[0] = 32;
 
   orphan.truncate(11);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(11, reader.size());
 
   for (uint i = 0; i < 7; i++) {
     EXPECT_EQ(123456789 + i, reader[i]);
     EXPECT_EQ(0, builder[i]);
   }
   for (uint i = 7; i < 11; i++) {
     EXPECT_EQ(0, reader[i]);
   }
 
   // Can't compare pointers directly, but we can check if builder modifications are visible using
   // the reader.
   builder.set(0, 321);
   EXPECT_EQ(123456789, reader[0]);
 
   EXPECT_EQ(32, orphan2.getReader()[0]);
 }
 
 TEST(Orphans, ExtendPointerListFromEmpty) {
   MallocMessageBuilder message;
 
   auto orphan = message.initRoot<TestAllTypes>().disownUInt32List();
   orphan.truncate(3);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(3, reader.size());
 
   for (uint i = 0; i < 3; i++) {
     EXPECT_EQ(0, reader[i]);
   }
 }
 
 TEST(Orphans, TruncatePointerList) {
   MallocMessageBuilder message;
 
   // Allocate data in advance so that the list itself is at the end of the segment.
   kj::Vector<Orphan<Text>> pointers(7);
   for (uint i = 0; i < 7; i++) {
     pointers.add(message.getOrphanage().newOrphanCopy(Text::Reader(kj::str("foo", i))));
   }
   size_t sizeBeforeList = message.getSegmentsForOutput()[0].size();
 
   auto orphan = message.getOrphanage().newOrphan<List<Text>>(7);
   auto builder = orphan.get();
   for (uint i = 0; i < 7; i++) {
     builder.adopt(i, kj::mv(pointers[i]));
   }
 
   EXPECT_EQ(sizeBeforeList + 7, message.getSegmentsForOutput()[0].size());
   orphan.truncate(3);
   EXPECT_EQ(sizeBeforeList + 3, message.getSegmentsForOutput()[0].size());
 
   auto reader = orphan.getReader();
   EXPECT_EQ(3, reader.size());
 
   for (uint i = 0; i < 3; i++) {
     EXPECT_EQ(kj::str("foo", i), builder[i]);
     EXPECT_EQ(kj::str("foo", i), reader[i]);
   }
   for (uint i = 3; i < 7; i++) {
     EXPECT_TRUE(builder[i] == nullptr);
   }
 
   // Can't compare pointers directly, but we can check if builder modifications are visible using
   // the reader.
   builder.set(0, "bar");
   EXPECT_EQ("bar", reader[0]);
 }
 
 TEST(Orphans, ExtendPointerList) {
   MallocMessageBuilder message;
 
   // Allocate data in advance so that the list itself is at the end of the segment.
   kj::Vector<Orphan<Text>> pointers(7);
   for (uint i = 0; i < 7; i++) {
     pointers.add(message.getOrphanage().newOrphanCopy(Text::Reader(kj::str("foo", i))));
   }
   size_t sizeBeforeList = message.getSegmentsForOutput()[0].size();
 
   auto orphan = message.getOrphanage().newOrphan<List<Text>>(7);
   auto builder = orphan.get();
   for (uint i = 0; i < 7; i++) {
     builder.adopt(i, kj::mv(pointers[i]));
   }
 
   EXPECT_EQ(sizeBeforeList + 7, message.getSegmentsForOutput()[0].size());
   orphan.truncate(11);
   EXPECT_EQ(sizeBeforeList + 11, message.getSegmentsForOutput()[0].size());
 
   auto reader = orphan.getReader();
   EXPECT_EQ(11, reader.size());
 
   for (uint i = 0; i < 7; i++) {
     EXPECT_EQ(kj::str("foo", i), reader[i]);
     EXPECT_EQ(kj::str("foo", i), builder[i]);
   }
   for (uint i = 7; i < 11; i++) {
     EXPECT_TRUE(reader[i] == nullptr);
   }
 
   // Can't compare pointers directly, but we can check if builder modifications are visible using
   // the reader.
   builder.set(0, "bar");
   EXPECT_EQ("bar", reader[0]);
 }
 
 TEST(Orphans, ExtendPointerListCopy) {
   MallocMessageBuilder message;
 
   // Allocate data in advance so that the list itself is at the end of the segment.
   kj::Vector<Orphan<Text>> pointers(7);
   for (uint i = 0; i < 7; i++) {
     pointers.add(message.getOrphanage().newOrphanCopy(Text::Reader(kj::str("foo", i))));
   }
 
   auto orphan = message.getOrphanage().newOrphan<List<Text>>(7);
   auto builder = orphan.get();
   for (uint i = 0; i < 7; i++) {
     builder.adopt(i, kj::mv(pointers[i]));
   }
 
   auto orphan2 = message.getOrphanage().newOrphan<Data>(1);
   orphan2.get()[0] = 32;
 
   orphan.truncate(11);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(11, reader.size());
 
   for (uint i = 0; i < 7; i++) {
     EXPECT_EQ(kj::str("foo", i), reader[i]);
     EXPECT_TRUE(builder[i] == nullptr);
   }
   for (uint i = 7; i < 11; i++) {
     EXPECT_TRUE(reader[i] == nullptr);
   }
 
   // Can't compare pointers directly, but we can check if builder modifications are visible using
   // the reader.
   builder.set(0, "bar");
   EXPECT_EQ("foo0", reader[0]);
 
   EXPECT_EQ(32, orphan2.getReader()[0]);
 }
 
 TEST(Orphans, ExtendPointerListFromEmpty) {
   MallocMessageBuilder message;
 
   auto orphan = message.initRoot<TestAllTypes>().disownTextList();
   orphan.truncate(3);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(3, reader.size());
 
   for (uint i = 0; i < 3; i++) {
     EXPECT_EQ("", reader[i]);
   }
 }
 
 TEST(Orphans, TruncateStructList) {
   MallocMessageBuilder message;
 
   // Allocate data in advance so that the list itself is at the end of the segment.
   kj::Vector<Orphan<TestAllTypes>> pointers(7);
   for (uint i = 0; i < 7; i++) {
     auto o = message.getOrphanage().newOrphan<TestAllTypes>();
     auto b = o.get();
     b.setUInt32Field(123456789 + i);
     b.setTextField(kj::str("foo", i));
     b.setUInt8List({123, 45});
     pointers.add(kj::mv(o));
   }
 
   auto orphan = message.getOrphanage().newOrphan<List<TestAllTypes>>(7);
   auto builder = orphan.get();
   for (uint i = 0; i < 7; i++) {
     builder.adoptWithCaveats(i, kj::mv(pointers[i]));
   }
 
   size_t sizeBeforeTruncate = message.getSegmentsForOutput()[0].size();
   orphan.truncate(3);
   EXPECT_LT(message.getSegmentsForOutput()[0].size(), sizeBeforeTruncate);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(3, reader.size());
 
   for (uint i = 0; i < 3; i++) {
     EXPECT_EQ(123456789 + i, reader[i].getUInt32Field());
     EXPECT_EQ(kj::str("foo", i), reader[i].getTextField());
     checkList(reader[i].getUInt8List(), {123, 45});
 
     EXPECT_EQ(123456789 + i, builder[i].getUInt32Field());
     EXPECT_EQ(kj::str("foo", i), builder[i].getTextField());
     checkList(builder[i].getUInt8List(), {123, 45});
   }
   for (uint i = 3; i < 7; i++) {
     checkTestMessageAllZero(builder[i]);
   }
 
   // Can't compare pointers directly, but we can check if builder modifications are visible using
   // the reader.
   builder[0].setUInt32Field(321);
   EXPECT_EQ(321, reader[0].getUInt32Field());
 }
 
 TEST(Orphans, ExtendStructList) {
   MallocMessageBuilder message;
 
   // Allocate data in advance so that the list itself is at the end of the segment.
   kj::Vector<Orphan<TestAllTypes>> pointers(7);
   for (uint i = 0; i < 7; i++) {
     auto o = message.getOrphanage().newOrphan<TestAllTypes>();
     auto b = o.get();
     b.setUInt32Field(123456789 + i);
     b.setTextField(kj::str("foo", i));
     b.setUInt8List({123, 45});
     pointers.add(kj::mv(o));
   }
 
   auto orphan = message.getOrphanage().newOrphan<List<TestAllTypes>>(7);
   auto builder = orphan.get();
   for (uint i = 0; i < 7; i++) {
     builder.adoptWithCaveats(i, kj::mv(pointers[i]));
   }
 
   orphan.truncate(11);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(11, reader.size());
 
   for (uint i = 0; i < 7; i++) {
     EXPECT_EQ(123456789 + i, reader[i].getUInt32Field());
     EXPECT_EQ(kj::str("foo", i), reader[i].getTextField());
     checkList(reader[i].getUInt8List(), {123, 45});
 
     EXPECT_EQ(123456789 + i, builder[i].getUInt32Field());
     EXPECT_EQ(kj::str("foo", i), builder[i].getTextField());
     checkList(builder[i].getUInt8List(), {123, 45});
   }
   for (uint i = 7; i < 11; i++) {
     checkTestMessageAllZero(reader[i]);
   }
 
   // Can't compare pointers directly, but we can check if builder modifications are visible using
   // the reader.
   builder[0].setUInt32Field(321);
   EXPECT_EQ(321, reader[0].getUInt32Field());
 }
 
 TEST(Orphans, ExtendStructListCopy) {
   MallocMessageBuilder message;
 
   // Allocate data in advance so that the list itself is at the end of the segment.
   kj::Vector<Orphan<TestAllTypes>> pointers(7);
   for (uint i = 0; i < 7; i++) {
     auto o = message.getOrphanage().newOrphan<TestAllTypes>();
     auto b = o.get();
     b.setUInt32Field(123456789 + i);
     b.setTextField(kj::str("foo", i));
     b.setUInt8List({123, 45});
     pointers.add(kj::mv(o));
   }
 
   auto orphan = message.getOrphanage().newOrphan<List<TestAllTypes>>(7);
   auto builder = orphan.get();
   for (uint i = 0; i < 7; i++) {
     builder.adoptWithCaveats(i, kj::mv(pointers[i]));
   }
 
   auto orphan2 = message.getOrphanage().newOrphan<Data>(1);
   orphan2.get()[0] = 32;
 
   orphan.truncate(11);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(11, reader.size());
 
   for (uint i = 0; i < 7; i++) {
     EXPECT_EQ(123456789 + i, reader[i].getUInt32Field());
     EXPECT_EQ(kj::str("foo", i), reader[i].getTextField());
     checkList(reader[i].getUInt8List(), {123, 45});
 
     checkTestMessageAllZero(builder[i]);
   }
   for (uint i = 7; i < 11; i++) {
     checkTestMessageAllZero(reader[i]);
   }
 
   // Can't compare pointers directly, but we can check if builder modifications are visible using
   // the reader.
   builder[0].setUInt32Field(321);
   EXPECT_EQ(123456789, reader[0].getUInt32Field());
 
   EXPECT_EQ(32, orphan2.getReader()[0]);
 }
 
 TEST(Orphans, ExtendStructListFromEmpty) {
   MallocMessageBuilder message;
 
   auto orphan = message.initRoot<TestAllTypes>().disownStructList();
   orphan.truncate(3);
 
   auto reader = orphan.getReader();
   EXPECT_EQ(3, reader.size());
 
   for (uint i = 0; i < 3; i++) {
     checkTestMessageAllZero(reader[i]);
   }
 }
 
 template <typename ListBuilder>
 void initList(ListBuilder builder,
     std::initializer_list<ReaderFor<ListElementType<FromBuilder<ListBuilder>>>> values) {
   KJ_ASSERT(builder.size() == values.size());
   size_t i = 0;
   for (auto& value: values) {
     builder.set(i++, value);
   }
 }
 
 TEST(Orphans, ConcatenatePrimitiveLists) {
   MallocMessageBuilder message;
   auto orphanage = message.getOrphanage();
 
   auto list1 = orphanage.newOrphan<List<uint32_t>>(3);
   initList(list1.get(), {12, 34, 56});
 
   auto list2 = orphanage.newOrphan<List<uint32_t>>(2);
   initList(list2.get(), {78, 90});
 
   auto list3 = orphanage.newOrphan<List<uint32_t>>(4);
   initList(list3.get(), {23, 45, 67, 89});
 
   List<uint32_t>::Reader lists[] = { list1.getReader(), list2.getReader(), list3.getReader() };
   kj::ArrayPtr<List<uint32_t>::Reader> array = lists;
 
   auto cat = message.getOrphanage().newOrphanConcat(array);
 
   checkList(cat.getReader(), {12, 34, 56, 78, 90, 23, 45, 67, 89});
 }
 
 TEST(Orphans, ConcatenateBitLists) {
   MallocMessageBuilder message;
   auto orphanage = message.getOrphanage();
 
   auto list1 = orphanage.newOrphan<List<bool>>(3);
   initList(list1.get(), {true, true, false});
 
   auto list2 = orphanage.newOrphan<List<bool>>(2);
   initList(list2.get(), {false, true});
 
   auto list3 = orphanage.newOrphan<List<bool>>(4);
   initList(list3.get(), {false, false, true, false});
 
   List<bool>::Reader lists[] = { list1.getReader(), list2.getReader(), list3.getReader() };
   kj::ArrayPtr<List<bool>::Reader> array = lists;
 
   auto cat = message.getOrphanage().newOrphanConcat(array);
 
   checkList(cat.getReader(), {true, true, false, false, true, false, false, true, false});
 }
 
 TEST(Orphans, ConcatenatePointerLists) {
   MallocMessageBuilder message;
   auto orphanage = message.getOrphanage();
 
   auto list1 = orphanage.newOrphan<List<Text>>(3);
   initList(list1.get(), {"foo", "bar", "baz"});
 
   auto list2 = orphanage.newOrphan<List<Text>>(2);
   initList(list2.get(), {"qux", "corge"});
 
   auto list3 = orphanage.newOrphan<List<Text>>(4);
   initList(list3.get(), {"grault", "garply", "waldo", "fred"});
 
   List<Text>::Reader lists[] = { list1.getReader(), list2.getReader(), list3.getReader() };
   kj::ArrayPtr<List<Text>::Reader> array = lists;
 
   auto cat = message.getOrphanage().newOrphanConcat(array);
 
   checkList(cat.getReader(), {
       "foo", "bar", "baz", "qux", "corge", "grault", "garply", "waldo", "fred"});
 }
 
 TEST(Orphans, ConcatenateStructLists) {
   // In this test, we not only concatenate two struct lists, but we concatenate in a list that
   // contains a newer-than-expected version of the struct with extra fields, in order to verify
   // that the new fields aren't lost.
 
   MallocMessageBuilder message;
   auto orphanage = message.getOrphanage();
 
   auto orphan1 = orphanage.newOrphan<List<test::TestOldVersion>>(2);
   auto list1 = orphan1.get();
   list1[0].setOld1(12);
   list1[0].setOld2("foo");
   list1[1].setOld1(34);
   list1[1].setOld2("bar");
 
   auto orphan2 = orphanage.newOrphan<test::TestAnyPointer>();
   auto list2 = orphan2.get().getAnyPointerField().initAs<List<test::TestNewVersion>>(2);
   list2[0].setOld1(56);
   list2[0].setOld2("baz");
   list2[0].setNew1(123);
   list2[0].setNew2("corge");
   list2[1].setOld1(78);
   list2[1].setOld2("qux");
   list2[1].setNew1(456);
   list2[1].setNew2("grault");
 
   List<test::TestOldVersion>::Reader lists[] = {
     orphan1.getReader(),
     orphan2.getReader().getAnyPointerField().getAs<List<test::TestOldVersion>>()
   };
   kj::ArrayPtr<List<test::TestOldVersion>::Reader> array = lists;
 
   auto orphan3 = orphanage.newOrphan<test::TestAnyPointer>();
   orphan3.get().getAnyPointerField().adopt(message.getOrphanage().newOrphanConcat(array));
 
   auto cat = orphan3.getReader().getAnyPointerField().getAs<List<test::TestNewVersion>>();
   ASSERT_EQ(4, cat.size());
 
   EXPECT_EQ(12, cat[0].getOld1());
   EXPECT_EQ("foo", cat[0].getOld2());
   EXPECT_EQ(987, cat[0].getNew1());
   EXPECT_FALSE(cat[0].hasNew2());
 
   EXPECT_EQ(34, cat[1].getOld1());
   EXPECT_EQ("bar", cat[1].getOld2());
   EXPECT_EQ(987, cat[1].getNew1());
   EXPECT_FALSE(cat[1].hasNew2());
 
   EXPECT_EQ(56, cat[2].getOld1());
   EXPECT_EQ("baz", cat[2].getOld2());
   EXPECT_EQ(123, cat[2].getNew1());
   EXPECT_EQ("corge", cat[2].getNew2());
 
   EXPECT_EQ(78, cat[3].getOld1());
   EXPECT_EQ("qux", cat[3].getOld2());
   EXPECT_EQ(456, cat[3].getNew1());
   EXPECT_EQ("grault", cat[3].getNew2());
 }
 
 TEST(Orphans, ConcatenateStructListsUpgradeFromPrimitive) {
   // Like above, but we're "upgrading" a primitive list to a struct list.
 
   MallocMessageBuilder message;
   auto orphanage = message.getOrphanage();
 
   auto orphan1 = orphanage.newOrphan<List<test::TestOldVersion>>(2);
   auto list1 = orphan1.get();
   list1[0].setOld1(12);
   list1[0].setOld2("foo");
   list1[1].setOld1(34);
   list1[1].setOld2("bar");
 
   auto orphan2 = orphanage.newOrphan<test::TestAnyPointer>();
   auto list2 = orphan2.get().getAnyPointerField().initAs<List<uint64_t>>(2);
   initList(list2, {12345, 67890});
 
   List<test::TestOldVersion>::Reader lists[] = {
     orphan1.getReader(),
     orphan2.getReader().getAnyPointerField().getAs<List<test::TestOldVersion>>()
   };
   kj::ArrayPtr<List<test::TestOldVersion>::Reader> array = lists;
 
   auto orphan3 = message.getOrphanage().newOrphanConcat(array);
   auto cat = orphan3.getReader();
   ASSERT_EQ(4, cat.size());
 
   EXPECT_EQ(12, cat[0].getOld1());
   EXPECT_EQ("foo", cat[0].getOld2());
 
   EXPECT_EQ(34, cat[1].getOld1());
   EXPECT_EQ("bar", cat[1].getOld2());
 
   EXPECT_EQ(12345, cat[2].getOld1());
   EXPECT_FALSE(cat[2].hasOld2());
 
   EXPECT_EQ(67890, cat[3].getOld1());
   EXPECT_FALSE(cat[3].hasOld2());
 }
 
 }  // namespace
 }  // namespace _ (private)
 }  // namespace capnp