Changeset 16210 for branches/PersistenceReintegration/HeuristicLab.Tests/HeuristicLab.Persistence-3.3/UseCasesPersistenceNew.cs

Timestamp:

10/03/18 17:48:20 (6 years ago)

Author:

jkarder

Message:

#2520: worked on new persistence

• added cache for different attributes
• refactored StorableTypeBoxTransformer
• implemented paths for Storable members
• implemented more unit tests

File:

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

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

@@ -32 +32 @@
 using System.Threading.Tasks;
 using HeuristicLab.Algorithms.GeneticAlgorithm;
-using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Persistence;
@@ -327 +326 @@
     }
 
-    public static void DeregisterType(Type type) {
-      var typeInfo = GetTypeInfo(type);
-      type2Guid.Remove(guid2Type[typeInfo.StorableTypeAttribute.Guid]);
-      guid2Type.Remove(typeInfo.StorableTypeAttribute.Guid);
+    public static void DeregisterType(Guid guid) {
+      if (!guid2Type.ContainsKey(guid)) return;
+      type2Guid.Remove(guid2Type[guid]);
+      guid2Type.Remove(guid);
     }
 
@@ -337 +336 @@
     }
 
-    //public static void RemoveTypeInfo(Type type) {
-    //  typeInfos.Remove(typeof(ConversionA));
+    private static void ReplaceTypeImplementation(Type old, Guid oldGuid, Type @new) {
+      DeregisterType(oldGuid);
+      DeregisterType(StorableTypeAttribute.GetStorableTypeAttribute(@new).Guid);
+
+      RegisterType(oldGuid, @new);
+      SetTypeGuid(@new, oldGuid);
+      typeInfos.Remove(old);
+    }
+
+    //public static Guid GetTypeGuid(Type type) {
+    //  var typeInfo = GetTypeInfo(type);
+    //  return typeInfo.StorableTypeAttribute.Guid;
     //}
-
-    public static Guid GetTypeGuid(Type type) {
-      var typeInfo = GetTypeInfo(type);
-      return typeInfo.StorableTypeAttribute.Guid;
-    }
 
     public static void SetTypeGuid(Type type, Guid guid) {
       var typeInfo = GetTypeInfo(type);
       guidPropertyInfo.SetValue(typeInfo.StorableTypeAttribute, guid);
+
+      var reflectMethod = typeInfo.GetType().GetMethod("Reflect", BindingFlags.NonPublic | BindingFlags.Instance);
+      reflectMethod.Invoke(typeInfo, new object[0]);
     }
     #endregion
@@ -2670 +2677 @@
     //}
     #endregion
