public void TestObjectGraphTraversal() { GeneticAlgorithm ga = (GeneticAlgorithm)serializer.Deserialize(@"Test Resources\GA_SymbReg.hl"); var objects = ga.GetObjectGraphObjects().ToList(); // Should be 3982, but count may change slightly as members are added or removed Assert.IsTrue(objects.Count > 1, "Number of objects in the object graph seems to small."); }
public void it_should_be_serializable_deserialiazble() { var someData = new SomeData { stringValue = "qwerty", intValue = 12345, boolValue = false, stringArray = new[] { "q", "w", "e" } }; var stream = ProtoBufSerializer.Serialize(someData); stream.Should().NotBeNull(); ProtoBufSerializer.Deserialize <SomeData>(stream).ShouldBeEquivalentTo(someData); }
public void ProtoBuf() { var serializer = new ProtoBufSerializer <LogIn>(); var bytes = BinaryProtocol.FromObject(_loginCmd, "LogIn", serializer); var receivedPacket = new BinaryProtocol(bytes.GetDataToSend()); var obj = serializer.Deserialize(receivedPacket.Data); }
public void ProtoBufSerializer_Deserialize_GivenNullInput_ShouldReturnNull() { var protoBufSerializer = new ProtoBufSerializer(); var result = protoBufSerializer.Deserialize <object>(null); Assert.IsNull(result); }
public void ProtoBufSerializer_Deserialize_GivenNullInput_ShouldReturnNull() { var protoBufSerializer = new ProtoBufSerializer(); var result = protoBufSerializer.Deserialize<object>(null); Assert.IsNull(result); }
protected override IStorableContent LoadContent(string filename, out Info info) { bool useOldPersistence = XmlParser.CanOpen(filename); IStorableContent content = null; if (useOldPersistence) { var sw = new Stopwatch(); sw.Start(); content = XmlParser.Deserialize <IStorableContent>(filename); sw.Stop(); info = new Info(filename, sw.Elapsed); } else { var ser = new ProtoBufSerializer(); content = (IStorableContent)ser.Deserialize(filename, out SerializationInfo serInfo); info = new Info(filename, serInfo); } if (content == null) { throw new PersistenceException($"Cannot deserialize root element of {filename}"); } return(content); }
protected T DeserializeItem(QueueItem item) { using (var mx = new MemoryStream(item.Payload)) { switch (item.SerializationType) { case SerializationType.NewtonsoftJson: return(JsonConvert.DeserializeObject <T>( Encoding.UTF8.GetString(mx.ToArray()))); case SerializationType.BinaryFormatter: return((T)_binaryFormatter.Deserialize(mx)); case SerializationType.Xml: return((T)_xmlSerializer.Deserialize(mx)); case SerializationType.DataContractJsonSerializer: return((T)_dataContractJsonSerializer.ReadObject(mx)); case SerializationType.ProtocolBuffer: return(_protobufSerializer.Deserialize <T>(mx)); default: throw new ArgumentException( $"Unknown serialization type {item.SerializationType}"); } } }
public void GeneticAlgorithmPerformanceTest() { ex = null; GeneticAlgorithm ga = (GeneticAlgorithm)serializer.Deserialize(@"Test Resources\GA_TSP.hl"); ga.ExceptionOccurred += new EventHandler <EventArgs <Exception> >(ga_ExceptionOccurred); ga.SetSeedRandomly.Value = false; ga.Seed.Value = 0; ga.Prepare(); ga.Start(); if (ex != null) { throw ex; } TestContext.WriteLine("Runtime: {0}", ga.ExecutionTime.ToString()); double expectedBestQuality = 12332.0; double expectedAverageQuality = 13123.2; double expectedWorstQuality = 14538.0; double bestQuality = (ga.Results["CurrentBestQuality"].Value as DoubleValue).Value; double averageQuality = (ga.Results["CurrentAverageQuality"].Value as DoubleValue).Value; double worstQuality = (ga.Results["CurrentWorstQuality"].Value as DoubleValue).Value; TestContext.WriteLine(""); TestContext.WriteLine("CurrentBestQuality: {0} (should be {1})", bestQuality, expectedBestQuality); TestContext.WriteLine("CurrentAverageQuality: {0} (should be {1})", averageQuality, expectedAverageQuality); TestContext.WriteLine("CurrentWorstQuality: {0} (should be {1})", worstQuality, expectedWorstQuality); Assert.AreEqual(bestQuality, expectedBestQuality); Assert.AreEqual(averageQuality, expectedAverageQuality); Assert.AreEqual(worstQuality, expectedWorstQuality); }
public bool DeserializeMessage(StreamBuffer streamBuffer, int start, int len, ref int msgLen, ref HjSendMsgDef msgObj) { msgObj = default(HjSendMsgDef); msgLen = 0; if (len < sizeof(int)) { return(false); } byte[] data = streamBuffer.GetBuffer(); int _len = BitConverter.ToInt32(data, start); if (len < _len + sizeof(int)) { return(false); } msgLen = _len + sizeof(int); start += sizeof(int); MemoryStream ms = streamBuffer.memStream; BinaryReader br = streamBuffer.binaryReader; ms.Seek(start, SeekOrigin.Begin); uint requestSeq = br.ReadUInt32(); msgObj.requestSeq = requestSeq; msgObj.msgProto = ProtoBufSerializer.Deserialize(ms, typeof(ntf_battle_frame_data), _len - sizeof(int)); return(true); }
public void TestLoadingRunAndStoreSamples() { CreateAllSamples(); var path = SamplesUtils.SamplesDirectory; var serializer = new ProtoBufSerializer(); foreach (var fileName in Directory.EnumerateFiles(path, "*.hl")) { var original = serializer.Deserialize(fileName); var exec = original as IExecutable; if (exec != null) { exec.Paused += (sender, e) => { serializer.Serialize(exec, fileName + "_paused.proto"); Console.WriteLine("Serialized paused file: " + fileName); File.Delete(fileName + "_paused.proto"); }; exec.Stopped += (sender, e) => { serializer.Serialize(exec, fileName + "_stopped.proto"); Console.WriteLine("Serialized stopped file: " + fileName); File.Delete(fileName + "_stopped.proto"); }; var t = exec.StartAsync(); System.Threading.Thread.Sleep(20000); // wait 20 secs if (exec.ExecutionState == ExecutionState.Started) // only if not already stopped { exec.Pause(); } } } }
public void ProtobufDeserializeChatPacket() { //--------------------------------------------------------------------- //Setup //--------------------------------------------------------------------- ProtoBufSerializer serializer = new ProtoBufSerializer(); ChatMessagePacket Expectedpacket = new ChatMessagePacket("This is a test", "Tester"); List <Packet> packet = new List <Packet>(); byte[] data = { 162, 6, 16, 26, 14, 84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 116, 101, 115, 116, 8, 2, 18, 6, 84, 101, 115, 116, 101, 114 }; //--------------------------------------------------------------------- //Run Test //--------------------------------------------------------------------- packet.Add(serializer.Deserialize(data)); //--------------------------------------------------------------------- //Gather Output //--------------------------------------------------------------------- ChatMessagePacket output = (ChatMessagePacket)packet[0]; //--------------------------------------------------------------------- //Assert //--------------------------------------------------------------------- Assert.IsNotNull(data); Assert.AreEqual(Expectedpacket.message, output.message); Assert.AreEqual(Expectedpacket.sender, output.sender); Assert.AreEqual(Expectedpacket.type, output.type); }
private void LoadSample(string name, Assembly assembly, ListViewGroup group, int count) { using (var stream = assembly.GetManifestResourceStream(name)) { var serializer = new ProtoBufSerializer(); var item = (NamedItem)serializer.Deserialize(stream, false); OnSampleLoaded(item, group, 1.0 / count); } }
public void Deserialize() { var serializer = new ProtoBufSerializer(); using (var memStream = new MemoryStream(buffer)) { var obj = serializer.Deserialize(memStream); } }
public void TestCloningFinishedExperiment() { Experiment experiment = (Experiment)serializer.Deserialize(@"Test Resources\SamplesExperimentFinished.hl"); Experiment clone = (Experiment)experiment.Clone(new Cloner()); var intersections = CheckTotalInequality(experiment, clone).Where(x => x.GetType().FullName.StartsWith("HeuristicLab")); Assert.IsTrue(ProcessEqualObjects(experiment, intersections)); }
public void ProtoBufSerializer_Primitives <T>(T value) { // arrange var serializer = new ProtoBufSerializer(); // act var data = serializer.Serialize(value); var result = serializer.Deserialize(data, typeof(T)); result.Should().Be(value); }
public void ProtoBufSerializer_Deserialize_GivenValidReferenceType_ShouldReturnReferenceType() { var protoBufSerializer = new ProtoBufSerializer(); var input = "test"; var serialized = protoBufSerializer.Serialize(input); var deserialized = protoBufSerializer.Deserialize <string>(serialized); Assert.IsNotNull(deserialized); Assert.AreEqual("test", deserialized); }
public void ProtoBufSerializer_Deserialize_GivenValidValueType_ShouldReturnValueType() { var protoBufSerializer = new ProtoBufSerializer(); var input = 123; var serialized = protoBufSerializer.Serialize(input); var deserialized = protoBufSerializer.Deserialize <int>(serialized); Assert.IsNotNull(deserialized); Assert.AreEqual(123, deserialized); }
public void ProtoBufSerializer_Deserialize_GivenValidValueType_ShouldReturnValueType() { var protoBufSerializer = new ProtoBufSerializer(); var input = 123; var serialized = protoBufSerializer.Serialize(input); var deserialized = protoBufSerializer.Deserialize<int>(serialized); Assert.IsNotNull(deserialized); Assert.AreEqual(123, deserialized); }
protected T CloneByPersistence <T>(T value) { using (var serializerStream = new MemoryStream()) { var serializer = new ProtoBufSerializer(); serializer.Serialize(value, serializerStream, disposeStream: false); var bytes = serializerStream.GetBuffer(); using (var deserializerStream = new MemoryStream(bytes)) { return((T)serializer.Deserialize(deserializerStream)); } } }
public void ProtoBufSerializer_Deserialize_GivenValidReferenceType_ShouldReturnReferenceType() { var protoBufSerializer = new ProtoBufSerializer(); var input = "test"; var serialized = protoBufSerializer.Serialize(input); var deserialized = protoBufSerializer.Deserialize<string>(serialized); Assert.IsNotNull(deserialized); Assert.AreEqual("test", deserialized); }
public T ReceiceRequest <T>() { if (_httpContext.Request.ContentLength64 == 0) { return(ProtoBufSerializer.Deserialize <T>(RpcNull.EmptyStream)); } else { return(ProtoBufSerializer.Deserialize <T>(_httpContext.Request.InputStream)); } }
public void ProtoBufSerializer_Pocco() { // arrange var serializer = new ProtoBufSerializer(); var item = SerializerPoccoSerializable.Create(); // act var data = serializer.Serialize(item); var result = serializer.Deserialize(data, item.GetType()); result.ShouldBeEquivalentTo(item); }
public void TestLoadingSamples() { CreateAllSamples(); var path = SamplesUtils.SamplesDirectory; var serializer = new ProtoBufSerializer(); foreach (var fileName in Directory.EnumerateFiles(path, "*.hl")) { var original = serializer.Deserialize(fileName); var ok = true; foreach (var t in original.GetObjectGraphObjects().Select(o => o.GetType())) { if ( t.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public) .Any(ctor => StorableConstructorAttribute.IsStorableConstructor(ctor))) { try { if (t.IsGenericType) { var g = Mapper.StaticCache.GetGuid(t.GetGenericTypeDefinition()); } else { var g = Mapper.StaticCache.GetGuid(t); } } catch (Exception e) { Console.WriteLine($"type {t.FullName} in {fileName} is not registered with a GUID in HEAL.Attic"); ok = false; } } } if (ok) { serializer.Serialize(original, fileName + ".proto"); var newVersion = serializer.Deserialize(fileName + ".proto"); Console.WriteLine("File: " + fileName); File.Delete(fileName + ".proto"); } } }
public void TestProtoBufSerializerDeserialize() { // Arrange byte[] b = { 10, 5, 75, 101, 118, 105, 110, 16, 5 }; ProtoBufSerializer serializer = new ProtoBufSerializer(); // Act ProtoBufSerializerTestEntity entity = serializer.Deserialize<ProtoBufSerializerTestEntity>(b); // Assert Assert.AreEqual("Kevin", entity.Name); Assert.AreEqual(5, entity.Number); }
public void TestDeSerialize() { var serializer = new ProtoBufSerializer(); var t = serializer.Serialize(new VPb { A = 10, B = 20, }); var r = serializer.Deserialize <VPb>(t); Assert.AreEqual(r.A, 10); }
public void Serialize_Deserialize() { // simple round-trip: here we're just testing ProtoBufSerializer .. not much point var sut = new ProtoBufSerializer(new ProtoBufOptions()); var expected = new TestClass { StringProperty = "string value" }; var bytes = sut.Serialize(expected); var actual = sut.Deserialize(typeof(TestClass), bytes) as TestClass; Assert.NotNull(actual); Assert.NotSame(expected, actual); Assert.Equal(expected.StringProperty, actual.StringProperty); }
public void TestPoint2d() { var tag = new IntValue(10); var p = new Point2D <double>(1.0, 2.0, tag); var ser = new ProtoBufSerializer(); ser.Serialize(p, tempFile); var p2 = (Point2D <double>)ser.Deserialize(tempFile); Assert.AreEqual(p.X, p2.X); Assert.AreEqual(p.Y, p2.Y); var tag2 = (IntValue)p2.Tag; Assert.AreEqual(tag.Value, tag2.Value); }
public void ProtoBufSerializer_List() { // arrange var serializer = new ProtoBufSerializer(); var items = new List <SerializerPoccoSerializable>() { SerializerPoccoSerializable.Create(), SerializerPoccoSerializable.Create(), SerializerPoccoSerializable.Create() }; // act var data = serializer.Serialize(items); var result = serializer.Deserialize(data, items.GetType()); result.ShouldBeEquivalentTo(items); }
public void TestIndexedDataTable() { var dt = new IndexedDataTable <int>("test", "test description"); var dr = new IndexedDataRow <int>("test row"); dr.Values.Add(Tuple.Create(1, 1.0)); dr.Values.Add(Tuple.Create(2, 2.0)); dr.Values.Add(Tuple.Create(3, 3.0)); dt.Rows.Add(dr); var ser = new ProtoBufSerializer(); ser.Serialize(dt, tempFile); var dt2 = (IndexedDataTable <int>)ser.Deserialize(tempFile); Assert.AreEqual(dt.Rows["test row"].Values[0], dt2.Rows["test row"].Values[0]); Assert.AreEqual(dt.Rows["test row"].Values[1], dt2.Rows["test row"].Values[1]); Assert.AreEqual(dt.Rows["test row"].Values[2], dt2.Rows["test row"].Values[2]); }
public static T Deserialize <T>(byte[] sjob) { var ser = new ProtoBufSerializer(); try { return((T)ser.Deserialize(sjob)); } catch (PersistenceException e) { if (e.InnerException is InvalidDataException) { // We assume the data was not serialized with HEAL.Attic, but with the former // XML-based persistence return(DeserializeWithXmlParser <T>(sjob)); } else { throw; } } }
private static void Benchmark(Func <int, Random, object> createObj) { var sw = new Stopwatch(); var serializer = new ProtoBufSerializer(); long serializationTime = 0; long deserializationTime = 0; var rand = new Random(1234); long fileSize = 0; Console.WriteLine("| Elements | Serialization time (ms) | Deserialization time (ms) | File size (kB) | avg. bytes per element |"); Console.WriteLine("|---------:|------------------------:|--------------------------:|---------------:|------------------------|"); for (int e = 13; e <= 21; e++) { for (int reps = 0; reps < REPS; reps++) { var obj = createObj(1 << e, rand); sw.Reset(); sw.Start(); byte[] buf; using (var memStream = new MemoryStream()) { serializer.Serialize(obj, memStream, false); buf = memStream.GetBuffer(); fileSize = memStream.Position; } sw.Stop(); serializationTime += sw.ElapsedMilliseconds; var fixedBuf = new byte[fileSize]; Array.Copy(buf, fixedBuf, fileSize); sw.Reset(); sw.Start(); using (var memStream = new MemoryStream(fixedBuf)) obj = serializer.Deserialize(memStream); sw.Stop(); deserializationTime += sw.ElapsedMilliseconds; } int numElems = 1 << e; Console.WriteLine($"| {numElems,8} | {serializationTime / (double)REPS,23:N1} | {deserializationTime / (double)REPS,25:N1} | {fileSize / 1024.0,14:N1} | {fileSize / (double)numElems,22:N1} | "); } }
protected virtual void loadProblemDataButton_Click(object sender, EventArgs e) { if (loadProblemDataFileDialog.ShowDialog(this) != DialogResult.OK) { return; } try { var ser = new ProtoBufSerializer(); object hlFile = ser.Deserialize(loadProblemDataFileDialog.FileName); IDataAnalysisProblemData problemData = null; if (hlFile is IDataAnalysisProblemData) { problemData = (IDataAnalysisProblemData)hlFile; } else if (hlFile is IDataAnalysisProblem) { problemData = ((IDataAnalysisProblem)hlFile).ProblemData; } else if (hlFile is IDataAnalysisSolution) { problemData = ((IDataAnalysisSolution)hlFile).ProblemData; } if (problemData == null) { throw new InvalidOperationException("The chosen HeuristicLab file does not contain a ProblemData, Problem, or DataAnalysisSolution."); } var solution = (IDataAnalysisSolution)Content.Clone(); solution.ProblemData = problemData; if (!solution.Name.EndsWith(" with loaded problemData")) { solution.Name += " with loaded problemData"; } MainFormManager.MainForm.ShowContent(solution); } catch (InvalidOperationException invalidOperationException) { ErrorHandling.ShowErrorDialog(this, invalidOperationException); } catch (ArgumentException argumentException) { ErrorHandling.ShowErrorDialog(this, argumentException); } }
void Test5() { msSend.SetLength(SENF_BUFFER_LEN); msSend.Seek(0, SeekOrigin.Begin); ntf_battle_frame_data dataTmp = ProtoFactory.Get <ntf_battle_frame_data>(); ntf_battle_frame_data.one_slot oneSlot = ProtoFactory.Get <ntf_battle_frame_data.one_slot>(); ntf_battle_frame_data.cmd_with_frame cmdWithFrame = ProtoFactory.Get <ntf_battle_frame_data.cmd_with_frame>(); one_cmd oneCmd = ProtoFactory.Get <one_cmd>(); cmdWithFrame.cmd = oneCmd; oneSlot.cmd_list.Add(cmdWithFrame); dataTmp.slot_list.Add(oneSlot); DeepCopyData(data, dataTmp); ProtoBufSerializer.Serialize(msSend, dataTmp); ProtoFactory.Recycle(dataTmp); //*************回收,很重要 msSend.SetLength(msSend.Position); //长度一定要设置对 msSend.Seek(0, SeekOrigin.Begin); //指针一定要复位 //msRecive.SetLength(msSend.Length);//同理,但是如果Deserialize指定长度,则不需要设置流长度 msRecive.Seek(0, SeekOrigin.Begin); //同理 Buffer.BlockCopy(msSend.GetBuffer(), 0, msRecive.GetBuffer(), 0, (int)msSend.Length); dataTmp = ProtoBufSerializer.Deserialize(msRecive, typeof(ntf_battle_frame_data), (int)msSend.Length) as ntf_battle_frame_data; PrintData(dataTmp); ProtoFactory.Recycle(dataTmp);//*************回收,很重要 data.server_curr_frame++; data.server_to_slot++; data.server_from_slot++; data.time++; data.slot_list[0].slot++; data.slot_list[0].cmd_list[0].server_frame++; data.slot_list[0].cmd_list[0].cmd.cmd_id++; data.slot_list[0].cmd_list[0].cmd.UID++; data.slot_list[0].cmd_list[0].cmd.cmd_data[0]++; data.slot_list[0].cmd_list[0].cmd.cmd_data[DATA_BYTE_LENGTH - 1]++; }
private void TestLuaEncodeAndCSDecode(byte[] luaEncodeBytes) { #if !FOR_GC_TEST // 打印字节流 Debug.Log("CS receive from Lua =================>>>" + luaEncodeBytes.Length + " bytes : "); var sb = new StringBuilder(); for (int i = 0; i < luaEncodeBytes.Length; i++) { sb.AppendFormat("{0}\t", luaEncodeBytes[i]); } Logger.Log(sb.ToString()); #endif // 解析协议 msRecive.ResetStream(); msRecive.CopyFrom(luaEncodeBytes, 0, 0, luaEncodeBytes.Length); ntf_battle_frame_data dataTmp = ProtoBufSerializer.Deserialize(msRecive.memStream, typeof(ntf_battle_frame_data), (int)luaEncodeBytes.Length) as ntf_battle_frame_data; #if !FOR_GC_TEST PrintData(dataTmp); #endif ProtoFactory.Recycle(dataTmp);//*************回收,很重要 }