mcs/class/System.Runtime.Serialization.Formatters.Soap/Test/SoapFormatterTest.cs

   1 // project created on 09/05/2003 at 18:07\r
   2 using System;\r
   3 using System.Collections;\r
   4 using System.Reflection;\r
   5 using System.Threading;\r
   6 using System.Globalization;\r
   7 using System.Runtime.Remoting;\r
   8 using System.Runtime.Remoting.Messaging;\r
   9 using System.Runtime.Serialization;\r
  10 using System.Runtime.Serialization.Formatters;\r
  11 using System.Runtime.Serialization.Formatters.Soap;\r
  12 using System.Runtime.Remoting.Metadata.W3cXsd2001;\r
  13 using System.IO;\r
  14 using NUnit.Framework;\r
  15 \r
  16 namespace MonoTests.System.Runtime.Serialization.Formatters.Soap {\r
  17         \r
  18         internal class NonSerializableObject {\r
  19                 \r
  20         }\r
  21         \r
  22         public delegate void TrucDlg(string s);\r
  23         \r
  24         [Serializable]\r
  25         public class MoreComplexObject {\r
  26                 public event TrucDlg TrucEvent;\r
  27                 private string _string;\r
  28                 private string[] _strings = new string[]{};\r
  29                 private Queue _queue = new Queue();\r
  30                 public Hashtable _table = new Hashtable();\r
  31 \r
  32                 public string ObjString {\r
  33                         get { return _string; }\r
  34                 }\r
  35 \r
  36                 public MoreComplexObject() {\r
  37                         TrucEvent += new TrucDlg(WriteString);\r
  38                         _queue.Enqueue(1);\r
  39                         _queue.Enqueue(null);\r
  40                         _queue.Enqueue("foo");\r
  41                         _table["foo"]="barr";\r
  42                         _table[1]="foo";\r
  43                         _table['c'] = "barr";\r
  44                         _table["barr"] = 1234567890;\r
  45                 }\r
  46 \r
  47                 public void OnTrucEvent(string s) {\r
  48                         TrucEvent(s);\r
  49                 }\r
  50 \r
  51                 public void WriteString(string s) {\r
  52                         _string = s;\r
  53                 }\r
  54 \r
  55                 public override bool Equals(object obj) {\r
  56                         MoreComplexObject objReturn = obj as MoreComplexObject;\r
  57                         if(objReturn == null) return false;\r
  58                         if(objReturn._string != this._string) return false;\r
  59                         IEnumerator myEnum = this._table.GetEnumerator();\r
  60                         foreach(DictionaryEntry e in objReturn._table) {\r
  61                                 myEnum.MoveNext();\r
  62                                 DictionaryEntry s = (DictionaryEntry) myEnum.Current;\r
  63                                 Assertion.AssertEquals("#_table", s.Key, e.Key);\r
  64                                 Assertion.AssertEquals("#_table", s.Value, e.Value);\r
  65                                 if(s.Key.ToString() != e.Key.ToString() || s.Value.ToString() != e.Value.ToString()) return false;\r
  66                         }\r
  67 //                      Assertion.Assert("#_table is null", objReturn._table != null);\r
  68 //                      Console.WriteLine("_table[foo]: {0}", objReturn._table["foo"]);\r
  69 //                      Assertion.AssertEquals("#_table[\"foo\"]", "barr", objReturn._table["foo"]);\r
  70 //                      Console.WriteLine("_table[1]: {0}", objReturn._table[1]);\r
  71 //                      Assertion.AssertEquals("#_table[1]", "foo", objReturn._table[1]);\r
  72 //                      Console.WriteLine("_table['c']: {0}", objReturn._table['c']);\r
  73 //                      Assertion.AssertEquals("#_table['c']", "barr", objReturn._table['c']);\r
  74 //                      Console.WriteLine("_table[barr]: {0}", objReturn._table["barr"]);\r
  75 //                      Assertion.AssertEquals("#_table[\"barr\"]", 1234567890, objReturn._table["barr"]);\r
  76                         return SoapFormatterTest.CheckArray(this._queue.ToArray(), objReturn._queue.ToArray());\r
  77                         \r
  78                 }\r
  79                 \r
  80         }\r
  81         \r
  82         [Serializable]\r
  83         internal class MarshalObject: MarshalByRefObject {\r
  84                 private string _name;\r
  85                 private long _id;\r
  86                 \r
  87                 public MarshalObject() {\r
  88                         \r
  89                 }\r
  90                 \r
  91                 public MarshalObject(string name, long id) {\r
  92                         _name = name;\r
  93                         _id = id;\r
  94                 }\r
  95         }\r
  96         \r
  97         [Serializable]\r
  98         internal class SimpleObject {\r
  99                 private string _name;\r
 100                 private int _id;\r
 101                 \r
 102                 public SimpleObject(string name, int id) {\r
 103                         _name = name;\r
 104                         _id = id;\r
 105                 }\r
 106                 \r
 107                 public override bool Equals(object obj) {\r
 108                         SimpleObject objCmp = obj as SimpleObject;\r
 109                         if(objCmp == null) return false;\r
 110                         if(objCmp._name != this._name) return false;\r
 111                         if(objCmp._id != this._id) return false;\r
 112                         return true;\r
 113                 }\r
 114         }\r
 115 \r
 116         [Serializable]\r
 117         internal class Version1 {\r
 118                 public int _value;\r
 119                 \r
 120                 public Version1(int value) {\r
 121                         _value = value;\r
 122                 }\r
 123         }\r
 124 \r
 125         [Serializable]\r
 126         internal class Version2: ISerializable {\r
 127                 public int _value;\r
 128                 public string _foo;\r
 129 \r
 130                 public Version2(int value, string foo) {\r
 131                         _value = value;\r
 132                         _foo = foo;\r
 133                 }\r
 134 \r
 135                 public void GetObjectData(SerializationInfo info, StreamingContext context) {\r
 136                         info.AddValue("_value", _value);\r
 137                         info.AddValue("_foo", _foo);\r
 138                 }\r
 139 \r
 140                 private Version2(SerializationInfo info, StreamingContext context) {\r
 141                         _value = info.GetInt32("_value");\r
 142                         try{\r
 143                                 _foo = info.GetString("_foo");\r
 144                         }\r
 145                         catch(SerializationException) {\r
 146                             _foo = "Default value";\r
 147                         }\r
 148                 }\r
 149         }\r
 150         \r
 151         public class Version1ToVersion2Binder: SerializationBinder {\r
 152                 public override Type BindToType (string assemblyName, string typeName) {\r
 153                         Type returnType = null;\r
 154                         string typeVersion1 = "MonoTests.System.Runtime.Serialization.Formatters.Soap.Version1";\r
 155                         string assemName = Assembly.GetExecutingAssembly().FullName;\r
 156 \r
 157                         if(typeName == typeVersion1) {\r
 158                                 typeName = "MonoTests.System.Runtime.Serialization.Formatters.Soap.Version2";\r
 159                         }\r
 160 \r
 161                         string typeFormat = String.Format("{0}, {1}", typeName, assemName);\r
 162                         returnType = Type.GetType( typeFormat);\r
 163 \r
 164                         return returnType;\r
 165                 }\r
 166         }\r
 167 \r
 168         [TestFixture]\r
 169         public class SoapFormatterTest\r
 170         {\r
 171                 private SoapFormatter _soapFormatter;\r
 172                 private SoapFormatter _soapFormatterDeserializer;\r
 173                 private RemotingSurrogateSelector _surrogate;\r
 174 \r
 175 #if DEBUG\r
 176                 private void Out(MemoryStream stream, object objGraph) {\r
 177                         Console.WriteLine("\n---------------------\n{0}\n", objGraph.ToString());\r
 178                         stream.Position = 0;\r
 179                         StreamReader r = new StreamReader(stream);\r
 180                         Console.WriteLine(r.ReadToEnd());\r
 181                 }                       \r
 182 #endif\r
 183                 \r
 184                 private object Serialize(object objGraph) {\r
 185                         MemoryStream stream = new MemoryStream();\r
 186                         Assertion.Assert(objGraph != null);\r
 187                         Assertion.Assert(stream != null);\r
 188                         _soapFormatter.SurrogateSelector = _surrogate;\r
 189                         _soapFormatter.Serialize(stream, objGraph);\r
 190                         \r
 191 #if DEBUG\r
 192                         Out(stream, objGraph);\r
 193 #endif\r
 194                         stream.Position = 0;\r
 195                         \r
 196                         object objReturn = _soapFormatterDeserializer.Deserialize(stream);\r
 197                         Assertion.Assert(objReturn != null);\r
 198                         Assertion.AssertEquals("#Tests "+objGraph.GetType(), objGraph.GetType(), objReturn.GetType());\r
 199                         stream = new MemoryStream();\r
 200                         _soapFormatter.Serialize(stream, objReturn);\r
 201                         stream.Position = 0;\r
 202                         return objReturn;\r
 203                         \r
 204                 }\r
 205                 \r
 206                 [SetUp]\r
 207                 public void GetReady() {\r
 208                         StreamingContext context = new StreamingContext(StreamingContextStates.All);\r
 209                         _surrogate = new RemotingSurrogateSelector();\r
 210                         _soapFormatter = new SoapFormatter(_surrogate, context);\r
 211                         _soapFormatterDeserializer = new SoapFormatter(null, context);\r
 212                 }\r
 213                 \r
 214                 [TearDown]\r
 215                 public void Clean() {\r
 216                         \r
 217                 }\r
 218                 \r
 219                 \r
 220                 [Test]\r
 221                 public void TestValueTypes() {\r
 222                         object objReturn;\r
 223                         objReturn = Serialize((short)1);\r
 224                         Assertion.AssertEquals("#int16", objReturn, 1);\r
 225                         objReturn = Serialize(1);\r
 226                         Assertion.AssertEquals("#int32", objReturn, 1);\r
 227                         objReturn = Serialize((Single)0.1234);\r
 228                         Assertion.AssertEquals("#Single", objReturn, 0.123400003f);\r
 229                         objReturn = Serialize((Double)1234567890.0987654321);\r
 230                         Assertion.AssertEquals("#iDouble", objReturn, 1234567890.0987654321);\r
 231                         objReturn = Serialize(true);\r
 232                         Assertion.AssertEquals("#Bool", objReturn, true);\r
 233                         objReturn = Serialize((Int64) 1234567890);\r
 234                         Assertion.AssertEquals("#Int64", objReturn, 1234567890);\r
 235                         objReturn = Serialize('c');\r
 236                         Assertion.AssertEquals("#Char", objReturn, 'c');\r
 237                 }\r
 238                 \r
 239                 [Test]\r
 240                 public void TestObjects() {\r
 241                         object objReturn;\r
 242                         objReturn = Serialize("");\r
 243                         objReturn = Serialize("hello world!");\r
 244                         Assertion.AssertEquals("#string", "hello world!", objReturn);\r
 245                         SoapMessage soapMsg = new SoapMessage();\r
 246                         soapMsg.Headers = new Header[0];\r
 247                         soapMsg.MethodName = "Equals";\r
 248                         soapMsg.ParamNames = new String[0];\r
 249                         soapMsg.ParamTypes = new Type[0];\r
 250                         soapMsg.ParamValues = new object[0];\r
 251                         soapMsg.XmlNameSpace = SoapServices.CodeXmlNamespaceForClrTypeNamespace("String", "System");\r
 252                         _soapFormatterDeserializer.TopObject = new SoapMessage();\r
 253                         objReturn = Serialize(soapMsg);\r
 254                         _soapFormatterDeserializer.TopObject = null;\r
 255                         SimpleObject obj = new SimpleObject("simple object", 1);\r
 256                         objReturn = Serialize(obj);\r
 257                         Assertion.AssertEquals("#SimpleObject", obj, objReturn);\r
 258                         objReturn = Serialize(typeof(SimpleObject));\r
 259                         Assertion.AssertEquals("#Type", typeof(SimpleObject), (Type)objReturn);\r
 260                         objReturn = Serialize(obj.GetType().Assembly);\r
 261                         Assertion.AssertEquals("#Assembly", obj.GetType().Assembly, objReturn);\r
 262                 }\r
 263                 \r
 264                 public static bool CheckArray(object objTest, object objReturn) {\r
 265                         Array objTestAsArray = objTest as Array;\r
 266                         Array objReturnAsArray = objReturn as Array;\r
 267                         \r
 268                         Assertion.Assert("#Not an Array "+objTest, objReturnAsArray != null);\r
 269                         Assertion.AssertEquals("#Different lengths "+objTest, objTestAsArray.Length, objReturnAsArray.Length);\r
 270                         \r
 271                         IEnumerator iEnum = objReturnAsArray.GetEnumerator();\r
 272                         iEnum.Reset();\r
 273                         object obj2;\r
 274                         foreach(object obj1 in objTestAsArray) {\r
 275                                 iEnum.MoveNext();\r
 276                                 obj2 = iEnum.Current;\r
 277                                 Assertion.AssertEquals("#The content of the 2 arrays is different", obj1, obj2);\r
 278                         }\r
 279                         \r
 280                         return true;\r
 281                 }\r
 282                 \r
 283                 [Test]\r
 284                 public void TestArray() {\r
 285                         object objReturn;\r
 286                         object objTest;\r
 287                         objReturn = Serialize(new int[]{});\r
 288                         objTest = new int[]{1, 2, 3, 4};\r
 289                         objReturn = Serialize(objTest);\r
 290                         CheckArray(objTest, objReturn);\r
 291                         objReturn = Serialize(new long[]{1, 2, 3, 4});\r
 292                         objTest = new object[]{1, null, ":-)", 1234567890};\r
 293                         objReturn = Serialize(objTest);\r
 294                         objTest = new int[,]{{0, 1}, {2, 3}, {123, 4}};\r
 295                         objReturn = Serialize(objTest);\r
 296                         CheckArray(objTest, objReturn);\r
 297                         objTest = new string[]{};\r
 298                         objReturn = Serialize(objTest);\r
 299                         CheckArray(objTest, objReturn);\r
 300                         object[,,] objArray = new object[3,2,1];\r
 301                         objArray[0,0,0] = 1;\r
 302                         objArray[2,1,0] = "end";\r
 303                         objReturn = Serialize(objArray);\r
 304                         CheckArray(objArray, objReturn);\r
 305                 }\r
 306                 \r
 307                 [Test]\r
 308                 public void TestMarshalByRefObject() {\r
 309                         Serialize(new MarshalObject("thing", 1234567890));\r
 310                 }\r
 311                 \r
 312                 [Test]\r
 313                 [ExpectedException(typeof(ArgumentNullException))]\r
 314                 public void TestNullObject() {\r
 315                         MemoryStream stream = new MemoryStream();\r
 316                         _soapFormatter.Serialize(stream, null);\r
 317                 }\r
 318                 \r
 319                 [Test]\r
 320                 [ExpectedException(typeof(SerializationException))]\r
 321                 public void TestNonSerialisable() {\r
 322                         Serialize(new NonSerializableObject());\r
 323                 }\r
 324 \r
 325                 [Test]\r
 326                 public void TestMoreComplexObject() {\r
 327                         MoreComplexObject objReturn;\r
 328                         MoreComplexObject objTest = new MoreComplexObject();\r
 329                         objReturn = (MoreComplexObject) Serialize(objTest);\r
 330                         Assertion.AssertEquals("#Equals", objTest, objReturn);\r
 331                         objReturn.OnTrucEvent("bidule");\r
 332                         Assertion.AssertEquals("#dlg", "bidule", objReturn.ObjString);\r
 333                 }\r
 334 \r
 335                 [Test]\r
 336                 public void TestSerializationbinder() {\r
 337                         Object objReturn;\r
 338                         MemoryStream stream = new MemoryStream();\r
 339                         Version1 objVer1 = new Version1(123);\r
 340 \r
 341                         _soapFormatter.SurrogateSelector = _surrogate;\r
 342                         _soapFormatter.Serialize(stream, objVer1);\r
 343 \r
 344                         stream.Position = 0;\r
 345                         _soapFormatterDeserializer.Binder = new Version1ToVersion2Binder();\r
 346                         objReturn = _soapFormatterDeserializer.Deserialize(stream);\r
 347 \r
 348                         Assertion.AssertEquals("#Version1 Version2", "Version2", objReturn.GetType().Name);\r
 349                         Assertion.AssertEquals("#_value", 123, ((Version2) objReturn)._value);\r
 350                         Assertion.AssertEquals("#_foo", "Default value", ((Version2) objReturn)._foo);\r
 351                 }\r
 352                 \r
 353                 [Test]\r
 354                 public void TestMethodSignatureSerialization ()\r
 355                 {\r
 356                         Header h = new Header ("__MethodSignature", new Type [] { typeof(string),typeof(SignatureTest[]) }, false, "http://schemas.microsoft.com/clr/soap/messageProperties");\r
 357 \r
 358                         SoapMessage msg = new SoapMessage ();\r
 359                         msg.MethodName = "Run";\r
 360                         msg.ParamNames = new string [] { "nom" };\r
 361                         msg.ParamTypes = new Type [] { typeof(SignatureTest) };\r
 362                         msg.ParamValues = new object[] { new SignatureTest () };\r
 363                         msg.Headers = new Header[] { h};\r
 364 \r
 365                         MemoryStream ms = new MemoryStream ();\r
 366                         SoapFormatter sf = new SoapFormatter ();\r
 367                         sf.Serialize (ms, msg);\r
 368 \r
 369                         ms.Position = 0;\r
 370 \r
 371                         SoapMessage t = new SoapMessage ();\r
 372                         sf.TopObject = t;\r
 373                         t = (SoapMessage) sf.Deserialize (ms);\r
 374                         \r
 375                         Assertion.AssertNotNull ("#1", t.Headers[0].Value);\r
 376                         Assertion.AssertEquals ("#2", t.Headers[0].Value.GetType (), typeof(Type[]));\r
 377                         \r
 378                         Type[] ts = (Type[]) t.Headers[0].Value;\r
 379                         \r
 380                         Assertion.AssertEquals ("#3", 2, ts.Length);\r
 381                         Assertion.AssertNotNull ("#4", ts[0]);\r
 382                         Assertion.AssertNotNull ("#5", ts[1]);\r
 383                         Console.WriteLine ("PPP:" + ts[0].GetType());\r
 384                         Assertion.AssertEquals ("#6", typeof(string), ts[0]);\r
 385                         Assertion.AssertEquals ("#7", typeof(SignatureTest[]), ts[1]);\r
 386                 }\r
 387 \r
 388                 [Test]\r
 389                 public void TestCulture ()\r
 390                 {\r
 391                         var currentCulture = Thread.CurrentThread.CurrentCulture;\r
 392                         try {\r
 393                                 Thread.CurrentThread.CurrentCulture = new CultureInfo ("de-DE");\r
 394 \r
 395                                 var ms = new MemoryStream ();\r
 396                                 var test = new CultureTest ();\r
 397 \r
 398                                 _soapFormatter.Serialize(ms, test);\r
 399                                 ms.Position = 0;\r
 400                                 _soapFormatter.Deserialize(ms);\r
 401                         } finally {\r
 402                                 Thread.CurrentThread.CurrentCulture = currentCulture;\r
 403                         }\r
 404                 }\r
 405 \r
 406                 [Serializable]\r
 407                 public class CultureTest\r
 408                 {\r
 409                         [OnDeserialized]\r
 410                         public void OnDeserialization (StreamingContext context)\r
 411                         {\r
 412                                 var ci = Thread.CurrentThread.CurrentCulture;\r
 413                                 Assertion.AssertEquals("#1", "German (Germany)", ci.EnglishName);\r
 414                         }\r
 415                         \r
 416                         [OnSerialized]\r
 417                         public void OnSerialized (StreamingContext context)\r
 418                         {\r
 419                                 var ci = Thread.CurrentThread.CurrentCulture;\r
 420                                 Assertion.AssertEquals("#2", "German (Germany)", ci.EnglishName);\r
 421                         }\r
 422                 }\r
 423         }\r
 424         \r
 425         [Serializable]\r
 426         public class SignatureTest\r
 427         {\r
 428                 public SoapQName qn = new SoapQName ("e", "name", "espai");\r
 429         }       \r
 430 }\r