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

   1 //
   2 // EnvironmentPermissionTest.cs - NUnit Test Cases for EnvironmentPermission
   3 //
   4 // Author:
   5 //      Sebastien Pouliot (spouliot@motus.com)
   6 //
   7 // (C) 2003 Motus Technologies Inc. (http://www.motus.com)
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12 using System.Security;
  13 using System.Security.Permissions;
  14
  15 namespace MonoTests.System.Security.Permissions {
  16
  17         [TestFixture]
  18         public class EnvironmentPermissionTest : Assertion {
  19
  20                 private static string className = "System.Security.Permissions.EnvironmentPermission, ";
  21                 private static string envVariables = "TMP;TEMP";
  22
  23                 [Test]
  24                 public void PermissionStateNone ()
  25                 {
  26                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
  27                         AssertNotNull ("EnvironmentPermission(PermissionState.None)", ep);
  28                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  29                         EnvironmentPermission copy = (EnvironmentPermission) ep.Copy ();
  30                         AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
  31                         SecurityElement se = ep.ToXml ();
  32                         Assert ("ToXml-class", (se.Attributes ["class"] as string).StartsWith (className));
  33                         AssertEquals ("ToXml-version", "1", (se.Attributes ["version"] as string));
  34                 }
  35
  36                 [Test]
  37                 public void PermissionStateUnrestricted ()
  38                 {
  39                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.Unrestricted);
  40                         AssertNotNull ("EnvironmentPermission(PermissionState.Unrestricted)", ep);
  41                         Assert ("IsUnrestricted", ep.IsUnrestricted ());
  42                         EnvironmentPermission copy = (EnvironmentPermission) ep.Copy ();
  43                         AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
  44                         SecurityElement se = ep.ToXml ();
  45                         AssertEquals ("ToXml-Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
  46                 }
  47
  48                 [Test]
  49                 [ExpectedException (typeof (ArgumentNullException))]
  50                 public void NullPathList ()
  51                 {
  52                         EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, null);
  53                 }
  54
  55                 [Test]
  56                 public void AllAccess ()
  57                 {
  58                         EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, envVariables);
  59                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  60                 }
  61
  62                 [Test]
  63                 public void NoAccess ()
  64                 {
  65                         EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.NoAccess, envVariables);
  66                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  67                 }
  68
  69                 [Test]
  70                 public void ReadAccess ()
  71                 {
  72                         EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
  73                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  74                 }
  75
  76                 [Test]
  77                 public void WriteAccess ()
  78                 {
  79                         EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
  80                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  81                 }
  82
  83                 [Test]
  84                 public void AddPathList ()
  85                 {
  86                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
  87                         ep.AddPathList (EnvironmentPermissionAccess.AllAccess, envVariables);
  88                         // LAMESPEC NoAccess do not remove the TMP from AllAccess
  89                         ep.AddPathList (EnvironmentPermissionAccess.NoAccess, "TMP");
  90                         ep.AddPathList (EnvironmentPermissionAccess.Read, "UID");
  91                         ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
  92                         SecurityElement se = ep.ToXml ();
  93                         // Note: Debugger can mess results (try to run without stepping)
  94                         AssertEquals ("AddPathList-ToXml-Read", "TMP;TEMP;UID", (se.Attributes ["Read"] as string));
  95                         AssertEquals ("AddPathList-ToXml-Write", "TMP;TEMP;PROMPT", (se.Attributes ["Write"] as string));
  96                 }
  97
  98                 [Test]
  99                 [ExpectedException (typeof (ArgumentException))]
 100                 public void GetPathListAllAccess ()
 101                 {
 102                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 103                         ep.AddPathList (EnvironmentPermissionAccess.Read, "UID");
 104                         ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
 105                         AssertEquals ("GetPathList-AllAccess", "", ep.GetPathList (EnvironmentPermissionAccess.AllAccess));
 106                 }
 107
 108                 [Test]
 109                 [ExpectedException (typeof (ArgumentException))]
 110                 public void GetPathListNoAccess ()
 111                 {
 112                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 113                         ep.AddPathList (EnvironmentPermissionAccess.Read, "UID");
 114                         ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
 115                         AssertEquals ("GetPathList-NoAccess", "", ep.GetPathList (EnvironmentPermissionAccess.NoAccess));
 116                 }
 117
 118                 [Test]
 119                 public void GetPathList ()
 120                 {
 121                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 122                         AssertNull ("GetPathList-Read-Empty", ep.GetPathList (EnvironmentPermissionAccess.Read));
 123                         AssertNull ("GetPathList-Write-Empty", ep.GetPathList (EnvironmentPermissionAccess.Write));
 124                         ep.AddPathList (EnvironmentPermissionAccess.Read, "UID");
 125                         ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
 126                         AssertEquals ("GetPathList-Read", "UID", ep.GetPathList (EnvironmentPermissionAccess.Read));
 127                         AssertEquals ("GetPathList-Write", "PROMPT", ep.GetPathList (EnvironmentPermissionAccess.Write));
 128                 }
 129
 130                 [Test]
 131                 public void SetPathList ()
 132                 {
 133                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 134                         ep.SetPathList (EnvironmentPermissionAccess.AllAccess, envVariables);
 135                         // LAMESPEC NoAccess do not remove the TMP from AllAccess
 136                         ep.SetPathList (EnvironmentPermissionAccess.NoAccess, "SYSTEMROOT");
 137                         ep.SetPathList (EnvironmentPermissionAccess.Read, "UID");
 138                         ep.SetPathList (EnvironmentPermissionAccess.Write, "PROMPT");
 139                         SecurityElement se = ep.ToXml ();
 140                         AssertEquals ("SetPathList-ToXml-Read", "UID", (se.Attributes ["Read"] as string));
 141                         AssertEquals ("SetPathList-ToXml-Write", "PROMPT", (se.Attributes ["Write"] as string));
 142                 }
 143
 144                 [Test]
 145                 [ExpectedException (typeof (ArgumentNullException))]
 146                 public void FromXmlNull ()
 147                 {
 148                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 149                         ep.FromXml (null);
 150                 }
 151
 152                 [Test]
 153                 [ExpectedException (typeof (ArgumentException))]
 154                 public void FromXmlInvalidPermission ()
 155                 {
 156                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 157                         SecurityElement se = ep.ToXml ();
 158                         // can't modify - so we create our own
 159                         SecurityElement se2 = new SecurityElement ("IInvalidPermission", se.Text);
 160                         se2.AddAttribute ("class", se.Attribute ("class"));
 161                         se2.AddAttribute ("version", se.Attribute ("version"));
 162                         ep.FromXml (se2);
 163                 }
 164
 165                 [Test]
 166                 [ExpectedException (typeof (ArgumentException))]
 167                 public void FromXmlWrongVersion ()
 168                 {
 169                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 170                         SecurityElement se = ep.ToXml ();
 171                         // can't modify - so we create our own
 172                         SecurityElement se2 = new SecurityElement (se.Tag, se.Text);
 173                         se2.AddAttribute ("class", se.Attribute ("class"));
 174                         se2.AddAttribute ("version", "2");
 175                         ep.FromXml (se2);
 176                 }
 177
 178                 [Test]
 179                 public void FromXml ()
 180                 {
 181                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 182                         SecurityElement se = ep.ToXml ();
 183                         AssertNotNull ("ToXml()", se);
 184                         ep.FromXml (se);
 185                         se.AddAttribute ("Read", envVariables);
 186                         ep.FromXml (se);
 187                         AssertEquals ("FromXml-Read", envVariables, ep.GetPathList (EnvironmentPermissionAccess.Read));
 188                         se.AddAttribute ("Write", envVariables);
 189                         ep.FromXml (se);
 190                         AssertEquals ("FromXml-Read", envVariables, ep.GetPathList (EnvironmentPermissionAccess.Read));
 191                         AssertEquals ("FromXml-Write", envVariables, ep.GetPathList (EnvironmentPermissionAccess.Write));
 192                 }
 193
 194                 [Test]
 195                 public void UnionWithNull ()
 196                 {
 197                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 198                         EnvironmentPermission ep2 = null;
 199                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Union (ep2);
 200                         AssertEquals ("EP1 U null == EP1", ep1.ToXml ().ToString (), ep3.ToXml ().ToString ());
 201                 }
 202
 203                 [Test]
 204                 public void UnionWithUnrestricted ()
 205                 {
 206                         EnvironmentPermission ep1 = new EnvironmentPermission (PermissionState.Unrestricted);
 207                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 208                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Union (ep2);
 209                         Assert ("Unrestricted U EP2 == Unrestricted", ep3.IsUnrestricted ());
 210                         ep3 = (EnvironmentPermission) ep2.Union (ep1);
 211                         Assert ("EP2 U Unrestricted == Unrestricted", ep3.IsUnrestricted ());
 212                 }
 213
 214                 [Test]
 215                 public void Union ()
 216                 {
 217                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 218                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
 219                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Union (ep2);
 220                         EnvironmentPermission ep4 = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, envVariables);
 221                         AssertEquals ("EP1 U EP2 == EP1+2", ep3.ToXml ().ToString (), ep4.ToXml ().ToString ());
 222                 }
 223
 224                 [Test]
 225                 [ExpectedException (typeof (ArgumentException))]
 226                 public void UnionWithBadPermission ()
 227                 {
 228                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 229                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 230                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Union (fdp2);
 231                 }
 232
 233                 [Test]
 234                 public void IntersectWithNull ()
 235                 {
 236                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 237                         EnvironmentPermission ep2 = null;
 238                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Intersect (ep2);
 239                         AssertNull ("EP1 N null == null", ep3);
 240                 }
 241
 242                 [Test]
 243                 public void IntersectWithUnrestricted ()
 244                 {
 245                         EnvironmentPermission ep1 = new EnvironmentPermission (PermissionState.Unrestricted);
 246                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 247                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Intersect (ep2);
 248                         Assert ("Unrestricted N EP2 == EP2", !ep3.IsUnrestricted ());
 249                         AssertEquals ("Unrestricted N EP2 == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
 250                         ep3 = (EnvironmentPermission) ep2.Intersect (ep1);
 251                         Assert ("EP2 N Unrestricted == EP2", !ep3.IsUnrestricted ());
 252                         AssertEquals ("EP2 N Unrestricted == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
 253                 }
 254
 255                 [Test]
 256                 public void Intersect ()
 257                 {
 258                         // no intersection
 259                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
 260                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 261                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Intersect (ep2);
 262                         AssertNull ("EP1 N EP2 == null", ep3);
 263                         // intersection in read
 264                         EnvironmentPermission ep4 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, "TMP");
 265                         ep3 = (EnvironmentPermission) ep4.Intersect (ep2);
 266                         AssertEquals ("Intersect-Read", "TMP", ep3.GetPathList (EnvironmentPermissionAccess.Read));
 267                         // intersection in write
 268                         EnvironmentPermission ep5 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, "TEMP");
 269                         ep3 = (EnvironmentPermission) ep5.Intersect (ep1);
 270                         AssertEquals ("Intersect-Read", "TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Write));
 271                         // intersection in read and write
 272                         EnvironmentPermission ep6 = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, "TEMP");
 273                         EnvironmentPermission ep7 = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, envVariables);
 274                         ep3 = (EnvironmentPermission) ep6.Intersect (ep7);
 275                         AssertEquals ("Intersect-AllAccess-Read", "TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Read));
 276                         AssertEquals ("Intersect-AllAccess-Write", "TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Write));
 277                 }
 278
 279                 [Test]
 280                 [ExpectedException (typeof (ArgumentException))]
 281                 public void IntersectWithBadPermission ()
 282                 {
 283                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 284                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 285                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Intersect (fdp2);
 286                 }
 287
 288                 [Test]
 289                 public void IsSubsetOfNull ()
 290                 {
 291                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 292                         Assert ("IsSubsetOf(null)", !ep1.IsSubsetOf (null));
 293                 }
 294
 295                 [Test]
 296                 public void IsSubsetOfUnrestricted ()
 297                 {
 298                         EnvironmentPermission ep1 = new EnvironmentPermission (PermissionState.Unrestricted);
 299                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 300                         EnvironmentPermission ep3 = new EnvironmentPermission (PermissionState.Unrestricted);
 301                         Assert ("Unrestricted.IsSubsetOf()", !ep1.IsSubsetOf (ep2));
 302                         Assert ("IsSubsetOf(Unrestricted)", ep2.IsSubsetOf (ep1));
 303                         Assert ("Unrestricted.IsSubsetOf(Unrestricted)", ep1.IsSubsetOf (ep3));
 304                 }
 305
 306                 [Test]
 307                 public void IsSubsetOf ()
 308                 {
 309                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
 310                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 311                         Assert ("IsSubsetOf(nosubset1)", !ep1.IsSubsetOf (ep2));
 312                         Assert ("IsSubsetOf(nosubset2)", !ep2.IsSubsetOf (ep1));
 313                         EnvironmentPermission ep3 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, "TMP");
 314                         Assert ("IsSubsetOf(TMP)", !ep1.IsSubsetOf (ep3));
 315                         Assert ("TMP.IsSubsetOf()", ep3.IsSubsetOf (ep1));
 316                 }
 317
 318                 [Test]
 319                 [ExpectedException (typeof (ArgumentException))]
 320                 public void IsSubsetOfBadPermission ()
 321                 {
 322                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 323                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 324                         Assert ("IsSubsetOf(FileDialogPermission)", ep1.IsSubsetOf (fdp2));
 325                 }
 326         }
 327 }