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);//*************回收，很重要
}
