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 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 ());
  51                 }
  52
  53                 [Test]
  54                 public void PermissionStateUnrestricted ()
  55                 {
  56                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
  57                         Assert ("PermissionStateUnrestricted.IsUnrestricted", ps.IsUnrestricted ());
  58                         Assert ("PermissionStateUnrestricted.IsEmpty", !ps.IsEmpty ());
  59                         Assert ("PermissionStateUnrestricted.IsReadOnly", !ps.IsReadOnly);
  60                         AssertEquals ("PermissionStateUnrestricted.ToXml().ToString()==ToString()", ps.ToXml ().ToString (), ps.ToString ());
  61                 }
  62
  63                 [Test]
  64                 public void PermissionSetNull ()
  65                 {
  66                         // no exception is thrown
  67                         PermissionSet ps = new PermissionSet (null);
  68 #if NET_2_0
  69                         Assert ("PermissionStateNull.IsUnrestricted", !ps.IsUnrestricted ());
  70                         Assert ("PermissionStateNull.IsEmpty", ps.IsEmpty ());
  71 #else
  72                         Assert ("PermissionStateNull.IsUnrestricted", ps.IsUnrestricted ());
  73                         Assert ("PermissionStateNull.IsEmpty", !ps.IsEmpty ());
  74 #endif
  75                         Assert ("PermissionStateNull.IsReadOnly", !ps.IsReadOnly);
  76                         AssertEquals ("PermissionStateNull.ToXml().ToString()==ToString()", ps.ToXml ().ToString (), ps.ToString ());
  77                 }
  78
  79                 [Test]
  80                 public void PermissionSetPermissionSet ()
  81                 {
  82                         FileDialogPermission fdp = new FileDialogPermission (FileDialogPermissionAccess.Open);
  83                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
  84                         ps1.AddPermission (fdp);
  85                         Assert ("ps1.IsEmpty", !ps1.IsEmpty ());
  86
  87                         PermissionSet ps = new PermissionSet (ps1);
  88                         Assert ("PermissionSetPermissionSet.IsUnrestricted", !ps.IsUnrestricted ());
  89                         Assert ("PermissionSetPermissionSet.IsEmpty", !ps.IsEmpty ());
  90                         Assert ("PermissionSetPermissionSet.IsReadOnly", !ps.IsReadOnly);
  91                         AssertEquals ("PermissionSetPermissionSet.ToXml().ToString()==ToString()", ps.ToXml ().ToString (), ps.ToString ());
  92                 }
  93
  94                 [Test]
  95                 public void PermissionSetNamedPermissionSet ()
  96                 {
  97                         NamedPermissionSet nps = new NamedPermissionSet ("Test", PermissionState.Unrestricted);
  98                         PermissionSet ps = new PermissionSet (nps);
  99                         Assert ("IsUnrestricted", ps.IsUnrestricted ());
 100                 }
 101
 102                 [Test]
 103                 public void AddPermission ()
 104                 {
 105                         SecurityPermission sp1 = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
 106                         SecurityPermission sp2 = new SecurityPermission (SecurityPermissionFlag.ControlPolicy);
 107                         PermissionSet ps = new PermissionSet (PermissionState.None);
 108                         SecurityPermission result = (SecurityPermission)ps.AddPermission (sp1);
 109                         AssertEquals ("1-ControlEvidence", 1, ps.Count);
 110                         AssertEquals ("Flags-1", SecurityPermissionFlag.ControlEvidence, result.Flags);
 111
 112                         result = (SecurityPermission)ps.AddPermission (sp2);
 113                         AssertEquals ("1-ControlEvidence+ControlPolicy", 1, ps.Count);
 114                         AssertEquals ("Flags-2", SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags);
 115
 116                         result = (SecurityPermission)ps.AddPermission (sp2);
 117                         AssertEquals ("no change-1", 1, ps.Count);
 118                         AssertEquals ("Flags-3", SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags);
 119
 120                         result = (SecurityPermission)ps.AddPermission (sp1);
 121                         AssertEquals ("no change-2", 1, ps.Count);
 122                         AssertEquals ("Flags-4", SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags);
 123                 }
 124
 125                 [Test]
 126                 public void AddPermission_Null ()
 127                 {
 128                         PermissionSet ps = new PermissionSet (PermissionState.None);
 129                         IPermission result = ps.AddPermission (null);
 130                         AssertNull ("Add(null)", result);
 131                         AssertEquals ("0", 0, ps.Count);
 132                 }
 133
 134                 [Test]
 135                 public void AddPermission_SetUnrestricted ()
 136                 {
 137                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 138                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
 139                         IPermission result = ps.AddPermission (sp);
 140                         AssertNotNull ("Add(SecurityPermission)", result);
 141                         AssertEquals ("SecurityPermission", SecurityPermissionFlag.AllFlags, (result as SecurityPermission).Flags);
 142                         AssertEquals ("0", 0, ps.Count);
 143                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 144                         result = ps.AddPermission (zip);
 145                         AssertNotNull ("Add(ZoneIdentityPermission)", result);
 146 #if NET_2_0
 147                         // Identity permissions aren't added to unrestricted permission sets in 2.0
 148                         AssertEquals ("ZoneIdentityPermission", SecurityZone.NoZone, (result as ZoneIdentityPermission).SecurityZone);
 149                         AssertEquals ("1", 0, ps.Count);
 150 #else
 151                         AssertEquals ("ZoneIdentityPermission", zip.SecurityZone, (result as ZoneIdentityPermission).SecurityZone);
 152                         AssertEquals ("1", 1, ps.Count);
 153 #endif
 154                 }
 155
 156                 [Test]
 157                 public void AddPermission_PermissionUnrestricted ()
 158                 {
 159                         PermissionSet ps = new PermissionSet (PermissionState.None);
 160                         SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
 161                         IPermission result = ps.AddPermission (sp);
 162                         AssertNotNull ("Add(SecurityPermission)", result);
 163                         AssertEquals ("SecurityPermission", SecurityPermissionFlag.AllFlags, (result as SecurityPermission).Flags);
 164                         AssertEquals ("1", 1, ps.Count);
 165                         Assert ("State", !ps.IsUnrestricted ());
 166                 }
 167
 168                 [Test]
 169                 public void AddPermission_NoCopy ()
 170                 {
 171                         PermissionSet ps = new PermissionSet (PermissionState.None);
 172                         SecurityPermission sp1 = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
 173                         SecurityPermission result = (SecurityPermission)ps.AddPermission (sp1);
 174                         SecurityPermission entry = (SecurityPermission)ps.GetPermission (typeof (SecurityPermission));
 175
 176                         // are they the same (reference) or different ?
 177                         sp1.Flags = SecurityPermissionFlag.AllFlags;
 178
 179                         result.Flags = SecurityPermissionFlag.Assertion;
 180                 }
 181
 182                 [Test]
 183                 public void ContainsNonCodeAccessPermissions ()
 184                 {
 185                         PermissionSet ps = new PermissionSet (PermissionState.None);
 186                         Assert ("Empty", !ps.ContainsNonCodeAccessPermissions ());
 187
 188                         SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
 189                         ps.AddPermission (sp);
 190                         Assert ("SecurityPermission", !ps.ContainsNonCodeAccessPermissions ());
 191
 192                         PrincipalPermission pp = new PrincipalPermission ("mono", "hacker");
 193                         ps.AddPermission (pp);
 194                         Assert ("PrincipalPermission", ps.ContainsNonCodeAccessPermissions ());
 195                 }
 196
 197                 [Test]
 198                 [ExpectedException (typeof (ArgumentNullException))]
 199                 public void ConvertPermissionSet_NullIn ()
 200                 {
 201                         PermissionSet.ConvertPermissionSet (null, new byte [0], "XML");
 202                 }
 203
 204                 [Test]
 205                 public void ConvertPermissionSet_UnknownIn ()
 206                 {
 207                         byte[] result = PermissionSet.ConvertPermissionSet (String.Empty, new byte [0], "XML");
 208                         AssertNull (result);
 209                 }
 210
 211                 [Test]
 212                 public void ConvertPermissionSet_NullData ()
 213                 {
 214                         byte[] result = PermissionSet.ConvertPermissionSet ("BINARY", null, "XML");
 215                         AssertNull (result);
 216                 }
 217
 218                 [Test]
 219                 [ExpectedException (typeof (ArgumentNullException))]
 220                 public void ConvertPermissionSet_NullOut ()
 221                 {
 222                         PermissionSet.ConvertPermissionSet ("BINARY", new byte [0], null);
 223                 }
 224
 225                 [Test]
 226                 [ExpectedException (typeof (SerializationException))]
 227                 public void ConvertPermissionSet_UnknownOut ()
 228                 {
 229                         PermissionSet.ConvertPermissionSet ("BINARY", new byte [0], String.Empty);
 230                 }
 231
 232                 [Test]
 233 #if !NET_2_0
 234                 [Ignore ("Don't know why it doesn't work under Fx 1.1")]
 235 #endif
 236                 public void ConvertPermissionSet_BinaryToBinary ()
 237                 {
 238                         PermissionSet ps = new PermissionSet (PermissionState.None);
 239                         byte[] data = Encoding.ASCII.GetBytes (ps.ToString ());
 240                         byte[] result = PermissionSet.ConvertPermissionSet ("XML", data, "BINARY");
 241
 242                         byte[] result2 = PermissionSet.ConvertPermissionSet ("BINARY", result, "BINARY");
 243                         // there's only a little difference - but it doesn't throw an exception
 244                         //Assert ("BINARY!=BINARY", BitConverter.ToString (result) != BitConverter.ToString (result2));
 245                 }
 246
 247                 [Test]
 248 #if !NET_2_0
 249                 [Ignore ("Don't know why it doesn't work under Fx 1.1")]
 250 #endif
 251                 public void ConvertPermissionSet_XmlToBinary ()
 252                 {
 253                         PermissionSet ps = new PermissionSet (PermissionState.None);
 254                         byte[] data = Encoding.ASCII.GetBytes (ps.ToString ());
 255                         byte[] result = PermissionSet.ConvertPermissionSet ("XML", data, "BINARY");
 256                         byte[] result2 = PermissionSet.ConvertPermissionSet ("XMLASCII", data, "BINARY");
 257                         AssertEquals ("XML==XMLASCII", BitConverter.ToString (result), BitConverter.ToString (result2));
 258                         byte[] back = PermissionSet.ConvertPermissionSet ("BINARY", result, "XML");
 259                         AssertEquals ("PS-XML", Encoding.ASCII.GetString (back), ps.ToString ());
 260                         back = PermissionSet.ConvertPermissionSet ("BINARY", result2, "XMLASCII");
 261                         AssertEquals ("PS-XMLASCII", Encoding.ASCII.GetString (back), ps.ToString ());
 262                 }
 263
 264                 [Test]
 265                 public void ConvertPermissionSet_XmlToXml ()
 266                 {
 267                         PermissionSet ps = new PermissionSet (PermissionState.None);
 268                         byte[] data = Encoding.ASCII.GetBytes (ps.ToString ());
 269                         byte[] result = PermissionSet.ConvertPermissionSet ("XML", data, "XML");
 270                         AssertEquals ("PS-XML", Encoding.ASCII.GetString (result), ps.ToString ());
 271
 272                         result = PermissionSet.ConvertPermissionSet ("XMLASCII", data, "XMLASCII");
 273                         AssertEquals ("PS-XMLASCII", Encoding.ASCII.GetString (result), ps.ToString ());
 274                 }
 275
 276                 [Test]
 277 #if NET_2_0
 278                 [ExpectedException (typeof (XmlSyntaxException))]
 279 #else
 280                 [ExpectedException (typeof (ArgumentException))]
 281 #endif
 282                 public void ConvertPermissionSet_XmlAsciiToXmlUnicode ()
 283                 {
 284                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 285                         byte[] data = Encoding.Unicode.GetBytes (ps.ToString ());
 286                         byte[] result = PermissionSet.ConvertPermissionSet ("XMLASCII", data, "XMLUNICODE");
 287                         // the method isn't intended to convert between ASCII and Unicode
 288                 }
 289
 290                 [Test]
 291                 public void Copy_None ()
 292                 {
 293                         PermissionSet ps = new PermissionSet (PermissionState.None);
 294                         PermissionSet copy = ps.Copy ();
 295                         Assert ("1.State", !copy.IsUnrestricted ());
 296                         AssertEquals ("1.Count", 0, copy.Count);
 297
 298                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
 299                         IPermission result = ps.AddPermission (sp);
 300                         AssertNotNull ("1.Add", result);
 301                         copy = ps.Copy ();
 302                         Assert ("2.State", !copy.IsUnrestricted ());
 303                         AssertEquals ("2.Count", 1, copy.Count);
 304
 305                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 306                         result = ps.AddPermission (zip);
 307                         AssertNotNull ("2.Add", result);
 308                         copy = ps.Copy ();
 309                         Assert ("3.State", !copy.IsUnrestricted ());
 310                         AssertEquals ("3.Count", 2, copy.Count);
 311                 }
 312
 313                 [Test]
 314                 public void Copy_Unrestricted ()
 315                 {
 316                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 317                         PermissionSet copy = ps.Copy ();
 318                         Assert ("1.State", copy.IsUnrestricted ());
 319                         AssertEquals ("1.Count", 0, copy.Count);
 320
 321                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
 322                         IPermission result = ps.AddPermission (sp);
 323                         AssertNotNull ("1.Add", result);
 324                         copy = ps.Copy ();
 325                         Assert ("2.State", copy.IsUnrestricted ());
 326                         AssertEquals ("2.Count", 0, copy.Count);
 327
 328                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 329                         result = ps.AddPermission (zip);
 330                         AssertNotNull ("2.Add", result);
 331                         copy = ps.Copy ();
 332                         Assert ("3.State", copy.IsUnrestricted ());
 333 #if NET_2_0
 334                         // Identity permissions aren't added to unrestricted permission sets in 2.0
 335                         AssertEquals ("3.Count", 0, copy.Count);
 336 #else
 337                         AssertEquals ("3.Count", 1, copy.Count);
 338 #endif
 339                 }
 340
 341                 [Test]
 342                 [ExpectedException (typeof (ArgumentNullException))]
 343                 public void CopyTo_Null ()
 344                 {
 345                         PermissionSet ps = new PermissionSet (PermissionState.None);
 346                         ps.CopyTo (null, 0);
 347                 }
 348
 349                 [Test]
 350                 public void CopyTo_Rank_Empty ()
 351                 {
 352                         IPermission[,] pa = new IPermission [1,1];
 353                         PermissionSet ps = new PermissionSet (PermissionState.None);
 354                         ps.CopyTo (pa, 0);
 355                 }
 356
 357                 [Test]
 358                 [ExpectedException (typeof (ArgumentException))]
 359                 public void CopyTo_Rank ()
 360                 {
 361                         IPermission [,] pa = new IPermission [1, 1];
 362                         PermissionSet ps = new PermissionSet (PermissionState.None);
 363                         ps.AddPermission (new SecurityPermission (SecurityPermissionFlag.Assertion));
 364                         ps.CopyTo (pa, 0);
 365                 }
 366
 367                 [Test]
 368                 public void CopyTo_NegativeIndex_Empty ()
 369                 {
 370                         IPermission[] pa = new IPermission [1];
 371                         PermissionSet ps = new PermissionSet (PermissionState.None);
 372                         ps.CopyTo (pa, Int32.MinValue);
 373                 }
 374
 375                 [Test]
 376                 [ExpectedException (typeof (IndexOutOfRangeException))]
 377                 public void CopyTo_NegativeIndex ()
 378                 {
 379                         IPermission [] pa = new IPermission [1];
 380                         PermissionSet ps = new PermissionSet (PermissionState.None);
 381                         ps.AddPermission (new SecurityPermission (SecurityPermissionFlag.Assertion));
 382                         ps.CopyTo (pa, Int32.MinValue);
 383                 }
 384
 385                 [Test]
 386                 public void CopyTo_IndexOverLength_Empty ()
 387                 {
 388                         IPermission [] pa = new IPermission [1];
 389                         PermissionSet ps = new PermissionSet (PermissionState.None);
 390                         ps.CopyTo (pa, pa.Length);
 391                 }
 392
 393                 [Test]
 394                 [ExpectedException (typeof (IndexOutOfRangeException))]
 395                 public void CopyTo_IndexOverLength ()
 396                 {
 397                         IPermission [] pa = new IPermission [1];
 398                         PermissionSet ps = new PermissionSet (PermissionState.None);
 399                         ps.AddPermission (new SecurityPermission (SecurityPermissionFlag.Assertion));
 400                         ps.CopyTo (pa, pa.Length);
 401                 }
 402
 403                 [Test]
 404                 public void CopyTo ()
 405                 {
 406                         IPermission [] pa = new IPermission [1];
 407                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 408                         PermissionSet ps = new PermissionSet (PermissionState.None);
 409                         ps.AddPermission (sp);
 410                         ps.CopyTo (pa, 0);
 411                         AssertEquals ("CopyTo", pa [0].ToString (), sp.ToString ());
 412                         Assert ("Reference", Object.ReferenceEquals (pa [0], sp));
 413                 }
 414
 415                 [Test]
 416                 [ExpectedException (typeof (ArgumentNullException))]
 417                 public void FromXmlNull ()
 418                 {
 419                         PermissionSet ps = new PermissionSet (PermissionState.None);
 420                         ps.FromXml (null);
 421                 }
 422
 423                 [Test]
 424                 [ExpectedException (typeof (ArgumentException))]
 425                 public void FromXmlInvalidPermission ()
 426                 {
 427                         PermissionSet ps = new PermissionSet (PermissionState.None);
 428                         SecurityElement se = ps.ToXml ();
 429                         // can't modify - so we create our own
 430                         SecurityElement se2 = new SecurityElement ("InvalidPermissionSet", se.Text);
 431                         se2.AddAttribute ("class", se.Attribute ("class"));
 432                         se2.AddAttribute ("version", se.Attribute ("version"));
 433                         ps.FromXml (se2);
 434                 }
 435
 436                 [Test]
 437                 // [ExpectedException (typeof (ArgumentException))]
 438                 public void FromXmlWrongVersion ()
 439                 {
 440                         PermissionSet ps = new PermissionSet (PermissionState.None);
 441                         SecurityElement se = ps.ToXml ();
 442                         // can't modify - so we create our own
 443                         SecurityElement se2 = new SecurityElement (se.Tag, se.Text);
 444                         se2.AddAttribute ("class", se.Attribute ("class"));
 445                         se2.AddAttribute ("version", "2");
 446                         ps.FromXml (se2);
 447                         // wow - here we accept a version 2 !!!
 448                 }
 449
 450                 [Test]
 451                 public void FromXmlEmpty ()
 452                 {
 453                         PermissionSet ps = new PermissionSet (PermissionState.None);
 454                         SecurityElement se = ps.ToXml ();
 455                         AssertNotNull ("Empty.ToXml()", se);
 456                         AssertEquals ("Empty.Count", 0, ps.Count);
 457
 458                         PermissionSet ps2 = (PermissionSet) ps.Copy ();
 459                         ps2.FromXml (se);
 460                         Assert ("FromXml-Copy.IsUnrestricted", !ps2.IsUnrestricted ());
 461
 462                         se.AddAttribute ("Unrestricted", "true");
 463                         ps2.FromXml (se);
 464                         Assert ("FromXml-Unrestricted.IsUnrestricted", ps2.IsUnrestricted ());
 465                 }
 466
 467                 [Test]
 468                 public void FromXmlOne ()
 469                 {
 470                         FileDialogPermission fdp = new FileDialogPermission (FileDialogPermissionAccess.Open);
 471                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 472                         ps1.AddPermission (fdp);
 473                         Assert ("ps1.IsEmpty", !ps1.IsEmpty ());
 474
 475                         PermissionSet ps = new PermissionSet (ps1);
 476                         SecurityElement se = ps.ToXml ();
 477                         AssertNotNull ("One.ToXml()", se);
 478                         AssertEquals ("One.Count", 1, ps.Count);
 479
 480                         PermissionSet ps2 = (PermissionSet) ps.Copy ();
 481                         ps2.FromXml (se);
 482                         Assert ("FromXml-Copy.IsUnrestricted", !ps2.IsUnrestricted ());
 483                         AssertEquals ("Copy.Count", 1, ps2.Count);
 484
 485                         se.AddAttribute ("Unrestricted", "true");
 486                         ps2.FromXml (se);
 487                         Assert ("FromXml-Unrestricted.IsUnrestricted", ps2.IsUnrestricted ());
 488 #if NET_2_0
 489                         AssertEquals ("Unrestricted.Count", 0, ps2.Count);
 490 #else
 491                         // IPermission not shown in XML but still present in Count
 492                         AssertEquals ("Unrestricted.Count", 1, ps2.Count);
 493 #endif
 494                 }
 495
 496                 [Test]
 497 #if !NET_2_0
 498                 [ExpectedException (typeof (ArgumentException))]
 499 #endif
 500                 public void FromXml_PermissionWithoutNamespace ()
 501                 {
 502                         SecurityElement child = new SecurityElement ("IPermission");
 503                         child.AddAttribute ("class", "EnvironmentPermission");
 504                         child.AddAttribute ("version", "1");
 505                         child.AddAttribute ("Read", "USERNAME");
 506
 507                         SecurityElement se = new SecurityElement ("PermissionSet");
 508                         se.AddAttribute ("class", "PermissionSet");
 509                         se.AddAttribute ("version", "1");
 510                         se.AddChild (child);
 511
 512                         PermissionSet ps = new PermissionSet (PermissionState.None);
 513                         ps.FromXml (se);
 514 #if NET_2_0
 515                         // not enough information but:
 516                         // a. it doesn't fail
 517                         // b. it does work for policies
 518                         AssertEquals ("Count", 0, ps.Count);
 519 #endif
 520                 }
 521
 522                 [Test]
 523 #if !NET_2_0
 524                 [ExpectedException (typeof (ArgumentException))]
 525 #endif
 526                 public void FromXml_PermissionOutsideCorlib ()
 527                 {
 528                         SecurityElement child = new SecurityElement ("IPermission");
 529                         child.AddAttribute ("class", "PrintingPermission");     // System.Drawing
 530                         child.AddAttribute ("version", "1");
 531                         child.AddAttribute ("Level", "DefaultPrinting");
 532
 533                         SecurityElement se = new SecurityElement ("PermissionSet");
 534                         se.AddAttribute ("class", "PermissionSet");
 535                         se.AddAttribute ("version", "1");
 536                         se.AddChild (child);
 537
 538                         PermissionSet ps = new PermissionSet (PermissionState.None);
 539                         ps.FromXml (se);
 540 #if NET_2_0
 541                         // not enough information but:
 542                         // a. it doesn't fail
 543                         // b. it does work for policies
 544                         AssertEquals ("Count", 0, ps.Count);
 545 #endif
 546                 }
 547
 548                 [Test]
 549                 [ExpectedException (typeof (ArgumentException))]
 550                 public void FromXml_WithPermissionWithoutClass ()
 551                 {
 552                         SecurityElement child = new SecurityElement ("IPermission");
 553                         child.AddAttribute ("version", "1");
 554
 555                         SecurityElement se = new SecurityElement ("PermissionSet");
 556                         se.AddAttribute ("class", "PermissionSet");
 557                         se.AddAttribute ("version", "1");
 558                         se.AddChild (child);
 559
 560                         PermissionSet ps = new PermissionSet (PermissionState.None);
 561                         ps.FromXml (se);
 562                 }
 563
 564                 [Test]
 565                 public void GetEnumerator ()
 566                 {
 567                         PermissionSet ps = new PermissionSet (PermissionState.None);
 568                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 569                         ps.AddPermission (sp);
 570                         IEnumerator e = ps.GetEnumerator ();
 571                         AssertNotNull ("GetEnumerator", e);
 572                         int i=0;
 573                         while (e.MoveNext ()) {
 574                                 Assert ("SecurityPermission", e.Current is SecurityPermission);
 575                                 i++;
 576                         }
 577                         AssertEquals ("Count", 1, i);
 578                 }
 579 #if NET_2_0
 580                 [Test]
 581                 public void GetHashCode_ ()
 582                 {
 583                         PermissionSet ps = new PermissionSet (PermissionState.None);
 584                         AssertEquals ("Empty", 0, ps.GetHashCode ());
 585                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 586                         ps.AddPermission (sp);
 587                         Assert ("SecurityPermission", ps.GetHashCode () != 0);
 588                         PermissionSet copy = ps.Copy ();
 589                         Assert ("Copy", ps.GetHashCode () != copy.GetHashCode ());
 590                 }
 591 #endif
 592                 [Test]
 593                 public void GetPermission_None ()
 594                 {
 595                         PermissionSet ps = new PermissionSet (PermissionState.None);
 596                         AssertNull ("Empty", ps.GetPermission (typeof (SecurityPermission)));
 597                 }
 598
 599                 [Test]
 600                 public void GetPermission_Unrestricted ()
 601                 {
 602                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 603                         AssertNull ("Empty", ps.GetPermission (typeof (SecurityPermission)));
 604                 }
 605
 606                 private void Compare (string msg, PermissionSet ps, bool unrestricted, int count)
 607                 {
 608                         AssertNotNull (msg + "-NullCheck", ps);
 609                         Assert (msg + "-State", (ps.IsUnrestricted () == unrestricted));
 610                         AssertEquals (msg + "-Count", count, ps.Count);
 611                 }
 612
 613                 [Test]
 614                 public void Intersect_Empty ()
 615                 {
 616                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 617                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 618                         AssertNull ("None N null", ps1.Intersect (null));
 619                         AssertNull ("None1 N None2", ps1.Intersect (ps2));
 620                         AssertNull ("None2 N None1", ps2.Intersect (ps1));
 621
 622                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 623                         AssertNull ("None1 N Unrestricted", ps1.Intersect (ups1));
 624                         AssertNull ("Unrestricted N None1", ups1.Intersect (ps1));
 625                         AssertNull ("Unrestricted N Null", ups1.Intersect (null));
 626
 627                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
 628                         Compare ("ups1 N ups2", ups1.Intersect (ups2), true, 0);
 629                         Compare ("ups2 N ups1", ups2.Intersect (ups1), true, 0);
 630                 }
 631
 632                 [Test]
 633                 public void Intersect_OnePermission ()
 634                 {
 635                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 636                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 637                         ps1.AddPermission (sp);
 638                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 639                         AssertNull ("PS1 N null", ps1.Intersect (null));
 640                         AssertNull ("PS1 N None", ps1.Intersect (ps2));
 641                         AssertNull ("None N PS1", ps2.Intersect (ps1));
 642
 643                         PermissionSet ps3 = ps1.Copy ();
 644                         Compare ("PS1 N PS3", ps1.Intersect (ps3), false, 1);
 645                         Compare ("PS3 N PS1", ps3.Intersect (ps1), false, 1);
 646
 647                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 648                         Compare ("PS1 N Unrestricted", ps1.Intersect (ups1), false, 1);
 649                         Compare ("Unrestricted N PS1", ups1.Intersect (ps1), false, 1);
 650                 }
 651
 652                 [Test]
 653                 public void Intersect_OneNonIUnrestrictedPermission ()
 654                 {
 655                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 656                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 657                         ps1.AddPermission (zip);
 658                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 659                         AssertNull ("PS1 N null", ps1.Intersect (null));
 660                         AssertNull ("PS1 N None", ps1.Intersect (ps2));
 661                         AssertNull ("None N PS1", ps2.Intersect (ps1));
 662
 663                         PermissionSet ps3 = ps1.Copy ();
 664                         Compare ("PS1 N PS3", ps1.Intersect (ps3), false, 1);
 665                         Compare ("PS3 N PS1", ps3.Intersect (ps1), false, 1);
 666
 667                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 668                         ups1.AddPermission (zip);
 669                         Compare ("PS1 N Unrestricted", ps1.Intersect (ups1), false, 1);
 670                         Compare ("Unrestricted N PS1", ups1.Intersect (ps1), false, 1);
 671
 672                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
 673                         Compare ("UPS1 N UPS2", ups1.Intersect (ups2), true, 0);
 674                         Compare ("UPS2 N UPS1", ups2.Intersect (ups1), true, 0);
 675                         ups2.AddPermission (zip);
 676 #if NET_2_0
 677                         // Identity permissions aren't added to unrestricted permission sets in 2.0
 678                         Compare ("UPS1 N UPS2+ZIP", ups1.Intersect (ups2), true, 0);
 679                         Compare ("UPS2+ZIP N UPS1", ups2.Intersect (ups1), true, 0);
 680 #else
 681                         Compare ("UPS1 N UPS2+ZIP", ups1.Intersect (ups2), true, 1);
 682                         Compare ("UPS2+ZIP N UPS1", ups2.Intersect (ups1), true, 1);
 683 #endif
 684                 }
 685
 686                 [Test]
 687                 public void IsEmpty_None ()
 688                 {
 689                         PermissionSet ps = new PermissionSet (PermissionState.None);
 690                         Assert ("Empty.IsEmpty", ps.IsEmpty ());
 691                         ps.AddPermission (new ZoneIdentityPermission (SecurityZone.NoZone));
 692                         AssertEquals ("Count==1", 1, ps.Count);
 693                         Assert ("Zip.IsEmpty", ps.IsEmpty ());  // yes empty!
 694                 }
 695
 696                 [Test]
 697                 public void IsEmpty_Unrestricted ()
 698                 {
 699                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 700                         Assert ("Unrestricted.IsEmpty", !ps.IsEmpty ());
 701                         ps.AddPermission (new ZoneIdentityPermission (SecurityZone.NoZone));
 702 #if NET_2_0
 703                         // Identity permissions aren't added to unrestricted permission sets in 2.0
 704                         AssertEquals ("Count==0", 0, ps.Count);
 705 #else
 706                         AssertEquals ("Count==1", 1, ps.Count);
 707 #endif
 708                         Assert ("Zip.IsEmpty", !ps.IsEmpty ()); // yes empty!
 709                 }
 710
 711                 [Test]
 712                 public void IsSubset_Empty ()
 713                 {
 714                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 715                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 716                         Assert ("None.IsSubsetOf(null)", ps1.IsSubsetOf (null));
 717                         Assert ("None1.IsSubsetOf(None2)", ps1.IsSubsetOf (ps2));
 718                         Assert ("None2.IsSubsetOf(None1)", ps2.IsSubsetOf (ps1));
 719
 720                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 721                         Assert ("None1.IsSubsetOf(Unrestricted)", ps1.IsSubsetOf (ups1));
 722                         Assert ("Unrestricted.IsSubsetOf(None1)", !ups1.IsSubsetOf (ps1));
 723                         Assert ("Unrestricted.IsSubsetOf(Null)", !ups1.IsSubsetOf (null));
 724
 725                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
 726                         Assert ("ups1IsSubsetOf(ups2)", ups1.IsSubsetOf (ups2));
 727                         Assert ("ups2.IsSubsetOf(ups1)", ups2.IsSubsetOf (ups1));
 728                 }
 729
 730                 [Test]
 731                 public void IsSubset_OnePermission ()
 732                 {
 733                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 734                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 735                         ps1.AddPermission (sp);
 736                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 737                         Assert ("PS1.IsSubset(null)", !ps1.IsSubsetOf (null));
 738                         Assert ("PS1.IsSubset(None)", !ps1.IsSubsetOf (ps2));
 739                         Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));
 740
 741                         PermissionSet ps3 = ps1.Copy ();
 742                         Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));
 743                         Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));
 744
 745                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 746                         Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));
 747                         Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));
 748                 }
 749
 750                 [Test]
 751                 public void IsSubset_OneNonIUnrestrictedPermission ()
 752                 {
 753                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 754                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 755                         ps1.AddPermission (zip);
 756                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 757                         Assert ("PS1.IsSubset(null)", !ps1.IsSubsetOf (null));
 758                         Assert ("PS1.IsSubset(None)", !ps1.IsSubsetOf (ps2));
 759                         Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));
 760
 761                         PermissionSet ps3 = ps1.Copy ();
 762                         Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));
 763                         Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));
 764
 765                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 766                         ups1.AddPermission (zip);
 767                         Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));
 768                         Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));
 769
 770                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
 771 #if NET_2_0
 772                         // as ZoneIdentityPermission isn't added UPS1Z == UPS2
 773                         Assert ("UPS1Z.IsSubset(UPS2)", ups1.IsSubsetOf (ups2));
 774 #else
 775                         Assert ("UPS1Z.IsSubset(UPS2)", !ups1.IsSubsetOf (ups2));
 776 #endif
 777                         Assert ("UPS2.IsSubset(UPS1Z)", ups2.IsSubsetOf (ups1));
 778                         ups2.AddPermission (zip);
 779                         Assert ("UPS1Z.IsSubset(UPS2Z)", ups1.IsSubsetOf (ups2));
 780                         Assert ("UPS2Z.IsSubset(UPS1Z)", ups2.IsSubsetOf (ups1));
 781                 }
 782
 783                 [Test]
 784                 public void RemovePermission_Null ()
 785                 {
 786                         PermissionSet ps = new PermissionSet (PermissionState.None);
 787                         AssertNull (ps.RemovePermission (null));
 788                 }
 789
 790                 [Test]
 791                 public void RemovePermission_None ()
 792                 {
 793                         PermissionSet ps = new PermissionSet (PermissionState.None);
 794                         AssertNull ("Empty", ps.RemovePermission (typeof (SecurityPermission)));
 795                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 796                         ps.AddPermission (sp);
 797                         SecurityPermission removed = (SecurityPermission) ps.RemovePermission (typeof (SecurityPermission));
 798                         AssertNotNull ("SecurityPermission", removed);
 799                         AssertEquals ("Flags", sp.Flags, removed.Flags);
 800                         AssertNull ("Empty-Again", ps.RemovePermission (typeof (SecurityPermission)));
 801                 }
 802
 803                 [Test]
 804                 public void RemovePermission_Unrestricted ()
 805                 {
 806                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 807                         AssertNull ("Empty", ps.RemovePermission (typeof (SecurityPermission)));
 808                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 809                         ps.AddPermission (sp);
 810                         AssertNull ("SecurityPermissionn", ps.RemovePermission (typeof (SecurityPermission)));
 811                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 812                         ps.AddPermission (zip);
 813                         ZoneIdentityPermission removed = (ZoneIdentityPermission)ps.RemovePermission (typeof (ZoneIdentityPermission));
 814 #if NET_2_0
 815                         // identity permissions aren't added to unrestricted permission sets
 816                         // so they cannot be removed later (hence the null)
 817                         AssertNull ("ZoneIdentityPermission", removed);
 818 #else
 819                         AssertNotNull ("ZoneIdentityPermission", removed);
 820 #endif
 821                 }
 822
 823                 [Test]
 824                 public void SetPermission_Null ()
 825                 {
 826                         PermissionSet ps = new PermissionSet (PermissionState.None);
 827                         AssertNull (ps.SetPermission (null));
 828                 }
 829
 830                 [Test]
 831                 public void SetPermission_None ()
 832                 {
 833                         PermissionSet ps = new PermissionSet (PermissionState.None);
 834                         AssertEquals ("Empty", 0, ps.Count);
 835                         Assert ("State-None", !ps.IsUnrestricted ());
 836
 837                         SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
 838                         SecurityPermission result = (SecurityPermission)ps.SetPermission (sp);
 839                         AssertEquals ("SecurityPermission", 1, ps.Count);
 840                         AssertEquals ("Flags", SecurityPermissionFlag.AllFlags, result.Flags);
 841                         Assert ("State-None-2", !ps.IsUnrestricted ());
 842
 843                         sp = new SecurityPermission (SecurityPermissionFlag.ControlAppDomain);
 844                         result = (SecurityPermission)ps.SetPermission (sp);
 845                         AssertEquals ("SecurityPermission-2", 1, ps.Count);
 846                         AssertEquals ("Flags", SecurityPermissionFlag.ControlAppDomain, result.Flags);
 847
 848                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 849                         ZoneIdentityPermission zipr = (ZoneIdentityPermission) ps.SetPermission (zip);
 850                         AssertEquals ("ZoneIdentityPermission", 2, ps.Count);
 851                         AssertEquals ("SecurityZone", SecurityZone.MyComputer, zipr.SecurityZone);
 852
 853                         zip = new ZoneIdentityPermission (SecurityZone.Intranet);
 854                         zipr = (ZoneIdentityPermission)ps.SetPermission (zip);
 855                         AssertEquals ("ZoneIdentityPermission", 2, ps.Count);
 856                         AssertEquals ("SecurityZone", SecurityZone.Intranet, zipr.SecurityZone);
 857                 }
 858
 859                 [Test]
 860                 public void SetPermission_Unrestricted ()
 861                 {
 862                         SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
 863                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 864                         AssertEquals ("Empty", 0, ps.Count);
 865                         Assert ("State-Unrestricted", ps.IsUnrestricted ());
 866
 867                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 868                         ZoneIdentityPermission zipr = (ZoneIdentityPermission)ps.SetPermission (zip);
 869                         AssertEquals ("ZoneIdentityPermission", 1, ps.Count);
 870                         AssertEquals ("SecurityZone", SecurityZone.MyComputer, zipr.SecurityZone);
 871 #if NET_2_0
 872                         // Adding a non unrestricted identity permission now results in
 873                         // a permission set loosing it's unrestricted status
 874                         Assert ("State-Unrestricted-2", !ps.IsUnrestricted ());
 875 #else
 876                         Assert ("State-Unrestricted-2", ps.IsUnrestricted ());
 877 #endif
 878                         zip = new ZoneIdentityPermission (SecurityZone.Intranet);
 879                         zipr = (ZoneIdentityPermission)ps.SetPermission (zip);
 880                         AssertEquals ("ZoneIdentityPermission-2", 1, ps.Count);
 881                         AssertEquals ("SecurityZone-2", SecurityZone.Intranet, zipr.SecurityZone);
 882
 883                         SecurityPermission result = (SecurityPermission)ps.SetPermission (sp);
 884                         AssertEquals ("SecurityPermission", 2, ps.Count);
 885                         AssertEquals ("Flags", SecurityPermissionFlag.AllFlags, result.Flags);
 886                         Assert ("State-None", !ps.IsUnrestricted ());
 887
 888                         sp = new SecurityPermission (SecurityPermissionFlag.ControlAppDomain);
 889                         result = (SecurityPermission)ps.SetPermission (sp);
 890                         AssertEquals ("SecurityPermission-2", 2, ps.Count);
 891                         AssertEquals ("Flags-2", SecurityPermissionFlag.ControlAppDomain, result.Flags);
 892                 }
 893
 894                 [Test]
 895                 public void ToXmlNone ()
 896                 {
 897                         PermissionSet ps = new PermissionSet (PermissionState.None);
 898                         SecurityElement se = ps.ToXml ();
 899                         Assert ("None.ToString().StartsWith", ps.ToString().StartsWith ("<PermissionSet"));
 900                         AssertEquals ("None.class", "System.Security.PermissionSet", (se.Attributes ["class"] as string));
 901                         AssertEquals ("None.version", "1", (se.Attributes ["version"] as string));
 902                         AssertNull ("None.Unrestricted", (se.Attributes ["Unrestricted"] as string));
 903                 }
 904
 905                 [Test]
 906                 public void ToXmlUnrestricted ()
 907                 {
 908                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
 909                         SecurityElement se = ps.ToXml ();
 910                         Assert ("Unrestricted.ToString().StartsWith", ps.ToString().StartsWith ("<PermissionSet"));
 911                         AssertEquals ("Unrestricted.class", "System.Security.PermissionSet", (se.Attributes ["class"] as string));
 912                         AssertEquals ("Unrestricted.version", "1", (se.Attributes ["version"] as string));
 913                         AssertEquals ("Unrestricted.Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
 914                 }
 915
 916                 [Test]
 917                 public void Union_Empty ()
 918                 {
 919                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 920                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 921                         Compare ("None U null", ps1.Union (null), false, 0);
 922                         Compare ("None1 U None2", ps1.Union (ps2), false, 0);
 923                         Compare ("None2 U None1", ps2.Union (ps1), false, 0);
 924
 925                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 926                         Compare ("None1 U Unrestricted", ps1.Union (ups1), true, 0);
 927                         Compare ("Unrestricted U None1", ups1.Union (ps1), true, 0);
 928                         Compare ("Unrestricted U Null", ups1.Union (null), true, 0);
 929
 930                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
 931                         Compare ("ups1 U ups2", ups1.Union (ups2), true, 0);
 932                         Compare ("ups2 U ups1", ups2.Union (ups1), true, 0);
 933                 }
 934
 935                 [Test]
 936                 public void Union_OnePermission ()
 937                 {
 938                         SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
 939                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 940                         ps1.AddPermission (sp);
 941                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 942                         Compare ("PS1 U null", ps1.Union (null), false, 1);
 943                         Compare ("PS1 U None", ps1.Union (ps2), false, 1);
 944                         Compare ("None U PS1", ps2.Union (ps1), false, 1);
 945
 946                         PermissionSet ps3 = ps1.Copy ();
 947                         Compare ("PS1 U PS3", ps1.Union (ps3), false, 1);
 948                         Compare ("PS3 U PS1", ps3.Union (ps1), false, 1);
 949
 950                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 951                         Compare ("PS1 U Unrestricted", ps1.Union (ups1), true, 0);
 952                         Compare ("Unrestricted U PS1", ups1.Union (ps1), true, 0);
 953                 }
 954
 955                 [Test]
 956                 public void Union_OneNonIUnrestrictedPermission ()
 957                 {
 958                         ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
 959                         PermissionSet ps1 = new PermissionSet (PermissionState.None);
 960                         ps1.AddPermission (zip);
 961                         PermissionSet ps2 = new PermissionSet (PermissionState.None);
 962                         Compare ("PS1 U null", ps1.Union (null), false, 1);
 963                         Compare ("PS1 U None", ps1.Union (ps2), false, 1);
 964                         Compare ("None U PS1", ps2.Union (ps1), false, 1);
 965
 966                         PermissionSet ps3 = ps1.Copy ();
 967                         Compare ("PS1 U PS3", ps1.Union (ps3), false, 1);
 968                         Compare ("PS3 U PS1", ps3.Union (ps1), false, 1);
 969
 970                         PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
 971                         ups1.AddPermission (zip);
 972 #if NET_2_0
 973                         // Identity permissions aren't added to unrestricted permission sets in 2.0
 974                         Compare ("PS1 U Unrestricted", ps1.Union (ups1), true, 0);
 975                         Compare ("Unrestricted U PS1", ups1.Union (ps1), true, 0);
 976                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
 977                         Compare ("UPS1 U UPS2", ups1.Union (ups1), true, 0);
 978                         Compare ("UPS2 U UPS1", ups2.Union (ups1), true, 0);
 979                         ups2.AddPermission (zip);
 980                         Compare ("UPS1 U UPS2+ZIP", ups1.Union (ups2), true, 0);
 981                         Compare ("UPS2+ZIP U UPS1", ups2.Union (ups1), true, 0);
 982 #else
 983                         Compare ("PS1 U Unrestricted", ps1.Union (ups1), true, 1);
 984                         Compare ("Unrestricted U PS1", ups1.Union (ps1), true, 1);
 985                         PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
 986                         Compare ("UPS1 U UPS2", ups1.Union (ups1), true, 1);
 987                         Compare ("UPS2 U UPS1", ups2.Union (ups1), true, 1);
 988                         ups2.AddPermission (zip);
 989                         Compare ("UPS1 U UPS2+ZIP", ups1.Union (ups2), true, 1);
 990                         Compare ("UPS2+ZIP U UPS1", ups2.Union (ups1), true, 1);
 991 #endif
 992                 }
 993 #if NET_2_0
 994                 [Test]
 995                 [ExpectedException (typeof (ExecutionEngineException))]
 996                 public void RevertAssert_WithoutAssertion ()
 997                 {
 998                         PermissionSet.RevertAssert ();
 999                 }
1000
1001                 [Test]
1002                 public void RevertAssert_WithAssertion ()
1003                 {
1004                         PermissionSet ups = new PermissionSet (PermissionState.Unrestricted);
1005                         ups.Assert ();
1006                         PermissionSet.RevertAssert ();
1007                 }
1008 #endif
1009                 [Test]
1010                 public void Assert_NonCasPermission ()
1011                 {
1012                         PermissionSet ps = new PermissionSet (PermissionState.None);
1013                         ps.AddPermission (new PrincipalPermission (PermissionState.None));
1014                         Assert ("ContainsNonCodeAccessPermissions", ps.ContainsNonCodeAccessPermissions ());
1015                         AssertEquals ("Count", 1, ps.Count);
1016                         ps.Assert ();
1017                         // it's simply ignored
1018                 }
1019
1020                 [Test]
1021                 public void Deny_NonCasPermission ()
1022                 {
1023                         PermissionSet ps = new PermissionSet (PermissionState.None);
1024                         ps.AddPermission (new PrincipalPermission (PermissionState.None));
1025                         Assert ("ContainsNonCodeAccessPermissions", ps.ContainsNonCodeAccessPermissions ());
1026                         AssertEquals ("Count", 1, ps.Count);
1027                         ps.Deny ();
1028                         // it's simply ignored
1029                 }
1030
1031                 [Test]
1032                 public void PermitOnly_NonCasPermission ()
1033                 {
1034                         PermissionSet ps = new PermissionSet (PermissionState.None);
1035                         ps.AddPermission (new PrincipalPermission (PermissionState.None));
1036                         Assert ("ContainsNonCodeAccessPermissions", ps.ContainsNonCodeAccessPermissions ());
1037                         AssertEquals ("Count", 1, ps.Count);
1038                         ps.PermitOnly ();
1039                         // it's simply ignored
1040                 }
1041         }
1042 }