public void TypeModel_StructsWithPadding() { // inner strut is float + double + bool = 4x float + 4x padding + 8x double + 1 bool = 17. // outer struct is inner + double + bool = 17x inner + 7x padding + 8x double + 1x bool = 33 Type type = typeof(GenericStruct <GenericStruct <float> >); RuntimeTypeModel typeModel = RuntimeTypeModel.CreateFrom(type); Assert.AreEqual(typeModel.ClrType, type); Assert.AreEqual(FlatBufferSchemaType.Struct, typeModel.SchemaType); var structModel = (StructTypeModel)typeModel; Assert.AreEqual(3, structModel.Members.Count); Assert.AreEqual(FlatBufferSchemaType.Struct, structModel.Members[0].ItemTypeModel.SchemaType); Assert.AreEqual(0, structModel.Members[0].Index); Assert.AreEqual(0, structModel.Members[0].Offset); Assert.AreEqual(8, structModel.Members[0].ItemTypeModel.Alignment); Assert.AreEqual(17, structModel.Members[0].ItemTypeModel.InlineSize); Assert.AreEqual(FlatBufferSchemaType.Scalar, structModel.Members[1].ItemTypeModel.SchemaType); Assert.AreEqual(1, structModel.Members[1].Index); Assert.AreEqual(24, structModel.Members[1].Offset); Assert.AreEqual(8, structModel.Members[1].ItemTypeModel.Alignment); Assert.AreEqual(8, structModel.Members[1].ItemTypeModel.InlineSize); Assert.AreEqual(FlatBufferSchemaType.Scalar, structModel.Members[2].ItemTypeModel.SchemaType); Assert.AreEqual(2, structModel.Members[2].Index); Assert.AreEqual(32, structModel.Members[2].Offset); Assert.AreEqual(1, structModel.Members[2].ItemTypeModel.Alignment); Assert.AreEqual(1, structModel.Members[2].ItemTypeModel.InlineSize); Assert.AreEqual(33, structModel.InlineSize); Assert.AreEqual(8, structModel.Alignment); }
public void TypeModel_StructsWithPadding() { // inner strut is float + double + bool = 4x float + 4x padding + 8x double + 1 bool = 17. // outer struct is inner + double + bool = 17x inner + 7x padding + 8x double + 1x bool = 33 Type type = typeof(GenericStruct <GenericStruct <float> >); var typeModel = RuntimeTypeModel.CreateFrom(type); Assert.AreEqual(typeModel.ClrType, type); Assert.IsInstanceOfType(typeModel, typeof(StructTypeModel)); var structModel = (StructTypeModel)typeModel; Assert.AreEqual(3, structModel.Members.Count); Assert.IsInstanceOfType(structModel.Members[0].ItemTypeModel, typeof(StructTypeModel)); Assert.AreEqual(0, structModel.Members[0].Index); Assert.AreEqual(0, structModel.Members[0].Offset); Assert.AreEqual(8, structModel.Members[0].ItemTypeModel.PhysicalLayout.Single().Alignment); Assert.AreEqual(17, structModel.Members[0].ItemTypeModel.PhysicalLayout.Single().InlineSize); Assert.IsInstanceOfType(structModel.Members[1].ItemTypeModel, typeof(ScalarTypeModel)); Assert.AreEqual(1, structModel.Members[1].Index); Assert.AreEqual(24, structModel.Members[1].Offset); Assert.AreEqual(8, structModel.Members[1].ItemTypeModel.PhysicalLayout.Single().Alignment); Assert.AreEqual(8, structModel.Members[1].ItemTypeModel.PhysicalLayout.Single().InlineSize); Assert.IsInstanceOfType(structModel.Members[2].ItemTypeModel, typeof(ScalarTypeModel)); Assert.AreEqual(2, structModel.Members[2].Index); Assert.AreEqual(32, structModel.Members[2].Offset); Assert.AreEqual(1, structModel.Members[2].ItemTypeModel.PhysicalLayout.Single().Alignment); Assert.AreEqual(1, structModel.Members[2].ItemTypeModel.PhysicalLayout.Single().InlineSize); Assert.AreEqual(33, structModel.PhysicalLayout.Single().InlineSize); Assert.AreEqual(8, structModel.PhysicalLayout.Single().Alignment); }
private void ImplementMethod(Type type) { var typeModel = RuntimeTypeModel.CreateFrom(type); if (typeModel is TableTypeModel tableModel) { this.ImplementTableGetMaxSizeMethod(tableModel); } else if (typeModel is StructTypeModel structModel) { this.ImplementStructGetMaxSizeMethod(structModel); } else if (typeModel is VectorTypeModel vectorModel) { this.ImplementVectorGetMaxSizeMethod(vectorModel); } else if (typeModel is UnionTypeModel unionModel) { this.ImplementUnionGetMaxSizeMethod(unionModel); } else if (typeModel is EnumTypeModel enumModel) { this.ImplementEnumGetMaxSizeMethod(enumModel); } else { throw new InvalidOperationException(); } }
public void TypeModel_Enum_NullableTaggedEnum() { var model = RuntimeTypeModel.CreateFrom(typeof(TaggedEnum?)); Assert.IsTrue(model is NullableEnumTypeModel enumModel); Assert.AreEqual(typeof(TaggedEnum?), model.ClrType); Assert.IsTrue(model.IsFixedSize); }
public void TypeModel_Union_StringAndSharedStringNotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(FlatBufferUnion <string, SharedString>))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(FlatBufferUnion <string, GenericTable <string>, SharedString>))); }
// TODO: [InlineData(typeof(WriteThroughTable_NotRequired<ValueStruct[]>))] public void WriteThrough_Table_VectorOfDisallowed(Type type) { var ex = Assert.Throws <InvalidFlatBufferDefinitionException>( () => RuntimeTypeModel.CreateFrom(type)); Assert.Equal( $"Table property '{type.GetCompilableTypeName()}.Item' declared the WriteThrough on a vector. Vector WriteThrough is only valid for value type structs.", ex.Message); }
public void WriteThrough_Table_RequiredStructField(Type type) { type = typeof(WriteThroughTable_Required <>).MakeGenericType(type); var typeModel = RuntimeTypeModel.CreateFrom(type); Assert.True(((TableTypeModel)typeModel).IndexToMemberMap[0].IsWriteThrough); Assert.True(((TableTypeModel)typeModel).IndexToMemberMap[0].Attribute.WriteThrough); }
public void WriteThrough_Table_DisallowedTypes(Type type) { var ex = Assert.Throws <InvalidFlatBufferDefinitionException>( () => RuntimeTypeModel.CreateFrom(type)); Assert.Equal( $"Table property '{type.GetCompilableTypeName()}.Item' declared the WriteThrough attribute. WriteThrough on tables is only supported for value type structs.", ex.Message); }
public void TypeModel_Enum_TaggedEnum() { var model = RuntimeTypeModel.CreateFrom(typeof(TaggedEnum)); Assert.IsTrue(model is EnumTypeModel enumModel); Assert.AreEqual(typeof(TaggedEnum), model.ClrType); Assert.IsFalse(model.IsBuiltInType); Assert.IsTrue(model.IsFixedSize); Assert.AreEqual(FlatBufferSchemaType.Scalar, model.SchemaType); }
public void WriteThrough_Table_ValidCases(Type innerType, bool expectWriteThrough) { var typeModel = RuntimeTypeModel.CreateFrom(innerType); Assert.Equal( expectWriteThrough, ((TableTypeModel)typeModel).IndexToMemberMap[0].IsWriteThrough); Assert.True( ((TableTypeModel)typeModel).IndexToMemberMap[0].Attribute.WriteThrough); }
public void WriteThrough_Table_NonVirtualStructField(Type type) { type = typeof(WriteThroughTable_Required_NonVirtual <>).MakeGenericType(type); var ex = Assert.Throws <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(type)); Assert.Equal( $"Table member '{type.GetCompilableTypeName()}.Item' declared the WriteThrough attribute, but WriteThrough is only supported on virtual fields.", ex.Message); }
public void WriteThrough_Table_NotRequiredStructField(Type type) { type = typeof(WriteThroughTable_NotRequired <>).MakeGenericType(type); var ex = Assert.Throws <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(type)); Assert.Equal( $"Table property '{type.GetCompilableTypeName()}.Item' declared the WriteThrough attribute, but the field is not marked as required. WriteThrough fields must also be required.", ex.Message); }
public void TypeModel_Union_StructsTablesStringsAllowed() { var tableModel = (TableTypeModel)RuntimeTypeModel.CreateFrom(typeof(GenericTable <FlatBufferUnion <string, GenericTable <string>, GenericStruct <int> > >)); Assert.AreEqual(1, tableModel.IndexToMemberMap.Count); var model = (UnionTypeModel)tableModel.IndexToMemberMap[0].ItemTypeModel; Assert.AreEqual(3, model.UnionElementTypeModel.Length); Assert.IsInstanceOfType(model.UnionElementTypeModel[0], typeof(StringTypeModel)); Assert.IsInstanceOfType(model.UnionElementTypeModel[1], typeof(TableTypeModel)); Assert.IsInstanceOfType(model.UnionElementTypeModel[2], typeof(StructTypeModel)); }
public void TypeModel_Union_StructsTablesStringsAllowed() { var tableModel = (TableTypeModel)RuntimeTypeModel.CreateFrom(typeof(GenericTable <FlatBufferUnion <string, GenericTable <string>, GenericStruct <int> > >)); Assert.AreEqual(1, tableModel.IndexToMemberMap.Count); var model = (UnionTypeModel)tableModel.IndexToMemberMap[0].ItemTypeModel; Assert.AreEqual(FlatBufferSchemaType.Union, model.SchemaType); Assert.AreEqual(3, model.UnionElementTypeModel.Length); Assert.AreEqual(FlatBufferSchemaType.String, model.UnionElementTypeModel[0].SchemaType); Assert.AreEqual(FlatBufferSchemaType.Table, model.UnionElementTypeModel[1].SchemaType); Assert.AreEqual(FlatBufferSchemaType.Struct, model.UnionElementTypeModel[2].SchemaType); }
private BaseVectorTypeModel VectorTest(Type vectorDefinition, Type innerType) { var model = (BaseVectorTypeModel)RuntimeTypeModel.CreateFrom(vectorDefinition.MakeGenericType(innerType)); Assert.AreEqual(model.ClrType.GetGenericTypeDefinition(), vectorDefinition); Assert.AreEqual(model.PhysicalLayout.Single().InlineSize, 4); Assert.AreEqual(model.PhysicalLayout.Single().Alignment, 4); var innerModel = RuntimeTypeModel.CreateFrom(innerType); Assert.AreEqual(innerModel.ClrType, model.ItemTypeModel.ClrType); return(model); }
public void TypeModel_SortedVector_OfTableWithOptionalKey_NotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <bool?> >))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <byte?>[]>))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <sbyte?>[]>))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <ushort?>[]>))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <short?>[]>))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <uint?>[]>))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <int?>[]>))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <ulong?>[]>))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <long?>[]>))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <float?>[]>))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <double?>[]>))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <TaggedEnum?>[]>))); }
public void TypeModel_SortedVector_OfTableWithBuiltInKey() { RuntimeTypeModel.CreateFrom(typeof(SortedVector <IList <SortedVectorKeyTable <string> > >)); RuntimeTypeModel.CreateFrom(typeof(SortedVector <IReadOnlyList <SortedVectorKeyTable <bool> > >)); RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <byte>[]>)); RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <sbyte>[]>)); RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <ushort>[]>)); RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <short>[]>)); RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <uint>[]>)); RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <int>[]>)); RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <ulong>[]>)); RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <long>[]>)); RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <float>[]>)); RuntimeTypeModel.CreateFrom(typeof(SortedVector <SortedVectorKeyTable <double>[]>)); }
private VectorTypeModel VectorTest(Type vectorDefinition, Type innerType) { var model = (VectorTypeModel)RuntimeTypeModel.CreateFrom(vectorDefinition.MakeGenericType(innerType)); Assert.AreEqual(FlatBufferSchemaType.Vector, model.SchemaType); Assert.AreEqual(model.ClrType.GetGenericTypeDefinition(), vectorDefinition); Assert.AreEqual(model.InlineSize, 4); Assert.AreEqual(model.Alignment, 4); var innerModel = RuntimeTypeModel.CreateFrom(innerType); Assert.AreEqual(innerModel, model.ItemTypeModel); return(model); }
public void ValidStructs(Type type, bool marshalSerialize, bool marshalParse) { ITypeModel typeModel = RuntimeTypeModel.CreateFrom(type); var tm = Assert.IsType <ValueStructTypeModel>(typeModel); var children = tm.Children.ToArray(); Assert.Equal(typeof(byte), children[0].ClrType); Assert.Equal(typeof(short), children[1].ClrType); Assert.Equal(typeof(int), children[2].ClrType); Assert.Equal(typeof(long), children[3].ClrType); Assert.Equal(typeof(ValidStruct_Inner), children[4].ClrType); Assert.Equal(marshalSerialize, tm.CanMarshalOnSerialize); Assert.Equal(marshalParse, tm.CanMarshalOnParse); }
public void TypeModel_Vector_Indexed() { var model = RuntimeTypeModel.CreateFrom(typeof(GenericTable <IIndexedVector <string, SortedVectorKeyTable <string> > >)); Assert.AreEqual(FlatBufferSchemaType.Table, model.SchemaType); TableTypeModel tableModel = (TableTypeModel)model; var firstMember = tableModel.IndexToMemberMap[0]; Assert.IsTrue(firstMember.IsSortedVector); // sorted vector is set even though it's not explicitly declared. Indexed Vectors force it to be set. var vectorModel = firstMember.ItemTypeModel; Assert.AreEqual(FlatBufferSchemaType.Vector, vectorModel.SchemaType); }
public void TypeModel_Union_VectorsNotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(GenericTable <FlatBufferUnion <string, IList <string> > >))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(GenericTable <FlatBufferUnion <string, IReadOnlyList <string> > >))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(GenericTable <FlatBufferUnion <string, Memory <int> > >))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(GenericTable <FlatBufferUnion <string, ReadOnlyMemory <int> > >))); Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(GenericTable <FlatBufferUnion <string, string[]> >))); }
public void MarshalConfigTests(Type type, bool marshalEnable, bool marshalSerialize, bool marshalParse) { ITypeModel typeModel = RuntimeTypeModel.CreateFrom(type); var tm = Assert.IsType <ValueStructTypeModel>(typeModel); Assert.Equal(marshalSerialize, tm.CanMarshalOnSerialize); Assert.Equal(marshalParse, tm.CanMarshalOnParse); var options = new FlatBufferSerializerOptions { EnableValueStructMemoryMarshalDeserialization = marshalEnable }; CodeGeneratedMethod serializeMethod = tm.CreateSerializeMethodBody(ContextHelpers.CreateSerializeContext(options)); CodeGeneratedMethod parseMethod = tm.CreateParseMethodBody(ContextHelpers.CreateParserContext(options)); Assert.Equal(parseMethod.MethodBody.Contains("MemoryMarshal.Cast"), marshalEnable && marshalParse); Assert.Equal(serializeMethod.MethodBody.Contains("MemoryMarshal.Cast"), marshalEnable && marshalSerialize); }
private void RunTest <T>() where T : struct { OptionalTypeTable <T> table = new OptionalTypeTable <T> { Value = null }; byte[] data = new byte[1024]; int defaultBytesWritten = FlatBufferSerializer.Default.Serialize(table, data); Assert.Equal(12, defaultBytesWritten); Assert.Null(FlatBufferSerializer.Default.Parse <OptionalTypeTable <T> >(data).Value); table.Value = default(T); int actualBytesWritten = FlatBufferSerializer.Default.Serialize(table, data); Assert.True(actualBytesWritten >= defaultBytesWritten + RuntimeTypeModel.CreateFrom(typeof(T)).PhysicalLayout.Single().InlineSize); Assert.Equal(default(T), FlatBufferSerializer.Default.Parse <OptionalTypeTable <T> >(data).Value); }
private void ImplementMethod(Type type) { var typeModel = RuntimeTypeModel.CreateFrom(type); if (typeModel is TableTypeModel tableModel) { this.ImplementTableInlineWriteMethod(tableModel); } else if (typeModel is StructTypeModel structModel) { this.ImplementStructInlineWriteMethod(structModel); } else if (typeModel is VectorTypeModel vectorModel) { if (vectorModel.IsMemoryVector) { this.ImplementMemoryVectorInlineWriteMethod(vectorModel); } else if (vectorModel.IsArray || vectorModel.IsList) { // Array implements IList. this.ImplementListVectorInlineWriteMethod(vectorModel); } else { throw new InvalidOperationException(); } } else if (typeModel is EnumTypeModel enumModel) { this.ImplementEnumInlineWriteMethod(enumModel); } else if (typeModel is UnionTypeModel unionModel) { // Skip } else { throw new InvalidOperationException(); } }
private void ImplementMethod(Type type) { var typeModel = RuntimeTypeModel.CreateFrom(type); if (typeModel is TableTypeModel tableModel) { this.ImplementTableReadMethod(tableModel); } else if (typeModel is StructTypeModel structModel) { this.ImplementStructReadMethod(structModel); } else if (typeModel is VectorTypeModel vectorModel) { if (vectorModel.IsMemoryVector) { this.ImplementMemoryVectorReadMethod(vectorModel); } else if (vectorModel.IsArray) { this.ImplementArrayVectorReadMethod(vectorModel); } else { this.ImplementListVectorReadMethod(vectorModel); } } else if (typeModel is EnumTypeModel enumModel) { this.ImplementEnumReadMethod(enumModel); } else if (typeModel is UnionTypeModel) { // Explicitly left empty. } else { throw new InvalidOperationException(); } }
public void LayoutTests(Type structType, int expectedSize, int expectedAlignment) { ValueStructTypeModel model = (ValueStructTypeModel)RuntimeTypeModel.CreateFrom(structType); var layout = Assert.Single(model.PhysicalLayout); Assert.False(model.SerializeMethodRequiresContext); Assert.True(model.SerializesInline); Assert.True(model.IsValidStructMember); Assert.True(model.IsValidTableMember); Assert.True(model.IsValidUnionMember); Assert.True(model.IsValidVectorMember); Assert.False(model.IsValidSortedVectorKey); Assert.True(model.IsFixedSize); Assert.Equal(FlatBufferSchemaType.Struct, model.SchemaType); Assert.Equal( SerializationHelpers.GetMaxPadding(expectedAlignment) + expectedSize, model.MaxInlineSize); Assert.Equal(expectedSize, layout.InlineSize); Assert.Equal(expectedAlignment, layout.Alignment); Assert.Equal(Marshal.SizeOf(structType), layout.InlineSize); }
public void TypeModel_Struct_NoGetter() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(Struct_NoGetter))); }
public void TypeModel_Table_NonVirtual_NoSetter() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(Table_NonVirtual_NoSetter))); }
public void TypeModel_Table_InterfaceImplementationVirtual() { RuntimeTypeModel.CreateFrom(typeof(InterfaceTableSuccess)); }
public void TypeModel_Union_OptionalEnumsNotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(GenericTable <FlatBufferUnion <string, TaggedEnum?> >))); }