/// <summary> /// Tries to deserialize the gray box random forest. This method is the counterpart of TryToSerializeGrayBoxRandomForest in <see cref="AlgorithmTuner{TTargetAlgorithm,TInstance,TResult}"/>. /// </summary> /// <param name="grayBoxRandomForest">The gray box random forest.</param> /// <returns>True, if successful.</returns> private bool TryToDeserializeGrayBoxRandomForest(out ClassificationForestModel grayBoxRandomForest) { try { var timer = Stopwatch.StartNew(); using (var file = File.OpenRead(this._configuration.GrayBoxRandomForestFile.FullName)) { grayBoxRandomForest = new Hyperion.Serializer().Deserialize <ClassificationForestModel>(file); } timer.Stop(); if (grayBoxRandomForest != null) { LoggingHelper.WriteLine( VerbosityLevel.Info, $"The deserialization of the gray box random forest before generation {this._currentEvaluation.GenerationId} on evaluation actor with address {this.Self} took {timer.Elapsed.TotalSeconds} seconds."); return(true); } LoggingHelper.WriteLine( VerbosityLevel.Warn, $"Cannot deserialize gray box random forest before generation {this._currentEvaluation.GenerationId} on evaluation actor with address {this.Self}, because it is null."); return(false); } catch (Exception exception) { LoggingHelper.WriteLine( VerbosityLevel.Warn, $"Cannot deserialize gray box random forest before generation {this._currentEvaluation.GenerationId} on evaluation actor with address {this.Self}, because: {exception.Message}"); grayBoxRandomForest = null; return(false); } }
public void CheckIfTreeCanBeDeserialized() { var root = new AndNode(); root.AddChild(new ValueNode <int>("a", new IntegerDomain())); root.AddChild(new ValueNode <int>("b", new IntegerDomain())); var tree = new ParameterTree(root); var serializer = new Hyperion.Serializer(); var treeStream = new MemoryStream(); serializer.Serialize(tree, treeStream); var streamCopy = new MemoryStream(treeStream.GetBuffer()); var restoredTree = serializer.Deserialize <ParameterTree>(streamCopy); Assert.NotNull(restoredTree); var originalNodes = tree.GetParameters().ToList(); var restoredNodes = restoredTree.GetParameters().ToList(); Assert.Equal(originalNodes.Count, restoredNodes.Count); for (var i = 0; i < originalNodes.Count; i++) { var expectedNode = originalNodes[i]; var restoredNode = restoredNodes[i]; Assert.True(expectedNode.Identifier == restoredNode.Identifier, "Nodes were deserialized in wrong order."); Assert.Equal(expectedNode.Domain.DomainSize, restoredNode.Domain.DomainSize); } }
public void SetupSerializeHyperion() { var options = new Hyperion.SerializerOptions( versionTolerance: true, preserveObjectReferences: true ); _value = GetValue(); _serializer = new Hyperion.Serializer(options); }
public void CanSerializeFieldInfo() { var fieldInfo = typeof(Dummy).GetField("TestField"); var serializer = new Hyperion.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 Hyperion.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 Hyperion.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 Hyperion.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 SetupDeserializeHyperion() { var options = new Hyperion.SerializerOptions( versionTolerance: true, preserveObjectReferences: true ); _serializer1 = new Hyperion.Serializer(options); var s = new MemoryStream(); _serializer1.Serialize(GetValue(), s); _hyperionData = s.ToArray(); }
public void CanSerializeConstructorInfo() { var constructorInfo = typeof(Dummy).GetConstructor(new[] { typeof(string) }); var serializer = new Hyperion.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 CanSerializeDefaultExpression() { var expr = Expression.Default(typeof(int)); var serializer = new Hyperion.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 CanSerializeLabelTarget() { var label = Expression.Label(typeof(int), "testLabel"); var serializer = new Hyperion.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 CanSerializeBinaryExpression() { var expr = Expression.Add(Expression.Constant(1), Expression.Constant(2)); var serializer = new Hyperion.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 Hyperion.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 CanSerializeTargetInvocationException() { var exc = new TargetInvocationException(null); var serializer = new Hyperion.Serializer(); using (var stream = new MemoryStream()) { serializer.Serialize(exc, stream); stream.Position = 0; var deserialized = serializer.Deserialize <TargetInvocationException>(stream); Assert.Equal(exc.Message, deserialized.Message); Assert.Equal(exc.StackTrace, deserialized.StackTrace); } }
public void CanSerializeConstantExpression() { var expr = Expression.Constant(12); var serializer = new Hyperion.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 CanSerializeUnaryExpression() { var expr = Expression.Decrement(Expression.Constant(1)); var serializer = new Hyperion.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()); } }
/// <summary> /// Reads a serialized status object from file. /// </summary> /// <param name="path"> /// The file path. /// </param> /// <typeparam name="T"> /// The type of the expected deserialized object. /// </typeparam> /// <returns> /// The deserialized status object. /// </returns> public static T ReadFromFile <T>(string path) where T : StatusBase { T status; lock (StatusFileLock) { using (var file = File.OpenRead(path)) { status = new Hyperion.Serializer().Deserialize <T>(file); } } return(status); }
public void CanSerializeMemberAssignment() { var property = typeof(Dummy).GetProperty("TestProperty"); var expr = Expression.Bind(property.SetMethod, Expression.Constant(9)); var serializer = new Hyperion.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 Hyperion.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 CanSerializeConditionalExpression() { var expr = Expression.Condition(Expression.Constant(true), Expression.Constant(1), Expression.Constant(2)); var serializer = new Hyperion.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 CanSerializeLabelExpression() { var label = Expression.Label(typeof(int), "testLabel"); var expr = Expression.Label(label, Expression.Constant(2)); var serializer = new Hyperion.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 CanSerializeObjectDisposedException() { var exc = new ObjectDisposedException("Object is already disposed", new ArgumentException("One level deeper")); var serializer = new Hyperion.Serializer(); using (var stream = new MemoryStream()) { serializer.Serialize(exc, stream); stream.Position = 0; var deserialized = serializer.Deserialize <ObjectDisposedException>(stream); Assert.Equal(exc.Message, deserialized.Message); Assert.Equal(exc.StackTrace, deserialized.StackTrace); Assert.Equal(exc.InnerException.GetType(), deserialized.InnerException.GetType()); Assert.Equal(exc.InnerException.Message, deserialized.InnerException.Message); Assert.Equal(exc.InnerException.StackTrace, deserialized.InnerException.StackTrace); } }
public void CanSerializeGotoExpression() { var label = Expression.Label(typeof(void), "testLabel"); var expr = Expression.Continue(label); var serializer = new Hyperion.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 CanSerializeNewExpression() { var ctor = typeof(Dummy).GetConstructor(new[] { typeof(string) }); var expr = Expression.New(ctor, Expression.Constant("test param")); var serializer = new Hyperion.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 CanSerializeBlockExpression() { var expr = Expression.Block(new[] { Expression.Constant(1), Expression.Constant(2), Expression.Constant(3) }); var serializer = new Hyperion.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 Hyperion.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 CanSerializeMethodCallExpression() { var methodInfo = typeof(Dummy).GetMethod("Fact"); var expr = Expression.Call(Expression.Constant(new Dummy()), methodInfo, Expression.Constant("test string")); var serializer = new Hyperion.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 Hyperion.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 CanSerializeDebugInfoExpression() { var info = Expression.SymbolDocument("testFile"); var expr = Expression.DebugInfo(info, 1, 2, 3, 4); var serializer = new Hyperion.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 Hyperion.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); } }