mcs/class/System.XML/Test/System.Xml.Serialization/XmlSerializationReaderTests.cs

   1 //
   2 // MonoTests.System.Xml.Serialization.XmlSerializationReaderTests
   3 //
   4 // Author:
   5 //      Gert Driesen (drieseng@users.sourceforge.net)
   6 //      Atsushi Enomoto (atsushi@ximian.com)
   7 //
   8 //  (C) 2006 Gert Driesen
   9 //  Copyright (C) 2007 Novell, Inc.
  10 //
  11
  12 using System;
  13 using System.Collections;
  14 using System.IO;
  15 using System.Xml.Serialization;
  16
  17 using NUnit.Framework;
  18
  19 using MonoTests.System.Xml.TestClasses;
  20
  21 namespace MonoTests.System.XmlSerialization
  22 {
  23         [TestFixture]
  24         public class XmlSerializationReaderTests : XmlSerializarionReaderTester
  25         {
  26                 [Test]
  27                 public void TestToEnum ()
  28                 {
  29                         Hashtable values = new Hashtable ();
  30                         values.Add ("One", 1L);
  31                         values.Add ("Two", 2L);
  32                         values.Add ("Four", 4L);
  33
  34                         Assert.AreEqual (1, ToEnum ("One", values, "Some.Type.Name"), "#A1");
  35                         Assert.AreEqual (2, ToEnum (" Two ", values, "Some.Type.Name"), "#A2");
  36                         Assert.AreEqual (4, ToEnum ("Four", values, "Some.Type.Name"), "#A3");
  37                         Assert.AreEqual (5, ToEnum ("One Four", values, "Some.Type.Name"), "#A4");
  38                         Assert.AreEqual (7, ToEnum ("One Two Four", values, "Some.Type.Name"), "#A5");
  39                         Assert.AreEqual (0, ToEnum ("", values, "Some.Type.Name"), "#A6");
  40                         Assert.AreEqual (0, ToEnum ("     ", values, "Some.Type.Name"), "#A7");
  41                         Assert.AreEqual (2, ToEnum ("Two Two", values, "Some.Type.Name"), "#A8");
  42
  43                         values.Add ("", 24L);
  44                         Assert.AreEqual (24, ToEnum ("", values, "Some.Type.Name"), "#B1");
  45                         Assert.AreEqual (24, ToEnum ("  ", values, "Some.Type.Name"), "#B2");
  46                 }
  47
  48                 [Test]
  49                 public void TestToEnum_InvalidValue ()
  50                 {
  51                         try {
  52                                 ToEnum ("SomeValue", new Hashtable (), "Some.Type.Name");
  53                                 Assert.Fail ("#A1");
  54                         } catch (InvalidOperationException ex) {
  55                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
  56                                 Assert.IsNotNull (ex.Message, "#A3");
  57                                 Assert.IsTrue (ex.Message.IndexOf ("'SomeValue'") != -1, "#A4");
  58                                 Assert.IsTrue (ex.Message.IndexOf ("Some.Type.Name") != -1, "#A5");
  59                                 Assert.IsNull (ex.InnerException, "#A6");
  60                         }
  61
  62                         Hashtable values = new Hashtable ();
  63                         values.Add ("One", 1L);
  64                         values.Add ("Two", 2L);
  65                         values.Add ("Four", 4L);
  66
  67                         try {
  68                                 ToEnum ("one", values, "Some.Type.Name");
  69                                 Assert.Fail ("#B1");
  70                         } catch (InvalidOperationException ex) {
  71                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
  72                                 Assert.IsNotNull (ex.Message, "#B3");
  73                                 Assert.IsTrue (ex.Message.IndexOf ("'one'") != -1, "#B4");
  74                                 Assert.IsTrue (ex.Message.IndexOf ("Some.Type.Name") != -1, "#B5");
  75                                 Assert.IsNull (ex.InnerException, "#B6");
  76                         }
  77
  78                         values.Clear ();
  79                         values.Add ("One", FlagEnum.e1);
  80
  81                         try {
  82                                 ToEnum ("One", values, "Some.Type.Name");
  83                                 Assert.Fail ("#C1");
  84                         } catch (InvalidCastException ex) {
  85                         }
  86
  87                         values.Clear ();
  88                         values.Add ("One", 1);
  89
  90                         try {
  91                                 ToEnum ("One", values, "Some.Type.Name");
  92                                 Assert.Fail ("#D1");
  93                         } catch (InvalidCastException ex) {
  94                         }
  95
  96                         values.Clear ();
  97                         values.Add ("One", null);
  98
  99                         try {
 100                                 ToEnum ("One", values, "Some.Type.Name");
 101                                 Assert.Fail ("#E1");
 102                         } catch (InvalidOperationException ex) {
 103                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
 104                                 Assert.IsNotNull (ex.Message, "#E3");
 105                                 Assert.IsTrue (ex.Message.IndexOf ("'One'") != -1, "#E4");
 106                                 Assert.IsTrue (ex.Message.IndexOf ("Some.Type.Name") != -1, "#E5");
 107                                 Assert.IsNull (ex.InnerException, "#E6");
 108                         }
 109                 }
 110
 111                 [Test]
 112                 [ExpectedException (typeof (NullReferenceException))]
 113                 public void TestToEnum_Null_Value ()
 114                 {
 115                         ToEnum ((string) null, new Hashtable (), "DoesNotMatter");
 116                 }
 117
 118                 [Test]
 119                 [ExpectedException (typeof (NullReferenceException))]
 120                 public void TestToEnum_Null_Values ()
 121                 {
 122                         ToEnum ("", (Hashtable) null, "DoesNotMatter");
 123                 }
 124
 125                 [Test]
 126                 public void HandleOutAttributeParameters ()
 127                 {
 128                         XmlReflectionMember m = new XmlReflectionMember ();
 129                         m.MemberName = "hooray";
 130                         m.MemberType = typeof (string);
 131                         m.XmlAttributes = new XmlAttributes ();
 132                         m.XmlAttributes.XmlAttribute = new XmlAttributeAttribute ();
 133                         XmlReflectionImporter imp = new XmlReflectionImporter ();
 134                         XmlMembersMapping map = imp.ImportMembersMapping (
 135                                 "elem", "urn:x", new XmlReflectionMember [] {m}, true);
 136                         XmlSerializer ser = XmlSerializer.FromMappings (
 137                                 new XmlMapping [] {map}) [0];
 138                         string xml = "<elem xmlns='urn:x' hooray='doh' />";
 139                         object [] arr = ser.Deserialize (new StringReader (xml))
 140                                 as object [];
 141                         Assert.IsNotNull (arr, "#1");
 142                         Assert.AreEqual (1, arr.Length, "#2");
 143                         Assert.AreEqual ("doh", arr [0], "#3");
 144
 145                         xml = "<elem xmlns='urn:x' hooray='doh'></elem>";
 146                         arr = ser.Deserialize (new StringReader (xml)) as object [];
 147                         Assert.IsNotNull (arr, "#4");
 148                         Assert.AreEqual (1, arr.Length, "#5");
 149                         Assert.AreEqual ("doh", arr [0], "#6");
 150                 }
 151
 152                 [Test]
 153                 public void ExplicitlyOrderedMembers1 ()
 154                 {
 155                         var xs = new XmlSerializer (typeof (ExplicitlyOrderedMembersType1));
 156                         var result = (ExplicitlyOrderedMembersType1) xs.Deserialize(new StringReader (@"
 157 <root>
 158         <child>Hello</child>
 159         <child>World</child>
 160         <child0>test</child0>
 161 </root>"));
 162                         Assert.AreEqual ("Hello", result.Child1, "#1");
 163                         Assert.AreEqual ("World", result.Child2, "#2");
 164                         Assert.AreEqual ("test", result.Child0, "#3");
 165                 }
 166
 167                 [Test]
 168                 [ExpectedException (typeof (InvalidOperationException))]
 169                 public void ExplicitlyOrderedMembers2 ()
 170                 {
 171                         new XmlSerializer (typeof (ExplicitlyOrderedMembersType2));
 172                 }
 173
 174                 [Test]
 175                 public void ExplicitlyOrderedMembers3 ()
 176                 {
 177                         var xs = new XmlSerializer (typeof (ExplicitlyOrderedMembersType3));
 178                         var result = (ExplicitlyOrderedMembersType3) xs.Deserialize(new StringReader (@"
 179 <root>
 180         <child>Hello</child>
 181         <child>World</child>
 182         <child0>test</child0>
 183 </root>"));
 184                         Assert.AreEqual ("Hello", result.Child1, "#1");
 185                         Assert.AreEqual ("World", result.Child2, "#2");
 186                         Assert.IsNull (result.Child0, "#3"); // not "test"
 187                 }
 188
 189                 [Test]
 190                 public void ExplicitlyOrderedMembers4 ()
 191                 {
 192                         var xs = new XmlSerializer (typeof (ExplicitlyOrderedMembersType4));
 193                         //Would result in an Inconsistent XML sequence error , see Bug 707434
 194                         var result = (ExplicitlyOrderedMembersType4) xs.Deserialize(new StringReader (@"
 195 <root>
 196         <child>Hello</child>
 197         <child>World</child>
 198         <child0>test</child0>
 199 </root>"));
 200                         Assert.AreEqual ("Hello", result.Child1, "#1");
 201                         Assert.AreEqual ("World", result.Child2, "#2");
 202                         Assert.IsNull (result.Child0, "#3"); // not "test"
 203                 }
 204         }
 205
 206         public class XmlSerializarionReaderTester : XmlSerializationReader
 207         {
 208                 // appease the compiler
 209                 protected override void InitCallbacks ()
 210                 {
 211                 }
 212
 213                 protected override void InitIDs ()
 214                 {
 215                 }
 216         }
 217 }