#region License Information /* HeuristicLab * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL) * * This file is part of HeuristicLab. * * HeuristicLab is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * HeuristicLab is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with HeuristicLab. If not, see . */ #endregion using System; using System.Collections; using System.Collections.Generic; using System.Drawing; using System.IO; using System.Linq; using System.Reflection; using System.Text; using System.Text.RegularExpressions; using HeuristicLab.Persistence.Auxiliary; using HeuristicLab.Persistence.Core; using HeuristicLab.Persistence.Core.Tokens; using HeuristicLab.Persistence.Default.CompositeSerializers; using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; using HeuristicLab.Persistence.Default.DebugString; using HeuristicLab.Persistence.Default.Xml; using HeuristicLab.Persistence.Default.Xml.Primitive; using HeuristicLab.Persistence.Interfaces; using Microsoft.VisualStudio.TestTools.UnitTesting; using System.Threading.Tasks; using HeuristicLab.Algorithms.GeneticAlgorithm; namespace HeuristicLab.Persistence_33.Tests { [StorableClass] public class NumberTest { [Storable] private bool _bool = true; [Storable] private byte _byte = 0xFF; [Storable] private sbyte _sbyte = 0xF; [Storable] private short _short = -123; [Storable] private ushort _ushort = 123; [Storable] private int _int = -123; [Storable] private uint _uint = 123; [Storable] private long _long = 123456; [Storable] private ulong _ulong = 123456; public override bool Equals(object obj) { NumberTest nt = obj as NumberTest; if (nt == null) throw new NotSupportedException(); return nt._bool == _bool && nt._byte == _byte && nt._sbyte == _sbyte && nt._short == _short && nt._ushort == _ushort && nt._int == _int && nt._uint == _uint && nt._long == _long && nt._ulong == _ulong; } public override int GetHashCode() { return _bool.GetHashCode() ^ _byte.GetHashCode() ^ _sbyte.GetHashCode() ^ _short.GetHashCode() ^ _short.GetHashCode() ^ _int.GetHashCode() ^ _uint.GetHashCode() ^ _long.GetHashCode() ^ _ulong.GetHashCode(); } } [StorableClass] public class NonDefaultConstructorClass { [Storable] int value; public NonDefaultConstructorClass(int value) { this.value = value; } } [StorableClass] public class IntWrapper { [Storable] public int Value; private IntWrapper() { } public IntWrapper(int value) { this.Value = value; } public override bool Equals(object obj) { if (obj as IntWrapper == null) return false; return Value.Equals(((IntWrapper)obj).Value); } public override int GetHashCode() { return Value.GetHashCode(); } } [StorableClass] public class PrimitivesTest : NumberTest { [Storable] private char c = 'e'; [Storable] private long[,] _long_array = new long[,] { { 123, 456, }, { 789, 123 } }; [Storable] public List list = new List { 1, 2, 3, 4, 5 }; [Storable] private object o = new object(); public override bool Equals(object obj) { PrimitivesTest pt = obj as PrimitivesTest; if (pt == null) throw new NotSupportedException(); return base.Equals(obj) && c == pt.c && _long_array == pt._long_array && list == pt.list && o == pt.o; } public override int GetHashCode() { return base.GetHashCode() ^ c.GetHashCode() ^ _long_array.GetHashCode() ^ list.GetHashCode() ^ o.GetHashCode(); } } public enum TestEnum { va1, va2, va3, va8 } ; [StorableClass] public class RootBase { [Storable] private string baseString = " Serial "; [Storable] public TestEnum myEnum = TestEnum.va3; public override bool Equals(object obj) { RootBase rb = obj as RootBase; if (rb == null) throw new NotSupportedException(); return baseString == rb.baseString && myEnum == rb.myEnum; } public override int GetHashCode() { return baseString.GetHashCode() ^ myEnum.GetHashCode(); } } [StorableClass] public class Root : RootBase { [Storable] public Stack intStack = new Stack(); [Storable] public int[] i = new[] { 3, 4, 5, 6 }; [Storable(Name = "Test String")] public string s; [Storable] public ArrayList intArray = new ArrayList(new[] { 1, 2, 3 }); [Storable] public List intList = new List(new[] { 321, 312, 321 }); [Storable] public Custom c; [Storable] public List selfReferences; [Storable] public double[,] multiDimArray = new double[,] { { 1, 2, 3 }, { 3, 4, 5 } }; [Storable] public bool boolean = true; [Storable] public DateTime dateTime; [Storable] public KeyValuePair kvp = new KeyValuePair("Serial", 123); [Storable] public Dictionary dict = new Dictionary(); [Storable(DefaultValue = "default")] public string uninitialized; } public enum SimpleEnum { one, two, three } public enum ComplexEnum { one = 1, two = 2, three = 3 } [FlagsAttribute] public enum TrickyEnum { zero = 0, one = 1, two = 2 } [StorableClass] public class EnumTest { [Storable] public SimpleEnum simpleEnum = SimpleEnum.one; [Storable] public ComplexEnum complexEnum = (ComplexEnum)2; [Storable] public TrickyEnum trickyEnum = (TrickyEnum)15; } [StorableClass] public class Custom { [Storable] public int i; [Storable] public Root r; [Storable] public string name = "]]>"; } [StorableClass] public class Manager { public DateTime lastLoadTime; [Storable] private DateTime lastLoadTimePersistence { get { return lastLoadTime; } set { lastLoadTime = DateTime.Now; } } [Storable] public double? dbl; } [StorableClass] public class C { [Storable] public C[][] allCs; [Storable] public KeyValuePair, C> kvpList; } public class NonSerializable { int x = 0; public override bool Equals(object obj) { NonSerializable ns = obj as NonSerializable; if (ns == null) throw new NotSupportedException(); return ns.x == x; } public override int GetHashCode() { return x.GetHashCode(); } } [TestClass] public class UseCases { private string tempFile; [TestInitialize()] public void CreateTempFile() { tempFile = Path.GetTempFileName(); } [TestCleanup()] public void ClearTempFile() { StreamReader reader = new StreamReader(tempFile); string s = reader.ReadToEnd(); reader.Close(); File.Delete(tempFile); } [TestMethod] public void ComplexStorable() { Root r = InitializeComplexStorable(); XmlGenerator.Serialize(r, tempFile); Root newR = (Root)XmlParser.Deserialize(tempFile); CompareComplexStorables(r, newR); } [TestMethod] public void ComplexEasyStorable() { Root r = InitializeComplexStorable(); ReadableXmlGenerator.Serialize(r, tempFile); using (var reader = new StreamReader(tempFile)) { string text = reader.ReadToEnd(); Assert.IsTrue(text.StartsWith(" { r, r }; r.c = new Custom { r = r }; r.dict.Add("one", 1); r.dict.Add("two", 2); r.dict.Add("three", 3); r.myEnum = TestEnum.va1; r.i = new[] { 7, 5, 6 }; r.s = "new value"; r.intArray = new ArrayList { 3, 2, 1 }; r.intList = new List { 9, 8, 7 }; r.multiDimArray = new double[,] { { 5, 4, 3 }, { 1, 4, 6 } }; r.boolean = false; r.dateTime = DateTime.Now; r.kvp = new KeyValuePair("string key", 321); r.uninitialized = null; return r; } [TestMethod] public void SelfReferences() { C c = new C(); C[][] cs = new C[2][]; cs[0] = new C[] { c }; cs[1] = new C[] { c }; c.allCs = cs; c.kvpList = new KeyValuePair, C>(new List { c }, c); XmlGenerator.Serialize(cs, tempFile); object o = XmlParser.Deserialize(tempFile); Assert.AreEqual( DebugStringGenerator.Serialize(cs), DebugStringGenerator.Serialize(o)); Assert.AreSame(c, c.allCs[0][0]); Assert.AreSame(c, c.allCs[1][0]); Assert.AreSame(c, c.kvpList.Key[0]); Assert.AreSame(c, c.kvpList.Value); C[][] newCs = (C[][])o; C newC = newCs[0][0]; Assert.AreSame(newC, newC.allCs[0][0]); Assert.AreSame(newC, newC.allCs[1][0]); Assert.AreSame(newC, newC.kvpList.Key[0]); Assert.AreSame(newC, newC.kvpList.Value); } [TestMethod] public void ArrayCreation() { ArrayList[] arrayListArray = new ArrayList[4]; arrayListArray[0] = new ArrayList(); arrayListArray[0].Add(arrayListArray); arrayListArray[0].Add(arrayListArray); arrayListArray[1] = new ArrayList(); arrayListArray[1].Add(arrayListArray); arrayListArray[2] = new ArrayList(); arrayListArray[2].Add(arrayListArray); arrayListArray[2].Add(arrayListArray); Array a = Array.CreateInstance( typeof(object), new[] { 1, 2 }, new[] { 3, 4 }); arrayListArray[2].Add(a); XmlGenerator.Serialize(arrayListArray, tempFile); object o = XmlParser.Deserialize(tempFile); Assert.AreEqual( DebugStringGenerator.Serialize(arrayListArray), DebugStringGenerator.Serialize(o)); ArrayList[] newArray = (ArrayList[])o; Assert.AreSame(arrayListArray, arrayListArray[0][0]); Assert.AreSame(arrayListArray, arrayListArray[2][1]); Assert.AreSame(newArray, newArray[0][0]); Assert.AreSame(newArray, newArray[2][1]); } [TestMethod] public void CustomSerializationProperty() { Manager m = new Manager(); XmlGenerator.Serialize(m, tempFile); Manager newM = (Manager)XmlParser.Deserialize(tempFile); Assert.AreNotEqual( DebugStringGenerator.Serialize(m), DebugStringGenerator.Serialize(newM)); Assert.AreEqual(m.dbl, newM.dbl); Assert.AreEqual(m.lastLoadTime, new DateTime()); Assert.AreNotEqual(newM.lastLoadTime, new DateTime()); Assert.IsTrue((DateTime.Now - newM.lastLoadTime).TotalSeconds < 10); } [TestMethod] public void Primitives() { PrimitivesTest sdt = new PrimitivesTest(); XmlGenerator.Serialize(sdt, tempFile); object o = XmlParser.Deserialize(tempFile); Assert.AreEqual( DebugStringGenerator.Serialize(sdt), DebugStringGenerator.Serialize(o)); } [TestMethod] public void MultiDimensionalArray() { string[,] mDimString = new string[,] { {"ora", "et", "labora"}, {"Beten", "und", "Arbeiten"} }; XmlGenerator.Serialize(mDimString, tempFile); object o = XmlParser.Deserialize(tempFile); Assert.AreEqual( DebugStringGenerator.Serialize(mDimString), DebugStringGenerator.Serialize(o)); } [StorableClass] public class NestedType { [Storable] private string value = "value"; public override bool Equals(object obj) { NestedType nt = obj as NestedType; if (nt == null) throw new NotSupportedException(); return nt.value == value; } public override int GetHashCode() { return value.GetHashCode(); } } [TestMethod] public void NestedTypeTest() { NestedType t = new NestedType(); XmlGenerator.Serialize(t, tempFile); object o = XmlParser.Deserialize(tempFile); Assert.AreEqual( DebugStringGenerator.Serialize(t), DebugStringGenerator.Serialize(o)); Assert.IsTrue(t.Equals(o)); } [TestMethod] public void SimpleArray() { string[] strings = { "ora", "et", "labora" }; XmlGenerator.Serialize(strings, tempFile); object o = XmlParser.Deserialize(tempFile); Assert.AreEqual( DebugStringGenerator.Serialize(strings), DebugStringGenerator.Serialize(o)); } [TestMethod] public void PrimitiveRoot() { XmlGenerator.Serialize(12.3f, tempFile); object o = XmlParser.Deserialize(tempFile); Assert.AreEqual( DebugStringGenerator.Serialize(12.3f), DebugStringGenerator.Serialize(o)); } private string formatFullMemberName(MemberInfo mi) { return new StringBuilder() .Append(mi.DeclaringType.Assembly.GetName().Name) .Append(": ") .Append(mi.DeclaringType.Namespace) .Append('.') .Append(mi.DeclaringType.Name) .Append('.') .Append(mi.Name).ToString(); } [TestMethod] public void CodingConventions() { List lowerCaseMethodNames = new List(); List lowerCaseProperties = new List(); List lowerCaseFields = new List(); foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies()) { if (!a.GetName().Name.StartsWith("HeuristicLab")) continue; foreach (Type t in a.GetTypes()) { foreach (MemberInfo mi in t.GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)) { if (mi.DeclaringType.Name.StartsWith("<>")) continue; if (char.IsLower(mi.Name[0])) { if (mi.MemberType == MemberTypes.Field) lowerCaseFields.Add(formatFullMemberName(mi)); if (mi.MemberType == MemberTypes.Property) lowerCaseProperties.Add(formatFullMemberName(mi)); if (mi.MemberType == MemberTypes.Method && !mi.Name.StartsWith("get_") && !mi.Name.StartsWith("set_") && !mi.Name.StartsWith("add_") && !mi.Name.StartsWith("remove_")) lowerCaseMethodNames.Add(formatFullMemberName(mi)); } } } } //Assert.AreEqual("", lowerCaseFields.Aggregate("", (a, b) => a + "\r\n" + b)); Assert.AreEqual("", lowerCaseMethodNames.Aggregate("", (a, b) => a + "\r\n" + b)); Assert.AreEqual("", lowerCaseProperties.Aggregate("", (a, b) => a + "\r\n" + b)); } [TestMethod] public void Number2StringDecomposer() { NumberTest sdt = new NumberTest(); XmlGenerator.Serialize(sdt, tempFile, new Configuration(new XmlFormat(), new List { new String2XmlSerializer() }, new List { new StorableSerializer(), new Number2StringSerializer() })); object o = XmlParser.Deserialize(tempFile); Assert.AreEqual( DebugStringGenerator.Serialize(sdt), DebugStringGenerator.Serialize(o)); Assert.IsTrue(sdt.Equals(o)); } [TestMethod] public void Enums() { EnumTest et = new EnumTest(); et.simpleEnum = SimpleEnum.two; et.complexEnum = ComplexEnum.three; et.trickyEnum = TrickyEnum.two | TrickyEnum.one; XmlGenerator.Serialize(et, tempFile); EnumTest newEt = (EnumTest)XmlParser.Deserialize(tempFile); Assert.AreEqual(et.simpleEnum, SimpleEnum.two); Assert.AreEqual(et.complexEnum, ComplexEnum.three); Assert.AreEqual(et.trickyEnum, (TrickyEnum)3); } [TestMethod] public void TestAliasingWithOverriddenEquals() { List ints = new List(); ints.Add(new IntWrapper(1)); ints.Add(new IntWrapper(1)); Assert.AreEqual(ints[0], ints[1]); Assert.AreNotSame(ints[0], ints[1]); XmlGenerator.Serialize(ints, tempFile); List newInts = (List)XmlParser.Deserialize(tempFile); Assert.AreEqual(newInts[0].Value, 1); Assert.AreEqual(newInts[1].Value, 1); Assert.AreEqual(newInts[0], newInts[1]); Assert.AreNotSame(newInts[0], newInts[1]); } [TestMethod] public void NonDefaultConstructorTest() { NonDefaultConstructorClass c = new NonDefaultConstructorClass(1); try { XmlGenerator.Serialize(c, tempFile); Assert.Fail("Exception not thrown"); } catch (PersistenceException) { } } [TestMethod] public void TestSavingException() { List list = new List { 1, 2, 3 }; XmlGenerator.Serialize(list, tempFile); NonSerializable s = new NonSerializable(); try { XmlGenerator.Serialize(s, tempFile); Assert.Fail("Exception expected"); } catch (PersistenceException) { } List newList = (List)XmlParser.Deserialize(tempFile); Assert.AreEqual(list[0], newList[0]); Assert.AreEqual(list[1], newList[1]); } [TestMethod] public void TestTypeStringConversion() { string name = typeof(List[]).AssemblyQualifiedName; string shortName = "System.Collections.Generic.List`1[[System.Int32, mscorlib]][], mscorlib"; Assert.AreEqual(name, TypeNameParser.Parse(name).ToString()); Assert.AreEqual(shortName, TypeNameParser.Parse(name).ToString(false)); Assert.AreEqual(shortName, typeof(List[]).VersionInvariantName()); } [TestMethod] public void TestHexadecimalPublicKeyToken() { string name = "TestClass, TestAssembly, Version=1.2.3.4, PublicKey=1234abc"; string shortName = "TestClass, TestAssembly"; Assert.AreEqual(name, TypeNameParser.Parse(name).ToString()); Assert.AreEqual(shortName, TypeNameParser.Parse(name).ToString(false)); } [TestMethod] public void TestMultipleFailure() { List l = new List(); l.Add(new NonSerializable()); l.Add(new NonSerializable()); l.Add(new NonSerializable()); try { Serializer s = new Serializer(l, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), "ROOT", true); StringBuilder tokens = new StringBuilder(); foreach (var token in s) { tokens.Append(token.ToString()); } Assert.Fail("Exception expected"); } catch (PersistenceException px) { Assert.AreEqual(3, px.Data.Count); } } [TestMethod] public void TestAssemblyVersionCheck() { IntWrapper i = new IntWrapper(1); Serializer s = new Serializer(i, ConfigurationService.Instance.GetDefaultConfig(new XmlFormat())); XmlGenerator g = new XmlGenerator(); StringBuilder dataString = new StringBuilder(); foreach (var token in s) { dataString.Append(g.Format(token)); } StringBuilder typeString = new StringBuilder(); foreach (var line in g.Format(s.TypeCache)) typeString.Append(line); Deserializer d = new Deserializer(XmlParser.ParseTypeCache(new StringReader(typeString.ToString()))); XmlParser p = new XmlParser(new StringReader(dataString.ToString())); IntWrapper newI = (IntWrapper)d.Deserialize(p); Assert.AreEqual(i.Value, newI.Value); string newTypeString = Regex.Replace(typeString.ToString(), "Version=\\d+\\.\\d+\\.\\d+\\.\\d+", "Version=0.0.9999.9999"); try { d = new Deserializer(XmlParser.ParseTypeCache(new StringReader(newTypeString))); Assert.Fail("Exception expected"); } catch (PersistenceException x) { Assert.IsTrue(x.Message.Contains("incompatible")); } newTypeString = Regex.Replace(typeString.ToString(), "Version=(\\d+\\.\\d+)\\.\\d+\\.\\d+", "Version=$1.9999.9999"); try { d = new Deserializer(XmlParser.ParseTypeCache(new StringReader(newTypeString))); Assert.Fail("Exception expected"); } catch (PersistenceException x) { Assert.IsTrue(x.Message.Contains("newer")); } } [TestMethod] public void InheritanceTest() { New n = new New(); XmlGenerator.Serialize(n, tempFile); New nn = (New)XmlParser.Deserialize(tempFile); Assert.AreEqual(n.Name, nn.Name); Assert.AreEqual(((Override)n).Name, ((Override)nn).Name); } [StorableClass] class Child { [Storable] public GrandParent grandParent; } [StorableClass] class Parent { [Storable] public Child child; } [StorableClass] class GrandParent { [Storable] public Parent parent; } [TestMethod] public void InstantiateParentChainReference() { GrandParent gp = new GrandParent(); gp.parent = new Parent(); gp.parent.child = new Child(); gp.parent.child.grandParent = gp; Assert.AreSame(gp, gp.parent.child.grandParent); XmlGenerator.Serialize(gp, tempFile); GrandParent newGp = (GrandParent)XmlParser.Deserialize(tempFile); Assert.AreSame(newGp, newGp.parent.child.grandParent); } struct TestStruct { int value; int PropertyValue { get; set; } public TestStruct(int value) : this() { this.value = value; PropertyValue = value; } } [TestMethod] public void StructTest() { TestStruct s = new TestStruct(10); XmlGenerator.Serialize(s, tempFile); TestStruct newS = (TestStruct)XmlParser.Deserialize(tempFile); Assert.AreEqual(s, newS); } [TestMethod] public void PointTest() { Point p = new Point(12, 34); XmlGenerator.Serialize(p, tempFile); Point newP = (Point)XmlParser.Deserialize(tempFile); Assert.AreEqual(p, newP); } [TestMethod] public void NullableValueTypes() { double?[] d = new double?[] { null, 1, 2, 3 }; XmlGenerator.Serialize(d, tempFile); double?[] newD = (double?[])XmlParser.Deserialize(tempFile); Assert.AreEqual(d[0], newD[0]); Assert.AreEqual(d[1], newD[1]); Assert.AreEqual(d[2], newD[2]); Assert.AreEqual(d[3], newD[3]); } [TestMethod] public void BitmapTest() { Icon icon = System.Drawing.SystemIcons.Hand; Bitmap bitmap = icon.ToBitmap(); XmlGenerator.Serialize(bitmap, tempFile); Bitmap newBitmap = (Bitmap)XmlParser.Deserialize(tempFile); Assert.AreEqual(bitmap.Size, newBitmap.Size); for (int i = 0; i < bitmap.Size.Width; i++) for (int j = 0; j < bitmap.Size.Height; j++) Assert.AreEqual(bitmap.GetPixel(i, j), newBitmap.GetPixel(i, j)); } [StorableClass] private class PersistenceHooks { [Storable] public int a; [Storable] public int b; public int sum; public bool WasSerialized { get; private set; } [StorableHook(HookType.BeforeSerialization)] void BeforeSerialization() { WasSerialized = true; } [StorableHook(HookType.AfterDeserialization)] void AfterDeserialization() { sum = a + b; } } [TestMethod] public void HookTest() { PersistenceHooks hookTest = new PersistenceHooks(); hookTest.a = 2; hookTest.b = 5; Assert.IsFalse(hookTest.WasSerialized); Assert.AreEqual(hookTest.sum, 0); XmlGenerator.Serialize(hookTest, tempFile); Assert.IsTrue(hookTest.WasSerialized); Assert.AreEqual(hookTest.sum, 0); PersistenceHooks newHookTest = (PersistenceHooks)XmlParser.Deserialize(tempFile); Assert.AreEqual(newHookTest.a, hookTest.a); Assert.AreEqual(newHookTest.b, hookTest.b); Assert.AreEqual(newHookTest.sum, newHookTest.a + newHookTest.b); Assert.IsFalse(newHookTest.WasSerialized); } [StorableClass] private class CustomConstructor { public string Value = "none"; public CustomConstructor() { Value = "default"; } [StorableConstructor] private CustomConstructor(bool deserializing) { Assert.IsTrue(deserializing); Value = "persistence"; } } [TestMethod] public void TestCustomConstructor() { CustomConstructor cc = new CustomConstructor(); Assert.AreEqual(cc.Value, "default"); XmlGenerator.Serialize(cc, tempFile); CustomConstructor newCC = (CustomConstructor)XmlParser.Deserialize(tempFile); Assert.AreEqual(newCC.Value, "persistence"); } [StorableClass] public class ExplodingDefaultConstructor { public ExplodingDefaultConstructor() { throw new Exception("this constructor will always fail"); } public ExplodingDefaultConstructor(string password) { } } [TestMethod] public void TestConstructorExceptionUnwrapping() { ExplodingDefaultConstructor x = new ExplodingDefaultConstructor("password"); XmlGenerator.Serialize(x, tempFile); try { ExplodingDefaultConstructor newX = (ExplodingDefaultConstructor)XmlParser.Deserialize(tempFile); Assert.Fail("Exception expected"); } catch (PersistenceException pe) { Assert.AreEqual("this constructor will always fail", pe.InnerException.Message); } } [TestMethod] public void TestRejectionJustifications() { NonSerializable ns = new NonSerializable(); try { XmlGenerator.Serialize(ns, tempFile); Assert.Fail("PersistenceException expected"); } catch (PersistenceException x) { Assert.IsTrue(x.Message.Contains(new StorableSerializer().JustifyRejection(typeof(NonSerializable)))); } } [TestMethod] public void TestStreaming() { using (MemoryStream stream = new MemoryStream()) { Root r = InitializeComplexStorable(); XmlGenerator.Serialize(r, stream); using (MemoryStream stream2 = new MemoryStream(stream.ToArray())) { Root newR = (Root)XmlParser.Deserialize(stream2); CompareComplexStorables(r, newR); } } } [StorableClass] public class HookInheritanceTestBase { [Storable] public object a; public object link; [StorableHook(HookType.AfterDeserialization)] private void AfterDeserialization() { link = a; } } [StorableClass] public class HookInheritanceTestDerivedClass : HookInheritanceTestBase { [Storable] public object b; [StorableHook(HookType.AfterDeserialization)] private void AfterDeserialization() { Assert.AreSame(a, link); link = b; } } [TestMethod] public void TestLinkInheritance() { HookInheritanceTestDerivedClass c = new HookInheritanceTestDerivedClass(); c.a = new object(); XmlGenerator.Serialize(c, tempFile); HookInheritanceTestDerivedClass newC = (HookInheritanceTestDerivedClass)XmlParser.Deserialize(tempFile); Assert.AreSame(c.b, c.link); } [StorableClass] public class MarkedOnlyStorable { public int Value1 = 1; [Storable] public int Value2 = 2; public int Value3 { get; private set; } public int Value4 { get; private set; } [StorableConstructor] public MarkedOnlyStorable(bool isDeserializing) { if (!isDeserializing) { Value1 = 12; Value2 = 23; Value3 = 34; Value4 = 56; } } } [TestMethod] public void TestStorableClassDiscoveryMarkedOnly() { MarkedOnlyStorable afs = new MarkedOnlyStorable(false); XmlGenerator.Serialize(afs, tempFile); MarkedOnlyStorable newAfs = (MarkedOnlyStorable)XmlParser.Deserialize(tempFile); Assert.AreEqual(1, newAfs.Value1); Assert.AreEqual(afs.Value2, newAfs.Value2); Assert.AreEqual(0, newAfs.Value3); Assert.AreEqual(0, newAfs.Value4); } [TestMethod] public void TestLineEndings() { List lineBreaks = new List { "\r\n", "\n", "\r", "\n\r", Environment.NewLine }; List lines = new List(); foreach (var br in lineBreaks) lines.Add("line1" + br + "line2"); XmlGenerator.Serialize(lines, tempFile); List newLines = XmlParser.Deserialize>(tempFile); Assert.AreEqual(lines.Count, newLines.Count); for (int i = 0; i < lineBreaks.Count; i++) { Assert.AreEqual(lines[i], newLines[i]); } } [TestMethod] public void TestSpecialNumbers() { List specials = new List() { 1.0 / 0, -1.0 / 0, 0.0 / 0 }; Assert.IsTrue(double.IsPositiveInfinity(specials[0])); Assert.IsTrue(double.IsNegativeInfinity(specials[1])); Assert.IsTrue(double.IsNaN(specials[2])); XmlGenerator.Serialize(specials, tempFile); List newSpecials = XmlParser.Deserialize>(tempFile); Assert.IsTrue(double.IsPositiveInfinity(newSpecials[0])); Assert.IsTrue(double.IsNegativeInfinity(newSpecials[1])); Assert.IsTrue(double.IsNaN(newSpecials[2])); } [TestMethod] public void TestStringSplit() { string s = "1.2;2.3;3.4;;;4.9"; var l = s.EnumerateSplit(';').ToList(); Assert.AreEqual("1.2", l[0]); Assert.AreEqual("2.3", l[1]); Assert.AreEqual("3.4", l[2]); Assert.AreEqual("4.9", l[3]); } [TestMethod] public void TestCompactNumberArraySerializer() { Random r = new Random(); double[] a = new double[CompactNumberArray2StringSerializer.SPLIT_THRESHOLD * 2 + 1]; for (int i = 0; i < a.Length; i++) a[i] = r.Next(10); var config = ConfigurationService.Instance.GetDefaultConfig(new XmlFormat()); config = new Configuration(config.Format, config.PrimitiveSerializers.Where(s => s.SourceType != typeof(double[])), config.CompositeSerializers); XmlGenerator.Serialize(a, tempFile, config); double[] newA = XmlParser.Deserialize(tempFile); Assert.AreEqual(a.Length, newA.Length); for (int i = 0; i < a.Rank; i++) { Assert.AreEqual(a.GetLength(i), newA.GetLength(i)); Assert.AreEqual(a.GetLowerBound(i), newA.GetLowerBound(i)); } for (int i = 0; i < a.Length; i++) { Assert.AreEqual(a[i], newA[i]); } } private class IdentityComparer : IEqualityComparer { public bool Equals(T x, T y) { return x.Equals(y); } public int GetHashCode(T obj) { return obj.GetHashCode(); } } [TestMethod] public void TestHashSetSerializer() { var hashSets = new List>() { new HashSet(new[] { 1, 2, 3 }), new HashSet(new[] { 4, 5, 6 }, new IdentityComparer()), }; XmlGenerator.Serialize(hashSets, tempFile); var newHashSets = XmlParser.Deserialize>>(tempFile); Assert.IsTrue(newHashSets[0].Contains(1)); Assert.IsTrue(newHashSets[0].Contains(2)); Assert.IsTrue(newHashSets[0].Contains(3)); Assert.IsTrue(newHashSets[1].Contains(4)); Assert.IsTrue(newHashSets[1].Contains(5)); Assert.IsTrue(newHashSets[1].Contains(6)); Assert.AreEqual(newHashSets[0].Comparer.GetType(), new HashSet().Comparer.GetType()); Assert.AreEqual(newHashSets[1].Comparer.GetType(), typeof(IdentityComparer)); } [TestMethod] public void TestConcreteDictionarySerializer() { var dictionaries = new List>() { new Dictionary(), new Dictionary(new IdentityComparer()), }; dictionaries[0].Add(1, 1); dictionaries[0].Add(2, 2); dictionaries[0].Add(3, 3); dictionaries[1].Add(4, 4); dictionaries[1].Add(5, 5); dictionaries[1].Add(6, 6); XmlGenerator.Serialize(dictionaries, tempFile, ConfigurationService.Instance.GetDefaultConfig(new XmlFormat())); var newDictionaries = XmlParser.Deserialize>>(tempFile); Assert.IsTrue(newDictionaries[0].ContainsKey(1)); Assert.IsTrue(newDictionaries[0].ContainsKey(2)); Assert.IsTrue(newDictionaries[0].ContainsKey(3)); Assert.IsTrue(newDictionaries[1].ContainsKey(4)); Assert.IsTrue(newDictionaries[1].ContainsKey(5)); Assert.IsTrue(newDictionaries[1].ContainsKey(6)); Assert.IsTrue(newDictionaries[0].ContainsValue(1)); Assert.IsTrue(newDictionaries[0].ContainsValue(2)); Assert.IsTrue(newDictionaries[0].ContainsValue(3)); Assert.IsTrue(newDictionaries[1].ContainsValue(4)); Assert.IsTrue(newDictionaries[1].ContainsValue(5)); Assert.IsTrue(newDictionaries[1].ContainsValue(6)); Assert.AreEqual(new Dictionary().Comparer.GetType(), newDictionaries[0].Comparer.GetType()); Assert.AreEqual(typeof(IdentityComparer), newDictionaries[1].Comparer.GetType()); } [StorableClass] public class ReadOnlyFail { [Storable] public string ReadOnly { get { return "fail"; } } } [TestMethod] public void TestReadOnlyFail() { try { XmlGenerator.Serialize(new ReadOnlyFail(), tempFile); Assert.Fail("Exception expected"); } catch (PersistenceException) { } catch { Assert.Fail("PersistenceException expected"); } } [StorableClass] public class WriteOnlyFail { [Storable] public string WriteOnly { set { throw new InvalidOperationException("this property should never be set."); } } } [TestMethod] public void TestWriteOnlyFail() { try { XmlGenerator.Serialize(new WriteOnlyFail(), tempFile); Assert.Fail("Exception expected"); } catch (PersistenceException) { } catch { Assert.Fail("PersistenceException expected."); } } [StorableClass] public class OneWayTest { public OneWayTest() { this.value = "default"; } public string value; [Storable(AllowOneWay = true)] public string ReadOnly { get { return "ReadOnly"; } } [Storable(AllowOneWay = true)] public string WriteOnly { set { this.value = value; } } } [TestMethod] public void TestOneWaySerialization() { var test = new OneWayTest(); var serializer = new Serializer(test, ConfigurationService.Instance.GetDefaultConfig(new XmlFormat())); var it = serializer.GetEnumerator(); it.MoveNext(); Assert.AreEqual("ROOT", ((BeginToken)it.Current).Name); it.MoveNext(); Assert.AreEqual("ReadOnly", ((PrimitiveToken)it.Current).Name); it.MoveNext(); ReverseTypeCache typeCache = new ReverseTypeCache(); typeCache.AddType(0, typeof(OneWayTest)); typeCache.AddSerializer(0, typeof(StorableSerializer)); typeCache.AddType(1, typeof(string)); typeCache.AddSerializer(1, typeof(String2XmlSerializer)); var deserializer = new Deserializer(typeCache); var newTest = (OneWayTest)deserializer.Deserialize(new ISerializationToken[] { new BeginToken("ROOT", 0, 0), new PrimitiveToken("WriteOnly", 1, 1, new XmlString("")), new EndToken() }); Assert.AreEqual("serial data", newTest.value); } [TestMethod] public void TestTypeCacheExport() { var test = new List>(); test.Add(new List() { 1, 2, 3 }); IEnumerable types; using (var stream = new MemoryStream()) { XmlGenerator.Serialize(test, stream, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), false, out types); } List t = new List(types); // Assert.IsTrue(t.Contains(typeof(int))); not serialized as an int list is directly transformed into a string Assert.IsTrue(t.Contains(typeof(List))); Assert.IsTrue(t.Contains(typeof(List>))); Assert.AreEqual(t.Count, 2); } [TestMethod] public void TupleTest() { var t1 = Tuple.Create(1); var t2 = Tuple.Create('1', "2"); var t3 = Tuple.Create(3.0, 3f, 5); var t4 = Tuple.Create(Tuple.Create(1, 2, 3), Tuple.Create(4, 5, 6), Tuple.Create(8, 9, 10)); var tuple = Tuple.Create(t1, t2, t3, t4); XmlGenerator.Serialize(tuple, tempFile); var newTuple = XmlParser.Deserialize, Tuple, Tuple, Tuple, Tuple, Tuple>>>(tempFile); Assert.AreEqual(tuple, newTuple); } [TestMethod] public void TestCachedTypeSerializer() { List types = new List { typeof(object), typeof(UseCases), typeof(XmlGenerator) }; var s = new Serializer(types, ConfigurationService.Instance.GetDefaultConfig(new XmlFormat())); var tokens = s.ToList(); foreach (var type in types) Assert.IsTrue(s.SerializedTypes.Contains(type)); var d = new Deserializer(s.TypeCache.Reverse()); var newTypes = (List)d.Deserialize(tokens); for (int i = 0; i < types.Count; i++) Assert.AreEqual(types[i], newTypes[i]); } [TestMethod] public void FontTest() { List fonts = new List() { new Font(FontFamily.GenericSansSerif, 12), new Font("Times New Roman", 21, FontStyle.Bold, GraphicsUnit.Pixel), new Font("Courier New", 10, FontStyle.Underline, GraphicsUnit.Document), new Font("Helvetica", 21, FontStyle.Strikeout, GraphicsUnit.Inch, 0, true), }; XmlGenerator.Serialize(fonts, tempFile); var newFonts = XmlParser.Deserialize>(tempFile); Assert.AreEqual(fonts[0], newFonts[0]); Assert.AreEqual(fonts[1], newFonts[1]); Assert.AreEqual(fonts[2], newFonts[2]); Assert.AreEqual(fonts[3], newFonts[3]); } [TestMethod] public void ConcurrencyTest() { int n = 20; Task[] tasks = new Task[n]; for (int i = 0; i < n; i++) { tasks[i] = Task.Factory.StartNew((idx) => { byte[] data; using(var stream = new MemoryStream()) { XmlGenerator.Serialize(new GeneticAlgorithm(), stream); data = stream.ToArray(); } }, i); } Task.WaitAll(tasks); } [TestMethod] public void ConcurrentBitmapTest() { Bitmap b = new Bitmap(300, 300); Random r = new Random(); for (int x = 0; x { using (var stream = new MemoryStream()) { XmlGenerator.Serialize(b, stream); datas[(int)idx] = stream.ToArray(); } }, i); } Task.WaitAll(tasks); } [ClassInitialize] public static void Initialize(TestContext testContext) { ConfigurationService.Instance.Reset(); } } }