mcs/class/System/Test/System.Security.Permissions/ResourcePermissionBaseTest.cs

   1 //
   2 // ResourcePermissionBaseTest.cs - NUnit Test Cases for ResourcePermissionBase
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using NUnit.Framework;
  30 using System;
  31 using System.Security;
  32 using System.Security.Permissions;
  33
  34 namespace MonoTests.System.Security.Permissions {
  35
  36         // the publicizer of the protected ;-)
  37         public class NonAbstractResourcePermissionBase : ResourcePermissionBase {
  38
  39                 public NonAbstractResourcePermissionBase () : base ()
  40                 {
  41                 }
  42
  43                 public NonAbstractResourcePermissionBase (PermissionState state)
  44                         : base (state)
  45                 {
  46                 }
  47
  48                 public new Type PermissionAccessType {
  49                         get { return base.PermissionAccessType; }
  50                         set { base.PermissionAccessType = value; }
  51                 }
  52
  53                 public new string [] TagNames {
  54                         get { return base.TagNames; }
  55                         set { base.TagNames = value; }
  56                 }
  57
  58                 public new void AddPermissionAccess (ResourcePermissionBaseEntry entry)
  59                 {
  60                         base.AddPermissionAccess (entry);
  61                 }
  62
  63                 public new void Clear ()
  64                 {
  65                         base.Clear ();
  66                 }
  67
  68                 public new ResourcePermissionBaseEntry [] GetPermissionEntries ()
  69                 {
  70                         return base.GetPermissionEntries ();
  71                 }
  72
  73                 public new void RemovePermissionAccess (ResourcePermissionBaseEntry entry)
  74                 {
  75                         base.RemovePermissionAccess (entry);
  76                 }
  77         }
  78
  79         [TestFixture]
  80         public class ResourcePermissionBaseTest {
  81
  82                 [Test]
  83                 public void Constants ()
  84                 {
  85                         Assert.AreEqual ("*", ResourcePermissionBase.Any, "Any");
  86                         Assert.AreEqual (".", ResourcePermissionBase.Local, "Local");
  87                 }
  88
  89                 private void CheckDefaultValues (string msg, NonAbstractResourcePermissionBase rp, bool unrestricted)
  90                 {
  91                         Assert.IsNull (rp.PermissionAccessType, msg + "-PermissionAccessType");
  92                         Assert.IsNull (rp.TagNames, msg + "-TagNames");
  93                         Assert.AreEqual (unrestricted, rp.IsUnrestricted (), msg + "-IsUnrestricted");
  94                         ResourcePermissionBaseEntry[] entries = rp.GetPermissionEntries ();
  95                         Assert.AreEqual (0, entries.Length, msg + "Count");
  96                 }
  97
  98                 [Test]
  99                 public void Constructor_Empty ()
 100                 {
 101                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 102                         CheckDefaultValues ("original", rp, false);
 103                         NonAbstractResourcePermissionBase copy = (NonAbstractResourcePermissionBase) rp.Copy ();
 104                         CheckDefaultValues ("copy", rp, false);
 105                 }
 106
 107                 [Test]
 108                 public void Constructor_None ()
 109                 {
 110                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase (PermissionState.None);
 111                         CheckDefaultValues ("original", rp, false);
 112                         NonAbstractResourcePermissionBase copy = (NonAbstractResourcePermissionBase)rp.Copy ();
 113                         CheckDefaultValues ("copy", rp, false);
 114                 }
 115
 116                 [Test]
 117                 public void Constructor_Unrestricted ()
 118                 {
 119                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase (PermissionState.Unrestricted);
 120                         CheckDefaultValues ("original", rp, true);
 121                         NonAbstractResourcePermissionBase copy = (NonAbstractResourcePermissionBase)rp.Copy ();
 122                         CheckDefaultValues ("copy", rp, true);
 123                 }
 124
 125                 [Test]
 126                 [ExpectedException (typeof (ArgumentException))]
 127                 public void Constructor_Invalid ()
 128                 {
 129                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ((PermissionState)Int32.MaxValue);
 130                         CheckDefaultValues ("original", rp, false);
 131                         NonAbstractResourcePermissionBase copy = (NonAbstractResourcePermissionBase)rp.Copy ();
 132                         CheckDefaultValues ("copy", rp, false);
 133                 }
 134
 135                 [Test]
 136                 [ExpectedException (typeof (ArgumentNullException))]
 137                 public void PermissionAccessType_Null ()
 138                 {
 139                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 140                         rp.PermissionAccessType = null;
 141                 }
 142
 143                 [Test]
 144                 [ExpectedException (typeof (ArgumentException))]
 145                 public void PermissionAccessType_NonEnum ()
 146                 {
 147                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 148                         rp.PermissionAccessType = typeof (NonAbstractResourcePermissionBase);
 149                 }
 150
 151                 [Test]
 152                 public void PermissionAccessType ()
 153                 {
 154                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 155                         rp.PermissionAccessType = typeof (PermissionState);
 156                         Assert.AreEqual (typeof (PermissionState), rp.PermissionAccessType, "PermissionAccessType");
 157                 }
 158
 159                 [Test]
 160                 [ExpectedException (typeof (ArgumentNullException))]
 161                 public void TagNames_Null ()
 162                 {
 163                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 164                         rp.TagNames = null;
 165                 }
 166
 167                 [Test]
 168                 [ExpectedException (typeof (ArgumentException))]
 169                 public void TagNames_Length ()
 170                 {
 171                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 172                         rp.TagNames = new string [0];
 173                 }
 174
 175                 [Test]
 176                 public void TagNames ()
 177                 {
 178                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 179                         rp.TagNames = new string [2] { "Mono", "Novell" };
 180                         Assert.AreEqual (2, rp.TagNames.Length, "TagNames");
 181                         Assert.AreEqual ("Mono", rp.TagNames [0], "TagNames-1");
 182                         Assert.AreEqual ("Novell", rp.TagNames [1], "TagNames-2");
 183                 }
 184
 185                 [Test]
 186                 [ExpectedException (typeof (ArgumentNullException))]
 187                 public void AddPermissionAccess_Null ()
 188                 {
 189                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 190                         rp.AddPermissionAccess (null);
 191                 }
 192
 193                 [Test]
 194                 [ExpectedException (typeof (InvalidOperationException))]
 195                 public void AddPermissionAccess_MismatchTag ()
 196                 {
 197                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 198                         rp.TagNames = new string [1] { "Monkeys" };
 199                         rp.AddPermissionAccess (new ResourcePermissionBaseEntry ());
 200                 }
 201
 202                 [Test]
 203                 public void AddPermissionAccess ()
 204                 {
 205                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 206                         rp.TagNames = new string [1] { "Monkeys" };
 207                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 208                         rp.AddPermissionAccess (entry);
 209
 210                         ResourcePermissionBaseEntry[] entries = rp.GetPermissionEntries ();
 211                         Assert.AreEqual (1, entries.Length, "Count");
 212                 }
 213
 214                 [Test]
 215                 [ExpectedException (typeof (InvalidOperationException))]
 216                 public void AddPermissionAccess_Duplicates_SameInstance ()
 217                 {
 218                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 219                         rp.TagNames = new string [1] { "Monkeys" };
 220                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 221                         rp.AddPermissionAccess (entry);
 222                         rp.AddPermissionAccess (entry);
 223                 }
 224
 225                 [Test]
 226                 [ExpectedException (typeof (InvalidOperationException))]
 227                 public void AddPermissionAccess_Duplicates_DifferentInstances ()
 228                 {
 229                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 230                         rp.TagNames = new string [1] { "Monkeys" };
 231                         ResourcePermissionBaseEntry entry1 = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 232                         rp.AddPermissionAccess (entry1);
 233                         ResourcePermissionBaseEntry entry2 = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 234                         rp.AddPermissionAccess (entry2);
 235                 }
 236
 237                 [Test]
 238                 public void AddPermissionAccess_SemiDuplicates ()
 239                 {
 240                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 241                         rp.TagNames = new string [2] { "Monkeys", "Singes" };
 242                         ResourcePermissionBaseEntry entry1 = new ResourcePermissionBaseEntry (0, new string [2] { "1", "2" });
 243                         rp.AddPermissionAccess (entry1);
 244                         ResourcePermissionBaseEntry entry2 = new ResourcePermissionBaseEntry (0, new string [2] { "2", "1" });
 245                         rp.AddPermissionAccess (entry2);
 246                 }
 247
 248                 [Test]
 249                 public void Clear ()
 250                 {
 251                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 252                         rp.TagNames = new string [1] { "Monkeys" };
 253
 254                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 255                         rp.AddPermissionAccess (entry);
 256                         ResourcePermissionBaseEntry [] entries = rp.GetPermissionEntries ();
 257                         Assert.AreEqual (1, entries.Length, "Count");
 258
 259                         rp.Clear ();
 260                         entries = rp.GetPermissionEntries ();
 261                         Assert.AreEqual (0, entries.Length, "Count");
 262                 }
 263
 264                 [Test]
 265                 public void Copy ()
 266                 {
 267                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 268                         rp.PermissionAccessType = typeof (PermissionState);
 269                         rp.TagNames = new string [1] { "Monkeys" };
 270
 271                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 272                         rp.AddPermissionAccess (entry);
 273
 274                         NonAbstractResourcePermissionBase copy = (NonAbstractResourcePermissionBase) rp.Copy ();
 275                         Assert.AreEqual (typeof (PermissionState), copy.PermissionAccessType, "PermissionAccessType");
 276                         Assert.AreEqual ("Monkeys", copy.TagNames [0], "TagNames");
 277
 278                         ResourcePermissionBaseEntry [] entries = copy.GetPermissionEntries ();
 279                         Assert.AreEqual (1, entries.Length, "Count");
 280                 }
 281
 282                 [Test]
 283                 [ExpectedException (typeof (ArgumentNullException))]
 284                 public void FromXml_Null ()
 285                 {
 286                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 287                         rp.FromXml (null);
 288                 }
 289
 290                 [Test]
 291                 [ExpectedException (typeof (ArgumentException))]
 292                 public void FromXml_WrongTag ()
 293                 {
 294                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 295                         SecurityElement se = rp.ToXml ();
 296                         se.Tag = "IMono"; // instead of IPermission
 297                         rp.FromXml (se);
 298                 }
 299
 300                 [Test]
 301                 [ExpectedException (typeof (ArgumentException))]
 302                 public void FromXml_WrongTagCase ()
 303                 {
 304                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 305                         SecurityElement se = rp.ToXml ();
 306                         se.Tag = "IPERMISSION"; // instead of IPermission
 307                         rp.FromXml (se);
 308                 }
 309
 310                 [Test]
 311                 public void FromXml_WrongClass ()
 312                 {
 313                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 314                         SecurityElement se = rp.ToXml ();
 315
 316                         SecurityElement w = new SecurityElement (se.Tag);
 317                         w.AddAttribute ("class", "Wrong" + se.Attribute ("class"));
 318                         w.AddAttribute ("version", se.Attribute ("version"));
 319                         rp.FromXml (w);
 320                         // doesn't care of the class name at that stage
 321                         // anyway the class has already be created so...
 322                 }
 323
 324                 [Test]
 325                 public void FromXml_NoClass ()
 326                 {
 327                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 328                         SecurityElement se = rp.ToXml ();
 329
 330                         SecurityElement w = new SecurityElement (se.Tag);
 331                         w.AddAttribute ("version", se.Attribute ("version"));
 332                         rp.FromXml (w);
 333                         // doesn't even care of the class attribute presence
 334                 }
 335
 336                 [Test]
 337                 [ExpectedException (typeof (ArgumentException))]
 338                 public void FromXml_WrongVersion ()
 339                 {
 340                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 341                         SecurityElement se = rp.ToXml ();
 342
 343                         SecurityElement w = new SecurityElement (se.Tag);
 344                         w.AddAttribute ("class", se.Attribute ("class"));
 345                         w.AddAttribute ("version", "2");
 346                         rp.FromXml (w);
 347                 }
 348
 349                 [Test]
 350                 public void FromXml_NoVersion ()
 351                 {
 352                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 353                         SecurityElement se = rp.ToXml ();
 354
 355                         SecurityElement w = new SecurityElement (se.Tag);
 356                         w.AddAttribute ("class", se.Attribute ("class"));
 357                         rp.FromXml (w);
 358                 }
 359
 360                 [Test]
 361                 public void GetPermissionEntries ()
 362                 {
 363                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 364                         ResourcePermissionBaseEntry[] entries = rp.GetPermissionEntries ();
 365                         Assert.AreEqual (0, entries.Length, "Empty");
 366
 367                         rp.PermissionAccessType = typeof (PermissionState);
 368                         rp.TagNames = new string [1] { "Monkeys" };
 369                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 370                         rp.AddPermissionAccess (entry);
 371
 372                         entries = rp.GetPermissionEntries ();
 373                         Assert.AreEqual (1, entries.Length, "Count==1");
 374
 375                         rp.Clear ();
 376                         entries = rp.GetPermissionEntries ();
 377                         Assert.AreEqual (0, entries.Length, "Count==0");
 378                 }
 379
 380                 [Test]
 381                 [ExpectedException (typeof (ArgumentException))]
 382                 public void Intersect_DifferentPermissions ()
 383                 {
 384                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 385                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 386                         rp.Intersect (b);
 387                 }
 388
 389                 [Test]
 390                 public void IsSubsetOf_DifferentPermissions ()
 391                 {
 392                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 393                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 394                         // normally (other permissions) this would throw an ArgumentException
 395                         Assert.IsFalse (rp.IsSubsetOf (b));
 396                 }
 397
 398                 [Test]
 399                 [ExpectedException (typeof (ArgumentNullException))]
 400                 public void RemovePermissionAccess_Null ()
 401                 {
 402                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 403                         rp.RemovePermissionAccess (null);
 404                 }
 405
 406                 [Test]
 407                 [ExpectedException (typeof (InvalidOperationException))]
 408                 public void RemovePermissionAccess_MismatchTag ()
 409                 {
 410                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 411                         rp.TagNames = new string [1] { "Monkeys" };
 412                         rp.RemovePermissionAccess (new ResourcePermissionBaseEntry ());
 413                 }
 414
 415                 [Test]
 416                 public void RemovePermissionAccess ()
 417                 {
 418                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 419                         rp.TagNames = new string [1] { "Monkeys" };
 420
 421                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 422                         rp.AddPermissionAccess (entry);
 423
 424                         ResourcePermissionBaseEntry[] entries = rp.GetPermissionEntries ();
 425                         Assert.AreEqual (1, entries.Length, "Count==1");
 426
 427                         rp.RemovePermissionAccess (entry);
 428                         entries = rp.GetPermissionEntries ();
 429                         Assert.AreEqual (0, entries.Length, "Count==0");
 430                 }
 431
 432                 [Test]
 433                 [ExpectedException (typeof (InvalidOperationException))]
 434                 public void RemovePermissionAccess_Unexisting ()
 435                 {
 436                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 437                         rp.TagNames = new string [1] { "Monkeys" };
 438
 439                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 440                         rp.RemovePermissionAccess (entry);
 441                 }
 442
 443                 private void CheckCommonXml (string msg, SecurityElement se)
 444                 {
 445                         Assert.AreEqual ("IPermission", se.Tag, msg + "Tag");
 446                         Assert.IsTrue (se.Attribute ("class").StartsWith ("MonoTests.System.Security.Permissions.NonAbstractResourcePermissionBase, "), msg + "class");
 447                         Assert.AreEqual ("1", se.Attribute ("version"), msg + "version");
 448                 }
 449
 450                 [Test]
 451                 public void ToXml ()
 452                 {
 453                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 454                         rp.TagNames = new string [1] { "Monkeys" };
 455                         SecurityElement se = rp.ToXml ();
 456                         CheckCommonXml ("empty", se);
 457                         Assert.AreEqual (2, se.Attributes.Count, "#attributes");
 458                         Assert.IsNull (se.Children, "Children");
 459
 460                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 461                         rp.AddPermissionAccess (entry);
 462                         se = rp.ToXml ();
 463                         CheckCommonXml ("one", se);
 464                         Assert.AreEqual (2, se.Attributes.Count, "#attributes");
 465                         Assert.AreEqual (1, se.Children.Count, "1-Children");
 466                         SecurityElement child = (SecurityElement) se.Children [0];
 467                         Assert.AreEqual ("Monkeys", child.Tag, "Monkeys");
 468                         Assert.AreEqual ("Singes", child.Attribute ("name"), "Singes");
 469                 }
 470
 471                 [Test]
 472                 public void ToXml_Unrestricted ()
 473                 {
 474                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase (PermissionState.Unrestricted);
 475                         rp.TagNames = new string [1] { "Monkeys" };
 476                         SecurityElement se = rp.ToXml ();
 477                         CheckCommonXml ("empty", se);
 478                         Assert.AreEqual (3, se.Attributes.Count, "#attributes");
 479                         Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "Unrestricted");
 480                         Assert.IsNull (se.Children, "Children");
 481
 482                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 483                         rp.AddPermissionAccess (entry);
 484                         se = rp.ToXml ();
 485                         CheckCommonXml ("one", se);
 486                         Assert.AreEqual (3, se.Attributes.Count, "#attributes");
 487                         // not XML output of childrens for unrestricted
 488                         Assert.IsNull (se.Children, "Children");
 489                 }
 490
 491                 [Test]
 492                 public void Union ()
 493                 {
 494                         NonAbstractResourcePermissionBase a = new NonAbstractResourcePermissionBase ();
 495                         NonAbstractResourcePermissionBase z = (NonAbstractResourcePermissionBase) a.Union (null);
 496                         CheckDefaultValues ("Empty U null", z, false);
 497                         Assert.IsFalse (Object.ReferenceEquals (a, z), "!ReferenceEquals1");
 498
 499                         NonAbstractResourcePermissionBase b = new NonAbstractResourcePermissionBase (PermissionState.None);
 500                         z = (NonAbstractResourcePermissionBase) a.Union (b);
 501                         Assert.IsNull (z, "Empty U Empty");
 502
 503                         NonAbstractResourcePermissionBase u = new NonAbstractResourcePermissionBase (PermissionState.Unrestricted);
 504                         z = (NonAbstractResourcePermissionBase) u.Union (b);
 505                         CheckDefaultValues ("Unrestricted U Empty", z, true);
 506                         Assert.IsFalse (Object.ReferenceEquals (u, z), "!ReferenceEquals2");
 507                         Assert.IsFalse (Object.ReferenceEquals (b, z), "!ReferenceEquals3");
 508
 509                         z = (NonAbstractResourcePermissionBase)b.Union (u);
 510                         CheckDefaultValues ("Empty U Unrestricted", z, true);
 511                         Assert.IsFalse (Object.ReferenceEquals (u, z), "!ReferenceEquals4");
 512                         Assert.IsFalse (Object.ReferenceEquals (b, z), "!ReferenceEquals5");
 513                 }
 514
 515                 [Test]
 516                 [ExpectedException (typeof (ArgumentException))]
 517                 public void Union_DifferentPermissions ()
 518                 {
 519                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 520                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 521                         rp.Union (b);
 522                 }
 523
 524                 [Test]
 525                 public void Unrestricted_AddRemove ()
 526                 {
 527                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase (PermissionState.Unrestricted);
 528                         rp.TagNames = new string [1] { "Monkeys" };
 529
 530                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 531                         rp.AddPermissionAccess (entry);
 532
 533                         ResourcePermissionBaseEntry [] entries = rp.GetPermissionEntries ();
 534                         Assert.AreEqual (1, entries.Length, "Count==1");
 535
 536                         rp.RemovePermissionAccess (entry);
 537                         entries = rp.GetPermissionEntries ();
 538                         Assert.AreEqual (0, entries.Length, "Count==0");
 539                 }
 540         }
 541 }