Free cookie consent management tool by TermsFeed Policy Generator

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

Last change on this file since 2950 was 2941, checked in by mkommend, 14 years ago

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