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

   1 //
   2 // EnvironmentPermissionTest.cs - NUnit Test Cases for EnvironmentPermission
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) 2003 Motus Technologies Inc. (http://www.motus.com)
   8 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using NUnit.Framework;
  31 using System;
  32 using System.Security;
  33 using System.Security.Permissions;
  34
  35 namespace MonoTests.System.Security.Permissions {
  36
  37         [TestFixture]
  38         public class EnvironmentPermissionTest : Assertion {
  39
  40                 private static string className = "System.Security.Permissions.EnvironmentPermission, ";
  41                 private static string envVariables = "TMP;TEMP";
  42
  43                 [Test]
  44                 public void PermissionStateNone ()
  45                 {
  46                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
  47                         AssertNotNull ("EnvironmentPermission(PermissionState.None)", ep);
  48                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  49                         EnvironmentPermission copy = (EnvironmentPermission) ep.Copy ();
  50                         AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
  51                         SecurityElement se = ep.ToXml ();
  52                         Assert ("ToXml-class", (se.Attributes ["class"] as string).StartsWith (className));
  53                         AssertEquals ("ToXml-version", "1", (se.Attributes ["version"] as string));
  54                 }
  55
  56                 [Test]
  57                 public void PermissionStateUnrestricted ()
  58                 {
  59                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.Unrestricted);
  60                         AssertNotNull ("EnvironmentPermission(PermissionState.Unrestricted)", ep);
  61                         Assert ("IsUnrestricted", ep.IsUnrestricted ());
  62                         EnvironmentPermission copy = (EnvironmentPermission) ep.Copy ();
  63                         AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
  64                         SecurityElement se = ep.ToXml ();
  65                         AssertEquals ("ToXml-Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
  66                 }
  67
  68                 [Test]
  69                 [ExpectedException (typeof (ArgumentNullException))]
  70                 public void NullPathList ()
  71                 {
  72                         EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, null);
  73                 }
  74
  75                 [Test]
  76                 public void AllAccess ()
  77                 {
  78                         EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, envVariables);
  79                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  80                 }
  81
  82                 [Test]
  83                 public void NoAccess ()
  84                 {
  85                         EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.NoAccess, envVariables);
  86                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  87                 }
  88
  89                 [Test]
  90                 public void ReadAccess ()
  91                 {
  92                         EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
  93                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
  94                 }
  95
  96                 [Test]
  97                 public void WriteAccess ()
  98                 {
  99                         EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
 100                         Assert ("IsUnrestricted", !ep.IsUnrestricted ());
 101                 }
 102
 103                 [Test]
 104                 public void AddPathList ()
 105                 {
 106                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 107                         ep.AddPathList (EnvironmentPermissionAccess.AllAccess, envVariables);
 108                         // LAMESPEC NoAccess do not remove the TMP from AllAccess
 109                         ep.AddPathList (EnvironmentPermissionAccess.NoAccess, "TMP");
 110                         ep.AddPathList (EnvironmentPermissionAccess.Read, "UID");
 111                         ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
 112                         SecurityElement se = ep.ToXml ();
 113                         // Note: Debugger can mess results (try to run without stepping)
 114                         AssertEquals ("AddPathList-ToXml-Read", "TMP;TEMP;UID", (se.Attributes ["Read"] as string));
 115                         AssertEquals ("AddPathList-ToXml-Write", "TMP;TEMP;PROMPT", (se.Attributes ["Write"] as string));
 116                 }
 117
 118                 [Test]
 119                 [ExpectedException (typeof (ArgumentException))]
 120                 public void GetPathListAllAccess ()
 121                 {
 122                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 123                         ep.AddPathList (EnvironmentPermissionAccess.Read, "UID");
 124                         ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
 125                         AssertEquals ("GetPathList-AllAccess", "", ep.GetPathList (EnvironmentPermissionAccess.AllAccess));
 126                 }
 127
 128                 [Test]
 129                 [ExpectedException (typeof (ArgumentException))]
 130                 public void GetPathListNoAccess ()
 131                 {
 132                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 133                         ep.AddPathList (EnvironmentPermissionAccess.Read, "UID");
 134                         ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
 135                         AssertEquals ("GetPathList-NoAccess", "", ep.GetPathList (EnvironmentPermissionAccess.NoAccess));
 136                 }
 137
 138                 [Test]
 139                 public void GetPathList ()
 140                 {
 141                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 142 #if NET_2_0
 143                         AssertEquals ("GetPathList-Read-Empty", String.Empty, ep.GetPathList (EnvironmentPermissionAccess.Read));
 144                         AssertEquals ("GetPathList-Write-Empty", String.Empty, ep.GetPathList (EnvironmentPermissionAccess.Write));
 145 #else
 146                         AssertNull ("GetPathList-Read-Empty", ep.GetPathList (EnvironmentPermissionAccess.Read));
 147                         AssertNull ("GetPathList-Write-Empty", ep.GetPathList (EnvironmentPermissionAccess.Write));
 148 #endif
 149                         ep.AddPathList (EnvironmentPermissionAccess.Read, "UID");
 150                         ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
 151                         AssertEquals ("GetPathList-Read", "UID", ep.GetPathList (EnvironmentPermissionAccess.Read));
 152                         AssertEquals ("GetPathList-Write", "PROMPT", ep.GetPathList (EnvironmentPermissionAccess.Write));
 153                 }
 154
 155                 [Test]
 156                 public void SetPathList ()
 157                 {
 158                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 159                         ep.SetPathList (EnvironmentPermissionAccess.AllAccess, envVariables);
 160                         // LAMESPEC NoAccess do not remove the TMP from AllAccess
 161                         ep.SetPathList (EnvironmentPermissionAccess.NoAccess, "SYSTEMROOT");
 162                         ep.SetPathList (EnvironmentPermissionAccess.Read, "UID");
 163                         ep.SetPathList (EnvironmentPermissionAccess.Write, "PROMPT");
 164                         SecurityElement se = ep.ToXml ();
 165                         AssertEquals ("SetPathList-ToXml-Read", "UID", (se.Attributes ["Read"] as string));
 166                         AssertEquals ("SetPathList-ToXml-Write", "PROMPT", (se.Attributes ["Write"] as string));
 167                 }
 168
 169                 [Test]
 170                 [ExpectedException (typeof (ArgumentNullException))]
 171                 public void FromXmlNull ()
 172                 {
 173                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 174                         ep.FromXml (null);
 175                 }
 176
 177                 [Test]
 178                 [ExpectedException (typeof (ArgumentException))]
 179                 public void FromXmlInvalidPermission ()
 180                 {
 181                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 182                         SecurityElement se = ep.ToXml ();
 183                         // can't modify - so we create our own
 184                         SecurityElement se2 = new SecurityElement ("IInvalidPermission", se.Text);
 185                         se2.AddAttribute ("class", se.Attribute ("class"));
 186                         se2.AddAttribute ("version", se.Attribute ("version"));
 187                         ep.FromXml (se2);
 188                 }
 189
 190                 [Test]
 191                 [ExpectedException (typeof (ArgumentException))]
 192                 public void FromXmlWrongVersion ()
 193                 {
 194                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 195                         SecurityElement se = ep.ToXml ();
 196                         // can't modify - so we create our own
 197                         SecurityElement se2 = new SecurityElement (se.Tag, se.Text);
 198                         se2.AddAttribute ("class", se.Attribute ("class"));
 199                         se2.AddAttribute ("version", "2");
 200                         ep.FromXml (se2);
 201                 }
 202
 203                 [Test]
 204                 public void FromXml ()
 205                 {
 206                         EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
 207                         SecurityElement se = ep.ToXml ();
 208                         AssertNotNull ("ToXml()", se);
 209                         ep.FromXml (se);
 210                         se.AddAttribute ("Read", envVariables);
 211                         ep.FromXml (se);
 212                         AssertEquals ("FromXml-Read", envVariables, ep.GetPathList (EnvironmentPermissionAccess.Read));
 213                         se.AddAttribute ("Write", envVariables);
 214                         ep.FromXml (se);
 215                         AssertEquals ("FromXml-Read", envVariables, ep.GetPathList (EnvironmentPermissionAccess.Read));
 216                         AssertEquals ("FromXml-Write", envVariables, ep.GetPathList (EnvironmentPermissionAccess.Write));
 217                 }
 218
 219                 [Test]
 220                 public void UnionWithNull ()
 221                 {
 222                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 223                         EnvironmentPermission ep2 = null;
 224                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Union (ep2);
 225                         AssertEquals ("EP1 U null == EP1", ep1.ToXml ().ToString (), ep3.ToXml ().ToString ());
 226                 }
 227
 228                 [Test]
 229                 public void UnionWithUnrestricted ()
 230                 {
 231                         EnvironmentPermission ep1 = new EnvironmentPermission (PermissionState.Unrestricted);
 232                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 233                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Union (ep2);
 234                         Assert ("Unrestricted U EP2 == Unrestricted", ep3.IsUnrestricted ());
 235                         ep3 = (EnvironmentPermission) ep2.Union (ep1);
 236                         Assert ("EP2 U Unrestricted == Unrestricted", ep3.IsUnrestricted ());
 237                 }
 238
 239                 [Test]
 240                 public void Union ()
 241                 {
 242                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 243                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
 244                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Union (ep2);
 245                         EnvironmentPermission ep4 = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, envVariables);
 246                         AssertEquals ("EP1 U EP2 == EP1+2", ep3.ToXml ().ToString (), ep4.ToXml ().ToString ());
 247                 }
 248
 249                 [Test]
 250                 [ExpectedException (typeof (ArgumentException))]
 251                 public void UnionWithBadPermission ()
 252                 {
 253                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 254                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 255                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Union (fdp2);
 256                 }
 257
 258                 [Test]
 259                 public void IntersectWithNull ()
 260                 {
 261                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 262                         EnvironmentPermission ep2 = null;
 263                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Intersect (ep2);
 264                         AssertNull ("EP1 N null == null", ep3);
 265                 }
 266
 267                 [Test]
 268                 public void IntersectWithUnrestricted ()
 269                 {
 270                         EnvironmentPermission ep1 = new EnvironmentPermission (PermissionState.Unrestricted);
 271                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 272                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Intersect (ep2);
 273                         Assert ("Unrestricted N EP2 == EP2", !ep3.IsUnrestricted ());
 274                         AssertEquals ("Unrestricted N EP2 == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
 275                         ep3 = (EnvironmentPermission) ep2.Intersect (ep1);
 276                         Assert ("EP2 N Unrestricted == EP2", !ep3.IsUnrestricted ());
 277                         AssertEquals ("EP2 N Unrestricted == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
 278                 }
 279
 280                 [Test]
 281                 public void Intersect ()
 282                 {
 283                         // no intersection
 284                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
 285                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 286                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Intersect (ep2);
 287                         AssertNull ("EP1 N EP2 == null", ep3);
 288                         // intersection in read
 289                         EnvironmentPermission ep4 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, "TMP");
 290                         ep3 = (EnvironmentPermission) ep4.Intersect (ep2);
 291                         AssertEquals ("Intersect-Read", "TMP", ep3.GetPathList (EnvironmentPermissionAccess.Read));
 292                         // intersection in write
 293                         EnvironmentPermission ep5 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, "TEMP");
 294                         ep3 = (EnvironmentPermission) ep5.Intersect (ep1);
 295                         AssertEquals ("Intersect-Read", "TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Write));
 296                         // intersection in read and write
 297                         EnvironmentPermission ep6 = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, "TEMP");
 298                         EnvironmentPermission ep7 = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, envVariables);
 299                         ep3 = (EnvironmentPermission) ep6.Intersect (ep7);
 300                         AssertEquals ("Intersect-AllAccess-Read", "TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Read));
 301                         AssertEquals ("Intersect-AllAccess-Write", "TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Write));
 302                 }
 303
 304                 [Test]
 305                 [ExpectedException (typeof (ArgumentException))]
 306                 public void IntersectWithBadPermission ()
 307                 {
 308                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 309                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 310                         EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Intersect (fdp2);
 311                 }
 312
 313                 [Test]
 314                 public void IsSubsetOfNull ()
 315                 {
 316                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 317                         Assert ("IsSubsetOf(null)", !ep1.IsSubsetOf (null));
 318                 }
 319
 320                 [Test]
 321                 public void IsSubsetOfUnrestricted ()
 322                 {
 323                         EnvironmentPermission ep1 = new EnvironmentPermission (PermissionState.Unrestricted);
 324                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 325                         EnvironmentPermission ep3 = new EnvironmentPermission (PermissionState.Unrestricted);
 326                         Assert ("Unrestricted.IsSubsetOf()", !ep1.IsSubsetOf (ep2));
 327                         Assert ("IsSubsetOf(Unrestricted)", ep2.IsSubsetOf (ep1));
 328                         Assert ("Unrestricted.IsSubsetOf(Unrestricted)", ep1.IsSubsetOf (ep3));
 329                 }
 330
 331                 [Test]
 332                 public void IsSubsetOf ()
 333                 {
 334                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
 335                         EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 336                         Assert ("IsSubsetOf(nosubset1)", !ep1.IsSubsetOf (ep2));
 337                         Assert ("IsSubsetOf(nosubset2)", !ep2.IsSubsetOf (ep1));
 338                         EnvironmentPermission ep3 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, "TMP");
 339                         Assert ("IsSubsetOf(TMP)", !ep1.IsSubsetOf (ep3));
 340                         Assert ("TMP.IsSubsetOf()", ep3.IsSubsetOf (ep1));
 341                 }
 342
 343                 [Test]
 344                 [ExpectedException (typeof (ArgumentException))]
 345                 public void IsSubsetOfBadPermission ()
 346                 {
 347                         EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
 348                         FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
 349                         Assert ("IsSubsetOf(FileDialogPermission)", ep1.IsSubsetOf (fdp2));
 350                 }
 351         }
 352 }