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