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