public void Should_Compute_Size_Of_Nullable_Properties_Correctly()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <NullablePropertyTestClass>()
.PublicProperties()
.Map();
var serializationOps = ObjectSerializerCompiler.CompileSerializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(NullablePropertyTestClass),
serializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(serializationOps).ToList().AsReadOnly()
);
var getSizeFromValueDelegate = ObjectSerializerInterpreter.InterpretDynamicGetSizeFromValueDelegate(
context,
typeof(NullablePropertyTestClass),
serializationOps
);
Assert.Equal(6, getSizeFromValueDelegate(context, new NullablePropertyTestClass()
{
X = 0
}));
Assert.Equal(10, getSizeFromValueDelegate(context, new NullablePropertyTestClass()
{
X = 0, Y = 200
}));
Assert.Equal(14, getSizeFromValueDelegate(context, new NullablePropertyTestClass()
{
X = 0, Y = 200, Z = 400
}));
}
public void Should_Compute_Size_Of_Value_Type_Structure_With_Parametrized_Activator_Correctly()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <ValueTypeParametrizedActivationTestClass>()
.PublicFields()
.ParametrizedActivation(ObjectActivationHint.Field("x", "X"),
ObjectActivationHint.Field("y", "Y"))
.Map();
var serializationOps = ObjectSerializerCompiler.CompileSerializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(ValueTypeParametrizedActivationTestClass),
serializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(serializationOps).ToList().AsReadOnly()
);
var getSizeFromValueDelegate = ObjectSerializerInterpreter.InterpretDynamicGetSizeFromValueDelegate(
context,
typeof(ValueTypeParametrizedActivationTestClass),
serializationOps
);
var testObject = new ValueTypeParametrizedActivationTestClass(0, 0);
Assert.Equal(12, getSizeFromValueDelegate(context, testObject));
}
public void Should_Compute_Size_Of_Non_Value_Type_Values_Correctly()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <NonValueTypeTestClass>()
.PublicFields()
.PublicProperties()
.Map();
var serializationOps = ObjectSerializerCompiler.CompileSerializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(NonValueTypeTestClass),
serializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(serializationOps).ToList().AsReadOnly()
);
var getSizeFromValueDelegate = ObjectSerializerInterpreter.InterpretDynamicGetSizeFromValueDelegate(
context,
typeof(NonValueTypeTestClass),
serializationOps
);
Assert.Equal(10, getSizeFromValueDelegate(context, new NonValueTypeTestClass()));
Assert.Equal(38, getSizeFromValueDelegate(context, new NonValueTypeTestClass()
{
PS = "hello, world!"
}));
Assert.Equal(50, getSizeFromValueDelegate(context, new NonValueTypeTestClass()
{
PS = "hello, world!", FS = "hello"
}));
}
public void Should_Serialize_Fields()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <FieldTestClass>()
.PublicFields()
.Map();
var serializationOps = ObjectSerializerCompiler.CompileSerializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(FieldTestClass),
serializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(serializationOps).ToList().AsReadOnly()
);
var serializeDelegate = ObjectSerializerInterpreter.InterpretDynamicSerializeDelegate(
context,
typeof(FieldTestClass),
serializationOps
);
var testObject = new FieldTestClass()
{
X = 1500, Y = 37500
};
var buffer = new byte[8];
serializeDelegate(context, testObject, buffer, 0);
Assert.Equal(testObject.X, MemoryMapper.ReadInt(buffer, 0));
Assert.Equal(testObject.Y, MemoryMapper.ReadInt(buffer, sizeof(int)));
}
public void Should_Serialize_Both_Properties_And_Fields()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <FieldAndPropertyTestClassClass>()
.PublicProperties()
.PublicFields()
.Map();
var serializationOps = ObjectSerializerCompiler.CompileSerializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(FieldAndPropertyTestClassClass),
serializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(serializationOps).ToList().AsReadOnly()
);
var serializeDelegate = ObjectSerializerInterpreter.InterpretDynamicSerializeDelegate(
context,
typeof(FieldAndPropertyTestClassClass),
serializationOps
);
var testObject = new FieldAndPropertyTestClassClass()
{
B1 = 0, B2 = 20, B3 = 150, B4 = 200
};
var buffer = new byte[64];
serializeDelegate(context, testObject, buffer, 0);
Assert.Equal(testObject.B1, MemoryMapper.ReadByte(buffer, 0));
Assert.Equal(testObject.B2, MemoryMapper.ReadByte(buffer, sizeof(byte)));
Assert.Equal(testObject.B3, MemoryMapper.ReadByte(buffer, sizeof(byte) * 2));
Assert.Equal(testObject.B4, MemoryMapper.ReadByte(buffer, sizeof(byte) * 3));
}
public void Should_Deserialize_Value_Type_Properties()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <ValueTypePropertyTestClass>()
.PublicProperties()
.Map();
var deserializationOps = ObjectSerializerCompiler.CompileDeserializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(ValueTypePropertyTestClass),
deserializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(deserializationOps).ToList().AsReadOnly()
);
var deserializeDelegate = ObjectSerializerInterpreter.InterpretDynamicDeserializeDelegate(
context,
typeof(ValueTypePropertyTestClass),
deserializationOps
);
var buffer = new byte[32];
MemoryMapper.WriteInt(300, buffer, 0);
MemoryMapper.WriteInt(400, buffer, sizeof(int));
var results = (ValueTypePropertyTestClass)deserializeDelegate(context, buffer, 0);
Assert.Equal(300, results.X);
Assert.Equal(400, results.Y);
}
public void Should_Deserialize_Non_Value_Type_Fields()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <NonValueTypeFieldTestClass>()
.PublicFields()
.Map();
var deserializationOps = ObjectSerializerCompiler.CompileDeserializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(NonValueTypeFieldTestClass),
deserializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(deserializationOps).ToList().AsReadOnly()
);
var deserializeDelegate = ObjectSerializerInterpreter.InterpretDynamicDeserializeDelegate(
context,
typeof(NonValueTypeFieldTestClass),
deserializationOps
);
var stringSerializer = new StringSerializer();
var bitFieldSerializer = new BitFieldSerializer();
var nullMask = new BitField(1);
nullMask.SetBit(0, true);
var buffer = new byte[64];
var offset = 0;
bitFieldSerializer.Serialize(nullMask, buffer, offset);
offset += bitFieldSerializer.GetSizeFromValue(nullMask);
// X.
MemoryMapper.WriteInt(25, buffer, offset);
offset += sizeof(int);
// Y.
MemoryMapper.WriteInt(50, buffer, offset);
offset += sizeof(int);
// S2.
stringSerializer.Serialize("hello!", buffer, offset);
var results = (NonValueTypeFieldTestClass)deserializeDelegate(context, buffer, 0);
Assert.Equal(25, results.X);
Assert.Equal(50, results.Y);
Assert.Equal("hello!", results.S2);
Assert.Null(results.S1);
Assert.True(string.IsNullOrEmpty(results.Null));
}
public void Should_Serialize_Non_Value_Type_Properties()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <NonValueTypePropertyTestClass>()
.PublicProperties()
.Map();
var serializationOps = ObjectSerializerCompiler.CompileSerializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(NonValueTypePropertyTestClass),
serializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(serializationOps).ToList().AsReadOnly()
);
var serializeDelegate = ObjectSerializerInterpreter.InterpretDynamicSerializeDelegate(
context,
typeof(NonValueTypePropertyTestClass),
serializationOps
);
var testObject = new NonValueTypePropertyTestClass()
{
S1 = "Hello f*****g world", S2 = null, S3 = "Hello again", I = 1993, J = 200
};
var stringSerializer = new StringSerializer();
var buffer = new byte[128];
serializeDelegate(context, testObject, buffer, 0);
var offset = 0;
// Null mask size in bytes.
Assert.Equal(1, MemoryMapper.ReadByte(buffer, offset));
offset += sizeof(byte);
// Null mask values.
Assert.Equal(64, MemoryMapper.ReadByte(buffer, offset));
offset += sizeof(byte);
Assert.Equal(testObject.S1, stringSerializer.Deserialize(buffer, offset));
offset += stringSerializer.GetSizeFromValue(testObject.S1);
Assert.Equal(testObject.S3, stringSerializer.Deserialize(buffer, offset));
offset += stringSerializer.GetSizeFromValue(testObject.S3);
Assert.Equal(testObject.I, MemoryMapper.ReadInt(buffer, offset));
offset += sizeof(int);
Assert.Equal(testObject.J, MemoryMapper.ReadInt(buffer, offset));
}
public void Should_Deserialize_Nullable_Properties()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <NullablePropertyTestClass>()
.PublicProperties()
.Map();
var deserializationOps = ObjectSerializerCompiler.CompileDeserializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(NullablePropertyTestClass),
deserializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(deserializationOps).ToList().AsReadOnly()
);
var deserializeDelegate = ObjectSerializerInterpreter.InterpretDynamicDeserializeDelegate(
context,
typeof(NullablePropertyTestClass),
deserializationOps
);
var bitFieldSerializer = new BitFieldSerializer();
var nullMask = new BitField(1);
nullMask.SetBit(0, true);
var buffer = new byte[32];
var offset = 0;
bitFieldSerializer.Serialize(nullMask, buffer, offset);
offset += bitFieldSerializer.GetSizeFromValue(nullMask);
MemoryMapper.WriteInt(50, buffer, offset);
offset += sizeof(int);
MemoryMapper.WriteInt(75, buffer, offset);
offset += sizeof(int);
MemoryMapper.WriteInt(100, buffer, offset);
var results = (NullablePropertyTestClass)deserializeDelegate(context, buffer, 0);
Assert.Equal(50, results.I);
Assert.Equal(75, results.X);
Assert.Equal(100, results.J);
}
public void Should_Compute_Size_Of_Non_Value_Type_Nullable_Values_Correctly()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <NullableNonValueTypeTestClass>()
.PublicFields()
.Map();
var serializationOps = ObjectSerializerCompiler.CompileSerializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(NullableNonValueTypeTestClass),
serializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(serializationOps).ToList().AsReadOnly()
);
var getSizeFromValueDelegate = ObjectSerializerInterpreter.InterpretDynamicGetSizeFromValueDelegate(
context,
typeof(NullableNonValueTypeTestClass),
serializationOps
);
}
public void Should_Deserialize_Objects_Containing_Value_Type_Fields_And_Properties_With_Parametrized_Constructor()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <ValueTypePropertyAndFieldWithParametrizedConstructorTestClass>()
.PublicProperties()
.ParametrizedActivation(ObjectActivationHint.Field("x", "X"),
ObjectActivationHint.Field("y", "Y"),
ObjectActivationHint.Property("x2", "X2"),
ObjectActivationHint.Property("y2", "Y2"))
.Map();
var deserializationOps = ObjectSerializerCompiler.CompileDeserializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(ValueTypePropertyAndFieldWithParametrizedConstructorTestClass),
deserializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(deserializationOps).ToList().AsReadOnly()
);
var deserializeDelegate = ObjectSerializerInterpreter.InterpretDynamicDeserializeDelegate(
context,
typeof(ValueTypePropertyAndFieldWithParametrizedConstructorTestClass),
deserializationOps
);
var buffer = new byte[32];
MemoryMapper.WriteInt(10, buffer, 0);
MemoryMapper.WriteInt(20, buffer, sizeof(int));
MemoryMapper.WriteInt(30, buffer, sizeof(int) * 2);
MemoryMapper.WriteInt(40, buffer, sizeof(int) * 3);
var results = (ValueTypePropertyAndFieldWithParametrizedConstructorTestClass)deserializeDelegate(context, buffer, 0);
Assert.Equal(10, results.X);
Assert.Equal(20, results.Y);
Assert.Equal(30, results.X2);
Assert.Equal(40, results.Y2);
}
public void Should_Serialize_Nullable_Properties()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <NullablePropertyTestClass>()
.PublicProperties()
.Map();
var serializationOps = ObjectSerializerCompiler.CompileSerializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(NullablePropertyTestClass),
serializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(serializationOps).ToList().AsReadOnly()
);
var serializeDelegate = ObjectSerializerInterpreter.InterpretDynamicSerializeDelegate(
context,
typeof(NullablePropertyTestClass),
serializationOps
);
var testObject = new NullablePropertyTestClass()
{
X = null, Y = null, I = 200, J = 300
};
var buffer = new byte[64];
serializeDelegate(context, testObject, buffer, 0);
// Null mask size in bytes.
Assert.Equal(1, MemoryMapper.ReadByte(buffer, 0));
// Null mask values.
Assert.Equal(224, MemoryMapper.ReadByte(buffer, sizeof(byte)));
// Field 'I' value.
Assert.Equal(testObject.I, MemoryMapper.ReadInt(buffer, sizeof(byte) * 2));
// Field 'J' value.
Assert.Equal(testObject.J, MemoryMapper.ReadInt(buffer, sizeof(int) + sizeof(byte) * 2));
}
public void Should_Serialize_Properties()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <PropertyTestClass>()
.PublicProperties()
.Map();
var serializationOps = ObjectSerializerCompiler.CompileSerializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(PropertyTestClass),
serializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(serializationOps).ToList().AsReadOnly()
);
var serializeDelegate = ObjectSerializerInterpreter.InterpretDynamicSerializeDelegate(
context,
typeof(PropertyTestClass),
serializationOps
);
var testObject = new PropertyTestClass()
{
Id = 255255, Greet = "Hello stranger!"
};
var stringSerializer = new StringSerializer();
var buffer = new byte[64];
serializeDelegate(context, testObject, buffer, 0);
// Null mask size in bytes.
Assert.Equal(1, MemoryMapper.ReadByte(buffer, 0));
// Null mask values.
Assert.Equal(0, MemoryMapper.ReadByte(buffer, sizeof(byte)));
Assert.Equal(testObject.Id, MemoryMapper.ReadInt(buffer, sizeof(byte) * 2));
Assert.Equal(testObject.Greet, stringSerializer.Deserialize(buffer, sizeof(byte) * 2 + sizeof(int)));
}
public void Should_Serialize_All_Supported_Field_And_Property_Kinds_Mixed()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <AllPropertyAndFieldKindsMixTestClass>()
.PublicProperties()
.PublicFields()
.Map();
var serializationOps = ObjectSerializerCompiler.CompileSerializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(AllPropertyAndFieldKindsMixTestClass),
serializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(serializationOps).ToList().AsReadOnly()
);
var serializeDelegate = ObjectSerializerInterpreter.InterpretDynamicSerializeDelegate(
context,
typeof(AllPropertyAndFieldKindsMixTestClass),
serializationOps
);
var testObject = new AllPropertyAndFieldKindsMixTestClass()
{
Y = 200,
X = null,
S2 = "hello world!",
S1 = null,
J = 400,
I = null,
S3 = null,
S4 = "f**k you"
};
var buffer = new byte[256];
serializeDelegate(context, testObject, buffer, 0);
var offset = 0;
var stringSerializer = new StringSerializer();
// Null mask size in bytes.
Assert.Equal(1, MemoryMapper.ReadByte(buffer, offset));
offset += sizeof(byte);
// Null mask values.
Assert.Equal(216, MemoryMapper.ReadByte(buffer, offset));
offset += sizeof(byte);
// J.
Assert.Equal(testObject.J, MemoryMapper.ReadInt(buffer, offset));
offset += sizeof(int);
// S4.
Assert.Equal(testObject.S4, stringSerializer.Deserialize(buffer, offset));
offset += stringSerializer.GetSizeFromBuffer(buffer, offset);
// Y.
Assert.Equal(testObject.Y, MemoryMapper.ReadInt(buffer, offset));
offset += sizeof(int);
// S2.
Assert.Equal(testObject.S2, stringSerializer.Deserialize(buffer, offset));
offset += stringSerializer.GetSizeFromBuffer(buffer, offset);
}
public void Should_Serialize_Non_Zero_Null_Offset_Mixed_Value_Types()
{
var mapping = ObjectSerializationMapper.Create()
.FromType <NonZeroNullValueOffsetMixedTestClass>()
.PublicProperties()
.PublicFields()
.Map();
var serializationOps = ObjectSerializerCompiler.CompileSerializationOps(mapping).ToList().AsReadOnly();
var context = ObjectSerializerInterpreter.InterpretObjectSerializationNullContext(
typeof(NonZeroNullValueOffsetMixedTestClass),
serializationOps,
ObjectSerializerProgram.GetOpValueSerializerTypes(serializationOps).ToList().AsReadOnly()
);
var serializeDelegate = ObjectSerializerInterpreter.InterpretDynamicSerializeDelegate(
context,
typeof(NonZeroNullValueOffsetMixedTestClass),
serializationOps
);
var testObject = new NonZeroNullValueOffsetMixedTestClass()
{
I = 200, J = 300, K = 400, X = 2, Y = 1, P9 = 500
};
var buffer = new byte[64];
serializeDelegate(context, testObject, buffer, 0);
var offset = 0;
// Null mask size in bytes.
Assert.Equal(2, MemoryMapper.ReadByte(buffer, offset));
offset += sizeof(byte);
// Null mask values.
Assert.Equal(33023, MemoryMapper.ReadUshort(buffer, offset));
offset += sizeof(ushort);
// K.
Assert.Equal(testObject.K, MemoryMapper.ReadInt(buffer, offset));
offset += sizeof(int);
// P9.
Assert.Equal(testObject.P9, MemoryMapper.ReadInt(buffer, offset));
offset += sizeof(int);
// X.
Assert.Equal(testObject.X, MemoryMapper.ReadInt(buffer, offset));
offset += sizeof(int);
// Y.
Assert.Equal(testObject.Y, MemoryMapper.ReadInt(buffer, offset));
offset += sizeof(int);
// I.
Assert.Equal(testObject.I, MemoryMapper.ReadInt(buffer, offset));
offset += sizeof(int);
// J.
Assert.Equal(testObject.J, MemoryMapper.ReadInt(buffer, offset));
}
