/// <summary>
/// Initializes a new instance of the <see cref="ByteArraySerializer"/> class.
/// </summary>
/// <param name="compressionOption">The compression option.</param>
public ByteArraySerializer(CompressionOption compressionOption)
{
_serializer = new WireSerializer();
_memoryManager = new RecyclableMemoryStreamManager();
_compressionOption = compressionOption;
_streamCompressor = GetCompressor(compressionOption);
}
public T Deserialize <T>(byte[] bytes)
{
var serializer = new Wire.Serializer();
T obj = serializer.Deserialize <T>(new MemoryStream(bytes));
return(obj);
}
public void CanSerializeImmutableDictionary()
{
var map = ImmutableDictionary <string, object> .Empty;
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(map, stream);
stream.Position = 0;
var map2 = serializer.Deserialize(stream); // exception
}
}
public void CanSerializeImmutableDictionary()
{
var map = ImmutableDictionary<string, object>.Empty;
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(map, stream);
stream.Position = 0;
var map2 = serializer.Deserialize(stream); // exception
}
}
public void CanSerializePropertyInfo()
{
var propertyInfo = typeof(Dummy).GetProperty("TestProperty");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(propertyInfo, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<PropertyInfo>(stream);
Assert.Equal(propertyInfo, deserialized);
}
}
public void CanSerializeMethodInfo()
{
var methodInfo = typeof(Dummy).GetMethod("Fact");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(methodInfo, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <MethodInfo>(stream);
Assert.Equal(methodInfo, deserialized);
}
}
public void CanSerializeSymbolDocumentInfo()
{
var info = Expression.SymbolDocument("testFile");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(info, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <SymbolDocumentInfo>(stream);
Assert.Equal(info.FileName, deserialized.FileName);
}
}
public void CanSerializeConstructorInfo()
{
var constructorInfo = typeof(Dummy).GetConstructor(new[] { typeof(string) });
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(constructorInfo, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <ConstructorInfo>(stream);
Assert.Equal(constructorInfo, deserialized);
}
}
public void CanSerializeFieldInfo()
{
var fieldInfo = typeof(Dummy).GetField("TestField");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(fieldInfo, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <FieldInfo>(stream);
Assert.Equal(fieldInfo, deserialized);
}
}
public void CanSerializePropertyInfo()
{
var propertyInfo = typeof(Dummy).GetProperty("TestProperty");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(propertyInfo, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <PropertyInfo>(stream);
Assert.Equal(propertyInfo, deserialized);
}
}
public void CanSerializeMethodInfo()
{
var methodInfo = typeof(Dummy).GetMethod("Fact");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(methodInfo, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<MethodInfo>(stream);
Assert.Equal(methodInfo, deserialized);
}
}
public void CanSerializeSymbolDocumentInfo()
{
var info = Expression.SymbolDocument("testFile");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(info, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<SymbolDocumentInfo>(stream);
Assert.Equal(info.FileName, deserialized.FileName);
}
}
public void CanSerializeFieldInfo()
{
var fieldInfo = typeof(Dummy).GetField("TestField");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(fieldInfo, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<FieldInfo>(stream);
Assert.Equal(fieldInfo, deserialized);
}
}
public void CanSerializeMethodInfo()
{
var methodInfo = typeof(Dummy).GetMethod("TestMethod");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(methodInfo, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <MethodInfo>(stream);
methodInfo.ShouldDeepEqual(deserialized);
}
}
public void CanSerializeBinaryExpression()
{
var expr = Expression.Add(Expression.Constant(1), Expression.Constant(2));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <BinaryExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Method, deserialized.Method);
}
}
public void CanSerializeLabelTarget()
{
var label = Expression.Label(typeof(int), "testLabel");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(label, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <LabelTarget>(stream);
Assert.Equal(label.Name, deserialized.Name);
Assert.Equal(label.Type, deserialized.Type);
}
}
public void CanSerializeDefaultExpression()
{
var expr = Expression.Default(typeof(int));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <DefaultExpression>(stream);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.NodeType, deserialized.NodeType);
}
}
public void CanSerializeCatchBlock()
{
var expr = Expression.Catch(typeof(DummyException), Expression.Constant(2));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <CatchBlock>(stream);
Assert.Equal(expr.Test, deserialized.Test);
Assert.Equal(expr.Body.ConstantValue(), deserialized.Body.ConstantValue());
}
}
public void CanSerializeConstantExpression()
{
var expr = Expression.Constant(12);
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <ConstantExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Value, deserialized.Value);
Assert.Equal(expr.Type, deserialized.Type);
}
}
public void CanSerializeParameterExpression()
{
var expr = Expression.Parameter(typeof(int), "p1");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <ParameterExpression>(stream);
Assert.AreEqual(expr.Type, deserialized.Type);
Assert.AreEqual(expr.NodeType, deserialized.NodeType);
Assert.AreEqual(expr.Name, deserialized.Name);
}
}
public void CanSerializeMemberAssignment()
{
var property = typeof(Dummy).GetProperty("TestProperty");
var expr = Expression.Bind(property.SetMethod, Expression.Constant(9));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <MemberAssignment>(stream);
Assert.Equal(expr.BindingType, deserialized.BindingType);
Assert.Equal(expr.Member, deserialized.Member);
Assert.Equal(expr.Expression.ConstantValue(), deserialized.Expression.ConstantValue());
}
}
public void CanSerializeElementInit()
{
var listAddMethod = typeof(List <int>).GetMethod("Add");
var expr = Expression.ElementInit(listAddMethod, Expression.Constant(1));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <ElementInit>(stream);
Assert.Equal(expr.AddMethod, deserialized.AddMethod);
Assert.Equal(1, deserialized.Arguments.Count);
Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
}
}
public void CanSerializeUnaryExpression()
{
var expr = Expression.Decrement(Expression.Constant(1));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <UnaryExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Method, deserialized.Method);
Assert.Equal(expr.Operand.ConstantValue(), deserialized.Operand.ConstantValue());
}
}
public void CanSerializeConditionalExpression()
{
var expr = Expression.Condition(Expression.Constant(true), Expression.Constant(1), Expression.Constant(2));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <ConditionalExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Test.ConstantValue(), deserialized.Test.ConstantValue());
Assert.Equal(expr.IfTrue.ConstantValue(), deserialized.IfTrue.ConstantValue());
Assert.Equal(expr.IfFalse.ConstantValue(), deserialized.IfFalse.ConstantValue());
}
}
public void CanSerializeGotoExpression()
{
var label = Expression.Label(typeof(void), "testLabel");
var expr = Expression.Continue(label);
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <GotoExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Kind, deserialized.Kind);
Assert.Equal(expr.Target.Name, deserialized.Target.Name);
}
}
public void CanSerializeLabelExpression()
{
var label = Expression.Label(typeof(int), "testLabel");
var expr = Expression.Label(label, Expression.Constant(2));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <LabelExpression>(stream);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Target.Name, deserialized.Target.Name);
Assert.Equal(expr.DefaultValue.ConstantValue(), deserialized.DefaultValue.ConstantValue());
}
}
public void CanSerializeBlockExpression()
{
var expr = Expression.Block(new[] { Expression.Constant(1), Expression.Constant(2), Expression.Constant(3) });
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <BlockExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Expressions.Count, deserialized.Expressions.Count);
Assert.Equal(expr.Expressions[0].ConstantValue(), deserialized.Expressions[0].ConstantValue());
Assert.Equal(expr.Expressions[1].ConstantValue(), deserialized.Expressions[1].ConstantValue());
Assert.Equal(expr.Result.ConstantValue(), deserialized.Result.ConstantValue());
}
}
public void CanSerializeNewExpression()
{
var ctor = typeof(Dummy).GetConstructor(new[] { typeof(string) });
var expr = Expression.New(ctor, Expression.Constant("test param"));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <NewExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Constructor, deserialized.Constructor);
Assert.Equal(expr.Arguments.Count, deserialized.Arguments.Count);
Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
}
}
public void CanSerializeMethodCallExpression()
{
var methodInfo = typeof(Dummy).GetMethod("Fact");
var expr = Expression.Call(Expression.Constant(new Dummy()), methodInfo, Expression.Constant("test string"));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <MethodCallExpression>(stream);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Method, deserialized.Method);
Assert.Equal(expr.Object.ConstantValue(), deserialized.Object.ConstantValue());
Assert.Equal(1, deserialized.Arguments.Count);
Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
}
}
public void CanSerializeInvocationExpression()
{
var methodInfo = typeof(Dummy).GetMethod("Fact");
var param = Expression.Parameter(typeof(Dummy), "dummy");
var lambda = Expression.Lambda(Expression.Call(param, methodInfo, Expression.Constant("s")), param);
var expr = Expression.Invoke(lambda, Expression.Constant(new Dummy()));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <InvocationExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Arguments.Count, deserialized.Arguments.Count);
Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
}
}
public void CanSerializeLoopExpression()
{
var breakLabel = Expression.Label(typeof(void), "break");
var continueLabel = Expression.Label(typeof(void), "cont");
var expr = Expression.Loop(Expression.Constant(2), breakLabel, continueLabel);
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <LoopExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Body.ConstantValue(), deserialized.Body.ConstantValue());
Assert.Equal(expr.BreakLabel.Name, deserialized.BreakLabel.Name);
Assert.Equal(expr.ContinueLabel.Name, deserialized.ContinueLabel.Name);
}
}
public void CanSerializeDebugInfoExpression()
{
var info = Expression.SymbolDocument("testFile");
var expr = Expression.DebugInfo(info, 1, 2, 3, 4);
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <DebugInfoExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Document.FileName, deserialized.Document.FileName);
Assert.Equal(expr.EndColumn, deserialized.EndColumn);
Assert.Equal(expr.StartColumn, deserialized.StartColumn);
Assert.Equal(expr.EndLine, deserialized.EndLine);
Assert.Equal(expr.StartLine, deserialized.StartLine);
}
}
public void CanSerializeLambdaExpression()
{
var methodInfo = typeof(Dummy).GetMethod("Fact");
var param = Expression.Parameter(typeof(Dummy), "dummy");
var expr = Expression.Lambda(Expression.Call(param, methodInfo, Expression.Constant("s")), param);
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <LambdaExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Name, deserialized.Name);
Assert.Equal(expr.TailCall, deserialized.TailCall);
Assert.Equal(expr.ReturnType, deserialized.ReturnType);
Assert.Equal(expr.Parameters.Count, deserialized.Parameters.Count);
Assert.Equal(expr.Parameters[0].Name, deserialized.Parameters[0].Name);
}
}
public void CanSerializeIndexExpression()
{
var value = new[] { 1, 2, 3 };
var arrayExpr = Expression.Constant(value);
var expr = Expression.ArrayAccess(arrayExpr, Expression.Constant(1));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize <IndexExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Indexer, deserialized.Indexer);
Assert.Equal(1, deserialized.Arguments.Count);
Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
var actual = (int[])deserialized.Object.ConstantValue();
Assert.Equal(value[0], actual[0]);
Assert.Equal(value[1], actual[1]);
Assert.Equal(value[2], actual[2]);
}
}
public void CanSerializeConstantExpression()
{
var expr = Expression.Constant(12);
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<ConstantExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Value, deserialized.Value);
Assert.Equal(expr.Type, deserialized.Type);
}
}
public void CanSerializeBlockExpression()
{
var expr = Expression.Block(new[] { Expression.Constant(1), Expression.Constant(2), Expression.Constant(3) });
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<BlockExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Expressions.Count, deserialized.Expressions.Count);
Assert.Equal(expr.Expressions[0].ConstantValue(), deserialized.Expressions[0].ConstantValue());
Assert.Equal(expr.Expressions[1].ConstantValue(), deserialized.Expressions[1].ConstantValue());
Assert.Equal(expr.Result.ConstantValue(), deserialized.Result.ConstantValue());
}
}
public void CanSerializeLoopExpression()
{
var breakLabel = Expression.Label(typeof (void), "break");
var continueLabel = Expression.Label(typeof(void), "cont");
var expr = Expression.Loop(Expression.Constant(2), breakLabel, continueLabel);
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<LoopExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Body.ConstantValue(), deserialized.Body.ConstantValue());
Assert.Equal(expr.BreakLabel.Name, deserialized.BreakLabel.Name);
Assert.Equal(expr.ContinueLabel.Name, deserialized.ContinueLabel.Name);
}
}
public void CanSerializeParameterExpression()
{
var expr = Expression.Parameter(typeof(int), "p1");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<ParameterExpression>(stream);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Name, deserialized.Name);
}
}
public void CanSerializeIndexExpression()
{
var value = new[] {1, 2, 3};
var arrayExpr = Expression.Constant(value);
var expr = Expression.ArrayAccess(arrayExpr, Expression.Constant(1));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<IndexExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Indexer, deserialized.Indexer);
Assert.Equal(1, deserialized.Arguments.Count);
Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
var actual = (int[])deserialized.Object.ConstantValue();
Assert.Equal(value[0], actual[0]);
Assert.Equal(value[1], actual[1]);
Assert.Equal(value[2], actual[2]);
}
}
public void CanSerializeConditionalExpression()
{
var expr = Expression.Condition(Expression.Constant(true), Expression.Constant(1), Expression.Constant(2));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<ConditionalExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Test.ConstantValue(), deserialized.Test.ConstantValue());
Assert.Equal(expr.IfTrue.ConstantValue(), deserialized.IfTrue.ConstantValue());
Assert.Equal(expr.IfFalse.ConstantValue(), deserialized.IfFalse.ConstantValue());
}
}
public void CanSerializeElementInit()
{
var listAddMethod = typeof (List<int>).GetMethod("Add");
var expr = Expression.ElementInit(listAddMethod, Expression.Constant(1));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<ElementInit>(stream);
Assert.Equal(expr.AddMethod, deserialized.AddMethod);
Assert.Equal(1, deserialized.Arguments.Count);
Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
}
}
public SnapshotEntrySerializer()
{
Serializer = new Wire.Serializer();
}
public void CanSerializeMethodCallExpression()
{
var methodInfo = typeof(Dummy).GetMethod("Fact");
var expr = Expression.Call(Expression.Constant(new Dummy()), methodInfo, Expression.Constant("test string"));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<MethodCallExpression>(stream);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Method, deserialized.Method);
Assert.Equal(expr.Object.ConstantValue(), deserialized.Object.ConstantValue());
Assert.Equal(1, deserialized.Arguments.Count);
Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
}
}
public void CanSerializeNewExpression()
{
var ctor = typeof(Dummy).GetConstructor(new[] { typeof(string) });
var expr = Expression.New(ctor, Expression.Constant("test param"));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<NewExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Constructor, deserialized.Constructor);
Assert.Equal(expr.Arguments.Count, deserialized.Arguments.Count);
Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
}
}
public void CanSerializeGotoExpression()
{
var label = Expression.Label(typeof(void), "testLabel");
var expr = Expression.Continue(label);
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<GotoExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Kind, deserialized.Kind);
Assert.Equal(expr.Target.Name, deserialized.Target.Name);
}
}
public void CanSerializeConstructorInfo()
{
var constructorInfo = typeof(Dummy).GetConstructor(new[] { typeof(string) });
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(constructorInfo, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<ConstructorInfo>(stream);
Assert.Equal(constructorInfo, deserialized);
}
}
public void CanSerializeInvocationExpression()
{
var methodInfo = typeof(Dummy).GetMethod("Fact");
var param = Expression.Parameter(typeof(Dummy), "dummy");
var lambda = Expression.Lambda(Expression.Call(param, methodInfo, Expression.Constant("s")), param);
var expr = Expression.Invoke(lambda, Expression.Constant(new Dummy()));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<InvocationExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Arguments.Count, deserialized.Arguments.Count);
Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
}
}
public void CanSerializeLabelTarget()
{
var label = Expression.Label(typeof(int), "testLabel");
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(label, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<LabelTarget>(stream);
Assert.Equal(label.Name, deserialized.Name);
Assert.Equal(label.Type, deserialized.Type);
}
}
public void CanSerializeMemberAssignment()
{
var property = typeof(Dummy).GetProperty("TestProperty");
var expr = Expression.Bind(property.SetMethod, Expression.Constant(9));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<MemberAssignment>(stream);
Assert.Equal(expr.BindingType, deserialized.BindingType);
Assert.Equal(expr.Member, deserialized.Member);
Assert.Equal(expr.Expression.ConstantValue(), deserialized.Expression.ConstantValue());
}
}
public void CanSerializeDebugInfoExpression()
{
var info = Expression.SymbolDocument("testFile");
var expr = Expression.DebugInfo(info, 1, 2, 3, 4);
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<DebugInfoExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Document.FileName, deserialized.Document.FileName);
Assert.Equal(expr.EndColumn, deserialized.EndColumn);
Assert.Equal(expr.StartColumn, deserialized.StartColumn);
Assert.Equal(expr.EndLine, deserialized.EndLine);
Assert.Equal(expr.StartLine, deserialized.StartLine);
}
}
public void CanSerializeBinaryExpression()
{
var expr = Expression.Add(Expression.Constant(1), Expression.Constant(2));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<BinaryExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Method, deserialized.Method);
}
}
public void CanSerializeCatchBlock()
{
var expr = Expression.Catch(typeof(DummyException), Expression.Constant(2));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<CatchBlock>(stream);
Assert.Equal(expr.Test, deserialized.Test);
Assert.Equal(expr.Body.ConstantValue(), deserialized.Body.ConstantValue());
}
}
public void CanSerializeUnaryExpression()
{
var expr = Expression.Decrement(Expression.Constant(1));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<UnaryExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Method, deserialized.Method);
Assert.Equal(expr.Operand.ConstantValue(), deserialized.Operand.ConstantValue());
}
}
public void CanSerializeLabelExpression()
{
var label = Expression.Label(typeof(int), "testLabel");
var expr = Expression.Label(label, Expression.Constant(2));
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<LabelExpression>(stream);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Target.Name, deserialized.Target.Name);
Assert.Equal(expr.DefaultValue.ConstantValue(), deserialized.DefaultValue.ConstantValue());
}
}
public void Setup()
{
//
// Create example data
var parent1 = new Person
{
Age = -901,
FirstName = "Parent 1",
LastName = "abc",
Sex = Sex.Male,
};
var parent2 = new Person
{
Age = 7881964,
FirstName = "Parent 2",
LastName = "xyz",
Sex = Sex.Female,
};
_person = new Person
{
Age = 5,
FirstName = "Riki",
LastName = "Example Person Object",
Sex = Sex.Unknown,
Parent1 = parent1,
Parent2 = parent2,
};
_list = Enumerable.Range(25000, 100).Select(x => new Person {
Age = x, FirstName = "a", LastName = "b", Sex = Sex.Female
}).ToArray();
//
// Config Serializers
_wire = new Wire.Serializer(new Wire.SerializerOptions(knownTypes: new Type[] { typeof(Person), typeof(Person[]) }));
_netSerializer = new NetSerializer.Serializer(rootTypes: new Type[] { typeof(Person), typeof(Person[]) });
var config = new SerializerConfig();
config.DefaultTargets = TargetMember.AllPublic;
var knownTypes = new[] { typeof(Person), typeof(List <>), typeof(Person[]) };
config.KnownTypes.AddRange(knownTypes);
config.PreserveReferences = false;
_ceras = new CerasSerializer(config);
//
// Run each serializer once to verify they work correctly!
if (!Equals(RunCeras(_person), _person))
{
ThrowError();
}
if (!Equals(RunJson(_person), _person))
{
ThrowError();
}
if (!Equals(RunMessagePackCSharp(_person), _person))
{
ThrowError();
}
if (!Equals(RunProtobuf(_person), _person))
{
ThrowError();
}
if (!Equals(RunWire(_person), _person))
{
ThrowError();
}
if (!Equals(RunNetSerializer(_person), _person))
{
ThrowError();
}
void ThrowError() => throw new InvalidOperationException("Cannot continue with the benchmark because a serializer does not round-trip an object correctly. (Benchmark results will be wrong)");
}
public void CanSerializeLambdaExpression()
{
var methodInfo = typeof(Dummy).GetMethod("Fact");
var param = Expression.Parameter(typeof (Dummy), "dummy");
var expr = Expression.Lambda(Expression.Call(param, methodInfo, Expression.Constant("s")), param);
var serializer = new Wire.Serializer();
using (var stream = new MemoryStream())
{
serializer.Serialize(expr, stream);
stream.Position = 0;
var deserialized = serializer.Deserialize<LambdaExpression>(stream);
Assert.Equal(expr.NodeType, deserialized.NodeType);
Assert.Equal(expr.Type, deserialized.Type);
Assert.Equal(expr.Name, deserialized.Name);
Assert.Equal(expr.TailCall, deserialized.TailCall);
Assert.Equal(expr.ReturnType, deserialized.ReturnType);
Assert.Equal(expr.Parameters.Count, deserialized.Parameters.Count);
Assert.Equal(expr.Parameters[0].Name, deserialized.Parameters[0].Name);
}
}
