Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Persistence/3.3/Tests/UseCases.cs @ 2994

Last change on this file since 2994 was 2994, checked in by epitzer, 14 years ago

Make StorableClass attribute compulsory for StorableSerializer to work, add named property StorableClassType to choose between Empty and MarkedOnly, later other options will be added. (#548)
File size: 26.0 KB
Line 
1using System;
2using System.Text;
3using System.Collections.Generic;
4using System.Linq;
5using Microsoft.VisualStudio.TestTools.UnitTesting;
6using HeuristicLab.Persistence.Core;
7using System.Collections;
8using HeuristicLab.Persistence.Default.Xml;
9using HeuristicLab.Persistence.Default.DebugString;
10using System.IO;
11using System.Reflection;
12using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
13using HeuristicLab.Persistence.Interfaces;
14using HeuristicLab.Persistence.Default.Xml.Primitive;
15using HeuristicLab.Persistence.Default.CompositeSerializers;
16using HeuristicLab.Persistence.Auxiliary;
17using System.Text.RegularExpressions;
18using System.Drawing;
19using System.Drawing.Imaging;
20
21namespace HeuristicLab.Persistence_33.Tests {
22
23  [StorableClass(StorableClassType.MarkedOnly)] 
24  public class NumberTest {
25    [Storable]
26    private bool _bool = true;
27    [Storable]
28    private byte _byte = 0xFF;
29    [Storable]
30    private sbyte _sbyte = 0xF;
31    [Storable]
32    private short _short = -123;
33    [Storable]
34    private ushort _ushort = 123;
35    [Storable]
36    private int _int = -123;
37    [Storable]
38    private uint _uint = 123;
39    [Storable]
40    private long _long = 123456;
41    [Storable]
42    private ulong _ulong = 123456;
43  }
44
45  [StorableClass(StorableClassType.MarkedOnly)]
46  public class NonDefaultConstructorClass {
47    [Storable]
48    int value;
49    public NonDefaultConstructorClass(int value) {
50      this.value = value;
51    }
52  }
53
54  [StorableClass(StorableClassType.MarkedOnly)]
55  public class IntWrapper {
56
57    [Storable]
58    public int Value;
59
60    private IntWrapper() { }
61
62    public IntWrapper(int value) {
63      this.Value = value;
64    }
65
66    public override bool Equals(object obj) {
67      if (obj as IntWrapper == null)
68        return false;
69      return Value.Equals(((IntWrapper)obj).Value);
70    }
71    public override int GetHashCode() {
72      return Value.GetHashCode();
73    }
74
75  }
76
77  [StorableClass(StorableClassType.MarkedOnly)]
78  public class PrimitivesTest : NumberTest {
79    [Storable]
80    private char c = 'e';
81    [Storable]
82    private long[,] _long_array =
83      new long[,] { { 123, 456, }, { 789, 123 } };
84    [Storable]
85    public List<int> list = new List<int> { 1, 2, 3, 4, 5 };
86    [Storable]
87    private object o = new object();
88  }
89
90  public enum TestEnum { va1, va2, va3, va8 } ;
91
92  [StorableClass(StorableClassType.MarkedOnly)]
93  public class RootBase {
94    [Storable]
95    private string baseString = "   Serial  ";
96    [Storable]
97    public TestEnum myEnum = TestEnum.va3;
98  }
99
100  [StorableClass(StorableClassType.MarkedOnly)]
101  public class Root : RootBase {
102    [Storable]
103    public Stack<int> intStack = new Stack<int>();
104    [Storable]
105    public int[] i = new[] { 3, 4, 5, 6 };
106    [Storable(Name = "Test String")]
107    public string s;
108    [Storable]
109    public ArrayList intArray = new ArrayList(new[] { 1, 2, 3 });
110    [Storable]
111    public List<int> intList = new List<int>(new[] { 321, 312, 321 });
112    [Storable]
113    public Custom c;
114    [Storable]
115    public List<Root> selfReferences;
116    [Storable]
117    public double[,] multiDimArray = new double[,] { { 1, 2, 3 }, { 3, 4, 5 } };
118    [Storable]
119    public bool boolean = true;
120    [Storable]
121    public DateTime dateTime;
122    [Storable]
123    public KeyValuePair<string, int> kvp = new KeyValuePair<string, int>("Serial", 123);
124    [Storable]
125    public Dictionary<string, int> dict = new Dictionary<string, int>();
126    [Storable(DefaultValue = "default")]
127    public string uninitialized;
128  }
129
130  public enum SimpleEnum { one, two, three }
131  public enum ComplexEnum { one = 1, two = 2, three = 3 }
132  [FlagsAttribute]
133  public enum TrickyEnum { zero = 0, one = 1, two = 2 }
134
135  [StorableClass(StorableClassType.MarkedOnly)]
136  public class EnumTest {
137    [Storable]
138    public SimpleEnum simpleEnum = SimpleEnum.one;
139    [Storable]
140    public ComplexEnum complexEnum = (ComplexEnum)2;
141    [Storable]
142    public TrickyEnum trickyEnum = (TrickyEnum)15;
143  }
144
145  [StorableClass(StorableClassType.MarkedOnly)]
146  public class Custom {
147    [Storable]
148    public int i;
149    [Storable]
150    public Root r;
151    [Storable]
152    public string name = "<![CDATA[<![CDATA[Serial]]>]]>";
153  }
154
155  [StorableClass(StorableClassType.MarkedOnly)]
156  public class Manager {
157
158    public DateTime lastLoadTime;
159    [Storable]
160    private DateTime lastLoadTimePersistence {
161      get { return lastLoadTime; }
162      set { lastLoadTime = DateTime.Now; }
163    }
164    [Storable]
165    public double? dbl;
166  }
167
168  [StorableClass(StorableClassType.MarkedOnly)]
169  public class C {
170    [Storable]
171    public C[][] allCs;
172    [Storable]
173    public KeyValuePair<List<C>, C> kvpList;
174  }
175
176  public class NonSerializable {
177    int x;
178  }
179
180
181  [TestClass]
182  public class UseCases {
183
184    private string tempFile;
185
186    [TestInitialize()]
187    public void CreateTempFile() {
188      tempFile = Path.GetTempFileName();
189    }
190
191    [TestCleanup()]
192    public void ClearTempFile() {
193      StreamReader reader = new StreamReader(tempFile);
194      string s = reader.ReadToEnd();
195      reader.Close();
196      File.Delete(tempFile);
197    }
198
199    [TestMethod]
200    public void ComplexStorable() {
201      Root r = new Root();
202      r.intStack.Push(1);
203      r.intStack.Push(2);
204      r.intStack.Push(3);
205      r.selfReferences = new List<Root> { r, r };
206      r.c = new Custom { r = r };
207      r.dict.Add("one", 1);
208      r.dict.Add("two", 2);
209      r.dict.Add("three", 3);
210      r.myEnum = TestEnum.va1;
211      r.i = new[] { 7, 5, 6 };
212      r.s = "new value";
213      r.intArray = new ArrayList { 3, 2, 1 };
214      r.intList = new List<int> { 9, 8, 7 };
215      r.multiDimArray = new double[,] { { 5, 4, 3 }, { 1, 4, 6 } };
216      r.boolean = false;
217      r.dateTime = DateTime.Now;
218      r.kvp = new KeyValuePair<string, int>("string key", 321);
219      r.uninitialized = null;
220      XmlGenerator.Serialize(r, tempFile);
221      Root newR = (Root)XmlParser.Deserialize(tempFile);
222      Assert.AreEqual(
223        DebugStringGenerator.Serialize(r),
224        DebugStringGenerator.Serialize(newR));
225      Assert.AreSame(newR, newR.selfReferences[0]);
226      Assert.AreNotSame(r, newR);
227      Assert.AreEqual(r.myEnum, TestEnum.va1);
228      Assert.AreEqual(r.i[0], 7);
229      Assert.AreEqual(r.i[1], 5);
230      Assert.AreEqual(r.i[2], 6);
231      Assert.AreEqual(r.s, "new value");
232      Assert.AreEqual(r.intArray[0], 3);
233      Assert.AreEqual(r.intArray[1], 2);
234      Assert.AreEqual(r.intArray[2], 1);
235      Assert.AreEqual(r.intList[0], 9);
236      Assert.AreEqual(r.intList[1], 8);
237      Assert.AreEqual(r.intList[2], 7);
238      Assert.AreEqual(r.multiDimArray[0, 0], 5);
239      Assert.AreEqual(r.multiDimArray[0, 1], 4);
240      Assert.AreEqual(r.multiDimArray[0, 2], 3);
241      Assert.AreEqual(r.multiDimArray[1, 0], 1);
242      Assert.AreEqual(r.multiDimArray[1, 1], 4);
243      Assert.AreEqual(r.multiDimArray[1, 2], 6);
244      Assert.IsFalse(r.boolean);
245      Assert.IsTrue((DateTime.Now - r.dateTime).TotalSeconds < 10);
246      Assert.AreEqual(r.kvp.Key, "string key");
247      Assert.AreEqual(r.kvp.Value, 321);
248      Assert.IsNull(r.uninitialized);
249      Assert.AreEqual(newR.myEnum, TestEnum.va1);
250      Assert.AreEqual(newR.i[0], 7);
251      Assert.AreEqual(newR.i[1], 5);
252      Assert.AreEqual(newR.i[2], 6);
253      Assert.AreEqual(newR.s, "new value");
254      Assert.AreEqual(newR.intArray[0], 3);
255      Assert.AreEqual(newR.intArray[1], 2);
256      Assert.AreEqual(newR.intArray[2], 1);
257      Assert.AreEqual(newR.intList[0], 9);
258      Assert.AreEqual(newR.intList[1], 8);
259      Assert.AreEqual(newR.intList[2], 7);
260      Assert.AreEqual(newR.multiDimArray[0, 0], 5);
261      Assert.AreEqual(newR.multiDimArray[0, 1], 4);
262      Assert.AreEqual(newR.multiDimArray[0, 2], 3);
263      Assert.AreEqual(newR.multiDimArray[1, 0], 1);
264      Assert.AreEqual(newR.multiDimArray[1, 1], 4);
265      Assert.AreEqual(newR.multiDimArray[1, 2], 6);
266      Assert.AreEqual(newR.intStack.Pop(), 3);
267      Assert.AreEqual(newR.intStack.Pop(), 2);
268      Assert.AreEqual(newR.intStack.Pop(), 1);
269      Assert.IsFalse(newR.boolean);
270      Assert.IsTrue((DateTime.Now - newR.dateTime).TotalSeconds < 10);
271      Assert.AreEqual(newR.kvp.Key, "string key");
272      Assert.AreEqual(newR.kvp.Value, 321);
273      Assert.IsNull(newR.uninitialized);
274    }
275
276    [TestMethod]
277    public void SelfReferences() {
278      C c = new C();
279      C[][] cs = new C[2][];
280      cs[0] = new C[] { c };
281      cs[1] = new C[] { c };
282      c.allCs = cs;
283      c.kvpList = new KeyValuePair<List<C>, C>(new List<C> { c }, c);
284      XmlGenerator.Serialize(cs, tempFile);
285      object o = XmlParser.Deserialize(tempFile);
286      Assert.AreEqual(
287        DebugStringGenerator.Serialize(cs),
288        DebugStringGenerator.Serialize(o));
289      Assert.AreSame(c, c.allCs[0][0]);
290      Assert.AreSame(c, c.allCs[1][0]);
291      Assert.AreSame(c, c.kvpList.Key[0]);
292      Assert.AreSame(c, c.kvpList.Value);
293      C[][] newCs = (C[][])o;
294      C newC = newCs[0][0];
295      Assert.AreSame(newC, newC.allCs[0][0]);
296      Assert.AreSame(newC, newC.allCs[1][0]);
297      Assert.AreSame(newC, newC.kvpList.Key[0]);
298      Assert.AreSame(newC, newC.kvpList.Value);
299    }
300
301    [TestMethod]
302    public void ArrayCreation() {
303      ArrayList[] arrayListArray = new ArrayList[4];
304      arrayListArray[0] = new ArrayList();
305      arrayListArray[0].Add(arrayListArray);
306      arrayListArray[0].Add(arrayListArray);
307      arrayListArray[1] = new ArrayList();
308      arrayListArray[1].Add(arrayListArray);
309      arrayListArray[2] = new ArrayList();
310      arrayListArray[2].Add(arrayListArray);
311      arrayListArray[2].Add(arrayListArray);
312      Array a = Array.CreateInstance(
313                              typeof(object),
314                              new[] { 1, 2 }, new[] { 3, 4 });
315      arrayListArray[2].Add(a);
316      XmlGenerator.Serialize(arrayListArray, tempFile);
317      object o = XmlParser.Deserialize(tempFile);
318      Assert.AreEqual(
319        DebugStringGenerator.Serialize(arrayListArray),
320        DebugStringGenerator.Serialize(o));
321      ArrayList[] newArray = (ArrayList[])o;
322      Assert.AreSame(arrayListArray, arrayListArray[0][0]);
323      Assert.AreSame(arrayListArray, arrayListArray[2][1]);
324      Assert.AreSame(newArray, newArray[0][0]);
325      Assert.AreSame(newArray, newArray[2][1]);
326    }
327
328    [TestMethod]
329    public void CustomSerializationProperty() {
330      Manager m = new Manager();
331      XmlGenerator.Serialize(m, tempFile);
332      Manager newM = (Manager)XmlParser.Deserialize(tempFile);
333      Assert.AreNotEqual(
334        DebugStringGenerator.Serialize(m),
335        DebugStringGenerator.Serialize(newM));
336      Assert.AreEqual(m.dbl, newM.dbl);
337      Assert.AreEqual(m.lastLoadTime, new DateTime());
338      Assert.AreNotEqual(newM.lastLoadTime, new DateTime());
339      Assert.IsTrue((DateTime.Now - newM.lastLoadTime).TotalSeconds < 10);
340    }
341
342    [TestMethod]
343    public void Primitives() {
344      PrimitivesTest sdt = new PrimitivesTest();
345      XmlGenerator.Serialize(sdt, tempFile);
346      object o = XmlParser.Deserialize(tempFile);
347      Assert.AreEqual(
348        DebugStringGenerator.Serialize(sdt),
349        DebugStringGenerator.Serialize(o));
350    }
351
352    [TestMethod]
353    public void MultiDimensionalArray() {
354      string[,] mDimString = new string[,] {
355        {"ora", "et", "labora"},
356        {"Beten", "und", "Arbeiten"}
357      };
358      XmlGenerator.Serialize(mDimString, tempFile);
359      object o = XmlParser.Deserialize(tempFile);
360      Assert.AreEqual(
361        DebugStringGenerator.Serialize(mDimString),
362        DebugStringGenerator.Serialize(o));
363    }
364
365    [StorableClass(StorableClassType.MarkedOnly)]
366    public class NestedType {
367      [Storable]
368      private string value = "value";
369    }
370
371    [TestMethod]
372    public void NestedTypeTest() {
373      NestedType t = new NestedType();
374      XmlGenerator.Serialize(t, tempFile);
375      object o = XmlParser.Deserialize(tempFile);
376      Assert.AreEqual(
377        DebugStringGenerator.Serialize(t),
378        DebugStringGenerator.Serialize(o));
379    }
380
381
382    [TestMethod]
383    public void SimpleArray() {
384      string[] strings = { "ora", "et", "labora" };
385      XmlGenerator.Serialize(strings, tempFile);
386      object o = XmlParser.Deserialize(tempFile);
387      Assert.AreEqual(
388        DebugStringGenerator.Serialize(strings),
389        DebugStringGenerator.Serialize(o));
390    }
391
392    [TestMethod]
393    public void PrimitiveRoot() {
394      XmlGenerator.Serialize(12.3f, tempFile);
395      object o = XmlParser.Deserialize(tempFile);
396      Assert.AreEqual(
397        DebugStringGenerator.Serialize(12.3f),
398        DebugStringGenerator.Serialize(o));
399    }
400
401    private string formatFullMemberName(MemberInfo mi) {
402      return new StringBuilder()
403        .Append(mi.DeclaringType.Assembly.GetName().Name)
404        .Append(": ")
405        .Append(mi.DeclaringType.Namespace)
406        .Append('.')
407        .Append(mi.DeclaringType.Name)
408        .Append('.')
409        .Append(mi.Name).ToString();
410    }
411
412    [TestMethod]
413    public void CodingConventions() {
414      List<string> lowerCaseMethodNames = new List<string>();
415      List<string> lowerCaseProperties = new List<string>();
416      List<string> lowerCaseFields = new List<string>();
417      foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies()) {
418        if (!a.GetName().Name.StartsWith("HeuristicLab"))
419          continue;
420        foreach (Type t in a.GetTypes()) {
421          foreach (MemberInfo mi in t.GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)) {
422            if (mi.DeclaringType.Name.StartsWith("<>"))
423              continue;
424            if (char.IsLower(mi.Name[0])) {
425              if (mi.MemberType == MemberTypes.Field)
426                lowerCaseFields.Add(formatFullMemberName(mi));
427              if (mi.MemberType == MemberTypes.Property)
428                lowerCaseProperties.Add(formatFullMemberName(mi));
429              if (mi.MemberType == MemberTypes.Method &&
430                !mi.Name.StartsWith("get_") &&
431                !mi.Name.StartsWith("set_") &&
432                !mi.Name.StartsWith("add_") &&
433                !mi.Name.StartsWith("remove_"))
434                lowerCaseMethodNames.Add(formatFullMemberName(mi));
435            }
436          }
437        }
438      }
439      //Assert.AreEqual("", lowerCaseFields.Aggregate("", (a, b) => a + "\r\n" + b));
440      Assert.AreEqual("", lowerCaseMethodNames.Aggregate("", (a, b) => a + "\r\n" + b));
441      Assert.AreEqual("", lowerCaseProperties.Aggregate("", (a, b) => a + "\r\n" + b));
442    }
443
444    [TestMethod]
445    public void Number2StringDecomposer() {
446      NumberTest sdt = new NumberTest();
447      XmlGenerator.Serialize(sdt, tempFile,
448        new Configuration(new XmlFormat(),
449          new List<IPrimitiveSerializer> { new String2XmlSerializer() },
450          new List<ICompositeSerializer> {
451            new StorableSerializer(),
452            new Number2StringSerializer() }));
453      object o = XmlParser.Deserialize(tempFile);
454      Assert.AreEqual(
455        DebugStringGenerator.Serialize(sdt),
456        DebugStringGenerator.Serialize(o));
457    }
458
459    [TestMethod]
460    public void Enums() {
461      EnumTest et = new EnumTest();
462      et.simpleEnum = SimpleEnum.two;
463      et.complexEnum = ComplexEnum.three;
464      et.trickyEnum = TrickyEnum.two | TrickyEnum.one;
465      XmlGenerator.Serialize(et, tempFile);
466      EnumTest newEt = (EnumTest)XmlParser.Deserialize(tempFile);
467      Assert.AreEqual(et.simpleEnum, SimpleEnum.two);
468      Assert.AreEqual(et.complexEnum, ComplexEnum.three);
469      Assert.AreEqual(et.trickyEnum, (TrickyEnum)3);
470    }
471
472    [TestMethod]
473    public void TestAliasingWithOverriddenEquals() {
474      List<IntWrapper> ints = new List<IntWrapper>();
475      ints.Add(new IntWrapper(1));
476      ints.Add(new IntWrapper(1));
477      Assert.AreEqual(ints[0], ints[1]);
478      Assert.AreNotSame(ints[0], ints[1]);
479      XmlGenerator.Serialize(ints, tempFile);
480      List<IntWrapper> newInts = (List<IntWrapper>)XmlParser.Deserialize(tempFile);
481      Assert.AreEqual(newInts[0].Value, 1);
482      Assert.AreEqual(newInts[1].Value, 1);
483      Assert.AreEqual(newInts[0], newInts[1]);
484      Assert.AreNotSame(newInts[0], newInts[1]);
485    }
486
487    [TestMethod]
488    public void NonDefaultConstructorTest() {
489      NonDefaultConstructorClass c = new NonDefaultConstructorClass(1);
490      try {
491        XmlGenerator.Serialize(c, tempFile);
492        Assert.Fail("Exception not thrown");
493      } catch (PersistenceException) {
494      }
495    }
496
497    [TestMethod]
498    public void TestSavingException() {
499      List<int> list = new List<int> { 1, 2, 3 };
500      XmlGenerator.Serialize(list, tempFile);
501      NonSerializable s = new NonSerializable();
502      try {
503        XmlGenerator.Serialize(s, tempFile);
504        Assert.Fail("Exception expected");
505      } catch (PersistenceException) { }
506      List<int> newList = (List<int>)XmlParser.Deserialize(tempFile);
507      Assert.AreEqual(list[0], newList[0]);
508      Assert.AreEqual(list[1], newList[1]);
509    }
510
511    [TestMethod]
512    public void TestTypeStringConversion() {
513      string name = typeof(List<int>[]).AssemblyQualifiedName;
514      string shortName =
515        "System.Collections.Generic.List`1[[System.Int32, mscorlib]][], mscorlib";
516      Assert.AreEqual(name, TypeNameParser.Parse(name).ToString());
517      Assert.AreEqual(shortName, TypeNameParser.Parse(name).ToString(false));
518      Assert.AreEqual(shortName, typeof(List<int>[]).VersionInvariantName());
519    }
520
521    [TestMethod]
522    public void TestHexadecimalPublicKeyToken() {
523      string name = "TestClass, TestAssembly, Version=1.2.3.4, PublicKey=1234abc";
524      string shortName = "TestClass, TestAssembly";
525      Assert.AreEqual(name, TypeNameParser.Parse(name).ToString());
526      Assert.AreEqual(shortName, TypeNameParser.Parse(name).ToString(false));
527    }
528
529    [TestMethod]
530    public void TestMultipleFailure() {
531      List<NonSerializable> l = new List<NonSerializable>();
532      l.Add(new NonSerializable());
533      l.Add(new NonSerializable());
534      l.Add(new NonSerializable());
535      try {
536        Serializer s = new Serializer(l,
537          ConfigurationService.Instance.GetConfiguration(new XmlFormat()),
538          "ROOT", true);
539        StringBuilder tokens = new StringBuilder();
540        foreach (var token in s) {
541          tokens.Append(token.ToString());
542        }
543        Assert.Fail("Exception expected");
544      } catch (PersistenceException px) {
545        Assert.AreEqual(3, px.Data.Count);
546      }
547    }
548
549    [TestMethod]
550    public void TestAssemblyVersionCheck() {
551      IntWrapper i = new IntWrapper(1);
552      Serializer s = new Serializer(i, ConfigurationService.Instance.GetDefaultConfig(new XmlFormat()));
553      XmlGenerator g = new XmlGenerator();
554      StringBuilder dataString = new StringBuilder();
555      foreach (var token in s) {
556        dataString.Append(g.Format(token));
557      }
558      StringBuilder typeString = new StringBuilder();
559      foreach (var line in g.Format(s.TypeCache))
560        typeString.Append(line);
561      Deserializer d = new Deserializer(XmlParser.ParseTypeCache(new StringReader(typeString.ToString())));
562      XmlParser p = new XmlParser(new StringReader(dataString.ToString()));
563      IntWrapper newI = (IntWrapper)d.Deserialize(p);
564      Assert.AreEqual(i.Value, newI.Value);
565
566      string newTypeString = Regex.Replace(typeString.ToString(),
567        "Version=\\d+\\.\\d+\\.\\d+\\.\\d+",
568        "Version=0.0.9999.9999");
569      try {
570        d = new Deserializer(XmlParser.ParseTypeCache(new StringReader(newTypeString)));
571        Assert.Fail("Exception expected");
572      } catch (PersistenceException x) {
573        Assert.IsTrue(x.Message.Contains("incompatible"));
574      }
575      newTypeString = Regex.Replace(typeString.ToString(),
576        "Version=(\\d+\\.\\d+)\\.\\d+\\.\\d+",
577        "Version=$1.9999.9999");
578      try {
579        d = new Deserializer(XmlParser.ParseTypeCache(new StringReader(newTypeString)));
580        Assert.Fail("Exception expected");
581      } catch (PersistenceException x) {
582        Assert.IsTrue(x.Message.Contains("newer"));
583      }
584    }
585
586    [TestMethod]
587    public void InheritanceTest() {
588      New n = new New();
589      XmlGenerator.Serialize(n, tempFile);
590      New nn = (New)XmlParser.Deserialize(tempFile);
591      Assert.AreEqual(n.Name, nn.Name);
592      Assert.AreEqual(((Override)n).Name, ((Override)nn).Name);
593    }
594
595    [StorableClass(StorableClassType.MarkedOnly)]
596    class Child {
597      [Storable]
598      public GrandParent grandParent;
599    }
600
601    [StorableClass(StorableClassType.MarkedOnly)]
602    class Parent {
603      [Storable]
604      public Child child;
605    }
606
607    [StorableClass(StorableClassType.MarkedOnly)]
608    class GrandParent {
609      [Storable]
610      public Parent parent;
611    }
612
613    [TestMethod]
614    public void InstantiateParentChainReference() {
615      GrandParent gp = new GrandParent();
616      gp.parent = new Parent();
617      gp.parent.child = new Child();
618      gp.parent.child.grandParent = gp;
619      Assert.AreSame(gp, gp.parent.child.grandParent);
620      XmlGenerator.Serialize(gp, tempFile);
621      GrandParent newGp = (GrandParent)XmlParser.Deserialize(tempFile);
622      Assert.AreSame(newGp, newGp.parent.child.grandParent);
623    }
624
625    struct TestStruct {
626      int value;
627      int PropertyValue { get; set; }
628      public TestStruct(int value)
629        : this() {
630        this.value = value;
631        PropertyValue = value;
632      }
633    }
634
635    [TestMethod]
636    public void StructTest() {
637      TestStruct s = new TestStruct(10);
638      XmlGenerator.Serialize(s, tempFile);
639      TestStruct newS = (TestStruct)XmlParser.Deserialize(tempFile);
640      Assert.AreEqual(s, newS);
641    }
642
643    [TestMethod]
644    public void PointTest() {
645      Point p = new Point(12, 34);
646      XmlGenerator.Serialize(p, tempFile);
647      Point newP = (Point)XmlParser.Deserialize(tempFile);
648      Assert.AreEqual(p, newP);
649    }
650
651    [TestMethod]
652    public void NullableValueTypes() {
653      double?[] d = new double?[] { null, 1, 2, 3 };
654      XmlGenerator.Serialize(d, tempFile);
655      double?[] newD = (double?[])XmlParser.Deserialize(tempFile);
656      Assert.AreEqual(d[0], newD[0]);
657      Assert.AreEqual(d[1], newD[1]);
658      Assert.AreEqual(d[2], newD[2]);
659      Assert.AreEqual(d[3], newD[3]);
660    }
661
662    [TestMethod]
663    public void BitmapTest() {
664      Icon icon = System.Drawing.SystemIcons.Hand;
665      Bitmap bitmap = icon.ToBitmap();
666      XmlGenerator.Serialize(bitmap, tempFile);
667      Bitmap newBitmap = (Bitmap)XmlParser.Deserialize(tempFile);
668
669      Assert.AreEqual(bitmap.Size, newBitmap.Size);
670      for(int i=0; i< bitmap.Size.Width; i++)
671        for(int j =0; j< bitmap.Size.Height; j++)
672          Assert.AreEqual(bitmap.GetPixel(i,j),newBitmap.GetPixel(i,j));
673    }
674
675    [StorableClass(StorableClassType.MarkedOnly)]
676    private class PersistenceHooks {
677      [Storable]
678      public int a;
679      [Storable]
680      public int b;
681      public int sum;
682      public bool WasSerialized { get; private set; }
683      [StorableHook(HookType.BeforeSerialization)]
684      void PreSerializationHook() {
685        WasSerialized = true;
686      }
687      [StorableHook(HookType.AfterDeserialization)]
688      void PostDeserializationHook() {
689        sum = a + b;
690      }
691    }
692
693    [TestMethod]
694    public void HookTest() {
695      PersistenceHooks hookTest = new PersistenceHooks();
696      hookTest.a = 2;
697      hookTest.b = 5;
698      Assert.IsFalse(hookTest.WasSerialized);
699      Assert.AreEqual(hookTest.sum, 0);
700      XmlGenerator.Serialize(hookTest, tempFile);
701      Assert.IsTrue(hookTest.WasSerialized);
702      Assert.AreEqual(hookTest.sum, 0);
703      PersistenceHooks newHookTest = (PersistenceHooks)XmlParser.Deserialize(tempFile);
704      Assert.AreEqual(newHookTest.a, hookTest.a);
705      Assert.AreEqual(newHookTest.b, hookTest.b);
706      Assert.AreEqual(newHookTest.sum, newHookTest.a + newHookTest.b);
707      Assert.IsFalse(newHookTest.WasSerialized);
708    }
709   
710    [StorableClass(StorableClassType.Empty)]
711    private class CustomConstructor {
712      public string Value = "none";
713      public CustomConstructor() {
714        Value = "default";
715      }
716      [StorableConstructor]
717      private CustomConstructor(bool deserializing) {
718        Assert.IsTrue(deserializing);
719        Value = "persistence";
720      }
721    }
722
723    [TestMethod]
724    public void TestCustomConstructor() {
725      CustomConstructor cc = new CustomConstructor();
726      Assert.AreEqual(cc.Value, "default");
727      XmlGenerator.Serialize(cc, tempFile);
728      CustomConstructor newCC = (CustomConstructor)XmlParser.Deserialize(tempFile);
729      Assert.AreEqual(newCC.Value, "persistence");
730    }
731
732    [StorableClass(StorableClassType.Empty)]
733    public class ExplodingDefaultConstructor {
734      public ExplodingDefaultConstructor() {
735        throw new Exception("this constructor will always fail");
736      }
737      public ExplodingDefaultConstructor(string password) {
738      }
739    }
740
741    [TestMethod]
742    public void TestConstructorExceptionUnwrapping() {
743      ExplodingDefaultConstructor x = new ExplodingDefaultConstructor("password");
744      XmlGenerator.Serialize(x, tempFile);
745      try {
746        ExplodingDefaultConstructor newX = (ExplodingDefaultConstructor)XmlParser.Deserialize(tempFile);
747        Assert.Fail("Exception expected");
748      } catch (PersistenceException pe) {
749        Assert.AreEqual(pe.InnerException.Message, "this constructor will always fail");
750      }
751    }
752
753    [TestMethod]
754    public void TestRejectionJustifications() {
755      NonSerializable ns = new NonSerializable();
756      try {
757        XmlGenerator.Serialize(ns, tempFile);
758        Assert.Fail("PersistenceException expected");
759      } catch (PersistenceException x) {
760        Assert.IsTrue(x.Message.Contains(new StorableSerializer().JustifyRejection(typeof(NonSerializable))));       
761      }
762    }
763
764    [ClassInitialize]
765    public static void Initialize(TestContext testContext) {
766      ConfigurationService.Instance.Reset();
767    }
768  }
769}
Note: See TracBrowser for help on using the repository browser.