Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Persistence/UnitTests/UseCases.cs @ 1795

Last change on this file since 1795 was 1795, checked in by epitzer, 15 years ago

Also make sure major and minor version match (not only newer) + better tests. (#613)
File size: 19.3 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.Decomposers.Storable;
13using HeuristicLab.Persistence.Interfaces;
14using HeuristicLab.Persistence.Default.Xml.Primitive;
15using HeuristicLab.Persistence.Default.Decomposers;
16using HeuristicLab.Persistence.Auxiliary;
17using System.Text.RegularExpressions;
18
19namespace HeuristicLab.Persistence.UnitTest {
20
21  public class NumberTest {
22    [Storable]
23    private bool _bool = true;
24    [Storable]
25    private byte _byte = 0xFF;
26    [Storable]
27    private sbyte _sbyte = 0xF;
28    [Storable]
29    private short _short = -123;
30    [Storable]
31    private ushort _ushort = 123;
32    [Storable]
33    private int _int = -123;
34    [Storable]
35    private uint _uint = 123;
36    [Storable]
37    private long _long = 123456;
38    [Storable]
39    private ulong _ulong = 123456;
40  }
41
42  public class NonDefaultConstructorClass {
43    [Storable]
44    int value;
45    public NonDefaultConstructorClass(int value) {
46      this.value = value;
47    }
48  }
49
50  public class IntWrapper {
51
52    [Storable]
53    public int Value;
54
55    private IntWrapper() { }
56
57    public IntWrapper(int value) {
58      this.Value = value;
59    }
60
61    public override bool Equals(object obj) {
62      if (obj as IntWrapper == null)
63        return false;
64      return Value.Equals(((IntWrapper)obj).Value);
65    }
66    public override int GetHashCode() {
67      return Value.GetHashCode();
68    }
69
70  }
71
72  public class EventTest {
73    public delegate object Filter(object o);
74    public event Filter OnChange;
75    [Storable]
76    private Delegate[] OnChangeListener {
77      get { return OnChange.GetInvocationList(); }
78      set {
79        foreach (Delegate d in value) {
80          OnChange += (Filter)d;
81        }
82      }
83    }
84  }
85
86  public class PrimitivesTest : NumberTest {
87    [Storable]
88    private char c = 'e';
89    [Storable]
90    private long[,] _long_array =
91      new long[,] { { 123, 456, }, { 789, 123 } };
92    [Storable]
93    public List<int> list = new List<int> { 1, 2, 3, 4, 5 };
94    [Storable]
95    private object o = new object();
96  }
97
98  public enum TestEnum { va1, va2, va3, va8 } ;
99
100  public class RootBase {
101    [Storable]
102    private string baseString = "   Serial  ";
103    [Storable]
104    public TestEnum myEnum = TestEnum.va3;
105  }
106
107  public class Root : RootBase {
108    [Storable]
109    public Stack<int> intStack = new Stack<int>();
110    [Storable]
111    public int[] i = new[] { 3, 4, 5, 6 };
112    [Storable(Name = "Test String")]
113    public string s;
114    [Storable]
115    public ArrayList intArray = new ArrayList(new[] { 1, 2, 3 });
116    [Storable]
117    public List<int> intList = new List<int>(new[] { 321, 312, 321 });
118    [Storable]
119    public Custom c;
120    [Storable]
121    public List<Root> selfReferences;
122    [Storable]
123    public double[,] multiDimArray = new double[,] { { 1, 2, 3 }, { 3, 4, 5 } };
124    [Storable]
125    public bool boolean = true;
126    [Storable]
127    public DateTime dateTime;
128    [Storable]
129    public KeyValuePair<string, int> kvp = new KeyValuePair<string, int>("Serial", 123);
130    [Storable]
131    public Dictionary<string, int> dict = new Dictionary<string, int>();
132    [Storable(DefaultValue = "default")]
133    public string uninitialized;
134  }
135
136  public enum SimpleEnum { one, two, three }
137  public enum ComplexEnum { one = 1, two = 2, three = 3 }
138  [FlagsAttribute]
139  public enum TrickyEnum { zero = 0, one = 1, two = 2 }
140
141  public class EnumTest {
142    [Storable]
143    public SimpleEnum simpleEnum = SimpleEnum.one;
144    [Storable]
145    public ComplexEnum complexEnum = (ComplexEnum)2;
146    [Storable]
147    public TrickyEnum trickyEnum = (TrickyEnum)15;
148  }
149
150  public class Custom {
151    [Storable]
152    public int i;
153    [Storable]
154    public Root r;
155    [Storable]
156    public string name = "<![CDATA[<![CDATA[Serial]]>]]>";
157  }
158
159  public class Manager {
160
161    public DateTime lastLoadTime;
162    [Storable]
163    private DateTime lastLoadTimePersistence {
164      get { return lastLoadTime; }
165      set { lastLoadTime = DateTime.Now; }
166    }
167    [Storable]
168    public double? dbl;
169  }
170
171  public class C {
172    [Storable]
173    public C[][] allCs;
174    [Storable]
175    public KeyValuePair<List<C>, C> kvpList;
176  }
177
178  public class NonSerializable {
179    int x;
180  }
181
182
183  [TestClass]
184  public class UseCases {
185
186    private string tempFile;
187
188    [TestInitialize()]
189    public void CreateTempFile() {
190      tempFile = Path.GetTempFileName();
191    }
192
193    [TestCleanup()]
194    public void ClearTempFile() {
195      StreamReader reader = new StreamReader(tempFile);
196      string s = reader.ReadToEnd();
197      reader.Close();
198      File.Delete(tempFile);
199    }
200
201    [TestMethod]
202    public void ComplexStorable() {
203      Root r = new Root();
204      r.intStack.Push(1);
205      r.intStack.Push(2);
206      r.intStack.Push(3);
207      r.selfReferences = new List<Root> { r, r };
208      r.c = new Custom { r = r };
209      r.dict.Add("one", 1);
210      r.dict.Add("two", 2);
211      r.dict.Add("three", 3);
212      r.myEnum = TestEnum.va1;
213      r.i = new[] { 7, 5, 6 };
214      r.s = "new value";
215      r.intArray = new ArrayList { 3, 2, 1 };
216      r.intList = new List<int> { 9, 8, 7 };
217      r.multiDimArray = new double[,] { { 5, 4, 3 }, { 1, 4, 6 } };
218      r.boolean = false;
219      r.dateTime = DateTime.Now;
220      r.kvp = new KeyValuePair<string, int>("string key", 321);
221      r.uninitialized = null;
222      XmlGenerator.Serialize(r, tempFile);
223      Root newR = (Root)XmlParser.Deserialize(tempFile);
224      Assert.AreEqual(
225        DebugStringGenerator.Serialize(r),
226        DebugStringGenerator.Serialize(newR));
227      Assert.AreSame(newR, newR.selfReferences[0]);
228      Assert.AreNotSame(r, newR);
229      Assert.AreEqual(r.myEnum, TestEnum.va1);
230      Assert.AreEqual(r.i[0], 7);
231      Assert.AreEqual(r.i[1], 5);
232      Assert.AreEqual(r.i[2], 6);
233      Assert.AreEqual(r.s, "new value");
234      Assert.AreEqual(r.intArray[0], 3);
235      Assert.AreEqual(r.intArray[1], 2);
236      Assert.AreEqual(r.intArray[2], 1);
237      Assert.AreEqual(r.intList[0], 9);
238      Assert.AreEqual(r.intList[1], 8);
239      Assert.AreEqual(r.intList[2], 7);
240      Assert.AreEqual(r.multiDimArray[0, 0], 5);
241      Assert.AreEqual(r.multiDimArray[0, 1], 4);
242      Assert.AreEqual(r.multiDimArray[0, 2], 3);
243      Assert.AreEqual(r.multiDimArray[1, 0], 1);
244      Assert.AreEqual(r.multiDimArray[1, 1], 4);
245      Assert.AreEqual(r.multiDimArray[1, 2], 6);
246      Assert.IsFalse(r.boolean);
247      Assert.IsTrue((DateTime.Now - r.dateTime).TotalSeconds < 10);
248      Assert.AreEqual(r.kvp.Key, "string key");
249      Assert.AreEqual(r.kvp.Value, 321);
250      Assert.IsNull(r.uninitialized);
251      Assert.AreEqual(newR.myEnum, TestEnum.va1);
252      Assert.AreEqual(newR.i[0], 7);
253      Assert.AreEqual(newR.i[1], 5);
254      Assert.AreEqual(newR.i[2], 6);
255      Assert.AreEqual(newR.s, "new value");
256      Assert.AreEqual(newR.intArray[0], 3);
257      Assert.AreEqual(newR.intArray[1], 2);
258      Assert.AreEqual(newR.intArray[2], 1);
259      Assert.AreEqual(newR.intList[0], 9);
260      Assert.AreEqual(newR.intList[1], 8);
261      Assert.AreEqual(newR.intList[2], 7);
262      Assert.AreEqual(newR.multiDimArray[0, 0], 5);
263      Assert.AreEqual(newR.multiDimArray[0, 1], 4);
264      Assert.AreEqual(newR.multiDimArray[0, 2], 3);
265      Assert.AreEqual(newR.multiDimArray[1, 0], 1);
266      Assert.AreEqual(newR.multiDimArray[1, 1], 4);
267      Assert.AreEqual(newR.multiDimArray[1, 2], 6);
268      Assert.AreEqual(newR.intStack.Pop(), 3);
269      Assert.AreEqual(newR.intStack.Pop(), 2);
270      Assert.AreEqual(newR.intStack.Pop(), 1);
271      Assert.IsFalse(newR.boolean);
272      Assert.IsTrue((DateTime.Now - newR.dateTime).TotalSeconds < 10);
273      Assert.AreEqual(newR.kvp.Key, "string key");
274      Assert.AreEqual(newR.kvp.Value, 321);
275      Assert.IsNull(newR.uninitialized);
276    }
277
278    [TestMethod]
279    public void SelfReferences() {
280      C c = new C();
281      C[][] cs = new C[2][];
282      cs[0] = new C[] { c };
283      cs[1] = new C[] { c };
284      c.allCs = cs;
285      c.kvpList = new KeyValuePair<List<C>, C>(new List<C> { c }, c);
286      XmlGenerator.Serialize(cs, tempFile);
287      object o = XmlParser.Deserialize(tempFile);
288      Assert.AreEqual(
289        DebugStringGenerator.Serialize(cs),
290        DebugStringGenerator.Serialize(o));
291      Assert.AreSame(c, c.allCs[0][0]);
292      Assert.AreSame(c, c.allCs[1][0]);
293      Assert.AreSame(c, c.kvpList.Key[0]);
294      Assert.AreSame(c, c.kvpList.Value);
295      C[][] newCs = (C[][])o;
296      C newC = newCs[0][0];
297      Assert.AreSame(newC, newC.allCs[0][0]);
298      Assert.AreSame(newC, newC.allCs[1][0]);
299      Assert.AreSame(newC, newC.kvpList.Key[0]);
300      Assert.AreSame(newC, newC.kvpList.Value);
301    }
302
303    [TestMethod]
304    public void ArrayCreation() {
305      ArrayList[] arrayListArray = new ArrayList[4];
306      arrayListArray[0] = new ArrayList();
307      arrayListArray[0].Add(arrayListArray);
308      arrayListArray[0].Add(arrayListArray);
309      arrayListArray[1] = new ArrayList();
310      arrayListArray[1].Add(arrayListArray);
311      arrayListArray[2] = new ArrayList();
312      arrayListArray[2].Add(arrayListArray);
313      arrayListArray[2].Add(arrayListArray);
314      Array a = Array.CreateInstance(
315                              typeof(object),
316                              new[] { 1, 2 }, new[] { 3, 4 });
317      arrayListArray[2].Add(a);
318      XmlGenerator.Serialize(arrayListArray, tempFile);
319      object o = XmlParser.Deserialize(tempFile);
320      Assert.AreEqual(
321        DebugStringGenerator.Serialize(arrayListArray),
322        DebugStringGenerator.Serialize(o));
323      ArrayList[] newArray = (ArrayList[])o;
324      Assert.AreSame(arrayListArray, arrayListArray[0][0]);
325      Assert.AreSame(arrayListArray, arrayListArray[2][1]);
326      Assert.AreSame(newArray, newArray[0][0]);
327      Assert.AreSame(newArray, newArray[2][1]);
328    }
329
330    [TestMethod]
331    public void CustomSerializationProperty() {
332      Manager m = new Manager();
333      XmlGenerator.Serialize(m, tempFile);
334      Manager newM = (Manager)XmlParser.Deserialize(tempFile);
335      Assert.AreNotEqual(
336        DebugStringGenerator.Serialize(m),
337        DebugStringGenerator.Serialize(newM));
338      Assert.AreEqual(m.dbl, newM.dbl);
339      Assert.AreEqual(m.lastLoadTime, new DateTime());
340      Assert.AreNotEqual(newM.lastLoadTime, new DateTime());
341      Assert.IsTrue((DateTime.Now - newM.lastLoadTime).TotalSeconds < 10);
342    }
343
344    [TestMethod]
345    public void Primitives() {
346      PrimitivesTest sdt = new PrimitivesTest();
347      XmlGenerator.Serialize(sdt, tempFile);
348      object o = XmlParser.Deserialize(tempFile);
349      Assert.AreEqual(
350        DebugStringGenerator.Serialize(sdt),
351        DebugStringGenerator.Serialize(o));
352    }
353
354    [TestMethod]
355    public void MultiDimensionalArray() {
356      string[,] mDimString = new string[,] {
357        {"ora", "et", "labora"},
358        {"Beten", "und", "Arbeiten"}
359      };
360      XmlGenerator.Serialize(mDimString, tempFile);
361      object o = XmlParser.Deserialize(tempFile);
362      Assert.AreEqual(
363        DebugStringGenerator.Serialize(mDimString),
364        DebugStringGenerator.Serialize(o));
365    }
366
367    public class NestedType {
368      [Storable]
369      private string value = "value";
370    }
371
372    [TestMethod]
373    public void NestedTypeTest() {
374      NestedType t = new NestedType();
375      XmlGenerator.Serialize(t, tempFile);
376      object o = XmlParser.Deserialize(tempFile);
377      Assert.AreEqual(
378        DebugStringGenerator.Serialize(t),
379        DebugStringGenerator.Serialize(o));
380    }
381
382
383    [TestMethod]
384    public void SimpleArray() {
385      string[] strings = { "ora", "et", "labora" };
386      XmlGenerator.Serialize(strings, tempFile);
387      object o = XmlParser.Deserialize(tempFile);
388      Assert.AreEqual(
389        DebugStringGenerator.Serialize(strings),
390        DebugStringGenerator.Serialize(o));
391    }
392
393    [TestMethod]
394    public void BinaryFormatTest() {
395      Root r = new Root();
396      Assert.Fail("Not Implemented");
397      //BinaryGenerator.Serialize(r, "test.bin");
398    }
399
400
401    [TestMethod]
402    public void PrimitiveRoot() {
403      XmlGenerator.Serialize(12.3f, tempFile);
404      object o = XmlParser.Deserialize(tempFile);
405      Assert.AreEqual(
406        DebugStringGenerator.Serialize(12.3f),
407        DebugStringGenerator.Serialize(o));
408    }
409
410    private string formatFullMemberName(MemberInfo mi) {
411      return new StringBuilder()
412        .Append(mi.DeclaringType.Assembly.GetName().Name)
413        .Append(": ")
414        .Append(mi.DeclaringType.Namespace)
415        .Append('.')
416        .Append(mi.DeclaringType.Name)
417        .Append('.')
418        .Append(mi.Name).ToString();
419    }
420
421    [TestMethod]
422    public void CodingConventions() {
423      List<string> lowerCaseMethodNames = new List<string>();
424      List<string> lowerCaseProperties = new List<string>();
425      List<string> lowerCaseFields = new List<string>();
426      foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies()) {
427        if (!a.GetName().Name.StartsWith("HeuristicLab"))
428          continue;
429        foreach (Type t in a.GetTypes()) {
430          foreach (MemberInfo mi in t.GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)) {
431            if (char.IsLower(mi.Name[0])) {
432              if (mi.MemberType == MemberTypes.Field)
433                lowerCaseFields.Add(formatFullMemberName(mi));
434              if (mi.MemberType == MemberTypes.Property)
435                lowerCaseProperties.Add(formatFullMemberName(mi));
436              if (mi.MemberType == MemberTypes.Method &&
437                !mi.Name.StartsWith("get_") &&
438                !mi.Name.StartsWith("set_") &&
439                !mi.Name.StartsWith("add_") &&
440                !mi.Name.StartsWith("remove_"))
441                lowerCaseMethodNames.Add(formatFullMemberName(mi));
442            }
443          }
444        }
445      }
446      //Assert.AreEqual("", lowerCaseFields.Aggregate("", (a, b) => a + "\r\n" + b));
447      Assert.AreEqual("", lowerCaseMethodNames.Aggregate("", (a, b) => a + "\r\n" + b));
448      Assert.AreEqual("", lowerCaseProperties.Aggregate("", (a, b) => a + "\r\n" + b));
449    }
450
451    [TestMethod]
452    public void Number2StringDecomposer() {
453      NumberTest sdt = new NumberTest();
454      XmlGenerator.Serialize(sdt, tempFile,
455        new Configuration(new XmlFormat(),
456          new List<IFormatter> { new String2XmlFormatter() },
457          new List<IDecomposer> {
458            new StorableDecomposer(),
459            new Number2StringDecomposer() }));
460      object o = XmlParser.Deserialize(tempFile);
461      Assert.AreEqual(
462        DebugStringGenerator.Serialize(sdt),
463        DebugStringGenerator.Serialize(o));
464    }
465
466    [TestMethod]
467    public void Events() {
468      EventTest et = new EventTest();
469      et.OnChange += (o) => o;
470      XmlGenerator.Serialize(et, tempFile);
471      EventTest newEt = (EventTest)XmlParser.Deserialize(tempFile);
472    }
473
474    [TestMethod]
475    public void Enums() {
476      EnumTest et = new EnumTest();
477      et.simpleEnum = SimpleEnum.two;
478      et.complexEnum = ComplexEnum.three;
479      et.trickyEnum = TrickyEnum.two | TrickyEnum.one;
480      XmlGenerator.Serialize(et, tempFile);
481      EnumTest newEt = (EnumTest)XmlParser.Deserialize(tempFile);
482      Assert.AreEqual(et.simpleEnum, SimpleEnum.two);
483      Assert.AreEqual(et.complexEnum, ComplexEnum.three);
484      Assert.AreEqual(et.trickyEnum, (TrickyEnum)3);
485    }
486
487    [TestMethod]
488    public void TestAliasingWithOverriddenEquals() {
489      List<IntWrapper> ints = new List<IntWrapper>();
490      ints.Add(new IntWrapper(1));
491      ints.Add(new IntWrapper(1));
492      Assert.AreEqual(ints[0], ints[1]);
493      Assert.AreNotSame(ints[0], ints[1]);
494      XmlGenerator.Serialize(ints, tempFile);
495      List<IntWrapper> newInts = (List<IntWrapper>)XmlParser.Deserialize(tempFile);
496      Assert.AreEqual(newInts[0].Value, 1);
497      Assert.AreEqual(newInts[1].Value, 1);
498      Assert.AreEqual(newInts[0], newInts[1]);
499      Assert.AreNotSame(newInts[0], newInts[1]);
500    }
501
502    [TestMethod]
503    public void NonDefaultConstructorTest() {
504      NonDefaultConstructorClass c = new NonDefaultConstructorClass(1);
505      try {
506        XmlGenerator.Serialize(c, tempFile);
507        Assert.Fail("Exception not thrown");
508      } catch (PersistenceException) {
509      }
510    }
511
512    [TestMethod]
513    public void TestSavingException() {
514      List<int> list = new List<int> { 1, 2, 3 };
515      XmlGenerator.Serialize(list, tempFile);
516      NonSerializable s = new NonSerializable();
517      try {
518        XmlGenerator.Serialize(s, tempFile);
519        Assert.Fail("Exception expected");
520      } catch (PersistenceException) { }
521      List<int> newList = (List<int>)XmlParser.Deserialize(tempFile);
522      Assert.AreEqual(list[0], newList[0]);
523      Assert.AreEqual(list[1], newList[1]);
524    }
525
526    [TestMethod]
527    public void TestTypeStringConversion() {
528      string name = typeof(List<int>[]).AssemblyQualifiedName;
529      string shortName =
530        "System.Collections.Generic.List`1[[System.Int32, mscorlib]][], mscorlib";
531      Assert.AreEqual(name, TypeNameParser.Parse(name).ToString());
532      Assert.AreEqual(shortName, TypeNameParser.Parse(name).ToString(false));
533      Assert.AreEqual(shortName, typeof(List<int>[]).VersionInvariantName());
534    }
535
536    [TestMethod]
537    public void TestAssemblyVersionCheck() {
538      IntWrapper i = new IntWrapper(1);
539      Serializer s = new Serializer(i, ConfigurationService.Instance.GetDefaultConfig(new XmlFormat()));
540      XmlGenerator g = new XmlGenerator();
541      StringBuilder dataString = new StringBuilder();
542      foreach (var token in s) {
543        dataString.Append(g.Format(token));
544      }
545      StringBuilder typeString = new StringBuilder();
546      foreach (var line in g.Format(s.TypeCache))
547        typeString.Append(line);
548      Deserializer d = new Deserializer(XmlParser.ParseTypeCache(new StringReader(typeString.ToString())));
549      XmlParser p = new XmlParser(new StringReader(dataString.ToString()));
550      IntWrapper newI = (IntWrapper)d.Deserialize(p);
551      Assert.AreEqual(i.Value, newI.Value);
552
553      string newTypeString = Regex.Replace(typeString.ToString(),
554        "Version=\\d+\\.\\d+\\.\\d+\\.\\d+",
555        "Version=0.0.9999.9999");
556      try {
557        d = new Deserializer(XmlParser.ParseTypeCache(new StringReader(newTypeString)));
558        Assert.Fail("Exception expected");
559      } catch (PersistenceException x) {
560        Assert.IsTrue(x.Message.Contains("incompatible"));
561      }
562      newTypeString = Regex.Replace(typeString.ToString(),
563        "Version=(\\d+\\.\\d+)\\.\\d+\\.\\d+",
564        "Version=$1.9999.9999");
565      try {
566        d = new Deserializer(XmlParser.ParseTypeCache(new StringReader(newTypeString)));
567        Assert.Fail("Exception expected");
568      } catch (PersistenceException x) {
569        Assert.IsTrue(x.Message.Contains("newer"));
570      }
571    }
572
573    [ClassInitialize]
574    public static void Initialize(TestContext testContext) {
575      ConfigurationService.Instance.Reset();
576    }
577  }
578}
Note: See TracBrowser for help on using the repository browser.