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