Changeset 15529 for branches/PersistenceReintegration/HeuristicLab.Tests

Timestamp:

12/15/17 13:26:49 (7 years ago)

Author:

jkarder

Message:

#2520: worked on new persistence

• changed message definitions
• updated transformers
• worked on conversions
• cleaned up

File:

• branches/PersistenceReintegration/HeuristicLab.Tests/HeuristicLab.Persistence-3.3/UseCasesPersistenceNew.cs (modified) (8 diffs)

branches/PersistenceReintegration/HeuristicLab.Tests/HeuristicLab.Persistence-3.3/UseCasesPersistenceNew.cs

@@ -408 +408 @@
     }
 
-    public string Profile(Func<object> GenerateDataFunc) {
+    public string Profile(Func<object> GenerateDataFunc, string filename = null) {
       int nrOfRepetitions = 30;
       StringBuilder report = new StringBuilder();
@@ -417 +417 @@
       }
 
-      report.Append("Performance Report for " + GenerateDataFunc.Method.Name + ": " + Environment.NewLine);
+      //report.Append("Performance Report for " + GenerateDataFunc.Method.Name + ": " + Environment.NewLine);
       report.Append(Environment.NewLine);
-      report.AppendFormat("Avg. old vs. new time for serializing a file; {0};{1};{2}",
+      report.AppendFormat("Avg. old vs. new time for serializing a file; {3};{0};{1};{2}",
               dataList.Select(x => x.OldSerializingTime).Average(),
               dataList.Select(x => x.NewSerializingTime).Average(),
               dataList.Select(x => x.OldSerializingTime.TotalMilliseconds).Average() / dataList.Select(x => x.NewSerializingTime.TotalMilliseconds).Average()
-              );
+              , filename);
       report.Append(Environment.NewLine);
-      report.AppendFormat("Avg. old vs. new time for deserializing a file; {0};{1};{2}",
+      report.AppendFormat("Avg. old vs. new time for deserializing a file; {3};{0};{1};{2}",
               dataList.Select(x => x.OldDeserializingTime).Average(),
               dataList.Select(x => x.NewDeserializingTime).Average(),
               dataList.Select(x => x.OldDeserializingTime.TotalMilliseconds).Average() / dataList.Select(x => x.NewDeserializingTime.TotalMilliseconds).Average()
-              );
+              , filename);
       report.Append(Environment.NewLine);
-      report.AppendFormat("Avg. old vs. new file size (in bytes); {0};{1};{2}",
+      report.AppendFormat("Avg. old vs. new file size (in bytes); {3};{0};{1};{2}",
               dataList.Select(x => x.OldFileSize).Average(),
               dataList.Select(x => x.NewFileSize).Average(),
               dataList.Select(x => x.OldFileSize).Average() / dataList.Select(x => x.NewFileSize).Average()
-              );
+              , filename);
       report.Append(Environment.NewLine);
-      report.AppendFormat("Avg. old vs. new memory consumption for serializing a file (in bytes); {0};{1};{2}",
+      report.AppendFormat("Avg. old vs. new memory consumption for serializing a file (in bytes); {3};{0};{1};{2}",
               dataList.Select(x => x.OldSerializingMemoryConsumed).Average(),
               dataList.Select(x => x.NewSerializingMemoryConsumed).Average(),
               dataList.Select(x => x.OldSerializingMemoryConsumed).Average() / dataList.Select(x => x.NewSerializingMemoryConsumed).Average()
-              );
+              , filename);
       report.Append(Environment.NewLine);
-      report.AppendFormat("Avg. old vs. new memory consumption for deserializing a file (in bytes); {0};{1};{2}",
+      report.AppendFormat("Avg. old vs. new memory consumption for deserializing a file (in bytes); {3};{0};{1};{2}",
               dataList.Select(x => x.OldDeserializingMemoryConsumed).Average(),
               dataList.Select(x => x.NewDeserializingMemoryConsumed).Average(),
               dataList.Select(x => x.OldDeserializingMemoryConsumed).Average() / dataList.Select(x => x.NewDeserializingMemoryConsumed).Average()
-              );
+              , filename);
       report.Append(Environment.NewLine);
 
@@ -2160 +2160 @@
 
 
-    [StorableType("B72C58C8-3321-4706-AA94-578F57337070", 2)]
+    [StorableType("B72C58C8-3321-4706-AA94-578F57337070")]
     private class NewBaseType {
       [Storable]
       public DoubleValue[] items;
     }
-    [StorableType("00000000-0000-0000-0000-BADCAFFEE000", 2)] // for testing (version 2)
+    [StorableType("00000000-0000-0000-0000-BADCAFFEE001", 2)] // for testing (version 2)
     private class V2 : NewBaseType {
       [Storable]
@@ -2189 +2189 @@
     }
 
-    [StorableType("00000000-0000-0000-0000-BADCAFFEE200", 3)] // for testing (version 3)
+    [StorableType("00000000-0000-0000-0000-BADCAFFEE002", 3)] // for testing (version 3)
     private class V3 : NewBaseType {
       [Storable]
@@ -2215 +2215 @@
       private static Dictionary<string, object> ConvertV1(Dictionary<string, object> values) {
         var newValues = new Dictionary<string, object>();
-        var items = (ItemCollection<IItem>)values["OldBaseType.items"];
-        newValues["NewBaseType.items"] = items.Select(iv => new DoubleValue((double)(((dynamic)iv).Value))).ToArray();
-        newValues["V2.a"] = ((IntValue)values["V1.a"]).Value;
-        newValues["V2.val"] = ((ItemList<IntValue>)values["V1.vals"]).Select(iv => iv.Value).ToArray();
-
-        newValues["V2.mySelf"] = values["V1.mySelf"]; // myself type will be mapped correctly
-
-        var tup = (Tuple<int, int>)values["V1.tup"];
+        var items = (ItemCollection<IItem>)values["F9F51075-490C-48E3-BF64-14514A210149.items"];
+        newValues["B72C58C8-3321-4706-AA94-578F57337070.items"] = items.Select(iv => new DoubleValue((double)(((dynamic)iv).Value))).ToArray();
+        newValues["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.a"] = ((IntValue)values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.a"]).Value;
+        newValues["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.val"] = ((ItemList<IntValue>)values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.vals"]).Select(iv => iv.Value).ToArray();
+
+        newValues["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.mySelf"] = values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.mySelf"]; // myself type will be mapped correctly
+
+        var tup = (Tuple<int, int>)values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.tup"];
         if (tup != null) {
-          newValues["V2.TupItem1"] = tup.Item1;
-          newValues["V2.TupItem2"] = tup.Item2;
+          newValues["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.TupItem1"] = tup.Item1;
+          newValues["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.TupItem2"] = tup.Item2;
         }
 
-        newValues["V2.coords"] = new Point((int)values["V1.x"], (int)values["V1.y"]);
+        newValues["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.coords"] = new Point((int)values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.x"], (int)values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.y"]);
 
         return newValues;
@@ -2236 +2236 @@
       private static Dictionary<string, object> ConvertV2(Dictionary<string, object> values) {
         var newValues = new Dictionary<string, object>();
-        newValues["NewBaseType.items"] = values["NewBaseType.items"];
-        newValues["V3.a"] = values["V2.a"];
-        newValues["V3.val"] = values["V2.val"];
-        newValues["V3.mySelf"] = values["V2.mySelf"];
-
-        newValues["V3.tup"] = Tuple.Create((int)values["V2.TupItem1"], (int)values["V2.TupItem2"]);
-        newValues["V3.coords"] = values["V2.coords"];
+        newValues["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.a"] = values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.a"];
+        newValues["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.val"] = values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.val"];
+        newValues["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.mySelf"] = values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.mySelf"];
+
+        newValues["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.tup"] = Tuple.Create((int)values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.TupItem1"], (int)values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.TupItem2"]);
+        newValues["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.coords"] = values["D211A828-6440-4E72-A8C7-AA4F9B4FFA75.coords"];
 
         return newValues;
@@ -2270 +2269 @@
       Mapper.StaticCache.DeregisterType(StorableTypeAttribute.GetStorableTypeAttribute(typeof(V2)).Guid);
       Mapper.StaticCache.DeregisterType(StorableTypeAttribute.GetStorableTypeAttribute(typeof(V3)).Guid);
-
       Mapper.StaticCache.RegisterType(StorableTypeAttribute.GetStorableTypeAttribute(typeof(V1)).Guid, typeof(V3));
-      var pi = typeof(StorableTypeAttribute).GetProperty("Guid");
-      pi.SetValue(
-        Mapper.StaticCache.GetTypeInfo(typeof(V3)).StorableTypeAttribute,
-        StorableTypeAttribute.GetStorableTypeAttribute(typeof(V1)).Guid,
-        null);
+
+      var typeInfosField = typeof(StaticCache).GetField("typeInfos", BindingFlags.NonPublic | BindingFlags.Instance);
+      var typeInfos = (Dictionary<Type, Persistence.TypeInfo>)typeInfosField.GetValue(Mapper.StaticCache);
+
+      var guidPI = typeof(StorableTypeAttribute).GetProperty("Guid");
+      var convPI = typeof(Persistence.TypeInfo).GetProperty("ConversionMethods");
+
+      var oldBInfo = typeInfos[typeof(V1)];
+      var newBInfo = Mapper.StaticCache.GetTypeInfo(typeof(V3));
+      guidPI.SetValue(newBInfo.StorableTypeAttribute, oldBInfo.StorableTypeAttribute.Guid);
+      //convPI.SetValue(newBInfo, oldBInfo.ConversionMethods);
+      typeInfos.Remove(typeof(V1));
 
       object o = serializer.Deserialize(tempFile);
@@ -2348 +2353 @@
           serializer.Serialize(original, fileName + ".proto");
           // var newVersion = serializer.Deserialize(fileName + ".proto");
-          Console.WriteLine("File: " + fileName);
-          var p = Profile(() => original);
+          //Console.WriteLine("File: " + fileName);
+          var p = Profile(() => original, Path.GetFileName(fileName));
           Console.WriteLine(p);
         }
       }
     }
+
+    [StorableType("3B48A44F-93E2-4ECC-A9B9-56E425EF96F8")]
+    private class ConversionA {
+      [Storable]
+      public int f;
+    }
+
+    [StorableType("00000000-0000-0000-0000-000000000002", 2)]
+    private class ConversionANew {
+      [Storable]
+      public int g;
+    }
+
+    [StorableType("7CBF2251-CF9F-4D9E-AA7B-C65495AE078F")]
+    private class ConversionB : ConversionA {
+      [Storable]
+      public int f;
+      public int BaseF { get { return base.f; } }
+
+      public ConversionB() {
+
+      }
+
+      public ConversionB(int myF, int baseF) {
+        this.f = myF;
+        base.f = baseF;
+      }
+    }
+
+    [StorableType("00000000-0000-0000-0000-000000000001", 2)]
+    private class ConversionBNew : ConversionANew {
+      [Storable]
+      public int g;
+
+      public int BaseG { get { return base.g; } }
+    }
+
+    private static class NewConversions {
+      [StorableConversion("7CBF2251-CF9F-4D9E-AA7B-C65495AE078F", 1)]
+      private static Dictionary<string, object> ConvertB(Dictionary<string, object> values) {
+        var newValues = new Dictionary<string, object>();
+        newValues["7CBF2251-CF9F-4D9E-AA7B-C65495AE078F.g"] = values["7CBF2251-CF9F-4D9E-AA7B-C65495AE078F.f"];
+        return newValues;
+      }
+
+      [StorableConversion("3B48A44F-93E2-4ECC-A9B9-56E425EF96F8", 1)]
+      private static Dictionary<string, object> ConvertA(Dictionary<string, object> values) {
+        var newValues = new Dictionary<string, object>();
+        newValues["3B48A44F-93E2-4ECC-A9B9-56E425EF96F8.g"] = values["3B48A44F-93E2-4ECC-A9B9-56E425EF96F8.f"];
+        return newValues;
+      }
+    }
+
+    [TestMethod]
+    [TestCategory("Persistence4")]
+    [TestProperty("Time", "short")]
+    public void TestConversionCase1() {
+      var test = new Func<ConversionB>(() => {
+        return new ConversionB(1, 2);
+      });
+
+      ProtoBufSerializer serializer = new ProtoBufSerializer();
+      var old = test();
+      serializer.Serialize(old, tempFile);
+      Mapper.StaticCache.DeregisterType(StorableTypeAttribute.GetStorableTypeAttribute(typeof(ConversionB)).Guid);
+      Mapper.StaticCache.DeregisterType(StorableTypeAttribute.GetStorableTypeAttribute(typeof(ConversionBNew)).Guid);
+      Mapper.StaticCache.DeregisterType(StorableTypeAttribute.GetStorableTypeAttribute(typeof(ConversionA)).Guid);
+      Mapper.StaticCache.DeregisterType(StorableTypeAttribute.GetStorableTypeAttribute(typeof(ConversionANew)).Guid);
+      Mapper.StaticCache.RegisterType(StorableTypeAttribute.GetStorableTypeAttribute(typeof(ConversionB)).Guid, typeof(ConversionBNew));
+      Mapper.StaticCache.RegisterType(StorableTypeAttribute.GetStorableTypeAttribute(typeof(ConversionA)).Guid, typeof(ConversionANew));
+
+      var typeInfosField = typeof(StaticCache).GetField("typeInfos", BindingFlags.NonPublic | BindingFlags.Instance);
+      var typeInfos = (Dictionary<Type, Persistence.TypeInfo>)typeInfosField.GetValue(Mapper.StaticCache);
+
+      var guidPI = typeof(StorableTypeAttribute).GetProperty("Guid");
+      var convPI = typeof(Persistence.TypeInfo).GetProperty("ConversionMethods");
+
+      var oldAInfo = typeInfos[typeof(ConversionA)];
+      var newAInfo = Mapper.StaticCache.GetTypeInfo(typeof(ConversionANew));
+      guidPI.SetValue(newAInfo.StorableTypeAttribute, oldAInfo.StorableTypeAttribute.Guid);
+      //convPI.SetValue(newAInfo, oldAInfo.ConversionMethods);
+      typeInfos.Remove(typeof(ConversionA));
+
+      var oldBInfo = typeInfos[typeof(ConversionB)];
+      var newBInfo = Mapper.StaticCache.GetTypeInfo(typeof(ConversionBNew));
+      guidPI.SetValue(newBInfo.StorableTypeAttribute, oldBInfo.StorableTypeAttribute.Guid);
+      //convPI.SetValue(newBInfo, oldBInfo.ConversionMethods);
+      typeInfos.Remove(typeof(ConversionB));
+
+      object o = serializer.Deserialize(tempFile);
+      var restored = (ConversionBNew)o;
+      Assert.AreEqual(restored.g, old.f);
+      Assert.AreEqual(restored.BaseG, old.BaseF);
+    }
   }
 }