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