mcs/class/System.DirectoryServices/Test/System.DirectoryServices/DirectoryServicesPermissionTest.cs

   1 //\r
   2 // DirectoryServicesPermissionTest.cs -\r
   3 //      NUnit Test Cases for DirectoryServicesPermission\r
   4 //\r
   5 // Author:\r
   6 //      Sebastien Pouliot  <sebastien@ximian.com>\r
   7 //\r
   8 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)\r
   9 //\r
  10 // Permission is hereby granted, free of charge, to any person obtaining\r
  11 // a copy of this software and associated documentation files (the\r
  12 // "Software"), to deal in the Software without restriction, including\r
  13 // without limitation the rights to use, copy, modify, merge, publish,\r
  14 // distribute, sublicense, and/or sell copies of the Software, and to\r
  15 // permit persons to whom the Software is furnished to do so, subject to\r
  16 // the following conditions:\r
  17 // \r
  18 // The above copyright notice and this permission notice shall be\r
  19 // included in all copies or substantial portions of the Software.\r
  20 // \r
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  28 //\r
  29 \r
  30 using NUnit.Framework;\r
  31 using System;\r
  32 using System.DirectoryServices;\r
  33 using System.Security;\r
  34 using System.Security.Permissions;\r
  35 \r
  36 using System.Diagnostics;\r
  37 \r
  38 namespace MonoTests.System.DirectoryServices {\r
  39 \r
  40         [TestFixture]\r
  41         public class DirectoryServicesPermissionTest {\r
  42 \r
  43                 static DirectoryServicesPermissionAccess[] AllAccess = {\r
  44                         DirectoryServicesPermissionAccess.None,\r
  45                         DirectoryServicesPermissionAccess.Browse,\r
  46                         DirectoryServicesPermissionAccess.Write,\r
  47                         DirectoryServicesPermissionAccess.Browse | DirectoryServicesPermissionAccess.Write,\r
  48                 };\r
  49 \r
  50                 [Test]\r
  51                 public void PermissionState_None ()\r
  52                 {\r
  53                         PermissionState ps = PermissionState.None;\r
  54                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (ps);\r
  55                         Assert.AreEqual (0, dsp.PermissionEntries.Count, "PermissionEntries");\r
  56                         Assert.IsFalse (dsp.IsUnrestricted (), "IsUnrestricted");\r
  57 \r
  58                         SecurityElement se = dsp.ToXml ();\r
  59                         // only class and version are present\r
  60                         Assert.AreEqual (2, se.Attributes.Count, "Xml-Attributes");\r
  61                         Assert.IsNull (se.Children, "Xml-Children");\r
  62 \r
  63                         DirectoryServicesPermission copy = (DirectoryServicesPermission)dsp.Copy ();\r
  64                         Assert.IsFalse (Object.ReferenceEquals (dsp, copy), "ReferenceEquals");\r
  65                         Assert.AreEqual (dsp.PermissionEntries.Count, copy.PermissionEntries.Count, "copy-PermissionEntries");\r
  66                         Assert.AreEqual (dsp.IsUnrestricted (), copy.IsUnrestricted (), "IsUnrestricted ()");\r
  67                 }\r
  68 \r
  69                 [Test]\r
  70                 public void PermissionState_Unrestricted ()\r
  71                 {\r
  72                         PermissionState ps = PermissionState.Unrestricted;\r
  73                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (ps);\r
  74                         Assert.AreEqual (0, dsp.PermissionEntries.Count, "PermissionEntries");\r
  75                         Assert.IsTrue (dsp.IsUnrestricted (), "IsUnrestricted");\r
  76 \r
  77                         SecurityElement se = dsp.ToXml ();\r
  78                         // only class and version are present\r
  79                         Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "Xml-Unrestricted");\r
  80                         Assert.IsNull (se.Children, "Xml-Children");\r
  81 \r
  82                         DirectoryServicesPermission copy = (DirectoryServicesPermission)dsp.Copy ();\r
  83                         Assert.IsFalse (Object.ReferenceEquals (dsp, copy), "ReferenceEquals");\r
  84                         Assert.AreEqual (dsp.PermissionEntries.Count, copy.PermissionEntries.Count, "copy-PermissionEntries");\r
  85                         Assert.AreEqual (dsp.IsUnrestricted (), copy.IsUnrestricted (), "copy-IsUnrestricted ()");\r
  86                 }\r
  87 \r
  88                 [Test]\r
  89 #if NET_2_0\r
  90                 [ExpectedException (typeof (ArgumentException))]\r
  91 #endif\r
  92                 public void PermissionState_Bad ()\r
  93                 {\r
  94                         PermissionState ps = (PermissionState)77;\r
  95                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (ps);\r
  96                         Assert.IsFalse (dsp.IsUnrestricted (), "IsUnrestricted");\r
  97                 }\r
  98 \r
  99                 [Test]\r
 100                 public void DirectoryServicesPermissionAccesss_Bad ()\r
 101                 {\r
 102                         DirectoryServicesPermissionAccess dspa = (DirectoryServicesPermissionAccess) Int32.MinValue;\r
 103                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (dspa, String.Empty);\r
 104                         Assert.AreEqual (1, dsp.PermissionEntries.Count, "Count");\r
 105                         Assert.AreEqual ((DirectoryServicesPermissionAccess)Int32.MinValue, dsp.PermissionEntries [0].PermissionAccess, "PermissionAccess");\r
 106                         Assert.AreEqual (String.Empty, dsp.PermissionEntries [0].Path, "Path");\r
 107                 }\r
 108 \r
 109                 [Test]\r
 110                 public void PermissionEntries () \r
 111                 {\r
 112                         DirectoryServicesPermissionAccess dspa = DirectoryServicesPermissionAccess.None;\r
 113                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (dspa, String.Empty);\r
 114                         DirectoryServicesPermissionEntryCollection dspec = dsp.PermissionEntries;\r
 115                         Assert.AreEqual (1, dspec.Count, "Count==1");\r
 116 \r
 117                         DirectoryServicesPermissionEntry dspe = new DirectoryServicesPermissionEntry (DirectoryServicesPermissionAccess.Browse, "*");\r
 118                         dsp.PermissionEntries.Add (dspe);\r
 119                         Assert.AreEqual (2, dspec.Count, "Count==2");\r
 120 \r
 121                         // remove (same instance)\r
 122                         dsp.PermissionEntries.Remove (dspe);\r
 123                         Assert.AreEqual (1, dspec.Count, "Count==1 (b)");\r
 124 \r
 125                         // remove different instance (doesn't work)\r
 126                         dspe = new DirectoryServicesPermissionEntry (DirectoryServicesPermissionAccess.None, String.Empty);\r
 127                         Assert.AreEqual (1, dspec.Count, "Count==1");\r
 128                 }\r
 129 \r
 130                 [Test]\r
 131                 public void Copy ()\r
 132                 {\r
 133                         foreach (DirectoryServicesPermissionAccess ppl in AllAccess) {\r
 134                                 DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 135                                 DirectoryServicesPermissionEntry dspe = new DirectoryServicesPermissionEntry (ppl, ppl.ToString ());\r
 136                                 dsp.PermissionEntries.Add (dspe);\r
 137                                 DirectoryServicesPermission copy = (DirectoryServicesPermission)dsp.Copy ();\r
 138                                 Assert.AreEqual (1, copy.PermissionEntries.Count, "Count==1");\r
 139                                 Assert.AreEqual (ppl, dsp.PermissionEntries [0].PermissionAccess, ppl.ToString ());\r
 140                                 Assert.AreEqual (ppl.ToString (), dsp.PermissionEntries [0].Path, ppl.ToString () + "-Path");\r
 141                         }\r
 142                 }\r
 143 \r
 144                 [Test]\r
 145                 public void Intersect_Null ()\r
 146                 {\r
 147                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 148                         // No intersection with null\r
 149                         Assert.IsNull (dsp.Intersect (null), "None N null");\r
 150                 }\r
 151 \r
 152                 [Test]\r
 153                 public void Intersect_None ()\r
 154                 {\r
 155                         DirectoryServicesPermission dsp1 = new DirectoryServicesPermission (PermissionState.None);\r
 156                         DirectoryServicesPermission dsp2 = new DirectoryServicesPermission (PermissionState.None);\r
 157                         // 1. None N None\r
 158                         DirectoryServicesPermission result = (DirectoryServicesPermission) dsp1.Intersect (dsp2);\r
 159                         Assert.IsNull (result, "Empty N Empty");\r
 160                         // 2. None N Entry\r
 161                         dsp2.PermissionEntries.Add (new DirectoryServicesPermissionEntry (DirectoryServicesPermissionAccess.None, String.Empty));\r
 162                         result = (DirectoryServicesPermission) dsp1.Intersect (dsp2);\r
 163                         Assert.IsNull (result, "Empty N Entry");\r
 164                         // 3. Entry N None\r
 165                         result = (DirectoryServicesPermission) dsp2.Intersect (dsp1);\r
 166                         Assert.IsNull (result, "Entry N Empty");\r
 167                 }\r
 168 \r
 169                 [Test]\r
 170                 public void Intersect_Unrestricted ()\r
 171                 {\r
 172                         // Intersection with unrestricted == Copy\r
 173                         // a. source (this) is unrestricted\r
 174                         DirectoryServicesPermission dsp1 = new DirectoryServicesPermission (PermissionState.Unrestricted);\r
 175                         DirectoryServicesPermission dsp2 = new DirectoryServicesPermission (PermissionState.None);\r
 176 \r
 177                         // 1. Unrestricted N None\r
 178                         DirectoryServicesPermission result = (DirectoryServicesPermission) dsp1.Intersect (dsp2);\r
 179                         Assert.IsFalse (result.IsUnrestricted (), "(Unrestricted N None).IsUnrestricted");\r
 180                         Assert.AreEqual (0, result.PermissionEntries.Count, "(Unrestricted N None).Count");\r
 181 \r
 182                         // 2. None N Unrestricted\r
 183                         result = (DirectoryServicesPermission) dsp2.Intersect (dsp1);\r
 184                         Assert.IsFalse (result.IsUnrestricted (), "(None N Unrestricted).IsUnrestricted");\r
 185                         Assert.AreEqual (0, result.PermissionEntries.Count, "(None N Unrestricted).Count");\r
 186 \r
 187                         // 3. Unrestricted N Unrestricted\r
 188                         result = (DirectoryServicesPermission) dsp1.Intersect (dsp1);\r
 189                         Assert.IsTrue (result.IsUnrestricted (), "(Unrestricted N Unrestricted).IsUnrestricted");\r
 190                         Assert.AreEqual (0, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");\r
 191 \r
 192                         // 4. Unrestricted N Entry\r
 193                         dsp2.PermissionEntries.Add (new DirectoryServicesPermissionEntry (DirectoryServicesPermissionAccess.None, String.Empty));\r
 194                         result = (DirectoryServicesPermission)dsp1.Intersect (dsp2);\r
 195                         Assert.IsFalse (result.IsUnrestricted (), "(Unrestricted N Entry).IsUnrestricted");\r
 196                         Assert.AreEqual (1, result.PermissionEntries.Count, "(Unrestricted N Entry).Count");\r
 197 \r
 198                         // 5. Entry N Unrestricted\r
 199                         result = (DirectoryServicesPermission)dsp2.Intersect (dsp1);\r
 200                         Assert.IsFalse (result.IsUnrestricted (), "(Entry N Unrestricted).IsUnrestricted");\r
 201                         Assert.AreEqual (1, result.PermissionEntries.Count, "(Entry N Unrestricted).Count");\r
 202 \r
 203                         // 6. Unrestricted N Unrestricted\r
 204                         dsp1.PermissionEntries.Add (new DirectoryServicesPermissionEntry (DirectoryServicesPermissionAccess.None, String.Empty));\r
 205                         result = (DirectoryServicesPermission)dsp1.Intersect (dsp1);\r
 206                         Assert.IsTrue (result.IsUnrestricted (), "(Unrestricted N Unrestricted).IsUnrestricted");\r
 207                         Assert.AreEqual (1, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");\r
 208                 }\r
 209 \r
 210                 [Test]\r
 211                 public void IsSubset_Null ()\r
 212                 {\r
 213                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 214 #if NET_2_0\r
 215                         Assert.IsTrue (dsp.IsSubsetOf (null), "null");\r
 216 #else\r
 217                         Assert.IsFalse (dsp.IsSubsetOf (null), "null");\r
 218 #endif\r
 219                 }\r
 220 \r
 221                 [Test]\r
 222                 public void IsSubset_None ()\r
 223                 {\r
 224                         // IsSubset with none\r
 225                         // a. source (this) is none -> target is never a subset\r
 226                         // b. destination (target) is none -> target is always a subset\r
 227                         DirectoryServicesPermission dsp1 = new DirectoryServicesPermission (PermissionState.None);\r
 228                         foreach (DirectoryServicesPermissionAccess ppl in AllAccess) {\r
 229                                 DirectoryServicesPermission dsp2 = new DirectoryServicesPermission (PermissionState.None);\r
 230                                 dsp2.PermissionEntries.Add (new DirectoryServicesPermissionEntry (ppl, ppl.ToString ()));\r
 231                                 Assert.IsTrue (dsp1.IsSubsetOf (dsp2), "target " + ppl.ToString ());\r
 232                                 Assert.IsFalse (dsp2.IsSubsetOf (dsp1), "source " + ppl.ToString ());\r
 233                         }\r
 234                 }\r
 235 \r
 236                 [Test]\r
 237                 public void IsSubset_Self ()\r
 238                 {\r
 239                         foreach (DirectoryServicesPermissionAccess ppl in AllAccess) {\r
 240                                 DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 241                                 dsp.PermissionEntries.Add (new DirectoryServicesPermissionEntry (ppl, ppl.ToString ()));\r
 242                                 Assert.IsTrue (dsp.IsSubsetOf (dsp), ppl.ToString ());\r
 243                         }\r
 244                 }\r
 245 \r
 246                 [Test]\r
 247                 public void IsSubset_Unrestricted ()\r
 248                 {\r
 249                         // IsSubset with unrestricted\r
 250                         // a. source (this) is unrestricted -> target is never a subset\r
 251                         // b. destination (target) is unrestricted -> source is always a subset\r
 252                         DirectoryServicesPermission dsp1 = new DirectoryServicesPermission (PermissionState.Unrestricted);\r
 253                         foreach (DirectoryServicesPermissionAccess ppl in AllAccess) {\r
 254                                 DirectoryServicesPermission dsp2 = new DirectoryServicesPermission (PermissionState.None);\r
 255                                 dsp2.PermissionEntries.Add (new DirectoryServicesPermissionEntry (ppl, ppl.ToString ()));\r
 256                                 Assert.IsFalse (dsp1.IsSubsetOf (dsp2), "target " + ppl.ToString ());\r
 257                                 Assert.IsTrue (dsp2.IsSubsetOf (dsp1), "source " + ppl.ToString ());\r
 258                         }\r
 259                         Assert.IsTrue (dsp1.IsSubsetOf (dsp1), "Unrestricted.IsSubsetOf(Unrestricted)");\r
 260                 }\r
 261 \r
 262                 [Test]\r
 263                 public void Union_Null ()\r
 264                 {\r
 265                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 266                         dsp.PermissionEntries.Add (new DirectoryServicesPermissionEntry (DirectoryServicesPermissionAccess.None, String.Empty));\r
 267                         // Union with null is a simple copy\r
 268                         DirectoryServicesPermission union = (DirectoryServicesPermission)dsp.Union (null);\r
 269                         Assert.IsNotNull (dsp.PermissionEntries.Count, "Count");\r
 270                 }\r
 271 \r
 272                 [Test]\r
 273                 public void Union_None ()\r
 274                 {\r
 275                         DirectoryServicesPermission dsp1 = new DirectoryServicesPermission (PermissionState.None);\r
 276                         foreach (DirectoryServicesPermissionAccess ppl in AllAccess) {\r
 277                                 DirectoryServicesPermission dsp2 = new DirectoryServicesPermission (PermissionState.None);\r
 278                                 dsp2.PermissionEntries.Add (new DirectoryServicesPermissionEntry (ppl, ppl.ToString ()));\r
 279                                 DirectoryServicesPermission union = (DirectoryServicesPermission) dsp1.Union (dsp2);\r
 280                                 Assert.IsFalse (union.IsUnrestricted (), "target.IsUnrestricted " + ppl.ToString ());\r
 281                                 Assert.AreEqual (1, union.PermissionEntries.Count, "target.Count " + ppl.ToString ());\r
 282 \r
 283                                 union = (DirectoryServicesPermission) dsp2.Union (dsp1);\r
 284                                 Assert.IsFalse (union.IsUnrestricted (), "source.IsUnrestricted " + ppl.ToString ());\r
 285                                 Assert.AreEqual (1, union.PermissionEntries.Count, "source.Count " + ppl.ToString ());\r
 286                         }\r
 287                 }\r
 288 \r
 289                 [Test]\r
 290                 public void Union_Self ()\r
 291                 {\r
 292                         foreach (DirectoryServicesPermissionAccess ppl in AllAccess) {\r
 293                                 DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 294                                 dsp.PermissionEntries.Add (new DirectoryServicesPermissionEntry (ppl, ppl.ToString ()));\r
 295                                 DirectoryServicesPermission union = (DirectoryServicesPermission)dsp.Union (dsp);\r
 296                                 Assert.IsFalse (union.IsUnrestricted (), "IsUnrestricted " + ppl.ToString ());\r
 297                                 Assert.AreEqual (1, union.PermissionEntries.Count, "Count " + ppl.ToString ());\r
 298                         }\r
 299                 }\r
 300 \r
 301                 [Test]\r
 302                 public void Union_Unrestricted ()\r
 303                 {\r
 304                         // Union with unrestricted is unrestricted\r
 305                         DirectoryServicesPermission dsp1 = new DirectoryServicesPermission (PermissionState.Unrestricted);\r
 306                         foreach (DirectoryServicesPermissionAccess ppl in AllAccess) {\r
 307                                 DirectoryServicesPermission dsp2 = new DirectoryServicesPermission (PermissionState.None);\r
 308                                 dsp2.PermissionEntries.Add (new DirectoryServicesPermissionEntry (ppl, ppl.ToString ()));\r
 309                                 DirectoryServicesPermission union = (DirectoryServicesPermission)dsp1.Union (dsp2);\r
 310                                 Assert.IsTrue (union.IsUnrestricted (), "target.IsUnrestricted " + ppl.ToString ());\r
 311                                 Assert.AreEqual (0, union.PermissionEntries.Count, "target.Count " + ppl.ToString ());\r
 312 \r
 313                                 union = (DirectoryServicesPermission)dsp2.Union (dsp1);\r
 314                                 Assert.IsTrue (union.IsUnrestricted (), "source.IsUnrestricted " + ppl.ToString ());\r
 315                                 Assert.AreEqual (0, union.PermissionEntries.Count, "source.Count " + ppl.ToString ());\r
 316                         }\r
 317                 }\r
 318 \r
 319                 [Test]\r
 320 #if NET_2_0\r
 321                 [ExpectedException (typeof (ArgumentNullException))]\r
 322 #else\r
 323                 // Problem inherited from ResourcePermissionBase\r
 324                 [ExpectedException (typeof (NullReferenceException))]\r
 325 #endif\r
 326                 public void FromXml_Null ()\r
 327                 {\r
 328                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 329                         dsp.FromXml (null);\r
 330                 }\r
 331 \r
 332                 [Test]\r
 333 #if NET_2_0\r
 334                 [ExpectedException (typeof (ArgumentException))]\r
 335 #endif\r
 336                 public void FromXml_WrongTag ()\r
 337                 {\r
 338                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 339                         SecurityElement se = dsp.ToXml ();\r
 340                         se.Tag = "IMono";\r
 341                         dsp.FromXml (se);\r
 342                         // note: normally IPermission classes (in corlib) DO care about the\r
 343                         // IPermission tag\r
 344                 }\r
 345 \r
 346                 [Test]\r
 347 #if NET_2_0\r
 348                 [ExpectedException (typeof (ArgumentException))]\r
 349 #endif\r
 350                 public void FromXml_WrongTagCase ()\r
 351                 {\r
 352                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 353                         SecurityElement se = dsp.ToXml ();\r
 354                         se.Tag = "IPERMISSION"; // instead of IPermission\r
 355                         dsp.FromXml (se);\r
 356                         // note: normally IPermission classes (in corlib) DO care about the\r
 357                         // IPermission tag\r
 358                 }\r
 359 \r
 360                 [Test]\r
 361                 public void FromXml_WrongClass ()\r
 362                 {\r
 363                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 364                         SecurityElement se = dsp.ToXml ();\r
 365 \r
 366                         SecurityElement w = new SecurityElement (se.Tag);\r
 367                         w.AddAttribute ("class", "Wrong" + se.Attribute ("class"));\r
 368                         w.AddAttribute ("version", se.Attribute ("version"));\r
 369                         dsp.FromXml (w);\r
 370                         // doesn't care of the class name at that stage\r
 371                         // anyway the class has already be created so...\r
 372                 }\r
 373 \r
 374                 [Test]\r
 375                 public void FromXml_NoClass ()\r
 376                 {\r
 377                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 378                         SecurityElement se = dsp.ToXml ();\r
 379 \r
 380                         SecurityElement w = new SecurityElement (se.Tag);\r
 381                         w.AddAttribute ("version", se.Attribute ("version"));\r
 382                         dsp.FromXml (w);\r
 383                         // doesn't even care of the class attribute presence\r
 384                 }\r
 385 \r
 386                 [Test]\r
 387                 [ExpectedException (typeof (ArgumentException))]\r
 388                 public void FromXml_WrongVersion ()\r
 389                 {\r
 390                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 391                         SecurityElement se = dsp.ToXml ();\r
 392                         se.Attributes.Remove ("version");\r
 393                         se.Attributes.Add ("version", "2");\r
 394                         dsp.FromXml (se);\r
 395                 }\r
 396 \r
 397                 [Test]\r
 398                 public void FromXml_NoVersion ()\r
 399                 {\r
 400                         DirectoryServicesPermission dsp = new DirectoryServicesPermission (PermissionState.None);\r
 401                         SecurityElement se = dsp.ToXml ();\r
 402 \r
 403                         SecurityElement w = new SecurityElement (se.Tag);\r
 404                         w.AddAttribute ("class", se.Attribute ("class"));\r
 405                         dsp.FromXml (w);\r
 406                 }\r
 407         }\r
 408 }\r