mcs/class/corlib/Test/System.Security.Permissions/RegistryPermissionTest.cs

   1 //
   2 // RegistryPermissionTest.cs - NUnit Test Cases for RegistryPermission
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // Copyright (C) 2004 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         [TestFixture]
  37         public class RegistryPermissionTest : Assertion {
  38
  39                 private static string className = "System.Security.Permissions.RegistryPermission, ";
  40                 private static string keyCurrentUser = @"HKEY_CURRENT_USER\Software\Novell iFolder\spouliot\Home";
  41                 private static string keyCurrentUserSubset = @"HKEY_CURRENT_USER\Software\Novell iFolder\";
  42                 private static string keyLocalMachine = @"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\Novell iFolder\1.00.000";
  43                 private static string keyLocalMachineSubset = @"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\";
  44
  45                 [Test]
  46                 public void PermissionStateNone ()
  47                 {
  48                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
  49                         AssertNotNull ("RegistryPermission(PermissionState.None)", ep);
  50                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  51                         RegistryPermission copy = (RegistryPermission)ep.Copy ();
  52                         AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
  53                         SecurityElement se = ep.ToXml ();
  54                         Assert ("ToXml-class", se.Attribute ("class").StartsWith (className));
  55                         AssertEquals ("ToXml-version", "1", se.Attribute ("version"));
  56                 }
  57
  58                 [Test]
  59                 public void PermissionStateUnrestricted ()
  60                 {
  61                         RegistryPermission ep = new RegistryPermission (PermissionState.Unrestricted);
  62                         AssertNotNull ("RegistryPermission(PermissionState.Unrestricted)", ep);
  63                         Assert ("IsUnrestricted", ep.IsUnrestricted ());
  64                         RegistryPermission copy = (RegistryPermission)ep.Copy ();
  65                         AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
  66                         SecurityElement se = ep.ToXml ();
  67                         AssertEquals ("ToXml-Unrestricted", "true", se.Attribute ("Unrestricted"));
  68                 }
  69
  70                 [Test]
  71                 [ExpectedException (typeof (ArgumentNullException))]
  72                 public void NullPathList ()
  73                 {
  74                         RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.AllAccess, null);
  75                 }
  76
  77                 [Test]
  78                 public void AllAccess ()
  79                 {
  80                         RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
  81                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  82                 }
  83
  84                 [Test]
  85                 public void NoAccess ()
  86                 {
  87                         RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.NoAccess, keyLocalMachine);
  88                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  89                 }
  90
  91                 [Test]
  92                 public void CreateAccess ()
  93                 {
  94                         RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachine);
  95                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  96                 }
  97
  98                 [Test]
  99                 public void ReadAccess ()
 100                 {
 101                         RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 102                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
 103                 }
 104
 105                 [Test]
 106                 public void WriteAccess ()
 107                 {
 108                         RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.Write, keyLocalMachine);
 109                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
 110                 }
 111
 112                 [Test]
 113                 public void AddPathList ()
 114                 {
 115                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 116                         ep.AddPathList (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 117                         // LAMESPEC NoAccess do not remove the keyLocalMachine from AllAccess
 118                         ep.AddPathList (RegistryPermissionAccess.NoAccess, keyLocalMachine);
 119                         ep.AddPathList (RegistryPermissionAccess.Read, keyCurrentUser);
 120                         ep.AddPathList (RegistryPermissionAccess.Write, keyCurrentUser);
 121                         SecurityElement se = ep.ToXml ();
 122                         // Note: Debugger can mess results (try to run without stepping)
 123                         AssertEquals ("AddPathList-ToXml-Create", @"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\Novell iFolder\1.00.000", se.Attribute ("Create"));
 124                         AssertEquals ("AddPathList-ToXml-Read", @"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\Novell iFolder\1.00.000;HKEY_CURRENT_USER\Software\Novell iFolder\spouliot\Home", se.Attribute ("Read"));
 125                         AssertEquals ("AddPathList-ToXml-Write", @"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\Novell iFolder\1.00.000;HKEY_CURRENT_USER\Software\Novell iFolder\spouliot\Home", se.Attribute ("Write"));
 126                 }
 127
 128                 [Test]
 129                 public void AddPathList_Subset ()
 130                 {
 131                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 132                         ep.AddPathList (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 133                         ep.AddPathList (RegistryPermissionAccess.AllAccess, keyLocalMachineSubset);
 134                         SecurityElement se = ep.ToXml ();
 135                         AssertEquals ("AddPathList-ToXml-Create", keyLocalMachineSubset, se.Attribute ("Create"));
 136                         AssertEquals ("AddPathList-ToXml-Read", keyLocalMachineSubset, se.Attribute ("Read"));
 137                         AssertEquals ("AddPathList-ToXml-Write", keyLocalMachineSubset, se.Attribute ("Write"));
 138
 139                         ep = new RegistryPermission (PermissionState.None);
 140                         ep.AddPathList (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 141                         ep.AddPathList (RegistryPermissionAccess.Create, keyLocalMachineSubset);
 142                         ep.AddPathList (RegistryPermissionAccess.Read, keyCurrentUser);
 143                         se = ep.ToXml ();
 144                         AssertEquals ("AddPathList-ToXml-Create", keyLocalMachineSubset, se.Attribute ("Create"));
 145                         AssertEquals ("AddPathList-ToXml-Read", keyLocalMachine + ";" + keyCurrentUser, se.Attribute ("Read"));
 146                         AssertEquals ("AddPathList-ToXml-Write", keyLocalMachine, se.Attribute ("Write"));
 147                 }
 148
 149                 [Test]
 150                 [ExpectedException (typeof (ArgumentException))]
 151                 public void GetPathListAllAccess ()
 152                 {
 153                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 154                         ep.GetPathList (RegistryPermissionAccess.AllAccess);
 155                 }
 156
 157                 [Test]
 158                 [ExpectedException (typeof (ArgumentException))]
 159                 public void GetPathListNoAccess ()
 160                 {
 161                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 162                         ep.AddPathList (RegistryPermissionAccess.Read, keyCurrentUser);
 163                         ep.AddPathList (RegistryPermissionAccess.Write, keyLocalMachine);
 164                         AssertEquals ("GetPathList-NoAccess", String.Empty, ep.GetPathList (RegistryPermissionAccess.NoAccess));
 165                 }
 166
 167                 [Test]
 168                 public void GetPathList ()
 169                 {
 170                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 171 #if NET_2_0
 172                         AssertEquals ("GetPathList-Create-Empty", String.Empty, ep.GetPathList (RegistryPermissionAccess.Create));
 173                         AssertEquals ("GetPathList-Read-Empty", String.Empty, ep.GetPathList (RegistryPermissionAccess.Read));
 174                         AssertEquals ("GetPathList-Write-Empty", String.Empty, ep.GetPathList (RegistryPermissionAccess.Write));
 175 #else
 176                         AssertNull ("GetPathList-Create-Empty", ep.GetPathList (RegistryPermissionAccess.Create));
 177                         AssertNull ("GetPathList-Read-Empty", ep.GetPathList (RegistryPermissionAccess.Read));
 178                         AssertNull ("GetPathList-Write-Empty", ep.GetPathList (RegistryPermissionAccess.Write));
 179 #endif
 180                         ep.AddPathList (RegistryPermissionAccess.Create, keyLocalMachine);
 181                         ep.AddPathList (RegistryPermissionAccess.Create, keyCurrentUser);
 182                         AssertEquals ("GetPathList-Read", keyLocalMachine + ";" + keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Create));
 183
 184                         ep.AddPathList (RegistryPermissionAccess.Read, keyLocalMachine);
 185                         AssertEquals ("GetPathList-Read", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read));
 186
 187                         ep.AddPathList (RegistryPermissionAccess.Write, keyCurrentUser);
 188                         AssertEquals ("GetPathList-Write", keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Write));
 189                 }
 190
 191                 [Test]
 192                 public void SetPathList ()
 193                 {
 194                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 195                         ep.SetPathList (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 196                         // LAMESPEC NoAccess do not remove the TMP from AllAccess
 197                         ep.SetPathList (RegistryPermissionAccess.NoAccess, keyLocalMachine);
 198                         ep.SetPathList (RegistryPermissionAccess.Read, keyCurrentUser);
 199                         ep.SetPathList (RegistryPermissionAccess.Write, keyCurrentUser);
 200                         SecurityElement se = ep.ToXml ();
 201                         AssertEquals ("SetPathList-ToXml-Read", keyCurrentUser, se.Attribute ("Read"));
 202                         AssertEquals ("SetPathList-ToXml-Write", keyCurrentUser, se.Attribute ("Write"));
 203                 }
 204
 205                 [Test]
 206                 [ExpectedException (typeof (ArgumentNullException))]
 207                 public void FromXmlNull ()
 208                 {
 209                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 210                         ep.FromXml (null);
 211                 }
 212
 213                 [Test]
 214                 [ExpectedException (typeof (ArgumentException))]
 215                 public void FromXmlInvalidPermission ()
 216                 {
 217                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 218                         SecurityElement se = ep.ToXml ();
 219                         // can't modify - so we create our own
 220                         SecurityElement se2 = new SecurityElement ("IInvalidPermission", se.Text);
 221                         se2.AddAttribute ("class", se.Attribute ("class"));
 222                         se2.AddAttribute ("version", se.Attribute ("version"));
 223                         ep.FromXml (se2);
 224                 }
 225
 226                 [Test]
 227                 [ExpectedException (typeof (ArgumentException))]
 228                 public void FromXmlWrongVersion ()
 229                 {
 230                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 231                         SecurityElement se = ep.ToXml ();
 232                         // can't modify - so we create our own
 233                         SecurityElement se2 = new SecurityElement (se.Tag, se.Text);
 234                         se2.AddAttribute ("class", se.Attribute ("class"));
 235                         se2.AddAttribute ("version", "2");
 236                         ep.FromXml (se2);
 237                 }
 238
 239 #if NET_2_0
 240                 [Category ("NotWorking")]
 241 #endif
 242                 [Test]
 243                 public void FromXml ()
 244                 {
 245                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 246                         SecurityElement se = ep.ToXml ();
 247                         AssertNotNull ("ToXml()", se);
 248                         ep.FromXml (se);
 249                         se.AddAttribute ("Read", keyLocalMachine);
 250                         ep.FromXml (se);
 251                         AssertEquals ("FromXml-Read", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read));
 252                         se.AddAttribute ("Write", keyLocalMachine);
 253                         ep.FromXml (se);
 254                         AssertEquals ("FromXml-Read", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read));
 255                         AssertEquals ("FromXml-Write", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write));
 256                         se.AddAttribute ("Create", keyCurrentUser);
 257                         ep.FromXml (se);
 258                         AssertEquals ("FromXml-Read", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read));
 259                         AssertEquals ("FromXml-Write", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write));
 260                         AssertEquals ("FromXml-Create", keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Create));
 261                 }
 262
 263                 [Test]
 264                 public void UnionWithNull ()
 265                 {
 266                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 267                         RegistryPermission ep2 = null;
 268                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
 269                         AssertEquals ("EP1 U null == EP1", ep1.ToXml ().ToString (), ep3.ToXml ().ToString ());
 270                 }
 271
 272                 [Test]
 273                 public void UnionWithUnrestricted ()
 274                 {
 275                         RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
 276                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 277                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
 278                         Assert ("Unrestricted U EP2 == Unrestricted", ep3.IsUnrestricted ());
 279                         ep3 = (RegistryPermission)ep2.Union (ep1);
 280                         Assert ("EP2 U Unrestricted == Unrestricted", ep3.IsUnrestricted ());
 281                 }
 282
 283 #if NET_2_0
 284                 [Category ("NotWorking")]
 285 #endif
 286                 [Test]
 287                 public void Union ()
 288                 {
 289                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 290                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Write, keyLocalMachine);
 291                         RegistryPermission ep3 = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachine);
 292                         RegistryPermission ep4 = (RegistryPermission)ep1.Union (ep2);
 293                         ep4 = (RegistryPermission)ep4.Union (ep3);
 294                         RegistryPermission ep5 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 295                         AssertEquals ("EP1 U EP2 U EP3 == EP1+2+3", ep4.ToXml ().ToString (), ep5.ToXml ().ToString ());
 296                 }
 297
 298 #if NET_2_0
 299                 [Category ("NotWorking")]
 300 #endif
 301                 [Test]
 302                 public void Union_Subset ()
 303                 {
 304                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 305                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachineSubset);
 306                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
 307                         AssertEquals ("Create", keyLocalMachineSubset, ep3.GetPathList (RegistryPermissionAccess.Create));
 308                         AssertEquals ("Read", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read));
 309                         AssertEquals ("Write", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write));
 310                 }
 311
 312                 [Test]
 313                 [ExpectedException (typeof (ArgumentException))]
 314                 public void UnionWithBadPermission ()
 315                 {
 316                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 317                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 318                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (fdp2);
 319                 }
 320
 321                 [Test]
 322                 public void IntersectWithNull ()
 323                 {
 324                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 325                         RegistryPermission ep2 = null;
 326                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 327                         AssertNull ("EP1 N null == null", ep3);
 328                 }
 329
 330                 [Test]
 331                 public void IntersectWithUnrestricted ()
 332                 {
 333                         RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
 334                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 335                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 336                         Assert ("Unrestricted N EP2 == EP2", !ep3.IsUnrestricted ());
 337                         AssertEquals ("Unrestricted N EP2 == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
 338                         ep3 = (RegistryPermission)ep2.Intersect (ep1);
 339                         Assert ("EP2 N Unrestricted == EP2", !ep3.IsUnrestricted ());
 340                         AssertEquals ("EP2 N Unrestricted == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
 341                 }
 342
 343                 [Test]
 344                 public void Intersect ()
 345                 {
 346                         // no intersection
 347                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Write, keyCurrentUser);
 348                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 349                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 350                         AssertNull ("EP1 N EP2 == null", ep3);
 351                         // intersection in read
 352                         RegistryPermission ep4 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 353                         ep3 = (RegistryPermission)ep4.Intersect (ep2);
 354                         AssertEquals ("Intersect-Read", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read));
 355                         // intersection in write
 356                         RegistryPermission ep5 = new RegistryPermission (RegistryPermissionAccess.Write, keyCurrentUser);
 357                         ep3 = (RegistryPermission)ep5.Intersect (ep1);
 358                         AssertEquals ("Intersect-Write", keyCurrentUser, ep3.GetPathList (RegistryPermissionAccess.Write));
 359                         // intersection in read and write
 360                         RegistryPermission ep6 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 361                         RegistryPermission ep7 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 362                         ep3 = (RegistryPermission)ep6.Intersect (ep7);
 363                         AssertEquals ("Intersect-AllAccess-Create", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create));
 364                         AssertEquals ("Intersect-AllAccess-Read", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read));
 365                         AssertEquals ("Intersect-AllAccess-Write", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write));
 366                 }
 367
 368 #if NET_2_0
 369                 [Category ("NotWorking")]
 370 #endif
 371                 [Test]
 372                 public void Intersect_Subset ()
 373                 {
 374                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 375                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachineSubset);
 376                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 377                         AssertEquals ("Create", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create));
 378                         AssertNull ("Read", ep3.GetPathList (RegistryPermissionAccess.Read));
 379                         AssertNull ("Write", ep3.GetPathList (RegistryPermissionAccess.Write));
 380                 }
 381
 382                 [Test]
 383                 [ExpectedException (typeof (ArgumentException))]
 384                 public void IntersectWithBadPermission ()
 385                 {
 386                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 387                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 388                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (fdp2);
 389                 }
 390
 391                 [Test]
 392                 public void IsSubsetOfNull ()
 393                 {
 394                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 395                         Assert ("IsSubsetOf(null)", !ep1.IsSubsetOf (null));
 396                 }
 397
 398                 [Test]
 399                 public void IsSubsetOfUnrestricted ()
 400                 {
 401                         RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
 402                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 403                         RegistryPermission ep3 = new RegistryPermission (PermissionState.Unrestricted);
 404                         Assert ("Unrestricted.IsSubsetOf()", !ep1.IsSubsetOf (ep2));
 405                         Assert ("IsSubsetOf(Unrestricted)", ep2.IsSubsetOf (ep1));
 406                         Assert ("Unrestricted.IsSubsetOf(Unrestricted)", ep1.IsSubsetOf (ep3));
 407                 }
 408
 409                 [Test]
 410                 public void IsSubsetOf ()
 411                 {
 412                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Write, keyLocalMachine);
 413                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 414                         Assert ("IsSubsetOf(nosubset1)", !ep1.IsSubsetOf (ep2));
 415                         Assert ("IsSubsetOf(nosubset2)", !ep2.IsSubsetOf (ep1));
 416                         RegistryPermission ep3 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 417                         Assert ("Write.IsSubsetOf(All)", ep1.IsSubsetOf (ep3));
 418                         Assert ("All.IsSubsetOf(Write)", !ep3.IsSubsetOf (ep1));
 419                 }
 420
 421                 [Test]
 422                 [ExpectedException (typeof (ArgumentException))]
 423                 public void IsSubsetOfBadPermission ()
 424                 {
 425                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 426                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 427                         Assert ("IsSubsetOf(FileDialogPermission)", ep1.IsSubsetOf (fdp2));
 428                 }
 429         }
 430 }