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

   1 //
   2 // MonoTests.System.Security.Permissions.FileIOPermissionTest.cs
   3 //
   4 // Author:
   5 //   Nick Drochak (ndrochak@gol.com)
   6 //
   7 // (C) 2001-2002 Nick Drochak II
   8 //
   9 // Note: Only Unix and Windows file paths are tested.  To run the tests on Mac OS's
  10 // search for the "FIXME" notes below and adjust accordingly.
  11
  12 using System;
  13 using System.IO;
  14 using System.Runtime.InteropServices;
  15 using System.Security;
  16 using System.Security.Permissions;
  17 using System.Text;
  18
  19 using NUnit.Framework;
  20
  21 namespace MonoTests.System.Security.Permissions {
  22
  23         public class FilePathUtil {
  24                 [DllImport("kernel32.dll")]
  25                 private static extern uint GetLongPathName (string shortPath,
  26                         StringBuilder buffer, uint bufLength);
  27
  28                 static public string GetLongPathName (string somePath)
  29                 {
  30                         StringBuilder buffer = new StringBuilder(260);
  31                         if (0 != GetLongPathName (somePath, buffer, (uint) buffer.Capacity))
  32                                 return buffer.ToString ();
  33                         else
  34                                 return null;
  35                 }
  36         }
  37
  38         [TestFixture]
  39         public class FileIOPermissionTest : Assertion {
  40
  41                 string[] pathArrayGood;
  42                 string[] pathArrayBad;
  43                 FileIOPermission p;
  44                 FileIOPermission p2;
  45                 string[] pathsInPermission;
  46                 string[] pathArrayGood2;
  47                 FileIOPermission unrestricted;
  48
  49                 private string filename;
  50
  51                 [SetUp]
  52                 public void SetUp ()
  53                 {
  54                         Environment.CurrentDirectory = Path.GetTempPath();
  55                         filename = Path.GetTempFileName ();
  56
  57                         p = null;
  58                         pathsInPermission = null;
  59                         pathArrayGood = new string[2];
  60                         pathArrayBad = new string[2];
  61                         pathArrayGood2 = new string[3];
  62                         // FIXME: Adjust to run on Mac OS's
  63                         if (Path.VolumeSeparatorChar == ':') {
  64                                 pathArrayGood[0] = "c:\\temp1";
  65                                 pathArrayGood[1] = "d:\\temp2";
  66                                 pathArrayBad[0] = "c:\\temp1";
  67                                 pathArrayBad[1] = "d:\\temp*";
  68                                 pathArrayGood2[0] = "c:\\temp1";
  69                                 pathArrayGood2[1] = "d:\\temp2";
  70                                 pathArrayGood2[2] = "z:\\something";
  71                         }
  72                         else {
  73                                 pathArrayGood[0] = "/temp1";
  74                                 pathArrayGood[1] = "/usr/temp2";
  75                                 pathArrayBad[0] = "/temp1";
  76                                 pathArrayBad[1] = "/usr/temp*";
  77                                 pathArrayGood2[0] = "/temp1";
  78                                 pathArrayGood2[1] = "/usr/temp2";
  79                                 pathArrayGood2[2] = "/usr/bin/something";
  80                         }
  81                 }
  82
  83                 [TearDown]
  84                 public void TearDown ()
  85                 {
  86                         if (File.Exists (filename))
  87                                 File.Delete (filename);
  88                 }
  89
  90                 [Test]
  91                 public void ConstructorPermissionState ()
  92                 {
  93                         p = new FileIOPermission(PermissionState.None);
  94                         AssertEquals("Should be Restricted", false, p.IsUnrestricted());
  95                         p = new FileIOPermission(PermissionState.Unrestricted);
  96                         AssertEquals("Should be Unrestricted", true, p.IsUnrestricted());
  97                         try{
  98                                 p = new FileIOPermission((PermissionState)77);
  99                                 Fail("Should have thrown an exception on invalid PermissionState");
 100                         }
 101                         catch{
 102                                 // we should be here if things are working.  nothing to do
 103                         }
 104                 }
 105
 106                 [Test]
 107                 [ExpectedException (typeof (ArgumentNullException))]
 108                 public void ConstructorString_Null ()
 109                 {
 110                         p = new FileIOPermission(FileIOPermissionAccess.Append, (string)null);
 111                 }
 112
 113                 [Test]
 114                 [ExpectedException (typeof (ArgumentException))]
 115                 public void ConstructorString_NotRooted ()
 116                 {
 117                         p = new FileIOPermission(FileIOPermissionAccess.Append, "this path is not rooted");
 118                 }
 119
 120                 [Test]
 121                 [ExpectedException (typeof (ArgumentException))]
 122                 public void ConstructorString_InvalidPath ()
 123                 {
 124                         p = new FileIOPermission(FileIOPermissionAccess.Append, "<this is not a valid path>");
 125                 }
 126
 127                 [Test]
 128                 [ExpectedException (typeof (ArgumentException))]
 129                 public void ConstructorString_Wildcard ()
 130                 {
 131                         p = new FileIOPermission(FileIOPermissionAccess.Append, "\\\\mycomputer\\test*");
 132                 }
 133
 134                 [Test]
 135                 [ExpectedException (typeof (ArgumentException))]
 136                 public void ConstructorString_InvalidAccess ()
 137                 {
 138                         p = new FileIOPermission((FileIOPermissionAccess)77, "c:\\temp");
 139                 }
 140
 141                 [Test]
 142                 public void ConstructorString ()
 143                 {
 144                         string pathToAdd;
 145                         // FIXME: Adjust to run on Mac OS's
 146                         if (Path.VolumeSeparatorChar == ':')
 147                                 pathToAdd = "c:\\temp";
 148                         else
 149                                 pathToAdd = "/temp";
 150
 151                         p = new FileIOPermission(FileIOPermissionAccess.Read, pathToAdd);
 152                         pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);
 153                         Assert("Does not contain correct number of paths. Expected 1 but got: "+pathsInPermission.Length, pathsInPermission.Length == 1);
 154                         Assert("Does not contain expected path from constructor: "+pathToAdd, pathsInPermission[0] == pathToAdd);
 155                 }
 156
 157                 [Test]
 158                 [ExpectedException (typeof (ArgumentNullException))]
 159                 public void ConstructorStringArray_Null ()
 160                 {
 161                         p = new FileIOPermission(FileIOPermissionAccess.Append, (string[])null);
 162                 }
 163
 164                 [Test]
 165                 [ExpectedException (typeof (ArgumentException))]
 166                 public void ConstructorStringArray_Wildcard ()
 167                 {
 168                         p = new FileIOPermission(FileIOPermissionAccess.Append, pathArrayBad);
 169                 }
 170
 171                 [Test]
 172                 [ExpectedException (typeof (ArgumentException))]
 173                 public void ConstructorStringArray_InvalidAccess ()
 174                 {
 175                         p = new FileIOPermission((FileIOPermissionAccess)77, pathArrayGood);
 176                 }
 177
 178                 [Test]
 179                 public void ConstructorStringArray ()
 180                 {
 181                         p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
 182                         pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);
 183                         Assert("Does not contain correct number of paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);
 184                         foreach (string s in pathsInPermission){
 185                                 Assert("Unexpected path in the Permission: " + s, Array.IndexOf(pathsInPermission, s) >=0);
 186                         }
 187                 }
 188
 189                 [Test]
 190                 public void AddPathListStringArray ()
 191                 {
 192                         p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
 193                         pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);
 194                         Assert("Does not contain correct number of paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);
 195                         foreach (string s in pathsInPermission){
 196                                 Assert("Unexpected path in the Permission: " + s, Array.IndexOf(pathsInPermission, s) >=0);
 197                         }
 198
 199                         p.AddPathList(FileIOPermissionAccess.Append, pathArrayGood);
 200                         pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);
 201                         Assert("Should still contain correct number Read paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);
 202                         foreach (string s in pathsInPermission){
 203                                 Assert("Unexpected path in the Permission: " + s, Array.IndexOf(pathsInPermission, s) >=0);
 204                         }
 205                         pathsInPermission = p.GetPathList(FileIOPermissionAccess.Append);
 206                         Assert("Should contain correct number of Append paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);
 207                         foreach (string s in pathsInPermission){
 208                                 Assert("Unexpected path in the Permission: " + s, Array.IndexOf(pathsInPermission, s) >=0);
 209                         }
 210                 }
 211
 212                 [Test]
 213                 public void Intersect ()
 214                 {
 215                         p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
 216                         p.AllFiles = FileIOPermissionAccess.Append;
 217                         p.AllLocalFiles = FileIOPermissionAccess.Write;
 218
 219                         unrestricted = new FileIOPermission(PermissionState.Unrestricted);
 220
 221                         FileIOPermission intersection = (FileIOPermission)p.Intersect(unrestricted);
 222                         pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);
 223                         Assert("Should contain correct number of Read paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);
 224                         Assert("Should have Append bit in AllFiles.", (intersection.AllFiles & FileIOPermissionAccess.Append) != 0);
 225                         Assert("Should have Write bit in AllLocalFiles.", (intersection.AllLocalFiles & FileIOPermissionAccess.Write) != 0);
 226
 227                         intersection = (FileIOPermission)unrestricted.Intersect(p);
 228                         pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);
 229                         Assert("Should contain correct number of Read paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);
 230                         Assert("Should have Append bit in AllFiles.", (intersection.AllFiles & FileIOPermissionAccess.Append) != 0);
 231                         Assert("Should have Write bit in AllLocalFiles.", (intersection.AllLocalFiles & FileIOPermissionAccess.Write) != 0);
 232
 233                         p2 = new FileIOPermission(FileIOPermissionAccess.Append | FileIOPermissionAccess.Read, pathArrayGood2);
 234                         p2.AllFiles = FileIOPermissionAccess.Append | FileIOPermissionAccess.Write;
 235                         p2.AllLocalFiles = FileIOPermissionAccess.Write | FileIOPermissionAccess.Read;
 236                         intersection = (FileIOPermission)p.Intersect(p2);
 237                         pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);
 238                         AssertNotNull ("Should have some paths", pathsInPermission);
 239                         AssertEquals ("Should contain correct number of Read paths", 2, pathsInPermission.Length);
 240                         AssertEquals ("Should have only Append bit in AllFiles.",  FileIOPermissionAccess.Append, intersection.AllFiles);
 241                         AssertEquals ("Should have only Write bit in AllLocalFiles.",  FileIOPermissionAccess.Write, intersection.AllLocalFiles);
 242
 243                         intersection = (FileIOPermission)p2.Intersect(p);
 244                         pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);
 245                         Assert("Should contain correct number of Read paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);
 246                         Assert("Should have only Append bit in AllFiles.", intersection.AllFiles == FileIOPermissionAccess.Append);
 247                         Assert("Should have only Write bit in AllLocalFiles.", intersection.AllLocalFiles == FileIOPermissionAccess.Write);
 248                 }
 249
 250                 [Test]
 251                 public void IsSubsetOf ()
 252                 {
 253                         unrestricted = new FileIOPermission(PermissionState.Unrestricted);
 254                         Assert("IsSubsetOf reflective test failed", unrestricted.IsSubsetOf(unrestricted));
 255
 256                         p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
 257                         p.AllFiles = FileIOPermissionAccess.Append;
 258                         p.AllLocalFiles = FileIOPermissionAccess.Write;
 259                         Assert("#1 IsSubsetOf reflective test failed", p.IsSubsetOf(p));
 260                         Assert("#1 IsSubsetOf false test failed", !unrestricted.IsSubsetOf(p));
 261                         Assert("#1 IsSubsetOf true test failed", p.IsSubsetOf(unrestricted));
 262
 263                         p2 = new FileIOPermission(FileIOPermissionAccess.Append | FileIOPermissionAccess.Read, pathArrayGood2);
 264                         p2.AllFiles = FileIOPermissionAccess.Append | FileIOPermissionAccess.Write;
 265                         p2.AllLocalFiles = FileIOPermissionAccess.Write | FileIOPermissionAccess.Read;
 266                         Assert("#2 IsSubsetOf reflective test failed", p2.IsSubsetOf(p2));
 267                         Assert("#2 IsSubsetOf true test failed", p.IsSubsetOf(p2));
 268                         Assert("#2 IsSubsetOf false test failed", !p2.IsSubsetOf(p));
 269                 }
 270
 271                 [Test]
 272                 public void Union ()
 273                 {
 274                         unrestricted = new FileIOPermission(PermissionState.Unrestricted);
 275                         p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
 276
 277                         FileIOPermission union = (FileIOPermission)unrestricted.Union(p);
 278                         pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);
 279                         Assert("Should get an unrestricted permission", union.IsUnrestricted());
 280                         Assert("Path list should be empty", pathsInPermission == null);
 281
 282                         union = (FileIOPermission)p.Union(unrestricted);
 283                         pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);
 284                         Assert("Should get an unrestricted permission", union.IsUnrestricted());
 285                         Assert("Path list should be empty", pathsInPermission == null);
 286
 287                         p2 = new FileIOPermission(FileIOPermissionAccess.Append, pathArrayGood2);
 288
 289                         union = (FileIOPermission)p.Union(p2);
 290                         pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);
 291                         Assert("Path list should have 2 for Read", pathsInPermission.Length == pathArrayGood.Length);
 292                         pathsInPermission = union.GetPathList(FileIOPermissionAccess.Append);
 293                         Assert("Path list should have 3 for Append", pathsInPermission.Length == pathArrayGood2.Length);
 294
 295                         union = (FileIOPermission)p2.Union(p);
 296                         pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);
 297                         Assert("Path list should have 2 for Read", pathsInPermission.Length == pathArrayGood.Length);
 298                         pathsInPermission = union.GetPathList(FileIOPermissionAccess.Append);
 299                         Assert("Path list should have 3 for Append", pathsInPermission.Length == pathArrayGood2.Length);
 300                 }
 301
 302                 [Test]
 303                 public void FromXML ()
 304                 {
 305                         p = new FileIOPermission(PermissionState.None);
 306                         SecurityElement esd = new SecurityElement("IPermission");
 307                         esd.AddAttribute("class", "FileIOPermission");
 308                         esd.AddAttribute("version", "1");
 309                         esd.AddAttribute("Unrestricted", "true");
 310                         p.FromXml(esd);
 311                         Assert("Should get an unrestricted permission", p.IsUnrestricted());
 312
 313                         esd = new SecurityElement("IPermission");
 314                         esd.AddAttribute("class", "FileIOPermission");
 315                         esd.AddAttribute("version", "1");
 316                         // FIXME: Adjust to run on Mac OS's
 317                         if (Path.VolumeSeparatorChar == ':') {
 318                                 esd.AddAttribute("Read", "c:\\temp;d:\\temp2");
 319                                 esd.AddAttribute("Write", "c:\\temp;d:\\temp2;z:\\temp3");
 320                         }
 321                         else {
 322                                 esd.AddAttribute("Read", "/temp;/usr/temp2");
 323                                 esd.AddAttribute("Write", "/temp;/usr/temp2;/usr/bin/temp3");
 324                         }
 325                         p = new FileIOPermission(PermissionState.None);
 326                         p.FromXml(esd);
 327                         pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);
 328                         Assert("Path list should have 2 for Read", pathsInPermission.Length == 2);
 329                         pathsInPermission = p.GetPathList(FileIOPermissionAccess.Write);
 330                         Assert("Path list should have 2 for Write", pathsInPermission.Length == 3);
 331                 }
 332
 333                 [Test]
 334                 public void ToXML ()
 335                 {
 336                         p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
 337                         SecurityElement esd = p.ToXml();
 338                         Assert("Esd tag incorrect", esd.Tag == "IPermission");
 339                         Assert("Esd version incorrect", (String)esd.Attributes["version"] == "1");
 340                         string read = (String)esd.Attributes["Read"];
 341                         pathsInPermission = read.Split(';');
 342                         Assert("Path list should have 2 for Read", pathsInPermission.Length == 2);
 343                 }
 344
 345                 [Test]
 346                 [Ignore("should compatibility go that far ?")]
 347                 public void ShortToLong ()
 348                 {
 349                         // on windows this returns a "short" (8.3) path and filename
 350                         string filename = Path.GetTempFileName ();
 351                         p = new FileIOPermission(FileIOPermissionAccess.Read, filename);
 352                         string[] files = p.GetPathList (FileIOPermissionAccess.Read);
 353                         AssertEquals ("GetPathList.Count", 1, files.Length);
 354                         // FIXME: here GetTempFileName != GetPathList[0] for MS but == for Mono
 355                         AssertEquals ("Path.GetFileName(GetTempFileName)==Path.GetFileName(GetPathList[0])", Path.GetFileName (filename), Path.GetFileName (files [0]));
 356                         // note: this will fail on Linux as kernel32.dll isn't available
 357                         AssertEquals ("GetLongPathName(GetTempFileName)==GetPathList[0]", FilePathUtil.GetLongPathName (filename), files [0]);
 358                 }
 359         }
 360 }