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                 [Test]
 240                 public void FromXml ()
 241                 {
 242                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 243                         SecurityElement se = ep.ToXml ();
 244                         AssertNotNull ("ToXml()", se);
 245                         ep.FromXml (se);
 246                         se.AddAttribute ("Read", keyLocalMachine);
 247                         ep.FromXml (se);
 248                         AssertEquals ("FromXml-Read", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read));
 249                         se.AddAttribute ("Write", keyLocalMachine);
 250                         ep.FromXml (se);
 251                         AssertEquals ("FromXml-Read", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read));
 252                         AssertEquals ("FromXml-Write", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write));
 253                         se.AddAttribute ("Create", keyCurrentUser);
 254                         ep.FromXml (se);
 255                         AssertEquals ("FromXml-Read", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read));
 256                         AssertEquals ("FromXml-Write", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write));
 257                         AssertEquals ("FromXml-Create", keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Create));
 258                 }
 259
 260                 [Test]
 261                 public void UnionWithNull ()
 262                 {
 263                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 264                         RegistryPermission ep2 = null;
 265                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
 266                         AssertEquals ("EP1 U null == EP1", ep1.ToXml ().ToString (), ep3.ToXml ().ToString ());
 267                 }
 268
 269                 [Test]
 270                 public void UnionWithUnrestricted ()
 271                 {
 272                         RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
 273                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 274                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
 275                         Assert ("Unrestricted U EP2 == Unrestricted", ep3.IsUnrestricted ());
 276                         ep3 = (RegistryPermission)ep2.Union (ep1);
 277                         Assert ("EP2 U Unrestricted == Unrestricted", ep3.IsUnrestricted ());
 278                 }
 279
 280                 [Test]
 281                 public void Union ()
 282                 {
 283                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 284                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Write, keyLocalMachine);
 285                         RegistryPermission ep3 = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachine);
 286                         RegistryPermission ep4 = (RegistryPermission)ep1.Union (ep2);
 287                         ep4 = (RegistryPermission)ep4.Union (ep3);
 288                         RegistryPermission ep5 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 289                         AssertEquals ("EP1 U EP2 U EP3 == EP1+2+3", ep4.ToXml ().ToString (), ep5.ToXml ().ToString ());
 290                 }
 291
 292                 [Test]
 293                 public void Union_Subset ()
 294                 {
 295                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 296                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachineSubset);
 297                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
 298                         AssertEquals ("Create", keyLocalMachineSubset, ep3.GetPathList (RegistryPermissionAccess.Create));
 299                         AssertEquals ("Read", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read));
 300                         AssertEquals ("Write", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write));
 301                 }
 302
 303                 [Test]
 304                 [ExpectedException (typeof (ArgumentException))]
 305                 public void UnionWithBadPermission ()
 306                 {
 307                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 308                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 309                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (fdp2);
 310                 }
 311
 312                 [Test]
 313                 public void IntersectWithNull ()
 314                 {
 315                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 316                         RegistryPermission ep2 = null;
 317                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 318                         AssertNull ("EP1 N null == null", ep3);
 319                 }
 320
 321                 [Test]
 322                 public void IntersectWithUnrestricted ()
 323                 {
 324                         RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
 325                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 326                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 327                         Assert ("Unrestricted N EP2 == EP2", !ep3.IsUnrestricted ());
 328                         AssertEquals ("Unrestricted N EP2 == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
 329                         ep3 = (RegistryPermission)ep2.Intersect (ep1);
 330                         Assert ("EP2 N Unrestricted == EP2", !ep3.IsUnrestricted ());
 331                         AssertEquals ("EP2 N Unrestricted == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
 332                 }
 333
 334                 [Test]
 335                 public void Intersect ()
 336                 {
 337                         // no intersection
 338                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Write, keyCurrentUser);
 339                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 340                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 341                         AssertNull ("EP1 N EP2 == null", ep3);
 342                         // intersection in read
 343                         RegistryPermission ep4 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 344                         ep3 = (RegistryPermission)ep4.Intersect (ep2);
 345                         AssertEquals ("Intersect-Read", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read));
 346                         // intersection in write
 347                         RegistryPermission ep5 = new RegistryPermission (RegistryPermissionAccess.Write, keyCurrentUser);
 348                         ep3 = (RegistryPermission)ep5.Intersect (ep1);
 349                         AssertEquals ("Intersect-Write", keyCurrentUser, ep3.GetPathList (RegistryPermissionAccess.Write));
 350                         // intersection in read and write
 351                         RegistryPermission ep6 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 352                         RegistryPermission ep7 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 353                         ep3 = (RegistryPermission)ep6.Intersect (ep7);
 354                         AssertEquals ("Intersect-AllAccess-Create", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create));
 355                         AssertEquals ("Intersect-AllAccess-Read", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read));
 356                         AssertEquals ("Intersect-AllAccess-Write", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write));
 357                 }
 358
 359                 [Test]
 360                 public void Intersect_Subset ()
 361                 {
 362                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 363                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachineSubset);
 364                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 365                         AssertEquals ("Create", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create));
 366                         AssertNull ("Read", ep3.GetPathList (RegistryPermissionAccess.Read));
 367                         AssertNull ("Write", ep3.GetPathList (RegistryPermissionAccess.Write));
 368                 }
 369
 370                 [Test]
 371                 [ExpectedException (typeof (ArgumentException))]
 372                 public void IntersectWithBadPermission ()
 373                 {
 374                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 375                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 376                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (fdp2);
 377                 }
 378
 379                 [Test]
 380                 public void IsSubsetOfNull ()
 381                 {
 382                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 383                         Assert ("IsSubsetOf(null)", !ep1.IsSubsetOf (null));
 384                 }
 385
 386                 [Test]
 387                 public void IsSubsetOfUnrestricted ()
 388                 {
 389                         RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
 390                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 391                         RegistryPermission ep3 = new RegistryPermission (PermissionState.Unrestricted);
 392                         Assert ("Unrestricted.IsSubsetOf()", !ep1.IsSubsetOf (ep2));
 393                         Assert ("IsSubsetOf(Unrestricted)", ep2.IsSubsetOf (ep1));
 394                         Assert ("Unrestricted.IsSubsetOf(Unrestricted)", ep1.IsSubsetOf (ep3));
 395                 }
 396
 397                 [Test]
 398                 public void IsSubsetOf ()
 399                 {
 400                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Write, keyLocalMachine);
 401                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 402                         Assert ("IsSubsetOf(nosubset1)", !ep1.IsSubsetOf (ep2));
 403                         Assert ("IsSubsetOf(nosubset2)", !ep2.IsSubsetOf (ep1));
 404                         RegistryPermission ep3 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 405                         Assert ("Write.IsSubsetOf(All)", ep1.IsSubsetOf (ep3));
 406                         Assert ("All.IsSubsetOf(Write)", !ep3.IsSubsetOf (ep1));
 407                 }
 408
 409                 [Test]
 410                 [ExpectedException (typeof (ArgumentException))]
 411                 public void IsSubsetOfBadPermission ()
 412                 {
 413                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 414                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 415                         Assert ("IsSubsetOf(FileDialogPermission)", ep1.IsSubsetOf (fdp2));
 416                 }
 417         }
 418 }