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 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                         Assert.IsNotNull (ep, "RegistryPermission(PermissionState.None)");
  50                         Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
  51                         RegistryPermission copy = (RegistryPermission)ep.Copy ();
  52                         Assert.AreEqual (ep.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
  53                         SecurityElement se = ep.ToXml ();
  54                         Assert.IsTrue (se.Attribute ("class").StartsWith (className), "ToXml-class");
  55                         Assert.AreEqual ("1", se.Attribute ("version"), "ToXml-version");
  56                 }
  57
  58                 [Test]
  59                 public void PermissionStateUnrestricted ()
  60                 {
  61                         RegistryPermission ep = new RegistryPermission (PermissionState.Unrestricted);
  62                         Assert.IsNotNull (ep, "RegistryPermission(PermissionState.Unrestricted)");
  63                         Assert.IsTrue (ep.IsUnrestricted (), "IsUnrestricted");
  64                         RegistryPermission copy = (RegistryPermission)ep.Copy ();
  65                         Assert.AreEqual (ep.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
  66                         SecurityElement se = ep.ToXml ();
  67                         Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "ToXml-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.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
  82                 }
  83
  84                 [Test]
  85                 public void NoAccess ()
  86                 {
  87                         RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.NoAccess, keyLocalMachine);
  88                         Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
  89                 }
  90
  91                 [Test]
  92                 public void CreateAccess ()
  93                 {
  94                         RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachine);
  95                         Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
  96                 }
  97
  98                 [Test]
  99                 public void ReadAccess ()
 100                 {
 101                         RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 102                         Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
 103                 }
 104
 105                 [Test]
 106                 public void WriteAccess ()
 107                 {
 108                         RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.Write, keyLocalMachine);
 109                         Assert.IsTrue (!ep.IsUnrestricted (), "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                         Assert.AreEqual (@"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\Novell iFolder\1.00.000", se.Attribute ("Create"), "AddPathList-ToXml-Create");
 124                         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");
 125                         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");
 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                         Assert.AreEqual (keyLocalMachineSubset, se.Attribute ("Create"), "AddPathList-ToXml-Create");
 136                         Assert.AreEqual (keyLocalMachineSubset, se.Attribute ("Read"), "AddPathList-ToXml-Read");
 137                         Assert.AreEqual (keyLocalMachineSubset, se.Attribute ("Write"), "AddPathList-ToXml-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                         Assert.AreEqual (keyLocalMachineSubset, se.Attribute ("Create"), "AddPathList-ToXml-Create");
 145                         Assert.AreEqual (keyLocalMachine + ";" + keyCurrentUser, se.Attribute ("Read"), "AddPathList-ToXml-Read");
 146                         Assert.AreEqual (keyLocalMachine, se.Attribute ("Write"), "AddPathList-ToXml-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                         Assert.AreEqual (String.Empty, ep.GetPathList (RegistryPermissionAccess.NoAccess), "GetPathList-NoAccess");
 165                 }
 166
 167                 [Test]
 168                 public void GetPathList ()
 169                 {
 170                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 171 #if NET_2_0
 172                         Assert.AreEqual (String.Empty, ep.GetPathList (RegistryPermissionAccess.Create), "GetPathList-Create-Empty");
 173                         Assert.AreEqual (String.Empty, ep.GetPathList (RegistryPermissionAccess.Read), "GetPathList-Read-Empty");
 174                         Assert.AreEqual (String.Empty, ep.GetPathList (RegistryPermissionAccess.Write), "GetPathList-Write-Empty");
 175 #else
 176                         Assert.IsNull (ep.GetPathList (RegistryPermissionAccess.Create), "GetPathList-Create-Empty");
 177                         Assert.IsNull (ep.GetPathList (RegistryPermissionAccess.Read), "GetPathList-Read-Empty");
 178                         Assert.IsNull (ep.GetPathList (RegistryPermissionAccess.Write), "GetPathList-Write-Empty");
 179 #endif
 180                         ep.AddPathList (RegistryPermissionAccess.Create, keyLocalMachine);
 181                         ep.AddPathList (RegistryPermissionAccess.Create, keyCurrentUser);
 182                         Assert.AreEqual (keyLocalMachine + ";" + keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Create), "GetPathList-Read");
 183
 184                         ep.AddPathList (RegistryPermissionAccess.Read, keyLocalMachine);
 185                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "GetPathList-Read");
 186
 187                         ep.AddPathList (RegistryPermissionAccess.Write, keyCurrentUser);
 188                         Assert.AreEqual (keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Write), "GetPathList-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                         Assert.AreEqual (keyCurrentUser, se.Attribute ("Read"), "SetPathList-ToXml-Read");
 202                         Assert.AreEqual (keyCurrentUser, se.Attribute ("Write"), "SetPathList-ToXml-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                         Assert.IsNotNull (se, "ToXml()");
 248                         ep.FromXml (se);
 249                         se.AddAttribute ("Read", keyLocalMachine);
 250                         ep.FromXml (se);
 251                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "FromXml-Read");
 252                         se.AddAttribute ("Write", keyLocalMachine);
 253                         ep.FromXml (se);
 254                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "FromXml-Read");
 255                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write), "FromXml-Write");
 256                         se.AddAttribute ("Create", keyCurrentUser);
 257                         ep.FromXml (se);
 258                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "FromXml-Read");
 259                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write), "FromXml-Write");
 260                         Assert.AreEqual (keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Create), "FromXml-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                         Assert.AreEqual (ep1.ToXml ().ToString (), ep3.ToXml ().ToString (), "EP1 U null == EP1");
 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.IsTrue (ep3.IsUnrestricted (), "Unrestricted U EP2 == Unrestricted");
 279                         ep3 = (RegistryPermission)ep2.Union (ep1);
 280                         Assert.IsTrue (ep3.IsUnrestricted (), "EP2 U Unrestricted == Unrestricted");
 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                         Assert.AreEqual (ep4.ToXml ().ToString (), ep5.ToXml ().ToString (), "EP1 U EP2 U EP3 == EP1+2+3");
 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                         Assert.AreEqual (keyLocalMachineSubset, ep3.GetPathList (RegistryPermissionAccess.Create), "Create");
 308                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read), "Read");
 309                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write), "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                         Assert.IsNull (ep3, "EP1 N null == null");
 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.IsTrue (!ep3.IsUnrestricted (), "Unrestricted N EP2 == EP2");
 337                         Assert.AreEqual (ep2.ToXml ().ToString (), ep3.ToXml ().ToString (), "Unrestricted N EP2 == EP2");
 338                         ep3 = (RegistryPermission)ep2.Intersect (ep1);
 339                         Assert.IsTrue (!ep3.IsUnrestricted (), "EP2 N Unrestricted == EP2");
 340                         Assert.AreEqual (ep2.ToXml ().ToString (), ep3.ToXml ().ToString (), "EP2 N Unrestricted == EP2");
 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                         Assert.IsNull (ep3, "EP1 N EP2 == null");
 351                         // intersection in read
 352                         RegistryPermission ep4 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 353                         ep3 = (RegistryPermission)ep4.Intersect (ep2);
 354                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read), "Intersect-Read");
 355                         // intersection in write
 356                         RegistryPermission ep5 = new RegistryPermission (RegistryPermissionAccess.Write, keyCurrentUser);
 357                         ep3 = (RegistryPermission)ep5.Intersect (ep1);
 358                         Assert.AreEqual (keyCurrentUser, ep3.GetPathList (RegistryPermissionAccess.Write), "Intersect-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                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create), "Intersect-AllAccess-Create");
 364                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read), "Intersect-AllAccess-Read");
 365                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write), "Intersect-AllAccess-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                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create), "Create");
 378                         Assert.IsNull (ep3.GetPathList (RegistryPermissionAccess.Read), "Read");
 379                         Assert.IsNull (ep3.GetPathList (RegistryPermissionAccess.Write), "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.IsTrue (!ep1.IsSubsetOf (null), "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.IsTrue (!ep1.IsSubsetOf (ep2), "Unrestricted.IsSubsetOf()");
 405                         Assert.IsTrue (ep2.IsSubsetOf (ep1), "IsSubsetOf(Unrestricted)");
 406                         Assert.IsTrue (ep1.IsSubsetOf (ep3), "Unrestricted.IsSubsetOf(Unrestricted)");
 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.IsTrue (!ep1.IsSubsetOf (ep2), "IsSubsetOf(nosubset1)");
 415                         Assert.IsTrue (!ep2.IsSubsetOf (ep1), "IsSubsetOf(nosubset2)");
 416                         RegistryPermission ep3 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 417                         Assert.IsTrue (ep1.IsSubsetOf (ep3), "Write.IsSubsetOf(All)");
 418                         Assert.IsTrue (!ep3.IsSubsetOf (ep1), "All.IsSubsetOf(Write)");
 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.IsTrue (ep1.IsSubsetOf (fdp2), "IsSubsetOf(FileDialogPermission)");
 428                 }
 429         }
 430 }