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