mcs/class/corlib/Test/System.Security/PermissionSetTest.cs

   1 //
   2 // PermissionSetTest.cs - NUnit Test Cases for PermissionSet
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) 2003 Motus Technologies Inc. (http://www.motus.com)
   8 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using NUnit.Framework;
  31 using System;
  32 using System.Collections;
  33 using System.Runtime.Serialization;
  34 using System.Security;
  35 using System.Security.Permissions;
  36 using System.Text;
  37
  38 namespace MonoTests.System.Security {
  39
  40         [TestFixture]
  41         public class PermissionSetTest : Assertion {
  42
  43                 [Test]
  44                 public void PermissionStateNone ()
  45                 {
  46                         PermissionSet ps = new PermissionSet (PermissionState.None);
  47                         Assert ("PermissionStateNone.IsUnrestricted", !ps.IsUnrestricted ());
  48                         Assert ("PermissionStateNone.IsEmpty", ps.IsEmpty ());
  49                         Assert ("PermissionStateNone.IsReadOnly", !ps.IsReadOnly);
  50                         AssertEquals ("PermissionStateNone.ToXml().ToString()==ToString()", ps.ToXml ().ToString (), ps.ToString ());\r
  51                         Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());
  52                 }
  53
  54                 [Test]
  55                 public void PermissionStateUnrestricted ()
  56                 {
  57                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
  58                         Assert ("PermissionStateUnrestricted.IsUnrestricted", ps.IsUnrestricted ());
  59                         Assert ("PermissionStateUnrestricted.IsEmpty", !ps.IsEmpty ());
  60                         Assert ("PermissionStateUnrestricted.IsReadOnly", !ps.IsReadOnly);
  61                         AssertEquals ("PermissionStateUnrestricted.ToXml().ToString()==ToString()", ps.ToXml ().ToString (), ps.ToString ());\r
  62                         Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
  63                 }
  64
  65                 [Test]
  66                 public void PermissionSetNull ()
  67                 {
  68                         // no exception is thrown
  69                         PermissionSet ps = new PermissionSet (null);
  70 #if NET_2_0
  71                         Assert ("PermissionStateNull.IsUnrestricted", !ps.IsUnrestricted ());
  72                         Assert ("PermissionStateNull.IsEmpty", ps.IsEmpty ());
  73 #else
  74                         Assert ("PermissionStateNull.IsUnrestricted", ps.IsUnrestricted ());
  75                         Assert ("PermissionStateNull.IsEmpty", !ps.IsEmpty ());
  76 #endif
  77                         Assert ("PermissionStateNull.IsReadOnly", !ps.IsReadOnly);
  78                         AssertEquals ("PermissionStateNull.ToXml().ToString()==ToString()", ps.ToXml ().ToString (), ps.ToString ());\r
  79                         Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
  80                 }
  81
  82                 [Test]
  83                 public void PermissionSetPermissionSet ()
  84                 {
  85                         FileDialogPermission fdp = new FileDialogPermission (FileDialogPermissionAccess.Open);
  86                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
  87                         ps1.AddPermission (fdp);
  88                         Assert ("ps1.IsEmpty", !ps1.IsEmpty ());
  89
  90                         PermissionSet ps = new PermissionSet (ps1);
  91                         Assert ("PermissionSetPermissionSet.IsUnrestricted", !ps.IsUnrestricted ());
  92                         Assert ("PermissionSetPermissionSet.IsEmpty", !ps.IsEmpty ());
  93                         Assert ("PermissionSetPermissionSet.IsReadOnly", !ps.IsReadOnly);
  94                         AssertEquals ("PermissionSetPermissionSet.ToXml().ToString()==ToString()", ps.ToXml ().ToString (), ps.ToString ());\r
  95                         Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
  96                 }
  97
  98                 [Test]
  99                 public void PermissionSetNamedPermissionSet ()
 100                 {
 101                         NamedPermissionSet nps = new NamedPermissionSet ("Test", PermissionState.Unrestricted);
 102                         PermissionSet ps = new PermissionSet (nps);
 103                         Assert ("IsUnrestricted", ps.IsUnrestricted ());\r
 104                         Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
 105                 }
 106
 107                 [Test]
 108                 public void AddPermission ()
 109                 {
 110                         SecurityPermission sp1 = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
 111                         SecurityPermission sp2 = new SecurityPermission (SecurityPermissionFlag.ControlPolicy);
 112                         PermissionSet ps = new PermissionSet (PermissionState.None);
 113                         SecurityPermission result = (SecurityPermission)ps.AddPermission (sp1);
 114                         AssertEquals ("1-ControlEvidence", 1, ps.Count);
 115                         AssertEquals ("Flags-1", SecurityPermissionFlag.ControlEvidence, result.Flags);
 116
 117                         result = (SecurityPermission)ps.AddPermission (sp2);
 118                         AssertEquals ("1-ControlEvidence+ControlPolicy", 1, ps.Count);
 119                         AssertEquals ("Flags-2", SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags);
 120
 121                         result = (SecurityPermission)ps.AddPermission (sp2);
 122                         AssertEquals ("no change-1", 1, ps.Count);
 123                         AssertEquals ("Flags-3", SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags);
 124
 125                         result = (SecurityPermission)ps.AddPermission (sp1);
 126                         AssertEquals ("no change-2", 1, ps.Count);
 127                         AssertEquals ("Flags-4", SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags);
 128                 }
 129
 130                 [Test]
 131                 public void AddPermission_Null ()
 132                 {
 133                         PermissionSet ps = new PermissionSet (PermissionState.None);
 134                         IPermission result = ps.AddPermission (null);
 135                         AssertNull ("Add(null)", result);
 136                         AssertEquals ("0", 0, ps.Count);
 137                 }
 138
 139                 [Test]
 140                 public void AddPermission_SetUnrestricted ()
 141                 {
 142                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 143                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
 144                         IPermission result = ps.AddPermission (sp);
 145                         AssertNotNull ("Add(SecurityPermission)", result);
 146                         AssertEquals ("SecurityPermission", SecurityPermissionFlag.AllFlags, (result as SecurityPermission).Flags);
 147                         AssertEquals ("0", 0, ps.Count);
 148                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 149                         result = ps.AddPermission (zip);
 150                         AssertNotNull ("Add(ZoneIdentityPermission)", result);
 151 #if NET_2_0
 152                         // Identity permissions aren't added to unrestricted permission sets in 2.0
 153                         AssertEquals ("ZoneIdentityPermission", SecurityZone.NoZone, (result as ZoneIdentityPermission).SecurityZone);
 154                         AssertEquals ("1", 0, ps.Count);
 155 #else
 156                         AssertEquals ("ZoneIdentityPermission", zip.SecurityZone, (result as ZoneIdentityPermission).SecurityZone);
 157                         AssertEquals ("1", 1, ps.Count);
 158 #endif
 159                 }
 160
 161                 [Test]
 162                 public void AddPermission_PermissionUnrestricted ()
 163                 {
 164                         PermissionSet ps = new PermissionSet (PermissionState.None);
 165                         SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
 166                         IPermission result = ps.AddPermission (sp);
 167                         AssertNotNull ("Add(SecurityPermission)", result);
 168                         AssertEquals ("SecurityPermission", SecurityPermissionFlag.AllFlags, (result as SecurityPermission).Flags);
 169                         AssertEquals ("1", 1, ps.Count);
 170                         Assert ("State", !ps.IsUnrestricted ());
 171                 }\r
 172 \r
 173                 [Test]\r
 174                 public void AddPermission_NonCasPermission ()\r
 175                 {\r
 176                         PermissionSet ps = new PermissionSet (PermissionState.None);\r
 177                         ps.AddPermission (new PrincipalPermission ("name", "role"));\r
 178                         AssertEquals ("Count", 1, ps.Count);\r
 179                         Assert ("IsEmpty", !ps.IsEmpty ());\r
 180                 }\r
 181 \r
 182                 [Test]\r
 183                 public void AddPermission_NonCasPermissionNone ()\r
 184                 {\r
 185                         PermissionSet ps = new PermissionSet (PermissionState.None);\r
 186                         ps.AddPermission (new PrincipalPermission (PermissionState.None));\r
 187                         AssertEquals ("Count", 1, ps.Count);\r
 188                         Assert ("IsEmpty", ps.IsEmpty ());\r
 189                 }\r
 190 \r
 191                 [Test]\r
 192                 public void AddPermission_NonCasPermissionUnrestricted ()\r
 193                 {\r
 194                         PermissionSet ps = new PermissionSet (PermissionState.None);\r
 195                         ps.AddPermission (new PrincipalPermission (PermissionState.Unrestricted));\r
 196                         AssertEquals ("Count", 1, ps.Count);\r
 197                         Assert ("IsEmpty", !ps.IsEmpty ());\r
 198                 }\r
 199 \r
 200                 [Test]\r
 201                 public void AddPermission_NonCasPermission_Unrestricted ()\r
 202                 {\r
 203                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);\r
 204                         ps.AddPermission (new PrincipalPermission ("name", "role"));\r
 205                         AssertEquals ("Count", 0, ps.Count);\r
 206                         Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
 207                 }\r
 208 \r
 209                 [Test]\r
 210                 public void AddPermission_NonCasPermissionNone_Unrestricted ()\r
 211                 {\r
 212                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);\r
 213                         ps.AddPermission (new PrincipalPermission (PermissionState.None));\r
 214                         AssertEquals ("Count", 0, ps.Count);\r
 215                         Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
 216                 }\r
 217 \r
 218                 [Test]\r
 219                 public void AddPermission_NonCasPermissionUnrestricted_Unrestricted ()\r
 220                 {\r
 221                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);\r
 222                         ps.AddPermission (new PrincipalPermission (PermissionState.Unrestricted));\r
 223                         AssertEquals ("Count", 0, ps.Count);\r
 224                         Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
 225                 }\r
 226
 227                 [Test]
 228                 public void AddPermission_NoCopy ()
 229                 {
 230                         PermissionSet ps = new PermissionSet (PermissionState.None);
 231                         SecurityPermission sp1 = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
 232                         SecurityPermission result = (SecurityPermission)ps.AddPermission (sp1);
 233                         SecurityPermission entry = (SecurityPermission)ps.GetPermission (typeof (SecurityPermission));
 234
 235                         // are they the same (reference) or different ?
 236                         sp1.Flags = SecurityPermissionFlag.AllFlags;
 237
 238                         result.Flags = SecurityPermissionFlag.Assertion;
 239                 }
 240
 241                 [Test]
 242                 public void ContainsNonCodeAccessPermissions ()
 243                 {
 244                         PermissionSet ps = new PermissionSet (PermissionState.None);
 245                         Assert ("Empty", !ps.ContainsNonCodeAccessPermissions ());
 246
 247                         SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
 248                         ps.AddPermission (sp);
 249                         Assert ("SecurityPermission", !ps.ContainsNonCodeAccessPermissions ());
 250
 251                         PrincipalPermission pp = new PrincipalPermission ("mono", "hacker");
 252                         ps.AddPermission (pp);
 253                         Assert ("PrincipalPermission", ps.ContainsNonCodeAccessPermissions ());
 254                 }
 255
 256                 [Test]
 257                 [ExpectedException (typeof (ArgumentNullException))]
 258                 public void ConvertPermissionSet_NullIn ()
 259                 {
 260                         PermissionSet.ConvertPermissionSet (null, new byte [0], "XML");
 261                 }
 262
 263                 [Test]
 264                 public void ConvertPermissionSet_UnknownIn ()
 265                 {
 266                         byte[] result = PermissionSet.ConvertPermissionSet (String.Empty, new byte [0], "XML");
 267                         AssertNull (result);
 268                 }
 269
 270                 [Test]
 271                 public void ConvertPermissionSet_NullData ()
 272                 {
 273                         byte[] result = PermissionSet.ConvertPermissionSet ("BINARY", null, "XML");
 274                         AssertNull (result);
 275                 }
 276
 277                 [Test]
 278                 [ExpectedException (typeof (ArgumentNullException))]
 279                 public void ConvertPermissionSet_NullOut ()
 280                 {
 281                         PermissionSet.ConvertPermissionSet ("BINARY", new byte [0], null);
 282                 }
 283
 284                 [Test]
 285                 [ExpectedException (typeof (SerializationException))]
 286                 public void ConvertPermissionSet_UnknownOut ()
 287                 {
 288                         PermissionSet.ConvertPermissionSet ("BINARY", new byte [0], String.Empty);
 289                 }
 290
 291                 [Test]
 292 #if !NET_2_0
 293                 [Ignore ("Don't know why it doesn't work under Fx 1.1")]
 294 #endif
 295                 public void ConvertPermissionSet_BinaryToBinary ()
 296                 {
 297                         PermissionSet ps = new PermissionSet (PermissionState.None);
 298                         byte[] data = Encoding.ASCII.GetBytes (ps.ToString ());
 299                         byte[] result = PermissionSet.ConvertPermissionSet ("XML", data, "BINARY");
 300
 301                         byte[] result2 = PermissionSet.ConvertPermissionSet ("BINARY", result, "BINARY");
 302                         // there's only a little difference - but it doesn't throw an exception
 303                         //Assert ("BINARY!=BINARY", BitConverter.ToString (result) != BitConverter.ToString (result2));
 304                 }
 305
 306                 [Test]
 307 #if !NET_2_0
 308                 [Ignore ("Don't know why it doesn't work under Fx 1.1")]
 309 #endif
 310                 public void ConvertPermissionSet_XmlToBinary ()
 311                 {
 312                         PermissionSet ps = new PermissionSet (PermissionState.None);
 313                         byte[] data = Encoding.ASCII.GetBytes (ps.ToString ());
 314                         byte[] result = PermissionSet.ConvertPermissionSet ("XML", data, "BINARY");
 315                         byte[] result2 = PermissionSet.ConvertPermissionSet ("XMLASCII", data, "BINARY");
 316                         AssertEquals ("XML==XMLASCII", BitConverter.ToString (result), BitConverter.ToString (result2));
 317                         byte[] back = PermissionSet.ConvertPermissionSet ("BINARY", result, "XML");
 318                         AssertEquals ("PS-XML", Encoding.ASCII.GetString (back), ps.ToString ());
 319                         back = PermissionSet.ConvertPermissionSet ("BINARY", result2, "XMLASCII");
 320                         AssertEquals ("PS-XMLASCII", Encoding.ASCII.GetString (back), ps.ToString ());
 321                 }
 322
 323                 [Test]
 324                 public void ConvertPermissionSet_XmlToXml ()
 325                 {
 326                         PermissionSet ps = new PermissionSet (PermissionState.None);
 327                         byte[] data = Encoding.ASCII.GetBytes (ps.ToString ());
 328                         byte[] result = PermissionSet.ConvertPermissionSet ("XML", data, "XML");
 329                         AssertEquals ("PS-XML", Encoding.ASCII.GetString (result), ps.ToString ());
 330
 331                         result = PermissionSet.ConvertPermissionSet ("XMLASCII", data, "XMLASCII");
 332                         AssertEquals ("PS-XMLASCII", Encoding.ASCII.GetString (result), ps.ToString ());
 333                 }
 334
 335                 [Test]
 336 #if NET_2_0
 337                 [ExpectedException (typeof (XmlSyntaxException))]
 338 #else
 339                 [ExpectedException (typeof (ArgumentException))]
 340 #endif
 341                 public void ConvertPermissionSet_XmlAsciiToXmlUnicode ()
 342                 {
 343                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 344                         byte[] data = Encoding.Unicode.GetBytes (ps.ToString ());
 345                         byte[] result = PermissionSet.ConvertPermissionSet ("XMLASCII", data, "XMLUNICODE");
 346                         // the method isn't intended to convert between ASCII and Unicode
 347                 }
 348
 349                 [Test]
 350                 public void Copy_None ()
 351                 {
 352                         PermissionSet ps = new PermissionSet (PermissionState.None);
 353                         PermissionSet copy = ps.Copy ();
 354                         Assert ("1.State", !copy.IsUnrestricted ());
 355                         AssertEquals ("1.Count", 0, copy.Count);
 356
 357                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
 358                         IPermission result = ps.AddPermission (sp);
 359                         AssertNotNull ("1.Add", result);
 360                         copy = ps.Copy ();
 361                         Assert ("2.State", !copy.IsUnrestricted ());
 362                         AssertEquals ("2.Count", 1, copy.Count);
 363
 364                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 365                         result = ps.AddPermission (zip);
 366                         AssertNotNull ("2.Add", result);
 367                         copy = ps.Copy ();
 368                         Assert ("3.State", !copy.IsUnrestricted ());
 369                         AssertEquals ("3.Count", 2, copy.Count);
 370                 }
 371
 372                 [Test]
 373                 public void Copy_Unrestricted ()
 374                 {
 375                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 376                         PermissionSet copy = ps.Copy ();
 377                         Assert ("1.State", copy.IsUnrestricted ());
 378                         AssertEquals ("1.Count", 0, copy.Count);
 379
 380                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
 381                         IPermission result = ps.AddPermission (sp);
 382                         AssertNotNull ("1.Add", result);
 383                         copy = ps.Copy ();
 384                         Assert ("2.State", copy.IsUnrestricted ());
 385                         AssertEquals ("2.Count", 0, copy.Count);
 386
 387                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 388                         result = ps.AddPermission (zip);
 389                         AssertNotNull ("2.Add", result);
 390                         copy = ps.Copy ();
 391                         Assert ("3.State", copy.IsUnrestricted ());
 392 #if NET_2_0
 393                         // Identity permissions aren't added to unrestricted permission sets in 2.0
 394                         AssertEquals ("3.Count", 0, copy.Count);
 395 #else
 396                         AssertEquals ("3.Count", 1, copy.Count);
 397 #endif
 398                 }
 399
 400                 [Test]
 401                 [ExpectedException (typeof (ArgumentNullException))]
 402                 public void CopyTo_Null ()
 403                 {
 404                         PermissionSet ps = new PermissionSet (PermissionState.None);
 405                         ps.CopyTo (null, 0);
 406                 }
 407
 408                 [Test]
 409                 public void CopyTo_Rank_Empty ()
 410                 {
 411                         IPermission[,] pa = new IPermission [1,1];
 412                         PermissionSet ps = new PermissionSet (PermissionState.None);
 413                         ps.CopyTo (pa, 0);
 414                 }
 415
 416                 [Test]
 417                 [ExpectedException (typeof (ArgumentException))]
 418                 public void CopyTo_Rank ()
 419                 {
 420                         IPermission [,] pa = new IPermission [1, 1];
 421                         PermissionSet ps = new PermissionSet (PermissionState.None);
 422                         ps.AddPermission (new SecurityPermission (SecurityPermissionFlag.Assertion));
 423                         ps.CopyTo (pa, 0);
 424                 }
 425
 426                 [Test]
 427                 public void CopyTo_NegativeIndex_Empty ()
 428                 {
 429                         IPermission[] pa = new IPermission [1];
 430                         PermissionSet ps = new PermissionSet (PermissionState.None);
 431                         ps.CopyTo (pa, Int32.MinValue);
 432                 }
 433
 434                 [Test]
 435                 [ExpectedException (typeof (IndexOutOfRangeException))]
 436                 public void CopyTo_NegativeIndex ()
 437                 {
 438                         IPermission [] pa = new IPermission [1];
 439                         PermissionSet ps = new PermissionSet (PermissionState.None);
 440                         ps.AddPermission (new SecurityPermission (SecurityPermissionFlag.Assertion));
 441                         ps.CopyTo (pa, Int32.MinValue);
 442                 }
 443
 444                 [Test]
 445                 public void CopyTo_IndexOverLength_Empty ()
 446                 {
 447                         IPermission [] pa = new IPermission [1];
 448                         PermissionSet ps = new PermissionSet (PermissionState.None);
 449                         ps.CopyTo (pa, pa.Length);
 450                 }
 451
 452                 [Test]
 453                 [ExpectedException (typeof (IndexOutOfRangeException))]
 454                 public void CopyTo_IndexOverLength ()
 455                 {
 456                         IPermission [] pa = new IPermission [1];
 457                         PermissionSet ps = new PermissionSet (PermissionState.None);
 458                         ps.AddPermission (new SecurityPermission (SecurityPermissionFlag.Assertion));
 459                         ps.CopyTo (pa, pa.Length);
 460                 }
 461
 462                 [Test]
 463                 public void CopyTo ()
 464                 {
 465                         IPermission [] pa = new IPermission [1];
 466                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 467                         PermissionSet ps = new PermissionSet (PermissionState.None);
 468                         ps.AddPermission (sp);
 469                         ps.CopyTo (pa, 0);
 470                         AssertEquals ("CopyTo", pa [0].ToString (), sp.ToString ());
 471                         Assert ("Reference", Object.ReferenceEquals (pa [0], sp));
 472                 }
 473
 474                 [Test]
 475                 [ExpectedException (typeof (ArgumentNullException))]
 476                 public void FromXmlNull ()
 477                 {
 478                         PermissionSet ps = new PermissionSet (PermissionState.None);
 479                         ps.FromXml (null);
 480                 }
 481
 482                 [Test]
 483                 [ExpectedException (typeof (ArgumentException))]
 484                 public void FromXmlInvalidPermission ()
 485                 {
 486                         PermissionSet ps = new PermissionSet (PermissionState.None);
 487                         SecurityElement se = ps.ToXml ();
 488                         // can't modify - so we create our own
 489                         SecurityElement se2 = new SecurityElement ("InvalidPermissionSet", se.Text);
 490                         se2.AddAttribute ("class", se.Attribute ("class"));
 491                         se2.AddAttribute ("version", se.Attribute ("version"));
 492                         ps.FromXml (se2);
 493                 }
 494
 495                 [Test]
 496                 // [ExpectedException (typeof (ArgumentException))]
 497                 public void FromXmlWrongVersion ()
 498                 {
 499                         PermissionSet ps = new PermissionSet (PermissionState.None);
 500                         SecurityElement se = ps.ToXml ();
 501                         // can't modify - so we create our own
 502                         SecurityElement se2 = new SecurityElement (se.Tag, se.Text);
 503                         se2.AddAttribute ("class", se.Attribute ("class"));
 504                         se2.AddAttribute ("version", "2");
 505                         ps.FromXml (se2);
 506                         // wow - here we accept a version 2 !!!
 507                 }
 508
 509                 [Test]
 510                 public void FromXmlEmpty ()
 511                 {
 512                         PermissionSet ps = new PermissionSet (PermissionState.None);
 513                         SecurityElement se = ps.ToXml ();
 514                         AssertNotNull ("Empty.ToXml()", se);
 515                         AssertEquals ("Empty.Count", 0, ps.Count);
 516
 517                         PermissionSet ps2 = (PermissionSet) ps.Copy ();
 518                         ps2.FromXml (se);
 519                         Assert ("FromXml-Copy.IsUnrestricted", !ps2.IsUnrestricted ());
 520
 521                         se.AddAttribute ("Unrestricted", "true");
 522                         ps2.FromXml (se);
 523                         Assert ("FromXml-Unrestricted.IsUnrestricted", ps2.IsUnrestricted ());
 524                 }
 525
 526                 [Test]
 527                 public void FromXmlOne ()
 528                 {
 529                         FileDialogPermission fdp = new FileDialogPermission (FileDialogPermissionAccess.Open);
 530                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 531                         ps1.AddPermission (fdp);
 532                         Assert ("ps1.IsEmpty", !ps1.IsEmpty ());
 533
 534                         PermissionSet ps = new PermissionSet (ps1);
 535                         SecurityElement se = ps.ToXml ();
 536                         AssertNotNull ("One.ToXml()", se);
 537                         AssertEquals ("One.Count", 1, ps.Count);
 538
 539                         PermissionSet ps2 = (PermissionSet) ps.Copy ();
 540                         ps2.FromXml (se);
 541                         Assert ("FromXml-Copy.IsUnrestricted", !ps2.IsUnrestricted ());
 542                         AssertEquals ("Copy.Count", 1, ps2.Count);
 543
 544                         se.AddAttribute ("Unrestricted", "true");
 545                         ps2.FromXml (se);
 546                         Assert ("FromXml-Unrestricted.IsUnrestricted", ps2.IsUnrestricted ());
 547 #if NET_2_0
 548                         AssertEquals ("Unrestricted.Count", 0, ps2.Count);
 549 #else
 550                         // IPermission not shown in XML but still present in Count
 551                         AssertEquals ("Unrestricted.Count", 1, ps2.Count);
 552 #endif
 553                 }
 554
 555                 [Test]
 556 #if NET_2_0
 557                 [ExpectedException (typeof (TypeLoadException))]
 558 #else
 559                 [ExpectedException (typeof (ArgumentException))]
 560 #endif
 561                 public void FromXml_PermissionWithoutNamespace ()
 562                 {
 563                         SecurityElement child = new SecurityElement ("IPermission");
 564                         child.AddAttribute ("class", "EnvironmentPermission");
 565                         child.AddAttribute ("version", "1");
 566                         child.AddAttribute ("Read", "USERNAME");
 567
 568                         SecurityElement se = new SecurityElement ("PermissionSet");
 569                         se.AddAttribute ("class", "PermissionSet");
 570                         se.AddAttribute ("version", "1");
 571                         se.AddChild (child);
 572
 573                         PermissionSet ps = new PermissionSet (PermissionState.None);
 574                         ps.FromXml (se);
 575                 }
 576
 577                 [Test]
 578 #if NET_2_0
 579                 [ExpectedException (typeof (TypeLoadException))]
 580 #else
 581                 [ExpectedException (typeof (ArgumentException))]
 582 #endif
 583                 public void FromXml_PermissionOutsideCorlib ()
 584                 {
 585                         SecurityElement child = new SecurityElement ("IPermission");
 586                         child.AddAttribute ("class", "PrintingPermission");     // System.Drawing
 587                         child.AddAttribute ("version", "1");
 588                         child.AddAttribute ("Level", "DefaultPrinting");
 589
 590                         SecurityElement se = new SecurityElement ("PermissionSet");
 591                         se.AddAttribute ("class", "PermissionSet");
 592                         se.AddAttribute ("version", "1");
 593                         se.AddChild (child);
 594
 595                         PermissionSet ps = new PermissionSet (PermissionState.None);
 596                         ps.FromXml (se);
 597                 }
 598
 599                 [Test]
 600                 [ExpectedException (typeof (ArgumentException))]
 601                 public void FromXml_WithPermissionWithoutClass ()
 602                 {
 603                         SecurityElement child = new SecurityElement ("IPermission");
 604                         child.AddAttribute ("version", "1");
 605
 606                         SecurityElement se = new SecurityElement ("PermissionSet");
 607                         se.AddAttribute ("class", "PermissionSet");
 608                         se.AddAttribute ("version", "1");
 609                         se.AddChild (child);
 610
 611                         PermissionSet ps = new PermissionSet (PermissionState.None);
 612                         ps.FromXml (se);
 613                 }
 614
 615                 [Test]
 616                 public void GetEnumerator ()
 617                 {
 618                         PermissionSet ps = new PermissionSet (PermissionState.None);
 619                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 620                         ps.AddPermission (sp);
 621                         IEnumerator e = ps.GetEnumerator ();
 622                         AssertNotNull ("GetEnumerator", e);
 623                         int i=0;
 624                         while (e.MoveNext ()) {
 625                                 Assert ("SecurityPermission", e.Current is SecurityPermission);
 626                                 i++;
 627                         }
 628                         AssertEquals ("Count", 1, i);
 629                 }
 630 #if NET_2_0
 631                 [Test]
 632                 public void GetHashCode_ ()
 633                 {
 634                         PermissionSet ps = new PermissionSet (PermissionState.None);
 635                         AssertEquals ("Empty", 0, ps.GetHashCode ());
 636                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 637                         ps.AddPermission (sp);
 638                         Assert ("SecurityPermission", ps.GetHashCode () != 0);
 639                         PermissionSet copy = ps.Copy ();
 640                         Assert ("Copy", ps.GetHashCode () != copy.GetHashCode ());
 641                 }
 642 #endif
 643                 [Test]
 644                 public void GetPermission_Null ()
 645                 {
 646                         PermissionSet ps = new PermissionSet (PermissionState.None);
 647                         AssertNull ("Empty", ps.GetPermission (null));
 648                 }
 649
 650                 [Test]
 651                 public void GetPermission_None ()
 652                 {
 653                         PermissionSet ps = new PermissionSet (PermissionState.None);
 654                         AssertNull ("Empty", ps.GetPermission (typeof (SecurityPermission)));
 655                 }
 656
 657                 [Test]
 658                 public void GetPermission_Unrestricted ()
 659                 {
 660                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 661                         AssertNull ("Empty", ps.GetPermission (typeof (SecurityPermission)));
 662                 }
 663
 664                 [Test]
 665                 public void GetPermission_Subclass ()
 666                 {
 667                         IsolatedStorageFilePermission isfp = new IsolatedStorageFilePermission (PermissionState.Unrestricted);
 668                         PermissionSet ps = new PermissionSet (PermissionState.None);
 669                         ps.AddPermission (isfp);
 670                         AssertNull ("Subclass", ps.GetPermission (typeof (IsolatedStoragePermission)));
 671                 }
 672
 673                 private void Compare (string msg, PermissionSet ps, bool unrestricted, int count)
 674                 {
 675                         AssertNotNull (msg + "-NullCheck", ps);
 676                         Assert (msg + "-State", (ps.IsUnrestricted () == unrestricted));
 677                         AssertEquals (msg + "-Count", count, ps.Count);
 678                 }
 679
 680                 [Test]
 681                 public void Intersect_Empty ()
 682                 {
 683                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 684                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 685                         AssertNull ("None N null", ps1.Intersect (null));
 686                         AssertNull ("None1 N None2", ps1.Intersect (ps2));
 687                         AssertNull ("None2 N None1", ps2.Intersect (ps1));
 688
 689                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 690                         AssertNull ("None1 N Unrestricted", ps1.Intersect (ups1));
 691                         AssertNull ("Unrestricted N None1", ups1.Intersect (ps1));
 692                         AssertNull ("Unrestricted N Null", ups1.Intersect (null));
 693
 694                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
 695                         Compare ("ups1 N ups2", ups1.Intersect (ups2), true, 0);
 696                         Compare ("ups2 N ups1", ups2.Intersect (ups1), true, 0);
 697                 }
 698
 699                 [Test]
 700                 public void Intersect_OnePermission ()
 701                 {
 702                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 703                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 704                         ps1.AddPermission (sp);
 705                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 706                         AssertNull ("PS1 N null", ps1.Intersect (null));
 707                         AssertNull ("PS1 N None", ps1.Intersect (ps2));
 708                         AssertNull ("None N PS1", ps2.Intersect (ps1));
 709
 710                         PermissionSet ps3 = ps1.Copy ();
 711                         Compare ("PS1 N PS3", ps1.Intersect (ps3), false, 1);
 712                         Compare ("PS3 N PS1", ps3.Intersect (ps1), false, 1);
 713
 714                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 715                         Compare ("PS1 N Unrestricted", ps1.Intersect (ups1), false, 1);
 716                         Compare ("Unrestricted N PS1", ups1.Intersect (ps1), false, 1);
 717                 }
 718
 719                 [Test]
 720                 public void Intersect_OneNonIUnrestrictedPermission ()
 721                 {
 722                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 723                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 724                         ps1.AddPermission (zip);
 725                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 726                         AssertNull ("PS1 N null", ps1.Intersect (null));
 727                         AssertNull ("PS1 N None", ps1.Intersect (ps2));
 728                         AssertNull ("None N PS1", ps2.Intersect (ps1));
 729
 730                         PermissionSet ps3 = ps1.Copy ();
 731                         Compare ("PS1 N PS3", ps1.Intersect (ps3), false, 1);
 732                         Compare ("PS3 N PS1", ps3.Intersect (ps1), false, 1);
 733
 734                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 735                         ups1.AddPermission (zip);
 736                         Compare ("PS1 N Unrestricted", ps1.Intersect (ups1), false, 1);
 737                         Compare ("Unrestricted N PS1", ups1.Intersect (ps1), false, 1);
 738
 739                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
 740                         Compare ("UPS1 N UPS2", ups1.Intersect (ups2), true, 0);
 741                         Compare ("UPS2 N UPS1", ups2.Intersect (ups1), true, 0);
 742                         ups2.AddPermission (zip);
 743 #if NET_2_0
 744                         // Identity permissions aren't added to unrestricted permission sets in 2.0
 745                         Compare ("UPS1 N UPS2+ZIP", ups1.Intersect (ups2), true, 0);
 746                         Compare ("UPS2+ZIP N UPS1", ups2.Intersect (ups1), true, 0);
 747 #else
 748                         Compare ("UPS1 N UPS2+ZIP", ups1.Intersect (ups2), true, 1);
 749                         Compare ("UPS2+ZIP N UPS1", ups2.Intersect (ups1), true, 1);
 750 #endif
 751                 }
 752
 753                 [Test]
 754                 public void IsEmpty_None ()
 755                 {
 756                         PermissionSet ps = new PermissionSet (PermissionState.None);
 757                         Assert ("Empty.IsEmpty", ps.IsEmpty ());
 758                         ps.AddPermission (new ZoneIdentityPermission (SecurityZone.NoZone));
 759                         AssertEquals ("Count==1", 1, ps.Count);
 760                         Assert ("Zip.IsEmpty", ps.IsEmpty ());  // yes empty!
 761                 }
 762
 763                 [Test]
 764                 public void IsEmpty_Unrestricted ()
 765                 {
 766                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 767                         Assert ("Unrestricted.IsEmpty", !ps.IsEmpty ());
 768                         ps.AddPermission (new ZoneIdentityPermission (SecurityZone.NoZone));
 769 #if NET_2_0
 770                         // Identity permissions aren't added to unrestricted permission sets in 2.0
 771                         AssertEquals ("Count==0", 0, ps.Count);
 772 #else
 773                         AssertEquals ("Count==1", 1, ps.Count);
 774 #endif
 775                         Assert ("Zip.IsEmpty", !ps.IsEmpty ()); // yes empty!
 776                 }
 777
 778                 [Test]
 779                 public void IsSubset_Empty ()
 780                 {
 781                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 782                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 783                         Assert ("None.IsSubsetOf(null)", ps1.IsSubsetOf (null));
 784                         Assert ("None1.IsSubsetOf(None2)", ps1.IsSubsetOf (ps2));
 785                         Assert ("None2.IsSubsetOf(None1)", ps2.IsSubsetOf (ps1));
 786
 787                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 788                         Assert ("None1.IsSubsetOf(Unrestricted)", ps1.IsSubsetOf (ups1));
 789                         Assert ("Unrestricted.IsSubsetOf(None1)", !ups1.IsSubsetOf (ps1));
 790                         Assert ("Unrestricted.IsSubsetOf(Null)", !ups1.IsSubsetOf (null));
 791
 792                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
 793                         Assert ("ups1IsSubsetOf(ups2)", ups1.IsSubsetOf (ups2));
 794                         Assert ("ups2.IsSubsetOf(ups1)", ups2.IsSubsetOf (ups1));
 795                 }
 796
 797                 [Test]
 798                 public void IsSubset_OnePermission ()
 799                 {
 800                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 801                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 802                         ps1.AddPermission (sp);
 803                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 804                         Assert ("PS1.IsSubset(null)", !ps1.IsSubsetOf (null));
 805                         Assert ("PS1.IsSubset(None)", !ps1.IsSubsetOf (ps2));
 806                         Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));
 807
 808                         PermissionSet ps3 = ps1.Copy ();
 809                         Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));
 810                         Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));
 811
 812                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 813                         Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));
 814                         Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));
 815                 }
 816
 817                 [Test]
 818                 public void IsSubset_OneNonIUnrestrictedPermission ()
 819                 {
 820                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 821                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 822                         ps1.AddPermission (zip);
 823                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 824                         Assert ("PS1.IsSubset(null)", !ps1.IsSubsetOf (null));
 825                         Assert ("PS1.IsSubset(None)", !ps1.IsSubsetOf (ps2));
 826                         Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));
 827
 828                         PermissionSet ps3 = ps1.Copy ();
 829                         Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));
 830                         Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));
 831
 832                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 833                         ups1.AddPermission (zip);
 834                         Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));
 835                         Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));
 836
 837                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
 838 #if NET_2_0
 839                         // as ZoneIdentityPermission isn't added UPS1Z == UPS2
 840                         Assert ("UPS1Z.IsSubset(UPS2)", ups1.IsSubsetOf (ups2));
 841 #else
 842                         Assert ("UPS1Z.IsSubset(UPS2)", !ups1.IsSubsetOf (ups2));
 843 #endif
 844                         Assert ("UPS2.IsSubset(UPS1Z)", ups2.IsSubsetOf (ups1));
 845                         ups2.AddPermission (zip);
 846                         Assert ("UPS1Z.IsSubset(UPS2Z)", ups1.IsSubsetOf (ups2));
 847                         Assert ("UPS2Z.IsSubset(UPS1Z)", ups2.IsSubsetOf (ups1));
 848                 }\r
 849 \r
 850                 [Test]\r
 851                 public void IsSubset_NonCasPermission ()\r
 852                 {\r
 853                         PermissionSet ps1 = new PermissionSet (PermissionState.None);\r
 854                         ps1.AddPermission (new PrincipalPermission ("name", "role"));\r
 855                         PermissionSet ps2 = new PermissionSet (PermissionState.None);\r
 856                         Assert ("PS1.IsSubset(null)", !ps1.IsSubsetOf (null));\r
 857                         Assert ("PS1.IsSubset(None)", !ps1.IsSubsetOf (ps2));\r
 858                         Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));\r
 859 \r
 860                         PermissionSet ps3 = ps1.Copy ();\r
 861                         Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));\r
 862                         Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));\r
 863 \r
 864                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);\r
 865 #if NET_2_0\r
 866                         Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));\r
 867 #else
 868                         Assert ("PS1.IsSubset(Unrestricted)", !ps1.IsSubsetOf (ups1));\r
 869 #endif\r
 870                         Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));\r
 871                 }\r
 872 \r
 873                 [Test]\r
 874                 public void IsSubset_NonCasPermission_None ()\r
 875                 {\r
 876                         PermissionSet ps1 = new PermissionSet (PermissionState.None);\r
 877                         ps1.AddPermission (new PrincipalPermission (PermissionState.None));\r
 878                         PermissionSet ps2 = new PermissionSet (PermissionState.None);\r
 879                         Assert ("PS1.IsSubset(null)", ps1.IsSubsetOf (null));\r
 880                         Assert ("PS1.IsSubset(None)", ps1.IsSubsetOf (ps2));\r
 881                         Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));\r
 882 \r
 883                         PermissionSet ps3 = ps1.Copy ();\r
 884                         Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));\r
 885                         Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));\r
 886 \r
 887                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);\r
 888                         Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));\r
 889                         Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));\r
 890                 }
 891 \r
 892                 [Test]\r
 893                 public void IsSubset_NonCasPermission_Unrestricted ()\r
 894                 {\r
 895                         PermissionSet ps1 = new PermissionSet (PermissionState.None);\r
 896                         ps1.AddPermission (new PrincipalPermission (PermissionState.Unrestricted));\r
 897                         PermissionSet ps2 = new PermissionSet (PermissionState.None);\r
 898                         Assert ("PS1.IsSubset(null)", !ps1.IsSubsetOf (null));\r
 899                         Assert ("PS1.IsSubset(None)", !ps1.IsSubsetOf (ps2));\r
 900                         Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));\r
 901 \r
 902                         PermissionSet ps3 = ps1.Copy ();\r
 903                         Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));\r
 904                         Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));\r
 905 \r
 906                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);\r
 907 #if NET_2_0\r
 908                         Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));\r
 909 #else
 910                         Assert ("PS1.IsSubset(Unrestricted)", !ps1.IsSubsetOf (ups1));\r
 911 #endif\r
 912                         Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));\r
 913                 }
 914
 915                 [Test]
 916                 public void RemovePermission_Null ()
 917                 {
 918                         PermissionSet ps = new PermissionSet (PermissionState.None);
 919                         AssertNull (ps.RemovePermission (null));
 920                 }
 921
 922                 [Test]
 923                 public void RemovePermission_None ()
 924                 {
 925                         PermissionSet ps = new PermissionSet (PermissionState.None);
 926                         AssertNull ("Empty", ps.RemovePermission (typeof (SecurityPermission)));
 927                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 928                         ps.AddPermission (sp);
 929                         SecurityPermission removed = (SecurityPermission) ps.RemovePermission (typeof (SecurityPermission));
 930                         AssertNotNull ("SecurityPermission", removed);
 931                         AssertEquals ("Flags", sp.Flags, removed.Flags);
 932                         AssertNull ("Empty-Again", ps.RemovePermission (typeof (SecurityPermission)));
 933                 }
 934
 935                 [Test]
 936                 public void RemovePermission_Unrestricted ()
 937                 {
 938                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 939                         AssertNull ("Empty", ps.RemovePermission (typeof (SecurityPermission)));
 940                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 941                         ps.AddPermission (sp);
 942                         AssertNull ("SecurityPermissionn", ps.RemovePermission (typeof (SecurityPermission)));
 943                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 944                         ps.AddPermission (zip);
 945                         ZoneIdentityPermission removed = (ZoneIdentityPermission)ps.RemovePermission (typeof (ZoneIdentityPermission));
 946 #if NET_2_0
 947                         // identity permissions aren't added to unrestricted permission sets
 948                         // so they cannot be removed later (hence the null)
 949                         AssertNull ("ZoneIdentityPermission", removed);
 950 #else
 951                         AssertNotNull ("ZoneIdentityPermission", removed);
 952 #endif
 953                 }
 954
 955                 [Test]
 956                 public void SetPermission_Null ()
 957                 {
 958                         PermissionSet ps = new PermissionSet (PermissionState.None);
 959                         AssertNull (ps.SetPermission (null));
 960                 }
 961
 962                 [Test]
 963                 public void SetPermission_None ()
 964                 {
 965                         PermissionSet ps = new PermissionSet (PermissionState.None);
 966                         AssertEquals ("Empty", 0, ps.Count);
 967                         Assert ("State-None", !ps.IsUnrestricted ());
 968
 969                         SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
 970                         SecurityPermission result = (SecurityPermission)ps.SetPermission (sp);
 971                         AssertEquals ("SecurityPermission", 1, ps.Count);
 972                         AssertEquals ("Flags", SecurityPermissionFlag.AllFlags, result.Flags);
 973                         Assert ("State-None-2", !ps.IsUnrestricted ());
 974
 975                         sp = new SecurityPermission (SecurityPermissionFlag.ControlAppDomain);
 976                         result = (SecurityPermission)ps.SetPermission (sp);
 977                         AssertEquals ("SecurityPermission-2", 1, ps.Count);
 978                         AssertEquals ("Flags", SecurityPermissionFlag.ControlAppDomain, result.Flags);
 979
 980                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 981                         ZoneIdentityPermission zipr = (ZoneIdentityPermission) ps.SetPermission (zip);
 982                         AssertEquals ("ZoneIdentityPermission", 2, ps.Count);
 983                         AssertEquals ("SecurityZone", SecurityZone.MyComputer, zipr.SecurityZone);
 984
 985                         zip = new ZoneIdentityPermission (SecurityZone.Intranet);
 986                         zipr = (ZoneIdentityPermission)ps.SetPermission (zip);
 987                         AssertEquals ("ZoneIdentityPermission", 2, ps.Count);
 988                         AssertEquals ("SecurityZone", SecurityZone.Intranet, zipr.SecurityZone);
 989                 }
 990
 991                 [Test]
 992                 public void SetPermission_Unrestricted ()
 993                 {
 994                         SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
 995                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 996                         AssertEquals ("Empty", 0, ps.Count);
 997                         Assert ("State-Unrestricted", ps.IsUnrestricted ());
 998
 999                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
1000                         ZoneIdentityPermission zipr = (ZoneIdentityPermission)ps.SetPermission (zip);
1001                         AssertEquals ("ZoneIdentityPermission", 1, ps.Count);
1002                         AssertEquals ("SecurityZone", SecurityZone.MyComputer, zipr.SecurityZone);
1003 #if NET_2_0
1004                         // Adding a non unrestricted identity permission now results in
1005                         // a permission set loosing it's unrestricted status
1006                         Assert ("State-Unrestricted-2", !ps.IsUnrestricted ());
1007 #else
1008                         Assert ("State-Unrestricted-2", ps.IsUnrestricted ());
1009 #endif
1010                         zip = new ZoneIdentityPermission (SecurityZone.Intranet);
1011                         zipr = (ZoneIdentityPermission)ps.SetPermission (zip);
1012                         AssertEquals ("ZoneIdentityPermission-2", 1, ps.Count);
1013                         AssertEquals ("SecurityZone-2", SecurityZone.Intranet, zipr.SecurityZone);
1014
1015                         SecurityPermission result = (SecurityPermission)ps.SetPermission (sp);
1016                         AssertEquals ("SecurityPermission", 2, ps.Count);
1017                         AssertEquals ("Flags", SecurityPermissionFlag.AllFlags, result.Flags);
1018                         Assert ("State-None", !ps.IsUnrestricted ());
1019
1020                         sp = new SecurityPermission (SecurityPermissionFlag.ControlAppDomain);
1021                         result = (SecurityPermission)ps.SetPermission (sp);
1022                         AssertEquals ("SecurityPermission-2", 2, ps.Count);
1023                         AssertEquals ("Flags-2", SecurityPermissionFlag.ControlAppDomain, result.Flags);
1024                 }
1025
1026                 [Test]
1027                 public void ToXmlNone ()
1028                 {
1029                         PermissionSet ps = new PermissionSet (PermissionState.None);
1030                         SecurityElement se = ps.ToXml ();
1031                         Assert ("None.ToString().StartsWith", ps.ToString().StartsWith ("<PermissionSet"));
1032                         AssertEquals ("None.class", "System.Security.PermissionSet", (se.Attributes ["class"] as string));
1033                         AssertEquals ("None.version", "1", (se.Attributes ["version"] as string));
1034                         AssertNull ("None.Unrestricted", (se.Attributes ["Unrestricted"] as string));
1035                 }
1036
1037                 [Test]
1038                 public void ToXmlUnrestricted ()
1039                 {
1040                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
1041                         SecurityElement se = ps.ToXml ();
1042                         Assert ("Unrestricted.ToString().StartsWith", ps.ToString().StartsWith ("<PermissionSet"));
1043                         AssertEquals ("Unrestricted.class", "System.Security.PermissionSet", (se.Attributes ["class"] as string));
1044                         AssertEquals ("Unrestricted.version", "1", (se.Attributes ["version"] as string));
1045                         AssertEquals ("Unrestricted.Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
1046                 }
1047
1048                 [Test]
1049                 public void Union_Empty ()
1050                 {
1051                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
1052                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
1053                         Compare ("None U null", ps1.Union (null), false, 0);
1054                         Compare ("None1 U None2", ps1.Union (ps2), false, 0);
1055                         Compare ("None2 U None1", ps2.Union (ps1), false, 0);
1056
1057                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
1058                         Compare ("None1 U Unrestricted", ps1.Union (ups1), true, 0);
1059                         Compare ("Unrestricted U None1", ups1.Union (ps1), true, 0);
1060                         Compare ("Unrestricted U Null", ups1.Union (null), true, 0);
1061
1062                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
1063                         Compare ("ups1 U ups2", ups1.Union (ups2), true, 0);
1064                         Compare ("ups2 U ups1", ups2.Union (ups1), true, 0);
1065                 }
1066
1067                 [Test]
1068                 public void Union_OnePermission ()
1069                 {
1070                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
1071                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
1072                         ps1.AddPermission (sp);
1073                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
1074                         Compare ("PS1 U null", ps1.Union (null), false, 1);
1075                         Compare ("PS1 U None", ps1.Union (ps2), false, 1);
1076                         Compare ("None U PS1", ps2.Union (ps1), false, 1);
1077
1078                         PermissionSet ps3 = ps1.Copy ();
1079                         Compare ("PS1 U PS3", ps1.Union (ps3), false, 1);
1080                         Compare ("PS3 U PS1", ps3.Union (ps1), false, 1);
1081
1082                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
1083                         Compare ("PS1 U Unrestricted", ps1.Union (ups1), true, 0);
1084                         Compare ("Unrestricted U PS1", ups1.Union (ps1), true, 0);
1085                 }
1086
1087                 [Test]
1088                 public void Union_OneNonIUnrestrictedPermission ()
1089                 {
1090                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
1091                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
1092                         ps1.AddPermission (zip);
1093                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
1094                         Compare ("PS1 U null", ps1.Union (null), false, 1);
1095                         Compare ("PS1 U None", ps1.Union (ps2), false, 1);
1096                         Compare ("None U PS1", ps2.Union (ps1), false, 1);
1097
1098                         PermissionSet ps3 = ps1.Copy ();
1099                         Compare ("PS1 U PS3", ps1.Union (ps3), false, 1);
1100                         Compare ("PS3 U PS1", ps3.Union (ps1), false, 1);
1101
1102                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
1103                         ups1.AddPermission (zip);
1104 #if NET_2_0
1105                         // Identity permissions aren't added to unrestricted permission sets in 2.0
1106                         Compare ("PS1 U Unrestricted", ps1.Union (ups1), true, 0);
1107                         Compare ("Unrestricted U PS1", ups1.Union (ps1), true, 0);
1108                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
1109                         Compare ("UPS1 U UPS2", ups1.Union (ups1), true, 0);
1110                         Compare ("UPS2 U UPS1", ups2.Union (ups1), true, 0);
1111                         ups2.AddPermission (zip);
1112                         Compare ("UPS1 U UPS2+ZIP", ups1.Union (ups2), true, 0);
1113                         Compare ("UPS2+ZIP U UPS1", ups2.Union (ups1), true, 0);
1114 #else
1115                         Compare ("PS1 U Unrestricted", ps1.Union (ups1), true, 1);
1116                         Compare ("Unrestricted U PS1", ups1.Union (ps1), true, 1);
1117                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
1118                         Compare ("UPS1 U UPS2", ups1.Union (ups1), true, 1);
1119                         Compare ("UPS2 U UPS1", ups2.Union (ups1), true, 1);
1120                         ups2.AddPermission (zip);
1121                         Compare ("UPS1 U UPS2+ZIP", ups1.Union (ups2), true, 1);
1122                         Compare ("UPS2+ZIP U UPS1", ups2.Union (ups1), true, 1);
1123 #endif
1124                 }
1125 #if NET_2_0
1126                 [Test]
1127                 [Category ("NotWorking")] // requires imperative stack modifiers
1128                 [ExpectedException (typeof (ExecutionEngineException))]
1129                 public void RevertAssert_WithoutAssertion ()
1130                 {
1131                         PermissionSet.RevertAssert ();
1132                 }
1133
1134                 [Test]
1135                 [Category ("NotWorking")] // requires imperative stack modifiers
1136                 public void RevertAssert_WithAssertion ()
1137                 {
1138                         PermissionSet ups = new PermissionSet (PermissionState.Unrestricted);
1139                         ups.Assert ();
1140                         PermissionSet.RevertAssert ();
1141                 }
1142 #endif
1143                 [Test]
1144                 public void Assert_NonCasPermission ()
1145                 {
1146                         PermissionSet ps = new PermissionSet (PermissionState.None);
1147                         ps.AddPermission (new PrincipalPermission (PermissionState.None));
1148                         Assert ("ContainsNonCodeAccessPermissions", ps.ContainsNonCodeAccessPermissions ());
1149                         AssertEquals ("Count", 1, ps.Count);
1150                         ps.Assert ();
1151                         // it's simply ignored
1152                 }
1153
1154                 [Test]
1155                 public void Deny_NonCasPermission ()
1156                 {
1157                         PermissionSet ps = new PermissionSet (PermissionState.None);
1158                         ps.AddPermission (new PrincipalPermission (PermissionState.None));
1159                         Assert ("ContainsNonCodeAccessPermissions", ps.ContainsNonCodeAccessPermissions ());
1160                         AssertEquals ("Count", 1, ps.Count);
1161                         ps.Deny ();
1162                         // it's simply ignored
1163                 }
1164
1165                 [Test]
1166                 public void PermitOnly_NonCasPermission ()
1167                 {
1168                         PermissionSet ps = new PermissionSet (PermissionState.None);
1169                         ps.AddPermission (new PrincipalPermission (PermissionState.None));
1170                         Assert ("ContainsNonCodeAccessPermissions", ps.ContainsNonCodeAccessPermissions ());
1171                         AssertEquals ("Count", 1, ps.Count);
1172                         ps.PermitOnly ();
1173                         // it's simply ignored
1174                 }
1175
1176                 // note: this only ensure that the ECMA key support unification (more test required, outside corlib, for other keys, like MS final).
1177                 private const string PermissionPattern = "<PermissionSet class=\"System.Security.PermissionSet\" version=\"1\"><IPermission class=\"System.Security.Permissions.FileDialogPermission, mscorlib, Version={0}, Culture=neutral, PublicKeyToken=b77a5c561934e089\" version=\"1\" Access=\"Open\"/></PermissionSet>";
1178                 private const string fx10version = "1.0.3300.0";
1179                 private const string fx11version = "1.0.5000.0";
1180                 private const string fx20version = "2.0.0.0";
1181
1182                 private void Unification (string xml)
1183                 {
1184                         PermissionSetAttribute psa = new PermissionSetAttribute (SecurityAction.Assert);
1185                         psa.XML = xml;
1186                         string pset = psa.CreatePermissionSet ().ToString ();
1187                         string currentVersion = typeof (string).Assembly.GetName ().Version.ToString ();
1188                         Assert (currentVersion, pset.IndexOf (currentVersion) > 0);
1189                 }
1190
1191                 [Test]
1192                 public void Unification_FromFx10 ()
1193                 {
1194                         Unification (String.Format (PermissionPattern, fx10version));
1195                 }
1196
1197                 [Test]
1198                 public void Unification_FromFx11 ()
1199                 {
1200                         Unification (String.Format (PermissionPattern, fx11version));
1201                 }
1202
1203                 [Test]
1204                 public void Unification_FromFx20 ()
1205                 {
1206                         Unification (String.Format (PermissionPattern, fx20version));
1207                 }
1208
1209                 [Test]
1210                 public void Unification_FromFx99 ()
1211                 {
1212                         Unification (String.Format (PermissionPattern, "9.99.999.9999"));
1213                 }
1214         }
1215 }