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 #if NET_2_0
 127                 [ExpectedException (typeof (ArgumentException))]
 128 #endif
 129                 public void Constructor_Invalid ()
 130                 {
 131                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ((PermissionState)Int32.MaxValue);
 132                         CheckDefaultValues ("original", rp, false);
 133                         NonAbstractResourcePermissionBase copy = (NonAbstractResourcePermissionBase)rp.Copy ();
 134                         CheckDefaultValues ("copy", rp, false);
 135                 }
 136
 137                 [Test]
 138                 [ExpectedException (typeof (ArgumentNullException))]
 139                 public void PermissionAccessType_Null ()
 140                 {
 141                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 142                         rp.PermissionAccessType = null;
 143                 }
 144
 145                 [Test]
 146                 [ExpectedException (typeof (ArgumentException))]
 147                 public void PermissionAccessType_NonEnum ()
 148                 {
 149                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 150                         rp.PermissionAccessType = typeof (NonAbstractResourcePermissionBase);
 151                 }
 152
 153                 [Test]
 154                 public void PermissionAccessType ()
 155                 {
 156                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 157                         rp.PermissionAccessType = typeof (PermissionState);
 158                         Assert.AreEqual (typeof (PermissionState), rp.PermissionAccessType, "PermissionAccessType");
 159                 }
 160
 161                 [Test]
 162                 [ExpectedException (typeof (ArgumentNullException))]
 163                 public void TagNames_Null ()
 164                 {
 165                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 166                         rp.TagNames = null;
 167                 }
 168
 169                 [Test]
 170                 [ExpectedException (typeof (ArgumentException))]
 171                 public void TagNames_Length ()
 172                 {
 173                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 174                         rp.TagNames = new string [0];
 175                 }
 176
 177                 [Test]
 178                 public void TagNames ()
 179                 {
 180                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 181                         rp.TagNames = new string [2] { "Mono", "Novell" };
 182                         Assert.AreEqual (2, rp.TagNames.Length, "TagNames");
 183                         Assert.AreEqual ("Mono", rp.TagNames [0], "TagNames-1");
 184                         Assert.AreEqual ("Novell", rp.TagNames [1], "TagNames-2");
 185                 }
 186
 187                 [Test]
 188                 [ExpectedException (typeof (ArgumentNullException))]
 189                 public void AddPermissionAccess_Null ()
 190                 {
 191                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 192                         rp.AddPermissionAccess (null);
 193                 }
 194
 195                 [Test]
 196                 [ExpectedException (typeof (InvalidOperationException))]
 197                 public void AddPermissionAccess_MismatchTag ()
 198                 {
 199                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 200                         rp.TagNames = new string [1] { "Monkeys" };
 201                         rp.AddPermissionAccess (new ResourcePermissionBaseEntry ());
 202                 }
 203
 204                 [Test]
 205                 public void AddPermissionAccess ()
 206                 {
 207                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 208                         rp.TagNames = new string [1] { "Monkeys" };
 209                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 210                         rp.AddPermissionAccess (entry);
 211
 212                         ResourcePermissionBaseEntry[] entries = rp.GetPermissionEntries ();
 213                         Assert.AreEqual (1, entries.Length, "Count");
 214                 }
 215
 216                 [Test]
 217                 [ExpectedException (typeof (InvalidOperationException))]
 218                 public void AddPermissionAccess_Duplicates_SameInstance ()
 219                 {
 220                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 221                         rp.TagNames = new string [1] { "Monkeys" };
 222                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 223                         rp.AddPermissionAccess (entry);
 224                         rp.AddPermissionAccess (entry);
 225                 }
 226
 227                 [Test]
 228                 [ExpectedException (typeof (InvalidOperationException))]
 229                 public void AddPermissionAccess_Duplicates_DifferentInstances ()
 230                 {
 231                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 232                         rp.TagNames = new string [1] { "Monkeys" };
 233                         ResourcePermissionBaseEntry entry1 = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 234                         rp.AddPermissionAccess (entry1);
 235                         ResourcePermissionBaseEntry entry2 = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 236                         rp.AddPermissionAccess (entry2);
 237                 }
 238
 239                 [Test]
 240                 public void AddPermissionAccess_SemiDuplicates ()
 241                 {
 242                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 243                         rp.TagNames = new string [2] { "Monkeys", "Singes" };
 244                         ResourcePermissionBaseEntry entry1 = new ResourcePermissionBaseEntry (0, new string [2] { "1", "2" });
 245                         rp.AddPermissionAccess (entry1);
 246                         ResourcePermissionBaseEntry entry2 = new ResourcePermissionBaseEntry (0, new string [2] { "2", "1" });
 247                         rp.AddPermissionAccess (entry2);
 248                 }
 249
 250                 [Test]
 251                 public void Clear ()
 252                 {
 253                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 254                         rp.TagNames = new string [1] { "Monkeys" };
 255
 256                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 257                         rp.AddPermissionAccess (entry);
 258                         ResourcePermissionBaseEntry [] entries = rp.GetPermissionEntries ();
 259                         Assert.AreEqual (1, entries.Length, "Count");
 260
 261                         rp.Clear ();
 262                         entries = rp.GetPermissionEntries ();
 263                         Assert.AreEqual (0, entries.Length, "Count");
 264                 }
 265
 266                 [Test]
 267                 public void Copy ()
 268                 {
 269                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 270                         rp.PermissionAccessType = typeof (PermissionState);
 271                         rp.TagNames = new string [1] { "Monkeys" };
 272
 273                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 274                         rp.AddPermissionAccess (entry);
 275
 276                         NonAbstractResourcePermissionBase copy = (NonAbstractResourcePermissionBase) rp.Copy ();
 277                         Assert.AreEqual (typeof (PermissionState), copy.PermissionAccessType, "PermissionAccessType");
 278                         Assert.AreEqual ("Monkeys", copy.TagNames [0], "TagNames");
 279
 280                         ResourcePermissionBaseEntry [] entries = copy.GetPermissionEntries ();
 281                         Assert.AreEqual (1, entries.Length, "Count");
 282                 }
 283
 284                 [Test]
 285 #if NET_2_0
 286                 [ExpectedException (typeof (ArgumentNullException))]
 287 #else
 288                 [ExpectedException (typeof (NullReferenceException))]
 289 #endif
 290                 public void FromXml_Null ()
 291                 {
 292                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 293                         rp.FromXml (null);
 294                 }
 295
 296                 [Test]
 297 #if NET_2_0
 298                 [ExpectedException (typeof (ArgumentException))]
 299 #endif
 300                 public void FromXml_WrongTag ()
 301                 {
 302                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 303                         SecurityElement se = rp.ToXml ();
 304                         se.Tag = "IMono"; // instead of IPermission
 305                         rp.FromXml (se);
 306                 }
 307
 308                 [Test]
 309 #if NET_2_0
 310                 [ExpectedException (typeof (ArgumentException))]
 311 #endif
 312                 public void FromXml_WrongTagCase ()
 313                 {
 314                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 315                         SecurityElement se = rp.ToXml ();
 316                         se.Tag = "IPERMISSION"; // instead of IPermission
 317                         rp.FromXml (se);
 318                 }
 319
 320                 [Test]
 321                 public void FromXml_WrongClass ()
 322                 {
 323                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 324                         SecurityElement se = rp.ToXml ();
 325
 326                         SecurityElement w = new SecurityElement (se.Tag);
 327                         w.AddAttribute ("class", "Wrong" + se.Attribute ("class"));
 328                         w.AddAttribute ("version", se.Attribute ("version"));
 329                         rp.FromXml (w);
 330                         // doesn't care of the class name at that stage
 331                         // anyway the class has already be created so...
 332                 }
 333
 334                 [Test]
 335                 public void FromXml_NoClass ()
 336                 {
 337                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 338                         SecurityElement se = rp.ToXml ();
 339
 340                         SecurityElement w = new SecurityElement (se.Tag);
 341                         w.AddAttribute ("version", se.Attribute ("version"));
 342                         rp.FromXml (w);
 343                         // doesn't even care of the class attribute presence
 344                 }
 345
 346                 [Test]
 347 #if NET_2_0
 348                 [ExpectedException (typeof (ArgumentException))]
 349 #endif
 350                 public void FromXml_WrongVersion ()
 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                         w.AddAttribute ("version", "2");
 358                         rp.FromXml (w);
 359                 }
 360
 361                 [Test]
 362                 public void FromXml_NoVersion ()
 363                 {
 364                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 365                         SecurityElement se = rp.ToXml ();
 366
 367                         SecurityElement w = new SecurityElement (se.Tag);
 368                         w.AddAttribute ("class", se.Attribute ("class"));
 369                         rp.FromXml (w);
 370                 }
 371
 372                 [Test]
 373                 public void GetPermissionEntries ()
 374                 {
 375                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 376                         ResourcePermissionBaseEntry[] entries = rp.GetPermissionEntries ();
 377                         Assert.AreEqual (0, entries.Length, "Empty");
 378
 379                         rp.PermissionAccessType = typeof (PermissionState);
 380                         rp.TagNames = new string [1] { "Monkeys" };
 381                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 382                         rp.AddPermissionAccess (entry);
 383
 384                         entries = rp.GetPermissionEntries ();
 385                         Assert.AreEqual (1, entries.Length, "Count==1");
 386
 387                         rp.Clear ();
 388                         entries = rp.GetPermissionEntries ();
 389                         Assert.AreEqual (0, entries.Length, "Count==0");
 390                 }
 391
 392                 [Test]
 393                 [ExpectedException (typeof (ArgumentException))]
 394                 public void Intersect_DifferentPermissions ()
 395                 {
 396                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 397                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 398                         rp.Intersect (b);
 399                 }
 400
 401                 [Test]
 402                 public void IsSubsetOf_DifferentPermissions ()
 403                 {
 404                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 405                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 406                         // normally (other permissions) this would throw an ArgumentException
 407                         Assert.IsFalse (rp.IsSubsetOf (b));
 408                 }
 409
 410                 [Test]
 411                 [ExpectedException (typeof (ArgumentNullException))]
 412                 public void RemovePermissionAccess_Null ()
 413                 {
 414                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 415                         rp.RemovePermissionAccess (null);
 416                 }
 417
 418                 [Test]
 419                 [ExpectedException (typeof (InvalidOperationException))]
 420                 public void RemovePermissionAccess_MismatchTag ()
 421                 {
 422                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 423                         rp.TagNames = new string [1] { "Monkeys" };
 424                         rp.RemovePermissionAccess (new ResourcePermissionBaseEntry ());
 425                 }
 426
 427                 [Test]
 428                 public void RemovePermissionAccess ()
 429                 {
 430                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 431                         rp.TagNames = new string [1] { "Monkeys" };
 432
 433                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 434                         rp.AddPermissionAccess (entry);
 435
 436                         ResourcePermissionBaseEntry[] entries = rp.GetPermissionEntries ();
 437                         Assert.AreEqual (1, entries.Length, "Count==1");
 438
 439                         rp.RemovePermissionAccess (entry);
 440                         entries = rp.GetPermissionEntries ();
 441                         Assert.AreEqual (0, entries.Length, "Count==0");
 442                 }
 443
 444                 [Test]
 445                 [ExpectedException (typeof (InvalidOperationException))]
 446                 public void RemovePermissionAccess_Unexisting ()
 447                 {
 448                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 449                         rp.TagNames = new string [1] { "Monkeys" };
 450
 451                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 452                         rp.RemovePermissionAccess (entry);
 453                 }
 454
 455                 private void CheckCommonXml (string msg, SecurityElement se)
 456                 {
 457                         Assert.AreEqual ("IPermission", se.Tag, msg + "Tag");
 458                         Assert.IsTrue (se.Attribute ("class").StartsWith ("MonoTests.System.Security.Permissions.NonAbstractResourcePermissionBase, "), msg + "class");
 459                         Assert.AreEqual ("1", se.Attribute ("version"), msg + "version");
 460                 }
 461
 462                 [Test]
 463                 public void ToXml ()
 464                 {
 465                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 466                         rp.TagNames = new string [1] { "Monkeys" };
 467                         SecurityElement se = rp.ToXml ();
 468                         CheckCommonXml ("empty", se);
 469                         Assert.AreEqual (2, se.Attributes.Count, "#attributes");
 470                         Assert.IsNull (se.Children, "Children");
 471
 472                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 473                         rp.AddPermissionAccess (entry);
 474                         se = rp.ToXml ();
 475                         CheckCommonXml ("one", se);
 476                         Assert.AreEqual (2, se.Attributes.Count, "#attributes");
 477                         Assert.AreEqual (1, se.Children.Count, "1-Children");
 478                         SecurityElement child = (SecurityElement) se.Children [0];
 479                         Assert.AreEqual ("Monkeys", child.Tag, "Monkeys");
 480                         Assert.AreEqual ("Singes", child.Attribute ("name"), "Singes");
 481                 }
 482
 483                 [Test]
 484                 public void ToXml_Unrestricted ()
 485                 {
 486                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase (PermissionState.Unrestricted);
 487                         rp.TagNames = new string [1] { "Monkeys" };
 488                         SecurityElement se = rp.ToXml ();
 489                         CheckCommonXml ("empty", se);
 490                         Assert.AreEqual (3, se.Attributes.Count, "#attributes");
 491                         Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "Unrestricted");
 492                         Assert.IsNull (se.Children, "Children");
 493
 494                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 495                         rp.AddPermissionAccess (entry);
 496                         se = rp.ToXml ();
 497                         CheckCommonXml ("one", se);
 498                         Assert.AreEqual (3, se.Attributes.Count, "#attributes");
 499                         // not XML output of childrens for unrestricted
 500                         Assert.IsNull (se.Children, "Children");
 501                 }
 502
 503                 [Test]
 504                 public void Union ()
 505                 {
 506                         NonAbstractResourcePermissionBase a = new NonAbstractResourcePermissionBase ();
 507                         NonAbstractResourcePermissionBase z = (NonAbstractResourcePermissionBase) a.Union (null);
 508                         CheckDefaultValues ("Empty U null", z, false);
 509                         Assert.IsFalse (Object.ReferenceEquals (a, z), "!ReferenceEquals1");
 510
 511                         NonAbstractResourcePermissionBase b = new NonAbstractResourcePermissionBase (PermissionState.None);
 512                         z = (NonAbstractResourcePermissionBase) a.Union (b);
 513                         Assert.IsNull (z, "Empty U Empty");
 514
 515                         NonAbstractResourcePermissionBase u = new NonAbstractResourcePermissionBase (PermissionState.Unrestricted);
 516                         z = (NonAbstractResourcePermissionBase) u.Union (b);
 517                         CheckDefaultValues ("Unrestricted U Empty", z, true);
 518                         Assert.IsFalse (Object.ReferenceEquals (u, z), "!ReferenceEquals2");
 519                         Assert.IsFalse (Object.ReferenceEquals (b, z), "!ReferenceEquals3");
 520
 521                         z = (NonAbstractResourcePermissionBase)b.Union (u);
 522                         CheckDefaultValues ("Empty U Unrestricted", z, true);
 523                         Assert.IsFalse (Object.ReferenceEquals (u, z), "!ReferenceEquals4");
 524                         Assert.IsFalse (Object.ReferenceEquals (b, z), "!ReferenceEquals5");
 525                 }
 526
 527                 [Test]
 528                 [ExpectedException (typeof (ArgumentException))]
 529                 public void Union_DifferentPermissions ()
 530                 {
 531                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase ();
 532                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 533                         rp.Union (b);
 534                 }
 535
 536                 [Test]
 537                 public void Unrestricted_AddRemove ()
 538                 {
 539                         NonAbstractResourcePermissionBase rp = new NonAbstractResourcePermissionBase (PermissionState.Unrestricted);
 540                         rp.TagNames = new string [1] { "Monkeys" };
 541
 542                         ResourcePermissionBaseEntry entry = new ResourcePermissionBaseEntry (0, new string [1] { "Singes" });
 543                         rp.AddPermissionAccess (entry);
 544
 545                         ResourcePermissionBaseEntry [] entries = rp.GetPermissionEntries ();
 546                         Assert.AreEqual (1, entries.Length, "Count==1");
 547
 548                         rp.RemovePermissionAccess (entry);
 549                         entries = rp.GetPermissionEntries ();
 550                         Assert.AreEqual (0, entries.Length, "Count==0");
 551                 }
 552         }
 553 }