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 #if NET_2_0
 171                         Assert.AreEqual (String.Empty, ep.GetPathList (RegistryPermissionAccess.Create), "GetPathList-Create-Empty");
 172                         Assert.AreEqual (String.Empty, ep.GetPathList (RegistryPermissionAccess.Read), "GetPathList-Read-Empty");
 173                         Assert.AreEqual (String.Empty, ep.GetPathList (RegistryPermissionAccess.Write), "GetPathList-Write-Empty");
 174 #else
 175                         Assert.IsNull (ep.GetPathList (RegistryPermissionAccess.Create), "GetPathList-Create-Empty");
 176                         Assert.IsNull (ep.GetPathList (RegistryPermissionAccess.Read), "GetPathList-Read-Empty");
 177                         Assert.IsNull (ep.GetPathList (RegistryPermissionAccess.Write), "GetPathList-Write-Empty");
 178 #endif
 179                         ep.AddPathList (RegistryPermissionAccess.Create, keyLocalMachine);
 180                         ep.AddPathList (RegistryPermissionAccess.Create, keyCurrentUser);
 181                         Assert.AreEqual (keyLocalMachine + ";" + keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Create), "GetPathList-Read");
 182
 183                         ep.AddPathList (RegistryPermissionAccess.Read, keyLocalMachine);
 184                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "GetPathList-Read");
 185
 186                         ep.AddPathList (RegistryPermissionAccess.Write, keyCurrentUser);
 187                         Assert.AreEqual (keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Write), "GetPathList-Write");
 188                 }
 189
 190                 [Test]
 191                 public void SetPathList ()
 192                 {
 193                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 194                         ep.SetPathList (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 195                         // LAMESPEC NoAccess do not remove the TMP from AllAccess
 196                         ep.SetPathList (RegistryPermissionAccess.NoAccess, keyLocalMachine);
 197                         ep.SetPathList (RegistryPermissionAccess.Read, keyCurrentUser);
 198                         ep.SetPathList (RegistryPermissionAccess.Write, keyCurrentUser);
 199                         SecurityElement se = ep.ToXml ();
 200                         Assert.AreEqual (keyCurrentUser, se.Attribute ("Read"), "SetPathList-ToXml-Read");
 201                         Assert.AreEqual (keyCurrentUser, se.Attribute ("Write"), "SetPathList-ToXml-Write");
 202                 }
 203
 204                 [Test]
 205                 [ExpectedException (typeof (ArgumentNullException))]
 206                 public void FromXmlNull ()
 207                 {
 208                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 209                         ep.FromXml (null);
 210                 }
 211
 212                 [Test]
 213                 [ExpectedException (typeof (ArgumentException))]
 214                 public void FromXmlInvalidPermission ()
 215                 {
 216                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 217                         SecurityElement se = ep.ToXml ();
 218                         // can't modify - so we create our own
 219                         SecurityElement se2 = new SecurityElement ("IInvalidPermission", se.Text);
 220                         se2.AddAttribute ("class", se.Attribute ("class"));
 221                         se2.AddAttribute ("version", se.Attribute ("version"));
 222                         ep.FromXml (se2);
 223                 }
 224
 225                 [Test]
 226                 [ExpectedException (typeof (ArgumentException))]
 227                 public void FromXmlWrongVersion ()
 228                 {
 229                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 230                         SecurityElement se = ep.ToXml ();
 231                         // can't modify - so we create our own
 232                         SecurityElement se2 = new SecurityElement (se.Tag, se.Text);
 233                         se2.AddAttribute ("class", se.Attribute ("class"));
 234                         se2.AddAttribute ("version", "2");
 235                         ep.FromXml (se2);
 236                 }
 237
 238 #if NET_2_0
 239                 [Category ("NotWorking")]
 240 #endif
 241                 [Test]
 242                 public void FromXml ()
 243                 {
 244                         RegistryPermission ep = new RegistryPermission (PermissionState.None);
 245                         SecurityElement se = ep.ToXml ();
 246                         Assert.IsNotNull (se, "ToXml()");
 247                         ep.FromXml (se);
 248                         se.AddAttribute ("Read", keyLocalMachine);
 249                         ep.FromXml (se);
 250                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "FromXml-Read");
 251                         se.AddAttribute ("Write", keyLocalMachine);
 252                         ep.FromXml (se);
 253                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "FromXml-Read");
 254                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write), "FromXml-Write");
 255                         se.AddAttribute ("Create", keyCurrentUser);
 256                         ep.FromXml (se);
 257                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "FromXml-Read");
 258                         Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write), "FromXml-Write");
 259                         Assert.AreEqual (keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Create), "FromXml-Create");
 260                 }
 261
 262                 [Test]
 263                 public void UnionWithNull ()
 264                 {
 265                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 266                         RegistryPermission ep2 = null;
 267                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
 268                         Assert.AreEqual (ep1.ToXml ().ToString (), ep3.ToXml ().ToString (), "EP1 U null == EP1");
 269                 }
 270
 271                 [Test]
 272                 public void UnionWithUnrestricted ()
 273                 {
 274                         RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
 275                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 276                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
 277                         Assert.IsTrue (ep3.IsUnrestricted (), "Unrestricted U EP2 == Unrestricted");
 278                         ep3 = (RegistryPermission)ep2.Union (ep1);
 279                         Assert.IsTrue (ep3.IsUnrestricted (), "EP2 U Unrestricted == Unrestricted");
 280                 }
 281
 282 #if NET_2_0
 283                 [Category ("NotWorking")]
 284 #endif
 285                 [Test]
 286                 public void Union ()
 287                 {
 288                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 289                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Write, keyLocalMachine);
 290                         RegistryPermission ep3 = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachine);
 291                         RegistryPermission ep4 = (RegistryPermission)ep1.Union (ep2);
 292                         ep4 = (RegistryPermission)ep4.Union (ep3);
 293                         RegistryPermission ep5 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 294                         Assert.AreEqual (ep4.ToXml ().ToString (), ep5.ToXml ().ToString (), "EP1 U EP2 U EP3 == EP1+2+3");
 295                 }
 296
 297 #if NET_2_0
 298                 [Category ("NotWorking")]
 299 #endif
 300                 [Test]
 301                 public void Union_Subset ()
 302                 {
 303                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 304                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachineSubset);
 305                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
 306                         Assert.AreEqual (keyLocalMachineSubset, ep3.GetPathList (RegistryPermissionAccess.Create), "Create");
 307                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read), "Read");
 308                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write), "Write");
 309                 }
 310
 311                 [Test]
 312                 [ExpectedException (typeof (ArgumentException))]
 313                 public void UnionWithBadPermission ()
 314                 {
 315                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 316                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 317                         RegistryPermission ep3 = (RegistryPermission)ep1.Union (fdp2);
 318                 }
 319
 320                 [Test]
 321                 public void IntersectWithNull ()
 322                 {
 323                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 324                         RegistryPermission ep2 = null;
 325                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 326                         Assert.IsNull (ep3, "EP1 N null == null");
 327                 }
 328
 329                 [Test]
 330                 public void IntersectWithUnrestricted ()
 331                 {
 332                         RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
 333                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 334                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 335                         Assert.IsTrue (!ep3.IsUnrestricted (), "Unrestricted N EP2 == EP2");
 336                         Assert.AreEqual (ep2.ToXml ().ToString (), ep3.ToXml ().ToString (), "Unrestricted N EP2 == EP2");
 337                         ep3 = (RegistryPermission)ep2.Intersect (ep1);
 338                         Assert.IsTrue (!ep3.IsUnrestricted (), "EP2 N Unrestricted == EP2");
 339                         Assert.AreEqual (ep2.ToXml ().ToString (), ep3.ToXml ().ToString (), "EP2 N Unrestricted == EP2");
 340                 }
 341
 342                 [Test]
 343                 public void Intersect ()
 344                 {
 345                         // no intersection
 346                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Write, keyCurrentUser);
 347                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 348                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 349                         Assert.IsNull (ep3, "EP1 N EP2 == null");
 350                         // intersection in read
 351                         RegistryPermission ep4 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 352                         ep3 = (RegistryPermission)ep4.Intersect (ep2);
 353                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read), "Intersect-Read");
 354                         // intersection in write
 355                         RegistryPermission ep5 = new RegistryPermission (RegistryPermissionAccess.Write, keyCurrentUser);
 356                         ep3 = (RegistryPermission)ep5.Intersect (ep1);
 357                         Assert.AreEqual (keyCurrentUser, ep3.GetPathList (RegistryPermissionAccess.Write), "Intersect-Write");
 358                         // intersection in read and write
 359                         RegistryPermission ep6 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 360                         RegistryPermission ep7 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 361                         ep3 = (RegistryPermission)ep6.Intersect (ep7);
 362                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create), "Intersect-AllAccess-Create");
 363                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read), "Intersect-AllAccess-Read");
 364                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write), "Intersect-AllAccess-Write");
 365                 }
 366
 367 #if NET_2_0
 368                 [Category ("NotWorking")]
 369 #endif
 370                 [Test]
 371                 public void Intersect_Subset ()
 372                 {
 373                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 374                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachineSubset);
 375                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
 376                         Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create), "Create");
 377                         Assert.IsNull (ep3.GetPathList (RegistryPermissionAccess.Read), "Read");
 378                         Assert.IsNull (ep3.GetPathList (RegistryPermissionAccess.Write), "Write");
 379                 }
 380
 381                 [Test]
 382                 [ExpectedException (typeof (ArgumentException))]
 383                 public void IntersectWithBadPermission ()
 384                 {
 385                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 386                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 387                         RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (fdp2);
 388                 }
 389
 390                 [Test]
 391                 public void IsSubsetOfNull ()
 392                 {
 393                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 394                         Assert.IsTrue (!ep1.IsSubsetOf (null), "IsSubsetOf(null)");
 395                 }
 396
 397                 [Test]
 398                 public void IsSubsetOfUnrestricted ()
 399                 {
 400                         RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
 401                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 402                         RegistryPermission ep3 = new RegistryPermission (PermissionState.Unrestricted);
 403                         Assert.IsTrue (!ep1.IsSubsetOf (ep2), "Unrestricted.IsSubsetOf()");
 404                         Assert.IsTrue (ep2.IsSubsetOf (ep1), "IsSubsetOf(Unrestricted)");
 405                         Assert.IsTrue (ep1.IsSubsetOf (ep3), "Unrestricted.IsSubsetOf(Unrestricted)");
 406                 }
 407
 408                 [Test]
 409                 public void IsSubsetOf ()
 410                 {
 411                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Write, keyLocalMachine);
 412                         RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 413                         Assert.IsTrue (!ep1.IsSubsetOf (ep2), "IsSubsetOf(nosubset1)");
 414                         Assert.IsTrue (!ep2.IsSubsetOf (ep1), "IsSubsetOf(nosubset2)");
 415                         RegistryPermission ep3 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
 416                         Assert.IsTrue (ep1.IsSubsetOf (ep3), "Write.IsSubsetOf(All)");
 417                         Assert.IsTrue (!ep3.IsSubsetOf (ep1), "All.IsSubsetOf(Write)");
 418                 }
 419
 420                 [Test]
 421                 [ExpectedException (typeof (ArgumentException))]
 422                 public void IsSubsetOfBadPermission ()
 423                 {
 424                         RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
 425                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 426                         Assert.IsTrue (ep1.IsSubsetOf (fdp2), "IsSubsetOf(FileDialogPermission)");
 427                 }
 428         }
 429 }