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