+
+    [StorableType("28A5F6B8-49AF-4C6A-AF0E-F92EB4511722")]
+    private class PersistenceTestA0 {
+      [Storable]
+      public IntValue v;
+    }
+
+    [StorableType("00000000-0000-0000-0000-0000000000A1")]
+    private class PersistenceTestA1 {
+      [Storable(OldName = "v")]
+      private IntValue v1 {
+        set { v = value.Value; }
+      }
+
+      [Storable(Name = "v2")]
+      public int v;
+    }
+
+    [StorableType("00000000-0000-0000-0000-0000000000A2")]
+    private class PersistenceTestA2 {
+      [Storable(OldName = "v")]
+      private IntValue v1 {
+        set { v2 = value.Value; }
+      }
+
+      [Storable(OldName = "v2")]
+      private int v2 {
+        set { v = (double)value; }
+      }
+
+      [Storable(Name = "v3")]
+      public double v;
+    }
+
+    [TestMethod]
+    [TestCategory("PersistenceNew.Conversion")]
+    [TestProperty("Time", "short")]
+    public void TestConversionSample1() {
+      var v0Type = typeof(PersistenceTestA0);
+      var v0Guid = StorableTypeAttribute.GetStorableTypeAttribute(v0Type).Guid;
+
+      var test = new Func<PersistenceTestA0>(() => {
+        return new PersistenceTestA0() { v = new IntValue(1337) };
+      });
+
+      ProtoBufSerializer serializer = new ProtoBufSerializer();
+      var v0 = test();
+      serializer.Serialize(v0, tempFile);
+
+      ReplaceTypeImplementation(v0Type, v0Guid, typeof(PersistenceTestA1));
+
+      var v1 = (PersistenceTestA1)serializer.Deserialize(tempFile);
+      Assert.AreEqual(v0.v.Value, v1.v);
+
+      ReplaceTypeImplementation(typeof(PersistenceTestA1), v0Guid, typeof(PersistenceTestA2));
+
+      var v2 = (PersistenceTestA2)serializer.Deserialize(tempFile);
+      Assert.AreEqual(v2.v, v1.v);
+    }
+
+    [StorableType("7DCED655-D724-492E-9C6A-A22B376BADB2")]
+    private class PersistenceTestB0 {
+      [Storable]
+      public Point p;
+    }
+
+    [StorableType("00000000-0000-0000-0000-0000000000B1")]
+    private class PersistenceTestB1 {
+      [Storable(AllowOneWay = true)]
+      private Point p {
+        set {
+          x = value.X;
+          y = value.Y;
+        }
+      }
+
+      [Storable]
+      public int x;
+
+      [Storable]
+      public int y;
+    }
+
+    [StorableType("00000000-0000-0000-0000-0000000000B2")]
+    private class PersistenceTestB2 {
+      [Storable(AllowOneWay = true)]
+      private int x { set { p = new Point(value, p.Y); } }
+
+      [Storable(AllowOneWay = true)]
+      private int y { set { p = new Point(p.X, value); } }
+
+      [Storable]
+      public Point p { get; private set; }
+    }
+
+    [TestMethod]
+    [TestCategory("PersistenceNew.Conversion")]
+    [TestProperty("Time", "short")]
+    public void TestConversionSample2() {
+      var v0Type = typeof(PersistenceTestB0);
+      var v0Guid = StorableTypeAttribute.GetStorableTypeAttribute(v0Type).Guid;
+
+      var test = new Func<PersistenceTestB0>(() => {
+        return new PersistenceTestB0() { p = new Point(1, 2) };
+      });
+
+      ProtoBufSerializer serializer = new ProtoBufSerializer();
+      var v0 = test();
+
+      // seriealize B0, deserialize B0
+      serializer.Serialize(v0, tempFile);
+      var newV0 = (PersistenceTestB0)serializer.Deserialize(tempFile);
+      Assert.AreEqual(v0.p.X, newV0.p.X);
+      Assert.AreEqual(v0.p.Y, newV0.p.Y);
+
+      // serialize B0, deserialize B1
+      ReplaceTypeImplementation(v0Type, v0Guid, typeof(PersistenceTestB1));
+      var v1 = (PersistenceTestB1)serializer.Deserialize(tempFile);
+      Assert.AreEqual(v0.p.X, v1.x);
+      Assert.AreEqual(v0.p.Y, v1.y);
+
+      // serialize B0, deserialize B2
+      ReplaceTypeImplementation(v0Type, v0Guid, typeof(PersistenceTestB2));
+      var v2 = (PersistenceTestB2)serializer.Deserialize(tempFile);
+      Assert.AreEqual(v0.p.X, v2.p.X);
+      Assert.AreEqual(v0.p.Y, v2.p.Y);
+
+      // serialize B1, deserialize B1
+      ReplaceTypeImplementation(v0Type, v0Guid, typeof(PersistenceTestB1));
+      serializer.Serialize(v1, tempFile);
+      var newV1 = (PersistenceTestB1)serializer.Deserialize(tempFile);
+      Assert.AreEqual(v1.x, newV1.x);
+      Assert.AreEqual(v1.y, newV1.y);
+
+      // serialize B1, deserialize B2
+      ReplaceTypeImplementation(v0Type, v0Guid, typeof(PersistenceTestB2));
+      v2 = (PersistenceTestB2)serializer.Deserialize(tempFile);
+      Assert.AreEqual(v1.x, v2.p.X);
+      Assert.AreEqual(v1.y, v2.p.Y);
+
+      // serialize B2, deserialize B2
+      serializer.Serialize(v2, tempFile);
+      var newV2 = (PersistenceTestB2)serializer.Deserialize(tempFile);
+      Assert.AreEqual(v2.p.X, newV2.p.X);
+      Assert.AreEqual(v2.p.Y, newV2.p.Y);
+    }
+
+    [StorableType("FB649DF5-5B99-45DE-807A-27E86CB22F4B")]
+    private class PersistenceTestC0 {
+      [Storable]
+      public PersistenceTestC0 neighbor;
+
+      [Storable]
+      public int value;
+    }
+
+    [StorableType("00000000-0000-0000-0000-0000000000C1")]
+    private class PersistenceTestC1 {
+      [Storable]
+      private PersistenceTestC1 neighbor;
+
+      [Storable]
+      public int neighborValue;
+
+      [Storable]
+      public int value;
+
+      [StorableHook(HookType.AfterDeserialization)]
+      private void AfterDeserialization() {
+        if (neighbor != null)
+          neighborValue = neighbor.value;
+      }
+    }
+
+    [TestMethod]
+    [TestCategory("PersistenceNew.Conversion")]
+    [TestProperty("Time", "short")]
+    public void TestConversionSample3() {
+      var v0Type = typeof(PersistenceTestC0);
+      var v0Guid = StorableTypeAttribute.GetStorableTypeAttribute(v0Type).Guid;
+
+      var test = new Func<PersistenceTestC0>(() => {
+        var c0 = new PersistenceTestC0() {
+          value = 90
+        };
+        c0.neighbor = c0;
+        return c0;
+      });
+
+      ProtoBufSerializer serializer = new ProtoBufSerializer();
+      var v0 = test();
+
+      // seriealize C0, deserialize C0
+      serializer.Serialize(v0, tempFile);
+      var newV0 = (PersistenceTestC0)serializer.Deserialize(tempFile);
+      Assert.AreEqual(v0.value, newV0.value);
+      Assert.ReferenceEquals(newV0.neighbor, newV0);
+
+      // serialize C0, deserialize C1
+      ReplaceTypeImplementation(v0Type, v0Guid, typeof(PersistenceTestC1));
+      var v1 = (PersistenceTestC1)serializer.Deserialize(tempFile);
+      Assert.AreEqual(v0.value, v1.value);
+      Assert.AreEqual(v1.neighborValue, v0.neighbor.value);
+    }
+
+    [StorableType("5AF91FB9-DB53-40BD-B961-A968D2F7CDE3")]
+    private class PersistenceTestSample4A0 {
+      [Storable]
+      public string Name;
+
+      [Storable]
+      public string Description;
+    }
+
+    [StorableType("5EDF9D5D-3B60-42E9-BA8D-7A007916D6AE")]
+    private class PersistenceTestSample4C0 : PersistenceTestSample4A0 {
+      [Storable]
+      public int p;
+    }
+
+    [StorableType("00000000-0000-0000-0000-0000000000D1")]
+    private class PersistenceTestSample4A1 {
+      [Storable]
+      public string Name;
+    }
+
+    [StorableType("A55EE4D0-EE2F-4DBD-834E-51200BFDBB9C")]
+    private class PersistenceTestSample4B : PersistenceTestSample4A1 {
+      [Storable(OldName = "base.Description")]
+      private string Description1 { set { Description = value; } }
+
+      [Storable(Name = "Description2")]
+      public string Description;
+    }
+
+    [StorableType("00000000-0000-0000-0000-0000000000E1")]
+    private class PersistenceTestSample4C1 : PersistenceTestSample4B {
+      [Storable]
+      public int p;
+    }
+
+    [StorableType("8CB577B8-C36B-4749-8CF4-33DE4D5AC4BF")]
+    class PersistenceTestSample4NewType0 : PersistenceTestSample4A1 {
+      [Storable]
+      public StringValue Description;
+    }
+
+    [StorableType("BCD9D34C-901C-44E6-B1FD-8F5E9E09D686")]
+    class AB {
+      [Storable(OldName = "5AF91FB9-DB53-40BD-B961-A968D2F7CDE3.Name", DefaultValue = "No name")]
+      public string Name;
+
+      [Storable(OldName = "A55EE4D0-EE2F-4DBD-834E-51200BFDBB9C.Description2", DefaultValue = "No description")]
+      public string Description;
+    }
+
+    [StorableType("00000000-0000-0000-0000-0000000000F1")]
+    class PersistenceTestSample4C2 : AB {
+      [Storable]
+      public int p;
+    }
+
+    [StorableType("00000000-0000-0000-0000-0000000001A1")]
+    class PersistenceTestSample4NewType1 : AB {
+      [Storable(OldName = "Description")]
+      private StringValue Description_Persistence_Setter {
+        set {
+          base.Description = value.Value;
+        }
+      }
+    }
+
+    [TestMethod]
+    [TestCategory("PersistenceNew.Conversion")]
+    [TestProperty("Time", "short")]
+    public void TestConversionSample4() {
+      var a0Type = typeof(PersistenceTestSample4A0);
+      var a0Guid = StorableTypeAttribute.GetStorableTypeAttribute(a0Type).Guid;
+      var c0Type = typeof(PersistenceTestSample4C0);
+      var c0Guid = StorableTypeAttribute.GetStorableTypeAttribute(c0Type).Guid;
+
+      var test = new Func<PersistenceTestSample4C0>(() => {
+        return new PersistenceTestSample4C0 {
+          Name = "test",
+          Description = "description",
+          p = 99
+        };
+      });
+
+      ProtoBufSerializer serializer = new ProtoBufSerializer();
+      var c0 = test();
+
+      // seriealize C0, deserialize C0
+      serializer.Serialize(c0, tempFile);
+      var newC0 = (PersistenceTestSample4C0)serializer.Deserialize(tempFile);
+      Assert.AreEqual(c0.Name, newC0.Name);
+      Assert.AreEqual(c0.Description, newC0.Description);
+      Assert.AreEqual(c0.p, newC0.p);
+
+      // serialize C0, deserialize C1
+      ReplaceTypeImplementation(c0Type, c0Guid, typeof(PersistenceTestSample4C1));
+      ReplaceTypeImplementation(a0Type, a0Guid, typeof(PersistenceTestSample4A1));
+      var c1 = (PersistenceTestSample4C1)serializer.Deserialize(tempFile);
+      Assert.AreEqual(c0.Name, c1.Name);
+      Assert.AreEqual(c0.Description, c1.Description);
+      Assert.AreEqual(c0.p, c1.p);
+
+      // serialize C1, deserialize C1
+      serializer.Serialize(c1, tempFile);
+      var newC1 = (PersistenceTestSample4C1)serializer.Deserialize(tempFile);
+      Assert.AreEqual(c1.Name, newC1.Name);
+      Assert.AreEqual(c1.Description, newC1.Description);
+      Assert.AreEqual(c1.p, newC1.p);
+
+      // serialize C1, deserialize C2
+      serializer.Serialize(c1, tempFile);
+      ReplaceTypeImplementation(c0Type, c0Guid, typeof(PersistenceTestSample4C2));
+      var c2 = (PersistenceTestSample4C2)serializer.Deserialize(tempFile);
+      Assert.AreEqual(c1.Name, c2.Name);
+      Assert.AreEqual(c1.Description, c2.Description);
+      Assert.AreEqual(c1.p, c2.p);
+
+      // serialize NewType0, deserialize NewType1
+      var newType0Type = typeof(PersistenceTestSample4NewType0);
+      var newType0Guid = StorableTypeAttribute.GetStorableTypeAttribute(newType0Type).Guid;
+
+      var newType0 = new PersistenceTestSample4NewType0 {
+        Name = "yeah",
+        Description = new StringValue("blubb")
+      };
+
+      serializer.Serialize(newType0, tempFile);
+      ReplaceTypeImplementation(newType0Type, newType0Guid, typeof(PersistenceTestSample4NewType1));
+      var newType1 = (PersistenceTestSample4NewType1)serializer.Deserialize(tempFile);
+      Assert.AreEqual(newType0.Name, newType1.Name);
+      Assert.AreEqual(newType0.Description.Value, newType1.Description);
+    }
     #endregion
   }