Squashed 'third_party/flatbuffers/' content from commit acc9990ab
Change-Id: I48550d40d78fea996ebe74e9723a5d1f910de491
git-subtree-dir: third_party/flatbuffers
git-subtree-split: acc9990abd2206491480291b0f85f925110102ea
diff --git a/dart/test/flat_buffers_test.dart b/dart/test/flat_buffers_test.dart
new file mode 100644
index 0000000..f9c5e01
--- /dev/null
+++ b/dart/test/flat_buffers_test.dart
@@ -0,0 +1,573 @@
+// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:typed_data';
+import 'dart:io' as io;
+
+import 'package:path/path.dart' as path;
+
+import 'package:flat_buffers/flat_buffers.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import './monster_test_my_game.example_generated.dart' as example;
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(BuilderTest);
+ defineReflectiveTests(CheckOtherLangaugesData);
+ });
+}
+
+int indexToField(int index) {
+ return (1 + 1 + index) * 2;
+}
+
+@reflectiveTest
+class CheckOtherLangaugesData {
+ test_cppData() async {
+ List<int> data = await new io.File(path.join(
+ path.dirname(io.Platform.script.path),
+ 'monsterdata_test.mon',
+ ))
+ .readAsBytes();
+ example.Monster mon = new example.Monster(data);
+ expect(mon.hp, 80);
+ expect(mon.mana, 150);
+ expect(mon.name, 'MyMonster');
+ expect(mon.pos.x, 1.0);
+ expect(mon.pos.y, 2.0);
+ expect(mon.pos.z, 3.0);
+ expect(mon.pos.test1, 3.0);
+ expect(mon.pos.test2.value, 2.0);
+ expect(mon.pos.test3.a, 5);
+ expect(mon.pos.test3.b, 6);
+ expect(mon.testType.value, example.AnyTypeId.Monster.value);
+ expect(mon.test is example.Monster, true);
+ final monster2 = mon.test as example.Monster;
+ expect(monster2.name, "Fred");
+
+ expect(mon.inventory.length, 5);
+ expect(mon.inventory.reduce((cur, next) => cur + next), 10);
+ expect(mon.test4.length, 2);
+ expect(
+ mon.test4[0].a + mon.test4[0].b + mon.test4[1].a + mon.test4[1].b, 100);
+ expect(mon.testarrayofstring.length, 2);
+ expect(mon.testarrayofstring[0], "test1");
+ expect(mon.testarrayofstring[1], "test2");
+
+ // this will fail if accessing any field fails.
+ expect(mon.toString(),
+ 'Monster{pos: Vec3{x: 1.0, y: 2.0, z: 3.0, test1: 3.0, test2: Color{value: 2}, test3: Test{a: 5, b: 6}}, mana: 150, hp: 80, name: MyMonster, inventory: [0, 1, 2, 3, 4], color: Color{value: 8}, testType: AnyTypeId{value: 1}, test: Monster{pos: null, mana: 150, hp: 100, name: Fred, inventory: null, color: Color{value: 8}, testType: AnyTypeId{value: 0}, test: null, test4: null, testarrayofstring: null, testarrayoftables: null, enemy: null, testnestedflatbuffer: null, testempty: null, testbool: false, testhashs32Fnv1: 0, testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, testf2: 3.0, testf3: 0.0, testarrayofstring2: null, testarrayofsortedstruct: null, flex: null, test5: null, vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, vectorOfReferrables: null, singleWeakReference: 0, vectorOfWeakReferences: null, vectorOfStrongReferrables: null, coOwningReference: 0, vectorOfCoOwningReferences: null, nonOwningReference: 0, vectorOfNonOwningReferences: null}, test4: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], testarrayofstring: [test1, test2], testarrayoftables: null, enemy: Monster{pos: null, mana: 150, hp: 100, name: Fred, inventory: null, color: Color{value: 8}, testType: AnyTypeId{value: 0}, test: null, test4: null, testarrayofstring: null, testarrayoftables: null, enemy: null, testnestedflatbuffer: null, testempty: null, testbool: false, testhashs32Fnv1: 0, testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, testf2: 3.0, testf3: 0.0, testarrayofstring2: null, testarrayofsortedstruct: null, flex: null, test5: null, vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, vectorOfReferrables: null, singleWeakReference: 0, vectorOfWeakReferences: null, vectorOfStrongReferrables: null, coOwningReference: 0, vectorOfCoOwningReferences: null, nonOwningReference: 0, vectorOfNonOwningReferences: null}, testnestedflatbuffer: null, testempty: null, testbool: false, testhashs32Fnv1: -579221183, testhashu32Fnv1: 3715746113, testhashs64Fnv1: 7930699090847568257, testhashu64Fnv1: 7930699090847568257, testhashs32Fnv1a: -1904106383, testhashu32Fnv1a: 2390860913, testhashs64Fnv1a: 4898026182817603057, testhashu64Fnv1a: 4898026182817603057, testarrayofbools: [true, false, true], testf: 3.14159, testf2: 3.0, testf3: 0.0, testarrayofstring2: null, testarrayofsortedstruct: null, flex: null, test5: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], vectorOfLongs: [1, 100, 10000, 1000000, 100000000], vectorOfDoubles: [-1.7976931348623157e+308, 0.0, 1.7976931348623157e+308], parentNamespaceTest: null, vectorOfReferrables: null, singleWeakReference: 0, vectorOfWeakReferences: null, vectorOfStrongReferrables: null, coOwningReference: 0, vectorOfCoOwningReferences: null, nonOwningReference: 0, vectorOfNonOwningReferences: null}');
+ }
+}
+
+@reflectiveTest
+class BuilderTest {
+ void test_monsterBuilder() {
+ final fbBuilder = new Builder();
+ final str = fbBuilder.writeString('MyMonster');
+
+ fbBuilder.writeString('test1');
+ fbBuilder.writeString('test2');
+ final testArrayOfString = fbBuilder.endStructVector(2);
+
+ final fred = fbBuilder.writeString('Fred');
+
+ final List<int> treasure = [0, 1, 2, 3, 4];
+ final inventory = fbBuilder.writeListUint8(treasure);
+
+ final monBuilder = new example.MonsterBuilder(fbBuilder)
+ ..begin()
+ ..addNameOffset(fred);
+ final mon2 = monBuilder.finish();
+
+ final testBuilder = new example.TestBuilder(fbBuilder);
+ testBuilder.finish(10, 20);
+ testBuilder.finish(30, 40);
+ final test4 = fbBuilder.endStructVector(2);
+
+
+ monBuilder
+ ..begin()
+ ..addPos(
+ new example.Vec3Builder(fbBuilder).finish(
+ 1.0,
+ 2.0,
+ 3.0,
+ 3.0,
+ example.Color.Green,
+ () => testBuilder.finish(5, 6),
+ ),
+ )
+ ..addHp(80)
+ ..addNameOffset(str)
+ ..addInventoryOffset(inventory)
+ ..addTestType(example.AnyTypeId.Monster)
+ ..addTestOffset(mon2)
+ ..addTest4Offset(test4)
+ ..addTestarrayofstringOffset(testArrayOfString);
+ final mon = monBuilder.finish();
+ fbBuilder.finish(mon);
+ }
+
+ void test_error_addInt32_withoutStartTable() {
+ Builder builder = new Builder();
+ expect(() {
+ builder.addInt32(0, 0);
+ }, throwsStateError);
+ }
+
+ void test_error_addOffset_withoutStartTable() {
+ Builder builder = new Builder();
+ expect(() {
+ builder.addOffset(0, 0);
+ }, throwsStateError);
+ }
+
+ void test_error_endTable_withoutStartTable() {
+ Builder builder = new Builder();
+ expect(() {
+ builder.endTable();
+ }, throwsStateError);
+ }
+
+ void test_error_startTable_duringTable() {
+ Builder builder = new Builder();
+ builder.startTable();
+ expect(() {
+ builder.startTable();
+ }, throwsStateError);
+ }
+
+ void test_error_writeString_duringTable() {
+ Builder builder = new Builder();
+ builder.startTable();
+ expect(() {
+ builder.writeString('12345');
+ }, throwsStateError);
+ }
+
+ void test_file_identifier() {
+ Uint8List byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ builder.startTable();
+ int offset = builder.endTable();
+ byteList = builder.finish(offset, 'Az~ÿ');
+ }
+ // Convert byteList to a ByteData so that we can read data from it.
+ ByteData byteData = byteList.buffer.asByteData(byteList.offsetInBytes);
+ // First 4 bytes are an offset to the table data.
+ int tableDataLoc = byteData.getUint32(0, Endian.little);
+ // Next 4 bytes are the file identifier.
+ expect(byteData.getUint8(4), 65); // 'a'
+ expect(byteData.getUint8(5), 122); // 'z'
+ expect(byteData.getUint8(6), 126); // '~'
+ expect(byteData.getUint8(7), 255); // 'ÿ'
+ // First 4 bytes of the table data are a backwards offset to the vtable.
+ int vTableLoc = tableDataLoc -
+ byteData.getInt32(tableDataLoc, Endian.little);
+ // First 2 bytes of the vtable are the size of the vtable in bytes, which
+ // should be 4.
+ expect(byteData.getUint16(vTableLoc, Endian.little), 4);
+ // Next 2 bytes are the size of the object in bytes (including the vtable
+ // pointer), which should be 4.
+ expect(byteData.getUint16(vTableLoc + 2, Endian.little), 4);
+ }
+
+ void test_low() {
+ Builder builder = new Builder(initialSize: 0);
+ expect((builder..putUint8(1)).lowFinish(), [1]);
+ expect((builder..putUint32(2)).lowFinish(), [2, 0, 0, 0, 0, 0, 0, 1]);
+ expect((builder..putUint8(3)).lowFinish(),
+ [0, 0, 0, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
+ expect((builder..putUint8(4)).lowFinish(),
+ [0, 0, 4, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
+ expect((builder..putUint8(5)).lowFinish(),
+ [0, 5, 4, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
+ expect((builder..putUint32(6)).lowFinish(),
+ [6, 0, 0, 0, 0, 5, 4, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
+ }
+
+ void test_table_default() {
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ builder.startTable();
+ builder.addInt32(0, 10, 10);
+ builder.addInt32(1, 20, 10);
+ int offset = builder.endTable();
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buffer = new BufferContext.fromBytes(byteList);
+ int objectOffset = buffer.derefObject(0);
+ // was not written, so uses the new default value
+ expect(
+ const Int32Reader()
+ .vTableGet(buffer, objectOffset, indexToField(0), 15),
+ 15);
+ // has the written value
+ expect(
+ const Int32Reader()
+ .vTableGet(buffer, objectOffset, indexToField(1), 15),
+ 20);
+ }
+
+ void test_table_format() {
+ Uint8List byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ builder.startTable();
+ builder.addInt32(0, 10);
+ builder.addInt32(1, 20);
+ builder.addInt32(2, 30);
+ byteList = builder.finish(builder.endTable());
+ }
+ // Convert byteList to a ByteData so that we can read data from it.
+ ByteData byteData = byteList.buffer.asByteData(byteList.offsetInBytes);
+ // First 4 bytes are an offset to the table data.
+ int tableDataLoc = byteData.getUint32(0, Endian.little);
+ // First 4 bytes of the table data are a backwards offset to the vtable.
+ int vTableLoc = tableDataLoc -
+ byteData.getInt32(tableDataLoc, Endian.little);
+ // First 2 bytes of the vtable are the size of the vtable in bytes, which
+ // should be 10.
+ expect(byteData.getUint16(vTableLoc, Endian.little), 10);
+ // Next 2 bytes are the size of the object in bytes (including the vtable
+ // pointer), which should be 16.
+ expect(byteData.getUint16(vTableLoc + 2, Endian.little), 16);
+ // Remaining 6 bytes are the offsets within the object where the ints are
+ // located.
+ for (int i = 0; i < 3; i++) {
+ int offset =
+ byteData.getUint16(vTableLoc + 4 + 2 * i, Endian.little);
+ expect(byteData.getInt32(tableDataLoc + offset, Endian.little),
+ 10 + 10 * i);
+ }
+ }
+
+ void test_table_string() {
+ String latinString = 'test';
+ String unicodeString = 'Проба пера';
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ int latinStringOffset = builder.writeString(latinString);
+ int unicodeStringOffset = builder.writeString(unicodeString);
+ builder.startTable();
+ builder.addOffset(0, latinStringOffset);
+ builder.addOffset(1, unicodeStringOffset);
+ int offset = builder.endTable();
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ int objectOffset = buf.derefObject(0);
+ expect(const StringReader().vTableGet(buf, objectOffset, indexToField(0)),
+ latinString);
+ expect(const StringReader().vTableGet(buf, objectOffset, indexToField(1)),
+ unicodeString);
+ }
+
+ void test_table_types() {
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ int stringOffset = builder.writeString('12345');
+ builder.startTable();
+ builder.addBool(0, true);
+ builder.addInt8(1, 10);
+ builder.addInt32(2, 20);
+ builder.addOffset(3, stringOffset);
+ builder.addInt32(4, 40);
+ builder.addUint32(5, 0x9ABCDEF0);
+ builder.addUint8(6, 0x9A);
+ int offset = builder.endTable();
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ int objectOffset = buf.derefObject(0);
+ expect(
+ const BoolReader().vTableGet(buf, objectOffset, indexToField(0)), true);
+ expect(
+ const Int8Reader().vTableGet(buf, objectOffset, indexToField(1)), 10);
+ expect(
+ const Int32Reader().vTableGet(buf, objectOffset, indexToField(2)), 20);
+ expect(const StringReader().vTableGet(buf, objectOffset, indexToField(3)),
+ '12345');
+ expect(
+ const Int32Reader().vTableGet(buf, objectOffset, indexToField(4)), 40);
+ expect(const Uint32Reader().vTableGet(buf, objectOffset, indexToField(5)),
+ 0x9ABCDEF0);
+ expect(const Uint8Reader().vTableGet(buf, objectOffset, indexToField(6)),
+ 0x9A);
+ }
+
+ void test_writeList_of_Uint32() {
+ List<int> values = <int>[10, 100, 12345, 0x9abcdef0];
+ // write
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ int offset = builder.writeListUint32(values);
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ List<int> items = const Uint32ListReader().read(buf, 0);
+ expect(items, hasLength(4));
+ expect(items, orderedEquals(values));
+ }
+
+ void test_writeList_ofBool() {
+ void verifyListBooleans(int len, List<int> trueBits) {
+ // write
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ List<bool> values = new List<bool>.filled(len, false);
+ for (int bit in trueBits) {
+ values[bit] = true;
+ }
+ int offset = builder.writeListBool(values);
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ List<bool> items = const BoolListReader().read(buf, 0);
+ expect(items, hasLength(len));
+ for (int i = 0; i < items.length; i++) {
+ expect(items[i], trueBits.contains(i), reason: 'bit $i of $len');
+ }
+ }
+
+ verifyListBooleans(0, <int>[]);
+ verifyListBooleans(1, <int>[]);
+ verifyListBooleans(1, <int>[0]);
+ verifyListBooleans(31, <int>[0, 1]);
+ verifyListBooleans(31, <int>[1, 2, 24, 25, 30]);
+ verifyListBooleans(31, <int>[0, 30]);
+ verifyListBooleans(32, <int>[1, 2, 24, 25, 31]);
+ verifyListBooleans(33, <int>[1, 2, 24, 25, 32]);
+ verifyListBooleans(33, <int>[1, 2, 24, 25, 31, 32]);
+ verifyListBooleans(63, <int>[]);
+ verifyListBooleans(63, <int>[0, 1, 2, 61, 62]);
+ verifyListBooleans(63, new List<int>.generate(63, (i) => i));
+ verifyListBooleans(64, <int>[]);
+ verifyListBooleans(64, <int>[0, 1, 2, 61, 62, 63]);
+ verifyListBooleans(64, <int>[1, 2, 62]);
+ verifyListBooleans(64, <int>[0, 1, 2, 63]);
+ verifyListBooleans(64, new List<int>.generate(64, (i) => i));
+ verifyListBooleans(100, <int>[0, 3, 30, 60, 90, 99]);
+ }
+
+ void test_writeList_ofInt32() {
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ int offset = builder.writeListInt32(<int>[1, 2, 3, 4, 5]);
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ List<int> items = const ListReader<int>(const Int32Reader()).read(buf, 0);
+ expect(items, hasLength(5));
+ expect(items, orderedEquals(<int>[1, 2, 3, 4, 5]));
+ }
+
+ void test_writeList_ofFloat64() {
+ List<double> values = <double>[-1.234567, 3.4E+9, -5.6E-13, 7.8, 12.13];
+ // write
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ int offset = builder.writeListFloat64(values);
+ byteList = builder.finish(offset);
+ }
+
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ List<double> items = const Float64ListReader().read(buf, 0);
+
+ expect(items, hasLength(values.length));
+ for (int i = 0; i < values.length; i++) {
+ expect(values[i], closeTo(items[i], .001));
+ }
+ }
+
+ void test_writeList_ofFloat32() {
+ List<double> values = [1.0, 2.23, -3.213, 7.8, 12.13];
+ // write
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ int offset = builder.writeListFloat32(values);
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ List<double> items = const Float32ListReader().read(buf, 0);
+ expect(items, hasLength(5));
+ for (int i = 0; i < values.length; i++) {
+ expect(values[i], closeTo(items[i], .001));
+ }
+ }
+
+ void test_writeList_ofObjects() {
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ // write the object #1
+ int object1;
+ {
+ builder.startTable();
+ builder.addInt32(0, 10);
+ builder.addInt32(1, 20);
+ object1 = builder.endTable();
+ }
+ // write the object #1
+ int object2;
+ {
+ builder.startTable();
+ builder.addInt32(0, 100);
+ builder.addInt32(1, 200);
+ object2 = builder.endTable();
+ }
+ // write the list
+ int offset = builder.writeList([object1, object2]);
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ List<TestPointImpl> items =
+ const ListReader<TestPointImpl>(const TestPointReader()).read(buf, 0);
+ expect(items, hasLength(2));
+ expect(items[0].x, 10);
+ expect(items[0].y, 20);
+ expect(items[1].x, 100);
+ expect(items[1].y, 200);
+ }
+
+ void test_writeList_ofStrings_asRoot() {
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ int str1 = builder.writeString('12345');
+ int str2 = builder.writeString('ABC');
+ int offset = builder.writeList([str1, str2]);
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ List<String> items =
+ const ListReader<String>(const StringReader()).read(buf, 0);
+ expect(items, hasLength(2));
+ expect(items, contains('12345'));
+ expect(items, contains('ABC'));
+ }
+
+ void test_writeList_ofStrings_inObject() {
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ int listOffset = builder.writeList(
+ [builder.writeString('12345'), builder.writeString('ABC')]);
+ builder.startTable();
+ builder.addOffset(0, listOffset);
+ int offset = builder.endTable();
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ StringListWrapperImpl reader = new StringListWrapperReader().read(buf, 0);
+ List<String> items = reader.items;
+ expect(items, hasLength(2));
+ expect(items, contains('12345'));
+ expect(items, contains('ABC'));
+ }
+
+ void test_writeList_ofUint32() {
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ int offset = builder.writeListUint32(<int>[1, 2, 0x9ABCDEF0]);
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ List<int> items = const Uint32ListReader().read(buf, 0);
+ expect(items, hasLength(3));
+ expect(items, orderedEquals(<int>[1, 2, 0x9ABCDEF0]));
+ }
+
+ void test_writeList_ofUint16() {
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ int offset = builder.writeListUint16(<int>[1, 2, 60000]);
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ List<int> items = const Uint16ListReader().read(buf, 0);
+ expect(items, hasLength(3));
+ expect(items, orderedEquals(<int>[1, 2, 60000]));
+ }
+
+ void test_writeList_ofUint8() {
+ List<int> byteList;
+ {
+ Builder builder = new Builder(initialSize: 0);
+ int offset = builder.writeListUint8(<int>[1, 2, 3, 4, 0x9A]);
+ byteList = builder.finish(offset);
+ }
+ // read and verify
+ BufferContext buf = new BufferContext.fromBytes(byteList);
+ List<int> items = const Uint8ListReader().read(buf, 0);
+ expect(items, hasLength(5));
+ expect(items, orderedEquals(<int>[1, 2, 3, 4, 0x9A]));
+ }
+}
+
+class StringListWrapperImpl {
+ final BufferContext bp;
+ final int offset;
+
+ StringListWrapperImpl(this.bp, this.offset);
+
+ List<String> get items => const ListReader<String>(const StringReader())
+ .vTableGet(bp, offset, indexToField(0));
+}
+
+class StringListWrapperReader extends TableReader<StringListWrapperImpl> {
+ const StringListWrapperReader();
+
+ @override
+ StringListWrapperImpl createObject(BufferContext object, int offset) {
+ return new StringListWrapperImpl(object, offset);
+ }
+}
+
+class TestPointImpl {
+ final BufferContext bp;
+ final int offset;
+
+ TestPointImpl(this.bp, this.offset);
+
+ int get x => const Int32Reader().vTableGet(bp, offset, indexToField(0), 0);
+
+ int get y => const Int32Reader().vTableGet(bp, offset, indexToField(1), 0);
+}
+
+class TestPointReader extends TableReader<TestPointImpl> {
+ const TestPointReader();
+
+ @override
+ TestPointImpl createObject(BufferContext object, int offset) {
+ return new TestPointImpl(object, offset);
+ }
+}