mcs/class/corlib/Test/System.IO/DirectoryTest.cs

   1 //\r
   2 // System.IO.Directory\r
   3 //\r
   4 // Authors: \r
   5 //      Ville Palo (vi64pa@kolumbus.fi)\r
   6 //\r
   7 // (C) 2003 Ville Palo\r
   8 //\r
   9 // TODO: Find out why ArgumentOutOfRange tests does not release directories properly\r
  10 //\r
  11 \r
  12 using System;\r
  13 using System.Collections.Generic;\r
  14 using System.Diagnostics;\r
  15 using System.Globalization;\r
  16 using System.IO;\r
  17 using System.Text;\r
  18 using System.Threading;\r
  19 \r
  20 #if !MONOTOUCH\r
  21 using Mono.Unix;\r
  22 #endif\r
  23 using NUnit.Framework;\r
  24 \r
  25 namespace MonoTests.System.IO\r
  26 {\r
  27 \r
  28 [TestFixture]\r
  29 public class DirectoryTest\r
  30 {\r
  31         static readonly string TempSubFolder = "MonoTests.System.IO.Tests";\r
  32         string TempFolder = Path.Combine (Path.GetTempPath (), TempSubFolder);\r
  33         static readonly char DSC = Path.DirectorySeparatorChar;\r
  34 \r
  35         [SetUp]\r
  36         public void SetUp ()\r
  37         {\r
  38                 if (!Directory.Exists (TempFolder))\r
  39                         Directory.CreateDirectory (TempFolder);\r
  40 \r
  41                 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");\r
  42         }\r
  43         \r
  44         [TearDown]\r
  45         public void TearDown ()\r
  46         {\r
  47                 if (Directory.Exists (TempFolder))\r
  48                         Directory.Delete (TempFolder, true);\r
  49         }\r
  50 #if !MONOTOUCH\r
  51         [Test] //BXC #12461\r
  52         public void EnumerateFilesListSymlinks ()\r
  53         {\r
  54                 if (!RunningOnUnix)\r
  55                         return;\r
  56 \r
  57                 var afile = Path.Combine (TempFolder, "afile.src");\r
  58                 var bfile = Path.Combine (TempFolder, "bfile.src");\r
  59                 var cdir = Path.Combine (TempFolder, "cdir.src");\r
  60 \r
  61                 File.AppendAllText (afile, "hello");\r
  62                 var info = new UnixFileInfo (afile);\r
  63                 info.CreateSymbolicLink (bfile);\r
  64                 Directory.CreateDirectory (cdir);\r
  65 \r
  66                 var files0 = Directory.GetFiles (TempFolder, "*.src");\r
  67                 Array.Sort (files0);\r
  68                 Assert.AreEqual (2, files0.Length, "#1");\r
  69                 Assert.AreEqual (afile, files0 [0], "#2");\r
  70                 Assert.AreEqual (bfile, files0 [1], "#3");\r
  71 \r
  72 #if NET_4_0\r
  73                 var files1 = new List<string> (Directory.EnumerateFiles (TempFolder, "*.src")).ToArray ();\r
  74                 Array.Sort (files1);\r
  75                 Assert.AreEqual (2, files1.Length, "#1.b");\r
  76                 Assert.AreEqual (afile, files1 [0], "#2.b");\r
  77                 Assert.AreEqual (bfile, files1 [1], "#3.b");\r
  78 #endif\r
  79 \r
  80                 var files2 = Directory.GetFileSystemEntries (TempFolder, "*.src");\r
  81                 Array.Sort (files2);\r
  82                 Assert.AreEqual (3, files2.Length, "#1.c");\r
  83                 Assert.AreEqual (afile, files2 [0], "#2.c");\r
  84                 Assert.AreEqual (bfile, files2 [1], "#3.c");\r
  85                 Assert.AreEqual (cdir, files2 [2], "#4.c");\r
  86 \r
  87 #if NET_4_0\r
  88                 var files3 = new List<string> (Directory.EnumerateFileSystemEntries (TempFolder, "*.src")).ToArray ();\r
  89                 Array.Sort (files3);\r
  90                 Assert.AreEqual (3, files3.Length, "#1.d");\r
  91                 Assert.AreEqual (afile, files3 [0], "#2.d");\r
  92                 Assert.AreEqual (bfile, files3 [1], "#3.d");\r
  93                 Assert.AreEqual (cdir, files3 [2], "#4.d");\r
  94 #endif\r
  95         }\r
  96 #endif\r
  97         [Test]\r
  98         public void CreateDirectory ()\r
  99         {\r
 100                 string path = TempFolder + DSC + "DirectoryTest.Test.1";\r
 101                 DeleteDirectory (path);\r
 102                 try {\r
 103                         DirectoryInfo info = Directory.CreateDirectory (path);\r
 104                         Assert.IsTrue (info.Exists, "#1");\r
 105                         Assert.AreEqual (".1", info.Extension, "#2");\r
 106                         Assert.IsTrue (info.FullName.EndsWith ("DirectoryTest.Test.1"), "#3");\r
 107                         Assert.AreEqual ("DirectoryTest.Test.1", info.Name, "#4");\r
 108                 } finally {\r
 109                         DeleteDirectory (path);\r
 110                 }\r
 111         }\r
 112         \r
 113         /* Commented out: a directory named ":" is legal in unix\r
 114         [Test]\r
 115         public void CreateDirectoryNotSupportedException ()\r
 116         {\r
 117                 DeleteDirectory (":");\r
 118                 try {\r
 119                         DirectoryInfo info = Directory.CreateDirectory (":");\r
 120                         Assert.Fail ("#1");\r
 121                 } catch (ArgumentException ex) {\r
 122                         // The path is not of a legal form\r
 123                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
 124                         Assert.IsNull (ex.InnerException, "#3");\r
 125                         Assert.IsNotNull (ex.Message, "#4");\r
 126                         Assert.IsNull (ex.ParamName, "#5");\r
 127                 }\r
 128                 DeleteDirectory (":");\r
 129         }\r
 130         */\r
 131 \r
 132         [Test]\r
 133         public void CreateDirectory_Path_Null ()\r
 134         {\r
 135                 try {\r
 136                         Directory.CreateDirectory (null as string);\r
 137                         Assert.Fail ("#1");\r
 138                 } catch (ArgumentNullException ex) {\r
 139                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 140                         Assert.IsNull (ex.InnerException, "#3");\r
 141                         Assert.IsNotNull (ex.Message, "#4");\r
 142                         Assert.AreEqual ("path", ex.ParamName, "#5");\r
 143                 }\r
 144         }\r
 145 \r
 146         [Test]\r
 147         public void CreateDirectory_Path_Empty ()\r
 148         {\r
 149                 try {\r
 150                         Directory.CreateDirectory (string.Empty);\r
 151                         Assert.Fail ("#1");\r
 152                 } catch (ArgumentException ex) {\r
 153                         // Path cannot be the empty string or all whitespace\r
 154                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
 155                         Assert.IsNull (ex.InnerException, "#3");\r
 156                         Assert.IsNotNull (ex.Message, "#4");\r
 157                         Assert.IsNull (ex.ParamName, "#5");\r
 158                 }\r
 159         }\r
 160 \r
 161         [Test]\r
 162         public void CreateDirectory_Path_Whitespace ()\r
 163         {\r
 164                 try {\r
 165                         Directory.CreateDirectory ("            ");\r
 166                         Assert.Fail ("#1");\r
 167                 } catch (ArgumentException ex) {\r
 168                         // The path is not of a legal form\r
 169                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
 170                         Assert.IsNull (ex.InnerException, "#3");\r
 171                         Assert.IsNotNull (ex.Message, "#4");\r
 172                         Assert.IsNull (ex.ParamName, "#5");\r
 173                 }\r
 174         }\r
 175 \r
 176         [Test]\r
 177         public void CreateDirectory_Path_InvalidChars ()\r
 178         {\r
 179                 string path = TempFolder + DSC + "DirectoryTest.Test";\r
 180                 DeleteDirectory (path);\r
 181                 try {\r
 182                         path += '\x00';\r
 183                         path += ".2";\r
 184                         DirectoryInfo info = Directory.CreateDirectory (path);\r
 185                         Assert.Fail ("#1");\r
 186                 } catch (ArgumentException ex) {\r
 187                         // The path contains illegal characters\r
 188                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
 189                         Assert.IsNull (ex.InnerException, "#3");\r
 190                         Assert.IsNotNull (ex.Message, "#4");\r
 191                         Assert.IsNull (ex.ParamName, "#5");\r
 192                 } finally {\r
 193                         DeleteDirectory (path);\r
 194                 }\r
 195         }\r
 196 \r
 197         [Test]\r
 198         public void CreateDirectoryAlreadyExists ()\r
 199         {\r
 200                 string path = TempFolder + DSC + "DirectoryTest.Test.Exists";\r
 201                 DeleteDirectory (path);\r
 202                 try {\r
 203                         DirectoryInfo info1 = Directory.CreateDirectory (path);\r
 204                         DirectoryInfo info2 = Directory.CreateDirectory (path);\r
 205 \r
 206                         Assert.IsTrue (info2.Exists, "#1");\r
 207                         Assert.IsTrue (info2.FullName.EndsWith ("DirectoryTest.Test.Exists"), "#2");\r
 208                         Assert.AreEqual ("DirectoryTest.Test.Exists", info2.Name, "#3");\r
 209                 } finally {\r
 210                         DeleteDirectory (path);\r
 211                 }\r
 212         }\r
 213 \r
 214         [Test]\r
 215         public void CreateDirectoryAlreadyExistsAsFile ()\r
 216         {\r
 217                 string path = TempFolder + DSC + "DirectoryTest.Test.ExistsAsFile";\r
 218                 DeleteDirectory (path);\r
 219                 DeleteFile (path);\r
 220                 try {\r
 221                         FileStream fstream = File.Create (path);\r
 222                         fstream.Close();\r
 223 \r
 224                         DirectoryInfo dinfo = Directory.CreateDirectory (path);\r
 225 #if NET_2_0\r
 226                         Assert.Fail ("#1");\r
 227                 } catch (IOException ex) {\r
 228                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");\r
 229                         // exception message contains the path\r
 230                         Assert.IsTrue (ex.Message.Contains (path), "#3");\r
 231                         Assert.IsNull (ex.InnerException, "#4");\r
 232 #else\r
 233                         Assert.IsFalse (dinfo.Exists, "#2");\r
 234                         Assert.IsTrue (dinfo.FullName.EndsWith ("DirectoryTest.Test.ExistsAsFile"), "#3");\r
 235                         Assert.AreEqual ("DirectoryTest.Test.ExistsAsFile", dinfo.Name, "#4");\r
 236 #endif\r
 237                 } finally {\r
 238                         DeleteDirectory (path);\r
 239                         DeleteFile (path);\r
 240                 }\r
 241         }\r
 242 \r
 243         [Test]\r
 244         public void Delete ()\r
 245         {\r
 246                 string path = TempFolder + DSC + "DirectoryTest.Test.Delete.1";\r
 247                 DeleteDirectory (path);\r
 248                 try {\r
 249                         Directory.CreateDirectory (path);\r
 250                         Assert.IsTrue (Directory.Exists (path), "#1");\r
 251                 \r
 252                         Directory.CreateDirectory (path + DSC + "DirectoryTest.Test.Delete.1.2");\r
 253                         Assert.IsTrue (Directory.Exists (path + DSC + "DirectoryTest.Test.Delete.1.2"), "#2");\r
 254                 \r
 255                         Directory.Delete (path + DSC + "DirectoryTest.Test.Delete.1.2");\r
 256                         Assert.IsFalse (Directory.Exists (path + DSC + "DirectoryTest.Test.Delete.1.2"), "#3");\r
 257                         Assert.IsTrue (Directory.Exists (path), "#4");\r
 258                 \r
 259                         Directory.Delete (path);\r
 260                         Assert.IsFalse (Directory.Exists (path + DSC + "DirectoryTest.Test.Delete.1.2"), "#5");\r
 261                         Assert.IsFalse (Directory.Exists (path), "#6");\r
 262         \r
 263                         Directory.CreateDirectory (path);\r
 264                         Directory.CreateDirectory (path + DSC + "DirectoryTest.Test.Delete.1.2");\r
 265                         Assert.IsTrue (Directory.Exists (path + DSC + "DirectoryTest.Test.Delete.1.2"), "#7");\r
 266                         Assert.IsTrue (Directory.Exists (path), "#8");\r
 267                 \r
 268                         Directory.Delete (path, true);\r
 269                         Assert.IsFalse (Directory.Exists (path + DSC + "DirectoryTest.Test.Delete.1.2"), "#9");\r
 270                         Assert.IsFalse (Directory.Exists (path), "#10");\r
 271                 } finally {\r
 272                         DeleteDirectory (path);\r
 273                 }\r
 274         }\r
 275 \r
 276         [Test]  \r
 277         [ExpectedException(typeof(ArgumentException))]\r
 278         public void DeleteArgumentException ()\r
 279         {\r
 280                 Directory.Delete (string.Empty);\r
 281         }\r
 282 \r
 283         [Test]  \r
 284         [ExpectedException(typeof(ArgumentException))]\r
 285         public void DeleteArgumentException2 ()\r
 286         {\r
 287                 Directory.Delete ("     ");\r
 288         }\r
 289 \r
 290         [Test]  \r
 291         [ExpectedException(typeof(ArgumentException))]\r
 292         public void DeleteArgumentException3 ()\r
 293         {\r
 294                 string path = TempFolder + DSC + "DirectoryTest.Test.4";\r
 295                 DeleteDirectory (path);\r
 296                 \r
 297                 path += Path.InvalidPathChars [0];\r
 298                 Directory.Delete (path);\r
 299         }\r
 300 \r
 301         [Test]  \r
 302         [ExpectedException(typeof(ArgumentNullException))]\r
 303         public void DeleteArgumentNullException ()\r
 304         {\r
 305                 Directory.Delete (null as string);\r
 306         }\r
 307 \r
 308         [Test]  \r
 309         [ExpectedException(typeof(DirectoryNotFoundException))]\r
 310         public void DeleteDirectoryNotFoundException ()\r
 311         {\r
 312                 string path = TempFolder + DSC + "DirectoryTest.Test.5";\r
 313                 DeleteDirectory (path);\r
 314                 \r
 315                 Directory.Delete (path);\r
 316         }\r
 317 \r
 318         [Test]  \r
 319         [ExpectedException(typeof(IOException))]\r
 320         public void DeleteArgumentException4 ()\r
 321         {\r
 322                 string path = TempFolder + DSC + "DirectoryTest.Test.6";\r
 323                 DeleteDirectory (path);\r
 324                 FileStream s = null;\r
 325                 Directory.CreateDirectory (path);\r
 326                 try {\r
 327                         s = File.Create (path + DSC + "DirectoryTest.Test.6");\r
 328                         Directory.Delete (path);\r
 329                 } finally {\r
 330                         if (s != null)\r
 331                                 s.Close ();\r
 332                         DeleteDirectory (path);\r
 333                 };\r
 334         }\r
 335 \r
 336         [Test]\r
 337         public void DeleteDirectoryOnExistingFileName ()\r
 338         {\r
 339                 string path = TempFolder + DSC + "DirectoryTest.Test.ExistsAsFile";\r
 340                 DeleteDirectory (path);\r
 341                 DeleteFile (path);\r
 342                 try {\r
 343                         FileStream fstream = File.Create (path);\r
 344                         fstream.Close ();\r
 345 \r
 346                         Directory.Delete (path);\r
 347                         Assert.Fail ("#1");\r
 348                 }\r
 349                 catch (IOException ex) {\r
 350                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");\r
 351                         // exception message DOES NOT contains the path\r
 352                         Assert.IsFalse (ex.Message.IndexOf (path) >= 0, "#3");\r
 353                         Assert.IsNull (ex.InnerException, "#4");\r
 354                 }\r
 355                 finally {\r
 356                         DeleteDirectory (path);\r
 357                         DeleteFile (path);\r
 358                 }\r
 359         }\r
 360 \r
 361         [Test]\r
 362         public void Exists ()\r
 363         {\r
 364                 Assert.IsFalse (Directory.Exists (null as string));\r
 365         }\r
 366 \r
 367 #if !TARGET_JVM && !MOBILE // We don't support yet the Process class.\r
 368         [Test] // bug #78239\r
 369         public void ExistsAccessDenied ()\r
 370         {\r
 371                 if (!RunningOnUnix)\r
 372                         return; // this test does not work on Windows.\r
 373 \r
 374                 string path = TempFolder + DSC + "ExistsAccessDenied";\r
 375 \r
 376                 Directory.CreateDirectory (path);\r
 377                 Mono.Posix.Syscall.chmod (path, 0);\r
 378                 try {\r
 379                         Assert.IsFalse (Directory.Exists(path + DSC + "b"));\r
 380                 } finally {\r
 381                         Mono.Posix.Syscall.chmod (path, (Mono.Posix.FileMode) 755);\r
 382                         Directory.Delete (path);\r
 383                 }\r
 384         }\r
 385 #endif\r
 386         \r
 387         [Test]\r
 388         [Category("TargetJvmNotSupported")] // GetCreationTime not supported for TARGET_JVM\r
 389         [ExpectedException(typeof(ArgumentNullException))]\r
 390         public void GetCreationTimeException1 ()\r
 391         {\r
 392                 Directory.GetCreationTime (null as string);\r
 393         }\r
 394 \r
 395         [Test]\r
 396         [ExpectedException(typeof(ArgumentException))]\r
 397         [Category("TargetJvmNotSupported")] // GetCreationTime not supported for TARGET_JVM\r
 398         public void GetCreationTimeException2 ()\r
 399         {\r
 400                 Directory.GetCreationTime (string.Empty);\r
 401         }\r
 402         \r
 403         [Test]\r
 404 #if !NET_2_0\r
 405         [ExpectedException(typeof(IOException))]\r
 406 #endif\r
 407         [Category("TargetJvmNotSupported")] // GetCreationTime not supported for TARGET_JVM\r
 408         public void GetCreationTimeException_NonExistingPath ()\r
 409         {\r
 410                 string path = TempFolder + DSC + "DirectoryTest.GetCreationTime.1";\r
 411                 DeleteDirectory (path);\r
 412                 try {\r
 413                         DateTime time = Directory.GetCreationTime (path);\r
 414 \r
 415 #if NET_2_0\r
 416                         DateTime expectedTime = (new DateTime (1601, 1, 1)).ToLocalTime ();\r
 417                         Assert.AreEqual (expectedTime.Year, time.Year, "#1");\r
 418                         Assert.AreEqual (expectedTime.Month, time.Month, "#2");\r
 419                         Assert.AreEqual (expectedTime.Day, time.Day, "#3");\r
 420                         Assert.AreEqual (expectedTime.Hour, time.Hour, "#4");\r
 421                         Assert.AreEqual (expectedTime.Second, time.Second, "#5");\r
 422                         Assert.AreEqual (expectedTime.Millisecond, time.Millisecond, "#6");\r
 423 #endif\r
 424                 } finally {\r
 425                         DeleteDirectory (path);\r
 426                 }\r
 427         }\r
 428 \r
 429         [Test]\r
 430         [ExpectedException(typeof(ArgumentException))]\r
 431         [Category("TargetJvmNotSupported")] // GetCreationTime not supported for TARGET_JVM\r
 432         public void GetCreationTimeException4 ()\r
 433         {\r
 434                 Directory.GetCreationTime ("    ");\r
 435         }\r
 436 \r
 437         [Test]\r
 438         [ExpectedException(typeof(ArgumentException))]\r
 439         [Category("TargetJvmNotSupported")] // GetCreationTime not supported for TARGET_JVM\r
 440         public void GetCreationTimeException5 ()\r
 441         {\r
 442                 Directory.GetCreationTime (Path.InvalidPathChars [0].ToString ());\r
 443         }\r
 444 \r
 445         [Test]\r
 446         [ExpectedException(typeof(ArgumentNullException))]\r
 447         [Category("TargetJvmNotSupported")] // GetCreationTime not supported for TARGET_JVM\r
 448         public void GetCreationTimeUtcException1 ()\r
 449         {\r
 450                 Directory.GetCreationTimeUtc (null as string);\r
 451         }\r
 452 \r
 453         [Test]\r
 454         [ExpectedException(typeof(ArgumentException))]\r
 455         [Category("TargetJvmNotSupported")] // GetCreationTime not supported for TARGET_JVM\r
 456         public void GetCreationTimeUtcException2 ()\r
 457         {\r
 458                 Directory.GetCreationTimeUtc (string.Empty);\r
 459         }\r
 460         \r
 461         [Test]\r
 462 #if !NET_2_0\r
 463         [ExpectedException (typeof (IOException))]\r
 464 #endif\r
 465         [Category("TargetJvmNotSupported")] // GetCreationTime not supported for TARGET_JVM\r
 466         public void GetCreationTimeUtc_NonExistingPath ()\r
 467         {\r
 468                 string path = TempFolder + DSC + "DirectoryTest.GetCreationTimeUtc.1";\r
 469                 DeleteDirectory (path);\r
 470                 \r
 471                 try {\r
 472                         DateTime time = Directory.GetCreationTimeUtc (path);\r
 473 \r
 474 #if NET_2_0\r
 475                         Assert.AreEqual (1601, time.Year, "#1");\r
 476                         Assert.AreEqual (1, time.Month, "#2");\r
 477                         Assert.AreEqual (1, time.Day, "#3");\r
 478                         Assert.AreEqual (0, time.Hour, "#4");\r
 479                         Assert.AreEqual (0, time.Second, "#5");\r
 480                         Assert.AreEqual (0, time.Millisecond, "#6");\r
 481 #endif\r
 482                 } finally {\r
 483                         DeleteDirectory (path);\r
 484                 }\r
 485         }\r
 486 \r
 487         [Test]\r
 488         [ExpectedException(typeof(ArgumentException))]\r
 489         [Category("TargetJvmNotSupported")] // GetCreationTime not supported for TARGET_JVM\r
 490         public void GetCreationTimeUtcException4 ()\r
 491         {\r
 492                 Directory.GetCreationTimeUtc ("    ");\r
 493         }\r
 494 \r
 495         [Test]\r
 496         [ExpectedException(typeof(ArgumentException))]\r
 497         [Category("TargetJvmNotSupported")] // GetCreationTime not supported for TARGET_JVM\r
 498         public void GetCreationTimeUtcException5 ()\r
 499         {\r
 500                 Directory.GetCreationTime (Path.InvalidPathChars [0].ToString ());\r
 501         }\r
 502 \r
 503         [Test]\r
 504         [ExpectedException(typeof(ArgumentNullException))]\r
 505         [Category("TargetJvmNotSupported")] // GetLastAccessTime not supported for TARGET_JVM\r
 506         public void GetLastAccessTime_Null ()\r
 507         {\r
 508                 Directory.GetLastAccessTime (null as string);\r
 509         }\r
 510 \r
 511         [Test]\r
 512         [ExpectedException(typeof(ArgumentException))]\r
 513         [Category("TargetJvmNotSupported")] // GetLastAccessTime not supported for TARGET_JVM\r
 514         public void GetLastAccessTimeException2 ()\r
 515         {\r
 516                 Directory.GetLastAccessTime (string.Empty);\r
 517         }\r
 518         \r
 519         [Test]\r
 520 #if !NET_2_0\r
 521         [ExpectedException (typeof (IOException))]\r
 522 #endif\r
 523         [Category("TargetJvmNotSupported")] // GetLastAccessTime not supported for TARGET_JVM\r
 524         public void GetLastAccessTime_NonExistingPath ()\r
 525         {\r
 526                 string path = TempFolder + DSC + "DirectoryTest.GetLastAccessTime.1";\r
 527                 DeleteDirectory (path);\r
 528                 \r
 529                 try {\r
 530                         DateTime time = Directory.GetLastAccessTime (path);\r
 531 \r
 532 #if NET_2_0\r
 533                         DateTime expectedTime = (new DateTime (1601, 1, 1)).ToLocalTime ();\r
 534                         Assert.AreEqual (expectedTime.Year, time.Year, "#1");\r
 535                         Assert.AreEqual (expectedTime.Month, time.Month, "#2");\r
 536                         Assert.AreEqual (expectedTime.Day, time.Day, "#3");\r
 537                         Assert.AreEqual (expectedTime.Hour, time.Hour, "#4");\r
 538                         Assert.AreEqual (expectedTime.Second, time.Second, "#5");\r
 539                         Assert.AreEqual (expectedTime.Millisecond, time.Millisecond, "#6");\r
 540 #endif\r
 541                 } finally {\r
 542                         DeleteDirectory (path);\r
 543                 }\r
 544         }\r
 545 \r
 546         [Test]\r
 547         [ExpectedException(typeof(ArgumentException))]\r
 548         [Category("TargetJvmNotSupported")] // GetLastAccessTime not supported for TARGET_JVM\r
 549         public void GetLastAccessTimeException4 ()\r
 550         {\r
 551                 Directory.GetLastAccessTime ("    ");\r
 552         }\r
 553 \r
 554         [Test]\r
 555         [ExpectedException(typeof(ArgumentException))]\r
 556         [Category("TargetJvmNotSupported")] // GetLastAccessTime not supported for TARGET_JVM\r
 557         public void GetLastAccessTimeException5 ()\r
 558         {\r
 559                 Directory.GetLastAccessTime (Path.InvalidPathChars [0].ToString ());\r
 560         }\r
 561 \r
 562         [Test]\r
 563         [ExpectedException(typeof(ArgumentNullException))]\r
 564         [Category("TargetJvmNotSupported")] // GetLastAccessTime not supported for TARGET_JVM\r
 565         public void GetLastAccessTimeUtc_Null ()\r
 566         {\r
 567                 Directory.GetLastAccessTimeUtc (null as string);\r
 568         }\r
 569 \r
 570         [Test]\r
 571         [ExpectedException(typeof(ArgumentException))]\r
 572         [Category("TargetJvmNotSupported")] // GetLastAccessTime not supported for TARGET_JVM\r
 573         public void GetLastAccessTimeUtcException2 ()\r
 574         {\r
 575                 Directory.GetLastAccessTimeUtc (string.Empty);\r
 576         }\r
 577         \r
 578         [Test]\r
 579 #if !NET_2_0\r
 580         [ExpectedException (typeof (IOException))]\r
 581 #endif\r
 582         [Category("TargetJvmNotSupported")] // GetLastAccessTime not supported for TARGET_JVM\r
 583         public void GetLastAccessTimeUtc_NonExistingPath ()\r
 584         {\r
 585                 string path = TempFolder + DSC + "DirectoryTest.GetLastAccessTimeUtc.1";\r
 586                 DeleteDirectory (path);\r
 587                 try {\r
 588                         DateTime time = Directory.GetLastAccessTimeUtc (path);\r
 589 \r
 590 #if NET_2_0\r
 591                         Assert.AreEqual (1601, time.Year, "#1");\r
 592                         Assert.AreEqual (1, time.Month, "#2");\r
 593                         Assert.AreEqual (1, time.Day, "#3");\r
 594                         Assert.AreEqual (0, time.Hour, "#4");\r
 595                         Assert.AreEqual (0, time.Second, "#5");\r
 596                         Assert.AreEqual (0, time.Millisecond, "#6");\r
 597 #endif\r
 598                 } finally {\r
 599                         DeleteDirectory (path);\r
 600                 }\r
 601         }\r
 602 \r
 603         [Test]\r
 604         [ExpectedException(typeof(ArgumentException))]\r
 605         [Category("TargetJvmNotSupported")] // GetLastAccessTime not supported for TARGET_JVM\r
 606         public void GetLastAccessTimeUtcException4 ()\r
 607         {\r
 608                 Directory.GetLastAccessTimeUtc ("    ");\r
 609         }\r
 610 \r
 611         [Test]\r
 612         [ExpectedException(typeof(ArgumentException))]\r
 613         [Category("TargetJvmNotSupported")] // GetLastAccessTime not supported for TARGET_JVM\r
 614         public void GetLastAccessTimeUtcException5 ()\r
 615         {\r
 616                 Directory.GetLastAccessTimeUtc (Path.InvalidPathChars [0].ToString ());\r
 617         }\r
 618 \r
 619         [Test]\r
 620         [ExpectedException(typeof(ArgumentNullException))]\r
 621         public void GetLastWriteTimeException1 ()\r
 622         {\r
 623                 Directory.GetLastWriteTime (null as string);\r
 624         }\r
 625 \r
 626         [Test]\r
 627         [ExpectedException(typeof(ArgumentException))]\r
 628         public void GetLastWriteTimeException2 ()\r
 629         {\r
 630                 Directory.GetLastWriteTime (string.Empty);\r
 631         }\r
 632         \r
 633         [Test]\r
 634 #if !NET_2_0\r
 635         [ExpectedException (typeof (IOException))]\r
 636 #endif\r
 637         public void GetLastWriteTime_NonExistingPath ()\r
 638         {\r
 639                 string path = TempFolder + DSC + "DirectoryTest.GetLastWriteTime.1";\r
 640                 DeleteDirectory (path);\r
 641                 try {\r
 642                         DateTime time = Directory.GetLastWriteTime (path);\r
 643 \r
 644 #if NET_2_0\r
 645                         DateTime expectedTime = (new DateTime (1601, 1, 1)).ToLocalTime ();\r
 646                         Assert.AreEqual (expectedTime.Year, time.Year, "#1");\r
 647                         Assert.AreEqual (expectedTime.Month, time.Month, "#2");\r
 648                         Assert.AreEqual (expectedTime.Day, time.Day, "#3");\r
 649                         Assert.AreEqual (expectedTime.Hour, time.Hour, "#4");\r
 650                         Assert.AreEqual (expectedTime.Second, time.Second, "#5");\r
 651                         Assert.AreEqual (expectedTime.Millisecond, time.Millisecond, "#6");\r
 652 #endif\r
 653                 } finally {\r
 654                         DeleteDirectory (path);\r
 655                 }\r
 656         }\r
 657 \r
 658         [Test]\r
 659         [ExpectedException(typeof(ArgumentException))]\r
 660         public void GetLastWriteTimeException4 ()\r
 661         {\r
 662                 Directory.GetLastWriteTime ("    ");\r
 663         }\r
 664 \r
 665         [Test]\r
 666         [ExpectedException(typeof(ArgumentException))]\r
 667         public void GetLastWriteTimeException5 ()\r
 668         {\r
 669                 Directory.GetLastWriteTime (Path.InvalidPathChars [0].ToString ());\r
 670         }\r
 671 \r
 672         [Test]\r
 673         [ExpectedException(typeof(ArgumentNullException))]\r
 674         public void GetLastWriteTimeUtcException1 ()\r
 675         {\r
 676                 Directory.GetLastWriteTimeUtc (null as string);\r
 677         }\r
 678 \r
 679         [Test]\r
 680         [ExpectedException(typeof(ArgumentException))]\r
 681         public void GetLastWriteTimeUtcException2 ()\r
 682         {\r
 683                 Directory.GetLastWriteTimeUtc (string.Empty);\r
 684         }\r
 685         \r
 686         [Test]\r
 687 #if !NET_2_0\r
 688         [ExpectedException (typeof (IOException))]\r
 689 #endif\r
 690         public void GetLastWriteTimeUtc_NonExistingPath ()\r
 691         {\r
 692                 string path = TempFolder + DSC + "DirectoryTest.GetLastWriteTimeUtc.1";\r
 693                 DeleteDirectory (path);\r
 694                 try {\r
 695                         DateTime time = Directory.GetLastWriteTimeUtc (path);\r
 696 \r
 697 #if NET_2_0\r
 698                         Assert.AreEqual (1601, time.Year, "#1");\r
 699                         Assert.AreEqual (1, time.Month, "#2");\r
 700                         Assert.AreEqual (1, time.Day, "#3");\r
 701                         Assert.AreEqual (0, time.Hour, "#4");\r
 702                         Assert.AreEqual (0, time.Second, "#5");\r
 703                         Assert.AreEqual (0, time.Millisecond, "#6");\r
 704 #endif\r
 705                 } finally {\r
 706                         DeleteDirectory (path);\r
 707                 }\r
 708                 \r
 709         }\r
 710 \r
 711         [Test]\r
 712         [ExpectedException(typeof(ArgumentException))]\r
 713         public void GetLastWriteTimeUtcException4 ()\r
 714         {\r
 715                 Directory.GetLastWriteTimeUtc ("    ");\r
 716         }\r
 717 \r
 718         [Test]\r
 719         [ExpectedException(typeof(ArgumentException))]\r
 720         public void GetLastWriteTimeUtcException5 ()\r
 721         {\r
 722                 Directory.GetLastWriteTimeUtc (Path.InvalidPathChars[0].ToString ());\r
 723         }\r
 724 \r
 725         [Test]\r
 726         public void Move_DestDirName_Empty ()\r
 727         {\r
 728                 try {\r
 729                         Directory.Move (TempFolder, string.Empty);\r
 730                         Assert.Fail ("#A1");\r
 731                 } catch (ArgumentException ex) {\r
 732                         // Empty file name is not legal\r
 733                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 734                         Assert.IsNull (ex.InnerException, "#A3");\r
 735                         Assert.IsNotNull (ex.Message, "#A4");\r
 736                         Assert.IsNotNull (ex.ParamName, "#A5");\r
 737                         Assert.AreEqual ("destDirName", ex.ParamName, "#A6");\r
 738                 }\r
 739 \r
 740                 try {\r
 741                         Directory.Move (TempFolder, "             ");\r
 742                         Assert.Fail ("#B1");\r
 743                 } catch (ArgumentException ex) {\r
 744                         // The path is not of a legal form\r
 745                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 746                         Assert.IsNull (ex.InnerException, "#B3");\r
 747                         Assert.IsNotNull (ex.Message, "#B4");\r
 748                 }\r
 749         }\r
 750 \r
 751         [Test]\r
 752         public void Move_DestDirName_Null ()\r
 753         {\r
 754                 try {\r
 755                         Directory.Move (TempFolder, (string) null);\r
 756                         Assert.Fail ("#1");\r
 757                 } catch (ArgumentNullException ex) {\r
 758                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 759                         Assert.IsNull (ex.InnerException, "#3");\r
 760                         Assert.IsNotNull (ex.Message, "#4");\r
 761                         Assert.IsNotNull (ex.ParamName, "#5");\r
 762                         Assert.AreEqual ("destDirName", ex.ParamName, "#6");\r
 763                 }\r
 764         }\r
 765 \r
 766         [Test]\r
 767         public void Move_SourceDirName_Empty ()\r
 768         {\r
 769                 try {\r
 770                         Directory.Move (string.Empty, TempFolder);\r
 771                         Assert.Fail ("#A1");\r
 772                 } catch (ArgumentException ex) {\r
 773                         // Empty file name is not legal\r
 774                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 775                         Assert.IsNull (ex.InnerException, "#A3");\r
 776                         Assert.IsNotNull (ex.Message, "#A4");\r
 777                         Assert.IsNotNull (ex.ParamName, "#A5");\r
 778                         Assert.AreEqual ("sourceDirName", ex.ParamName, "#A6");\r
 779                 }\r
 780 \r
 781                 try {\r
 782                         Directory.Move ("             ", TempFolder);\r
 783                         Assert.Fail ("#B1");\r
 784                 } catch (ArgumentException ex) {\r
 785                         // The path is not of a legal form\r
 786                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 787                         Assert.IsNull (ex.InnerException, "#B3");\r
 788                         Assert.IsNotNull (ex.Message, "#B4");\r
 789                 }\r
 790         }\r
 791 \r
 792         [Test]\r
 793         public void Move_SourceDirName_Null ()\r
 794         {\r
 795                 try {\r
 796                         Directory.Move ((string) null, TempFolder);\r
 797                         Assert.Fail ("#1");\r
 798                 } catch (ArgumentNullException ex) {\r
 799                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 800                         Assert.IsNull (ex.InnerException, "#3");\r
 801                         Assert.IsNotNull (ex.Message, "#4");\r
 802                         Assert.IsNotNull (ex.ParamName, "#5");\r
 803                         Assert.AreEqual ("sourceDirName", ex.ParamName, "#6");\r
 804                 }\r
 805         }\r
 806 \r
 807         [Test]\r
 808         public void MoveDirectory ()\r
 809         {\r
 810                 string path = TempFolder + DSC + "DirectoryTest.Test.9";\r
 811                 string path2 = TempFolder + DSC + "DirectoryTest.Test.10";\r
 812                 DeleteDirectory (path);\r
 813                 DeleteDirectory (path2);\r
 814                 try {\r
 815                         Directory.CreateDirectory (path);\r
 816                         Directory.CreateDirectory (path + DSC + "dir");\r
 817                         Assert.IsTrue (Directory.Exists (path + DSC + "dir"), "#1");\r
 818                 \r
 819                         Directory.Move (path, path2);\r
 820                         Assert.IsFalse (Directory.Exists (path + DSC + "dir"), "#2");\r
 821                         Assert.IsTrue (Directory.Exists (path2 + DSC + "dir"), "#3");\r
 822                 } finally {\r
 823                         DeleteDirectory (path);\r
 824                         DeleteDirectory (path2);\r
 825                         if (Directory.Exists (path2 + DSC + "dir"))\r
 826                                 Directory.Delete (path2 + DSC + "dir", true);\r
 827                 }\r
 828         }\r
 829 \r
 830         [Test]\r
 831         [ExpectedException (typeof (IOException))]\r
 832         public void MoveDirectory_Same ()\r
 833         {\r
 834                 string path = TempFolder + DSC + "DirectoryTest.Test.8";\r
 835                 DeleteDirectory (path);\r
 836                 try {\r
 837                         Directory.Move (path, path);\r
 838                 } finally {\r
 839                         DeleteDirectory (path);\r
 840                 }\r
 841         }\r
 842 \r
 843         [Test]\r
 844         public void MoveFile ()\r
 845         {\r
 846                 string tempFile1 = Path.Combine (TempFolder, "temp1.txt");\r
 847                 string tempFile2 = Path.Combine (TempFolder, "temp2.txt");\r
 848 \r
 849                 using (StreamWriter sw = File.CreateText (tempFile1)) {\r
 850                         sw.Write ("temp1");\r
 851                 }\r
 852                 Assert.IsFalse (File.Exists (tempFile2), "#1");\r
 853                 Directory.Move (tempFile1, tempFile2);\r
 854                 Assert.IsFalse (File.Exists (tempFile1), "#2");\r
 855                 Assert.IsTrue (File.Exists (tempFile2), "#3");\r
 856                 using (StreamReader sr = File.OpenText (tempFile2)) {\r
 857                         Assert.AreEqual ("temp1", sr.ReadToEnd (), "#4");\r
 858                 }\r
 859         }\r
 860 \r
 861         [Test]\r
 862         public void MoveFile_DestDir_Exists ()\r
 863         {\r
 864                 string tempFile = Path.Combine (TempFolder, "temp1.txt");\r
 865                 string tempDir = Path.Combine (TempFolder, "temp2");\r
 866 \r
 867                 using (StreamWriter sw = File.CreateText (tempFile)) {\r
 868                         sw.Write ("temp1");\r
 869                 }\r
 870                 Directory.CreateDirectory (tempDir);\r
 871 \r
 872                 try {\r
 873                         Directory.Move (tempFile, tempDir);\r
 874                         Assert.Fail ("#A1");\r
 875                 } catch (IOException ex) {\r
 876                         // Cannot create a file when that file already exists\r
 877                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#A2");\r
 878                         Assert.IsNull (ex.InnerException, "#A3");\r
 879                         Assert.IsNotNull (ex.Message, "#A4");\r
 880                 }\r
 881 \r
 882                 Assert.IsTrue (File.Exists (tempFile), "#B1");\r
 883                 Assert.IsFalse (File.Exists (tempDir), "#B2");\r
 884                 Assert.IsTrue (Directory.Exists (tempDir), "#B3");\r
 885         }\r
 886 \r
 887         [Test]\r
 888         public void MoveFile_DestFile_Exists ()\r
 889         {\r
 890                 string tempFile1 = Path.Combine (TempFolder, "temp1.txt");\r
 891                 string tempFile2 = Path.Combine (TempFolder, "temp2.txt");\r
 892 \r
 893                 using (StreamWriter sw = File.CreateText (tempFile1)) {\r
 894                         sw.Write ("temp1");\r
 895                 }\r
 896                 using (StreamWriter sw = File.CreateText (tempFile2)) {\r
 897                         sw.Write ("temp2");\r
 898                 }\r
 899 \r
 900                 try {\r
 901                         Directory.Move (tempFile1, tempFile2);\r
 902                         Assert.Fail ("#A1");\r
 903                 } catch (IOException ex) {\r
 904                         // Cannot create a file when that file already exists\r
 905                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#A2");\r
 906                         Assert.IsNull (ex.InnerException, "#A3");\r
 907                         Assert.IsNotNull (ex.Message, "#A4");\r
 908                 }\r
 909 \r
 910                 Assert.IsTrue (File.Exists (tempFile1), "#B1");\r
 911                 using (StreamReader sr = File.OpenText (tempFile1)) {\r
 912                         Assert.AreEqual ("temp1", sr.ReadToEnd (), "#B2");\r
 913                 }\r
 914 \r
 915                 Assert.IsTrue (File.Exists (tempFile2), "#C1");\r
 916                 using (StreamReader sr = File.OpenText (tempFile2)) {\r
 917                         Assert.AreEqual ("temp2", sr.ReadToEnd (), "#C2");\r
 918                 }\r
 919         }\r
 920 \r
 921         [Test]\r
 922         public void MoveFile_Same ()\r
 923         {\r
 924                 string tempFile = Path.Combine (TempFolder, "temp.txt");\r
 925 \r
 926                 try {\r
 927                         Directory.Move (tempFile, tempFile);\r
 928                         Assert.Fail ("#1");\r
 929                 } catch (IOException ex) {\r
 930                         // Source and destination path must be different\r
 931                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");\r
 932                         Assert.IsNull (ex.InnerException, "#3");\r
 933                         Assert.IsNotNull (ex.Message, "#4");\r
 934                 }\r
 935         }\r
 936 \r
 937         [Test]\r
 938         [ExpectedException(typeof(ArgumentException))]\r
 939         [Ignore ("On IA64, causes nunit to abort due to bug #76388")]\r
 940         public void MoveException4 ()\r
 941         {\r
 942                 string path = TempFolder + DSC + "DirectoryTest.Test.13";\r
 943                 path += Path.InvalidPathChars [0];\r
 944                 string path2 = TempFolder + DSC + "DirectoryTest.Test.13";\r
 945                 DeleteDirectory (path);\r
 946                 DeleteDirectory (path2);\r
 947                 try {\r
 948                         Directory.CreateDirectory (path2);\r
 949                         Directory.Move (path2, path);\r
 950                 } finally {\r
 951                         DeleteDirectory (path);\r
 952                         DeleteDirectory (path2);\r
 953                 }\r
 954         }\r
 955 \r
 956         [Test]\r
 957         [ExpectedException(typeof(DirectoryNotFoundException))]\r
 958         public void MoveException5 ()\r
 959         {\r
 960                 string path = TempFolder + DSC + "DirectoryTest.Test.14";\r
 961                 DeleteDirectory (path);\r
 962                 try {\r
 963                         Directory.Move (path, path + "Test.Test");\r
 964                 } finally {\r
 965                         DeleteDirectory (path);\r
 966                         DeleteDirectory (path + "Test.Test");\r
 967                 }\r
 968         }\r
 969 \r
 970         [Test]\r
 971         [ExpectedException(typeof(IOException))]\r
 972         public void MoveDirectory_Dest_SubDir ()\r
 973         {\r
 974                 string path = TempFolder + DSC + "DirectoryTest.Test.15";\r
 975                 DeleteDirectory (path);\r
 976                 try {\r
 977                         Directory.CreateDirectory (path);\r
 978                         Directory.Move (path, path + DSC + "dir");\r
 979                 } finally {\r
 980                         DeleteDirectory (path);\r
 981                         DeleteDirectory (path + DSC + "dir");\r
 982                 }\r
 983         }\r
 984 \r
 985         [Test]\r
 986         [ExpectedException (typeof (IOException))]\r
 987         public void MoveDirectory_Dest_Exists ()\r
 988         {\r
 989                 string path = TempFolder + DSC + "DirectoryTest.Test.16";\r
 990                 string path2 = TempFolder + DSC + "DirectoryTest.Test.17";\r
 991                 \r
 992                 DeleteDirectory (path);\r
 993                 DeleteDirectory (path2);\r
 994                 try {\r
 995                         Directory.CreateDirectory (path);\r
 996                         Directory.CreateDirectory (path2);\r
 997                         Directory.Move (path, path2);\r
 998                 } finally {\r
 999                         DeleteDirectory (path);\r
1000                         DeleteDirectory (path2);\r
1001                 }\r
1002         }\r
1003         \r
1004         [Test]\r
1005         [Category("TargetJvmNotSupported")] // CreationTime not supported for TARGET_JVM\r
1006         public void CreationTime ()\r
1007         {\r
1008                 if (RunningOnUnix)\r
1009                         Assert.Ignore ("Unix doesn't support CreationTime");\r
1010 \r
1011                 string path = TempFolder + DSC + "DirectoryTest.CreationTime.1";\r
1012                 DeleteDirectory (path);\r
1013                 \r
1014                 try {\r
1015                         Directory.CreateDirectory (path);\r
1016                         Directory.SetCreationTime (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
1017 \r
1018                         DateTime time = Directory.GetCreationTime (path);\r
1019                         Assert.AreEqual (2003, time.Year, "#A1");\r
1020                         Assert.AreEqual (6, time.Month, "#A2");\r
1021                         Assert.AreEqual (4, time.Day, "#A3");\r
1022                         Assert.AreEqual (6, time.Hour, "#A4");\r
1023                         Assert.AreEqual (4, time.Minute, "#A5");\r
1024                         Assert.AreEqual (0, time.Second, "#A6");\r
1025                 \r
1026                         time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetCreationTimeUtc (path));\r
1027                         Assert.AreEqual (2003, time.Year, "#B1");\r
1028                         Assert.AreEqual (6, time.Month, "#B2");\r
1029                         Assert.AreEqual (4, time.Day, "#B3");\r
1030                         Assert.AreEqual (6, time.Hour, "#B4");\r
1031                         Assert.AreEqual (4, time.Minute, "#B5");\r
1032                         Assert.AreEqual (0, time.Second, "#B6");\r
1033 \r
1034                         Directory.SetCreationTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
1035                         time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetCreationTime (path));\r
1036                         Assert.AreEqual (2003, time.Year, "#C1");\r
1037                         Assert.AreEqual (6, time.Month, "#C2");\r
1038                         Assert.AreEqual (4, time.Day, "#C3");\r
1039                         Assert.AreEqual (6, time.Hour, "#C4");\r
1040                         Assert.AreEqual (4, time.Minute, "#C5");\r
1041                         Assert.AreEqual (0, time.Second, "#C6");\r
1042 \r
1043                         time = Directory.GetCreationTimeUtc (path);\r
1044                         Assert.AreEqual (2003, time.Year, "#D1");\r
1045                         Assert.AreEqual (6, time.Month, "#D2");\r
1046                         Assert.AreEqual (4, time.Day, "#D3");\r
1047                         Assert.AreEqual (6, time.Hour, "#D4");\r
1048                         Assert.AreEqual (4, time.Minute, "#D5");\r
1049                         Assert.AreEqual (0, time.Second, "#D6");\r
1050                 } finally {\r
1051                         DeleteDirectory (path);\r
1052                 }\r
1053         }\r
1054 \r
1055         [Test]\r
1056         [Category("TargetJvmNotSupported")] // LastAccessTime not supported for TARGET_JVM\r
1057         public void LastAccessTime ()\r
1058         {\r
1059                 string path = TempFolder + DSC + "DirectoryTest.AccessTime.1";\r
1060                 DeleteDirectory (path);\r
1061                 \r
1062                 try {\r
1063                         Directory.CreateDirectory (path);\r
1064                         Directory.SetLastAccessTime (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
1065 \r
1066                         DateTime time = Directory.GetLastAccessTime (path);\r
1067                         Assert.AreEqual (2003, time.Year, "#A1");\r
1068                         Assert.AreEqual (6, time.Month, "#A2");\r
1069                         Assert.AreEqual (4, time.Day, "#A3");\r
1070                         Assert.AreEqual (6, time.Hour, "#A4");\r
1071                         Assert.AreEqual (4, time.Minute, "#A5");\r
1072                         Assert.AreEqual (0, time.Second, "#A6");\r
1073                 \r
1074                         time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetLastAccessTimeUtc (path));\r
1075                         Assert.AreEqual (2003, time.Year, "#B1");\r
1076                         Assert.AreEqual (6, time.Month, "#B2");\r
1077                         Assert.AreEqual (4, time.Day, "#B3");\r
1078                         Assert.AreEqual (6, time.Hour, "#B4");\r
1079                         Assert.AreEqual (4, time.Minute, "#B5");\r
1080                         Assert.AreEqual (0, time.Second, "#B6");\r
1081 \r
1082                         Directory.SetLastAccessTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
1083                         time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetLastAccessTime (path));\r
1084                         Assert.AreEqual (2003, time.Year, "#C1");\r
1085                         Assert.AreEqual (6, time.Month, "#C2");\r
1086                         Assert.AreEqual (4, time.Day, "#C3");\r
1087                         Assert.AreEqual (6, time.Hour, "#C4");\r
1088                         Assert.AreEqual (4, time.Minute, "#C5");\r
1089                         Assert.AreEqual (0, time.Second, "#C6");\r
1090 \r
1091                         time = Directory.GetLastAccessTimeUtc (path);\r
1092                         Assert.AreEqual (2003, time.Year, "#D1");\r
1093                         Assert.AreEqual (6, time.Month, "#D2");\r
1094                         Assert.AreEqual (4, time.Day, "#D3");\r
1095                         Assert.AreEqual (6, time.Hour, "#D4");\r
1096                         Assert.AreEqual (4, time.Minute, "#D5");\r
1097                         Assert.AreEqual (0, time.Second, "#D6");\r
1098                 } finally {\r
1099                         DeleteDirectory (path);\r
1100                 }\r
1101         }\r
1102 \r
1103         [Test]\r
1104         public void LastWriteTime ()\r
1105         {\r
1106                 string path = TempFolder + DSC + "DirectoryTest.WriteTime.1";\r
1107                 DeleteDirectory (path);\r
1108                 \r
1109                 try {\r
1110                         Directory.CreateDirectory (path);\r
1111                         Directory.SetLastWriteTime (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
1112 \r
1113                         DateTime time = Directory.GetLastWriteTime (path);\r
1114                         Assert.AreEqual (2003, time.Year, "#A1");\r
1115                         Assert.AreEqual (6, time.Month, "#A2");\r
1116                         Assert.AreEqual (4, time.Day, "#A3");\r
1117                         Assert.AreEqual (6, time.Hour, "#A4");\r
1118                         Assert.AreEqual (4, time.Minute, "#A5");\r
1119                         Assert.AreEqual (0, time.Second, "#A6");\r
1120                 \r
1121                         time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetLastWriteTimeUtc (path));\r
1122                         Assert.AreEqual (2003, time.Year, "#B1");\r
1123                         Assert.AreEqual (6, time.Month, "#B2");\r
1124                         Assert.AreEqual (4, time.Day, "#B3");\r
1125                         Assert.AreEqual (6, time.Hour, "#B4");\r
1126                         Assert.AreEqual (4, time.Minute, "#B5");\r
1127                         Assert.AreEqual (0, time.Second, "#B6");\r
1128 \r
1129                         Directory.SetLastWriteTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
1130                         time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetLastWriteTime (path));\r
1131                         Assert.AreEqual (2003, time.Year, "#C1");\r
1132                         Assert.AreEqual (6, time.Month, "#C2");\r
1133                         Assert.AreEqual (4, time.Day, "#C3");\r
1134                         Assert.AreEqual (6, time.Hour, "#C4");\r
1135                         Assert.AreEqual (4, time.Minute, "#C5");\r
1136                         Assert.AreEqual (0, time.Second, "#C6");\r
1137 \r
1138                         time = Directory.GetLastWriteTimeUtc (path);\r
1139                         Assert.AreEqual (2003, time.Year, "#D1");\r
1140                         Assert.AreEqual (6, time.Month, "#D2");\r
1141                         Assert.AreEqual (4, time.Day, "#D3");\r
1142                         Assert.AreEqual (6, time.Hour, "#D4");\r
1143                         Assert.AreEqual (4, time.Minute, "#D5");\r
1144                         Assert.AreEqual (0, time.Second, "#D6");\r
1145                 } finally {\r
1146                         DeleteDirectory (path);\r
1147                 }\r
1148         }\r
1149 \r
1150         [Test]\r
1151         [ExpectedException(typeof(ArgumentNullException))]\r
1152         public void SetLastWriteTimeException1 ()\r
1153         {\r
1154                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1155                 Directory.SetLastWriteTime (null as string, time);\r
1156         }\r
1157 \r
1158         [Test]\r
1159         [ExpectedException(typeof(ArgumentException))]  \r
1160         public void SetLastWriteTimeException2 ()\r
1161         {\r
1162                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1163                 Directory.SetLastWriteTime (string.Empty, time);\r
1164         }\r
1165         \r
1166         [Test]\r
1167         [ExpectedException(typeof(FileNotFoundException))]\r
1168         public void SetLastWriteTimeException3 ()\r
1169         {\r
1170                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1171                 string path = TempFolder + DSC + "DirectoryTest.SetLastWriteTime.2";\r
1172                 DeleteDirectory (path);\r
1173                 try {\r
1174                         Directory.SetLastWriteTime (path, time);\r
1175                 } finally {\r
1176                         DeleteDirectory (path);\r
1177                 }\r
1178         }\r
1179 \r
1180         [Test]\r
1181         [ExpectedException(typeof(ArgumentException))]\r
1182         public void SetLastWriteTimeException4 ()\r
1183         {\r
1184                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1185                 Directory.SetLastWriteTime ("    ", time);\r
1186         }\r
1187 \r
1188         [Test]\r
1189         [ExpectedException(typeof(ArgumentException))]\r
1190         public void SetLastWriteTimeException5 ()\r
1191         {\r
1192                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1193                 Directory.SetLastWriteTime (Path.InvalidPathChars [0].ToString (), time);\r
1194         }\r
1195 \r
1196 //      [Test]\r
1197 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
1198 //      public void SetLastWriteTimeException6 ()\r
1199 //      {\r
1200 //              DateTime time = new DateTime (1003, 4, 6, 6, 4, 2);\r
1201 //              string path = TempFolder + Path.DirectorySeparatorChar + "DirectoryTest.SetLastWriteTime.1";\r
1202 //\r
1203 //              try {\r
1204 //                      if (!Directory.Exists (path))\r
1205 //                              Directory.CreateDirectory (path);\r
1206 //              \r
1207 //                      Directory.SetLastWriteTime (path, time);\r
1208 //              } finally {\r
1209 //                      DeleteDirectory (path);\r
1210 //              }\r
1211 //\r
1212 //      }\r
1213 \r
1214         [Test]\r
1215         [ExpectedException(typeof(ArgumentNullException))]\r
1216         public void SetLastWriteTimeUtcException1 ()\r
1217         {\r
1218                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1219                 Directory.SetLastWriteTimeUtc (null as string, time);\r
1220         }\r
1221 \r
1222         [Test]\r
1223         [ExpectedException(typeof(ArgumentException))]\r
1224         public void SetLastWriteTimeUtcException2 ()\r
1225         {\r
1226                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1227                 Directory.SetLastWriteTimeUtc (string.Empty, time);\r
1228         }\r
1229         \r
1230         [Test]\r
1231         [ExpectedException(typeof(FileNotFoundException))]\r
1232         public void SetLastWriteTimeUtcException3 ()\r
1233         {\r
1234                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1235                 string path = TempFolder + DSC + "DirectoryTest.SetLastWriteTimeUtc.2";\r
1236                 DeleteDirectory (path);\r
1237                 try {\r
1238                         Directory.SetLastWriteTimeUtc (path, time);\r
1239                 } finally {\r
1240                         DeleteDirectory (path);\r
1241                 }\r
1242         }\r
1243 \r
1244         [Test]\r
1245         [ExpectedException(typeof(ArgumentException))]\r
1246         public void SetLastWriteTimeUtcException4 ()\r
1247         {\r
1248                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1249                 Directory.SetLastWriteTimeUtc ("    ", time);\r
1250         }\r
1251 \r
1252         [Test]\r
1253         [ExpectedException(typeof(ArgumentException))]\r
1254         public void SetLastWriteTimeUtcException5 ()\r
1255         {\r
1256                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1257                 Directory.SetLastWriteTimeUtc (Path.InvalidPathChars [0].ToString (), time);\r
1258         }\r
1259 \r
1260 //      [Test]\r
1261 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
1262 //      public void SetLastWriteTimeUtcException6 ()\r
1263 //      {\r
1264 //              DateTime time = new DateTime (1000, 4, 6, 6, 4, 2);\r
1265 //              string path = TempFolder + DSC + "DirectoryTest.SetLastWriteTimeUtc.1";\r
1266 //\r
1267 //              if (!Directory.Exists (path))\r
1268 //                      Directory.CreateDirectory (path);\r
1269 //              try {\r
1270 //                      Directory.SetLastWriteTimeUtc (path, time);\r
1271 //              } finally {\r
1272 //                      DeleteDirectory (path);\r
1273 //              }\r
1274 //      }\r
1275 \r
1276         [Test]\r
1277         [ExpectedException(typeof(ArgumentNullException))]\r
1278         [Category("TargetJvmNotSupported")] // SetLastAccessTime not supported for TARGET_JVM\r
1279         public void SetLastAccessTimeException1 ()\r
1280         {\r
1281                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1282                 Directory.SetLastAccessTime (null as string, time);\r
1283         }\r
1284 \r
1285         [Test]\r
1286         [ExpectedException(typeof(ArgumentException))]\r
1287         [Category("TargetJvmNotSupported")] // SetLastAccessTime not supported for TARGET_JVM\r
1288         public void SetLastAccessTimeException2 ()\r
1289         {\r
1290                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1291                 Directory.SetLastAccessTime (string.Empty, time);\r
1292         }\r
1293         \r
1294         [Test]\r
1295         [ExpectedException(typeof(FileNotFoundException))]\r
1296         [Category("TargetJvmNotSupported")] // SetLastAccessTime not supported for TARGET_JVM\r
1297         public void SetLastAccessTimeException3 ()\r
1298         {\r
1299                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1300                 string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTime.2";\r
1301                 DeleteDirectory (path);\r
1302                 try {\r
1303                         Directory.SetLastAccessTime (path, time);\r
1304                 } finally {\r
1305                         DeleteDirectory (path);\r
1306                 }\r
1307         }\r
1308 \r
1309         [Test]\r
1310         [ExpectedException(typeof(ArgumentException))]\r
1311         [Category("TargetJvmNotSupported")] // SetLastAccessTime not supported for TARGET_JVM\r
1312         public void SetLastAccessTimeException4 ()\r
1313         {\r
1314                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1315                 Directory.SetLastAccessTime ("    ", time);\r
1316         }\r
1317 \r
1318         [Test]\r
1319         [ExpectedException(typeof(ArgumentException))]\r
1320         [Category("TargetJvmNotSupported")] // SetLastAccessTime not supported for TARGET_JVM\r
1321         public void SetLastAccessTimeException5 ()\r
1322         {\r
1323                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1324                 Directory.SetLastAccessTime (Path.InvalidPathChars [0].ToString (), time);\r
1325         }\r
1326 \r
1327 //      [Test]\r
1328 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
1329 //      public void SetLastAccessTimeException6 ()\r
1330 //      {\r
1331 //              DateTime time = new DateTime (1003, 4, 6, 6, 4, 2);\r
1332 //              string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTime.1";\r
1333 //\r
1334 //              if (!Directory.Exists (path))\r
1335 //                      Directory.CreateDirectory (path);\r
1336 //              try {\r
1337 //                      Directory.SetLastAccessTime (path, time);\r
1338 //              } finally {\r
1339 //                      DeleteDirectory (path);\r
1340 //              }\r
1341 //\r
1342 //      }\r
1343 \r
1344         [Test]\r
1345         [ExpectedException(typeof(ArgumentNullException))]\r
1346         [Category("TargetJvmNotSupported")] // SetLastAccessTime not supported for TARGET_JVM\r
1347         public void SetLastAccessTimeUtcException1 ()\r
1348         {\r
1349                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1350                 Directory.SetLastAccessTimeUtc (null as string, time);\r
1351         }\r
1352 \r
1353         [Test]\r
1354         [ExpectedException(typeof(ArgumentException))]\r
1355         [Category("TargetJvmNotSupported")] // SetLastAccessTime not supported for TARGET_JVM\r
1356         public void SetLastAccessTimeUtcException2 ()\r
1357         {\r
1358                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1359                 Directory.SetLastAccessTimeUtc (string.Empty, time);\r
1360         }\r
1361         \r
1362         [Test]\r
1363         [ExpectedException(typeof(FileNotFoundException))]\r
1364         [Category("TargetJvmNotSupported")] // SetLastAccessTime not supported for TARGET_JVM\r
1365         public void SetLastAccessTimeUtcException3 ()\r
1366         {\r
1367                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1368                 string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTimeUtc.2";\r
1369                 DeleteDirectory (path);\r
1370                 try {\r
1371                         Directory.SetLastAccessTimeUtc (path, time);\r
1372                 } finally {\r
1373                         DeleteDirectory (path);\r
1374                 }\r
1375         }\r
1376 \r
1377         [Test]\r
1378         [ExpectedException(typeof(ArgumentException))]\r
1379         [Category("TargetJvmNotSupported")] // SetLastAccessTime not supported for TARGET_JVM\r
1380         public void SetLastAccessTimeUtcException4 ()\r
1381         {\r
1382                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1383                 Directory.SetLastAccessTimeUtc ("    ", time);\r
1384         }\r
1385 \r
1386         [Test]\r
1387         [ExpectedException(typeof(ArgumentException))]\r
1388         [Category("TargetJvmNotSupported")] // SetLastAccessTime not supported for TARGET_JVM\r
1389         public void SetLastAccessTimeUtcException5 ()\r
1390         {\r
1391                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1392                 Directory.SetLastAccessTimeUtc (Path.InvalidPathChars [0].ToString (), time);\r
1393         }\r
1394 \r
1395 //      [Test]\r
1396 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
1397 //      public void SetLastAccessTimeUtcException6 ()\r
1398 //      {\r
1399 //              DateTime time = new DateTime (1000, 4, 6, 6, 4, 2);\r
1400 //              string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTimeUtc.1";\r
1401 //\r
1402 //              if (!Directory.Exists (path))\r
1403 //                      Directory.CreateDirectory (path);\r
1404 //              try {\r
1405 //                      Directory.SetLastAccessTimeUtc (path, time);\r
1406 //              } finally {\r
1407 //                      DeleteDirectory (path);\r
1408 //              }\r
1409 //      }\r
1410 \r
1411         [Test]\r
1412         [ExpectedException(typeof(ArgumentNullException))]\r
1413         [Category("TargetJvmNotSupported")] // SetCreationTime not supported for TARGET_JVM\r
1414         public void SetCreationTimeException1 ()\r
1415         {\r
1416                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1417                 Directory.SetCreationTime (null as string, time);\r
1418         }\r
1419 \r
1420         [Test]\r
1421         [ExpectedException(typeof(ArgumentException))]\r
1422         [Category("TargetJvmNotSupported")] // SetCreationTime not supported for TARGET_JVM\r
1423         public void SetCreationTimeException2 ()\r
1424         {\r
1425                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1426                 Directory.SetCreationTime (string.Empty, time);\r
1427         }\r
1428         \r
1429         [Test]\r
1430         [ExpectedException(typeof(FileNotFoundException))]\r
1431         [Category("TargetJvmNotSupported")] // SetCreationTime not supported for TARGET_JVM\r
1432         public void SetCreationTimeException3 ()\r
1433         {\r
1434                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1435                 string path = TempFolder + DSC + "DirectoryTest.SetCreationTime.2";\r
1436                 DeleteDirectory (path);\r
1437                 \r
1438                 try {\r
1439                         Directory.SetCreationTime (path, time);\r
1440                 } finally {\r
1441                         DeleteDirectory (path);\r
1442                 }\r
1443         }\r
1444 \r
1445         [Test]\r
1446         [ExpectedException(typeof(ArgumentException))]\r
1447         [Category("TargetJvmNotSupported")] // SetCreationTime not supported for TARGET_JVM\r
1448         public void SetCreationTimeException4 ()\r
1449         {\r
1450                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1451                 Directory.SetCreationTime ("    ", time);\r
1452         }\r
1453 \r
1454         [Test]\r
1455         [ExpectedException(typeof(ArgumentException))]\r
1456         [Category("TargetJvmNotSupported")] // SetCreationTime not supported for TARGET_JVM\r
1457         public void SetCreationTimeException5 ()\r
1458         {\r
1459                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1460                 Directory.SetCreationTime (Path.InvalidPathChars [0].ToString (), time);\r
1461         }\r
1462 \r
1463 //      [Test]\r
1464 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
1465 //      public void SetCreationTimeException6 ()\r
1466 //      {\r
1467 //              DateTime time = new DateTime (1003, 4, 6, 6, 4, 2);\r
1468 //              string path = TempFolder + DSC + "DirectoryTest.SetCreationTime.1";\r
1469 //\r
1470 //              if (!Directory.Exists (path))\r
1471 //                      Directory.CreateDirectory (path);\r
1472 //              try {\r
1473 //                      Directory.SetCreationTime (path, time);\r
1474 //                      DeleteDirectory (path);\r
1475 //              } finally {\r
1476 //                      DeleteDirectory (path);\r
1477 //              }\r
1478 //\r
1479 //      }\r
1480 \r
1481         [Test]\r
1482         [ExpectedException(typeof(ArgumentNullException))]\r
1483         [Category("TargetJvmNotSupported")] // SetCreationTime not supported for TARGET_JVM\r
1484         public void SetCreationTimeUtcException1 ()\r
1485         {\r
1486                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1487                 Directory.SetCreationTimeUtc (null as string, time);\r
1488         }\r
1489 \r
1490         [Test]\r
1491         [ExpectedException(typeof(ArgumentException))]\r
1492         [Category("TargetJvmNotSupported")] // SetCreationTime not supported for TARGET_JVM\r
1493         public void SetCreationTimeUtcException2 ()\r
1494         {\r
1495                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1496                 Directory.SetCreationTimeUtc (string.Empty, time);\r
1497         }\r
1498         \r
1499         [Test]\r
1500         [ExpectedException(typeof(FileNotFoundException))]\r
1501         [Category("TargetJvmNotSupported")] // SetCreationTime not supported for TARGET_JVM\r
1502         public void SetCreationTimeUtcException3 ()\r
1503         {\r
1504                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1505                 string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTimeUtc.2";\r
1506                 DeleteDirectory (path);\r
1507                 \r
1508                 try {\r
1509                         Directory.SetCreationTimeUtc (path, time);\r
1510                         DeleteDirectory (path);\r
1511                 } finally {\r
1512                         DeleteDirectory (path);\r
1513                 }\r
1514         }\r
1515 \r
1516         [Test]\r
1517         [ExpectedException(typeof(ArgumentException))]\r
1518         [Category("TargetJvmNotSupported")] // SetCreationTime not supported for TARGET_JVM\r
1519         public void SetCreationTimeUtcException4 ()\r
1520         {\r
1521                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1522                 Directory.SetCreationTimeUtc ("    ", time);\r
1523         }\r
1524 \r
1525         [Test]\r
1526         [ExpectedException(typeof(ArgumentException))]\r
1527         [Category("TargetJvmNotSupported")] // SetCreationTime not supported for TARGET_JVM\r
1528         public void SetCreationTimeUtcException5 ()\r
1529         {\r
1530                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
1531                 Directory.SetCreationTimeUtc (Path.InvalidPathChars [0].ToString (), time);\r
1532         }\r
1533 \r
1534 //      [Test]\r
1535 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
1536 //      public void SetCreationTimeUtcException6 ()\r
1537 //      {\r
1538 //              DateTime time = new DateTime (1000, 4, 6, 6, 4, 2);\r
1539 //              string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTimeUtc.1";\r
1540 //\r
1541 //              if (!Directory.Exists (path))\r
1542 //                      Directory.CreateDirectory (path);\r
1543 //              try {\r
1544 //                      Directory.SetCreationTimeUtc (path, time);\r
1545 //                      DeleteDirectory (path);\r
1546 //              } finally {\r
1547 //                      DeleteDirectory (path);\r
1548 //              }\r
1549 //      }\r
1550 \r
1551         [Test]\r
1552         public void GetDirectories ()\r
1553         {\r
1554                 string path = TempFolder;\r
1555                 string DirPath = TempFolder + Path.DirectorySeparatorChar + ".GetDirectories";\r
1556                 DeleteDirectory (DirPath);\r
1557                 \r
1558                 try {\r
1559                         Directory.CreateDirectory (DirPath);\r
1560                 \r
1561                         string [] dirs = Directory.GetDirectories (path);\r
1562                 \r
1563                         foreach (string directory in dirs) {\r
1564                         \r
1565                                 if (directory == DirPath)\r
1566                                         return;\r
1567                         }\r
1568                 \r
1569                         Assert.Fail ("Directory Not Found");\r
1570                 } finally {\r
1571                         DeleteDirectory (DirPath);\r
1572                 }\r
1573         }\r
1574 \r
1575         [Test] // bug #346123\r
1576         public void GetDirectories_Backslash ()\r
1577         {\r
1578                 if (!RunningOnUnix)\r
1579                         // on Windows, backslash is used as directory separator\r
1580                         return;\r
1581 \r
1582                 string dir = Path.Combine (TempFolder, @"sub\dir");\r
1583                 Directory.CreateDirectory (dir);\r
1584 \r
1585                 Assert.IsTrue (Directory.Exists (dir), "#A1");\r
1586                 Assert.IsFalse (Directory.Exists (Path.Combine (TempFolder, "dir")), "#A2");\r
1587 \r
1588                 string [] dirs = Directory.GetDirectories (TempFolder);\r
1589                 Assert.AreEqual (1, dirs.Length, "#B1");\r
1590                 Assert.AreEqual (dir, dirs [0], "#B2");\r
1591         }\r
1592 \r
1593         [Test]\r
1594         public void GetParentOfRootDirectory ()\r
1595         {\r
1596                 DirectoryInfo info;\r
1597 \r
1598                 info = Directory.GetParent (Path.GetPathRoot (Path.GetTempPath ()));\r
1599                 Assert.IsNull (info);\r
1600         }\r
1601         \r
1602         [Test]\r
1603         public void GetFiles ()\r
1604         {\r
1605                 string path = TempFolder;\r
1606                 string DirPath = TempFolder + Path.DirectorySeparatorChar + ".GetFiles";\r
1607                 if (File.Exists (DirPath))\r
1608                         File.Delete (DirPath);\r
1609                 \r
1610                 try {\r
1611                         File.Create (DirPath).Close ();\r
1612                         string [] files = Directory.GetFiles (TempFolder);\r
1613                         foreach (string directory in files) {\r
1614                         \r
1615                                 if (directory == DirPath)\r
1616                                         return;\r
1617                         }\r
1618                 \r
1619                         Assert.Fail ("File Not Found");\r
1620                 } finally {\r
1621                         if (File.Exists (DirPath))\r
1622                                 File.Delete (DirPath);\r
1623                 }\r
1624         }\r
1625 \r
1626         [Test] // bug #346123\r
1627         public void GetFiles_Backslash ()\r
1628         {\r
1629                 if (!RunningOnUnix)\r
1630                         // on Windows, backslash is used as directory separator\r
1631                         return;\r
1632 \r
1633                 string file = Path.Combine (TempFolder, @"doc\temp1.file");\r
1634                 File.Create (file).Close ();\r
1635 \r
1636                 Assert.IsTrue (File.Exists (file), "#A1");\r
1637                 Assert.IsFalse (File.Exists (Path.Combine (TempFolder, "temp1.file")), "#A2");\r
1638 \r
1639                 string [] files = Directory.GetFiles (TempFolder);\r
1640                 Assert.AreEqual (1, files.Length, "#B1");\r
1641                 Assert.AreEqual (file, files [0], "#B2");\r
1642         }\r
1643 \r
1644         [Test] // bug #82212 and bug #325107\r
1645         public void GetFiles_Pattern ()\r
1646         {\r
1647                 string [] files = Directory.GetFiles (TempFolder, "*.*");\r
1648                 Assert.IsNotNull (files, "#A1");\r
1649                 Assert.AreEqual (0, files.Length, "#A2");\r
1650 \r
1651                 string tempFile1 = Path.Combine (TempFolder, "tempFile1");\r
1652                 File.Create (tempFile1).Close ();\r
1653 \r
1654                 files = Directory.GetFiles (TempFolder, "*.*");\r
1655                 Assert.IsNotNull (files, "#B1");\r
1656                 Assert.AreEqual (1, files.Length, "#B2");\r
1657                 Assert.AreEqual (tempFile1, files [0], "#B3");\r
1658 \r
1659                 string tempFile2 = Path.Combine (TempFolder, "FileTemp2.tmp");\r
1660                 File.Create (tempFile2).Close ();\r
1661 \r
1662                 files = Directory.GetFiles (TempFolder, "*.*");\r
1663                 Assert.IsNotNull (files, "#C1");\r
1664                 Assert.AreEqual (2, files.Length, "#C2");\r
1665 \r
1666                 files = Directory.GetFiles (TempFolder, "temp*.*");\r
1667                 Assert.IsNotNull (files, "#D1");\r
1668                 Assert.AreEqual (1, files.Length, "#D2");\r
1669                 Assert.AreEqual (tempFile1, files [0], "#D3");\r
1670 \r
1671                 string tempFile3 = Path.Combine (TempFolder, "tempFile3.txt");\r
1672                 File.Create (tempFile3).Close ();\r
1673 \r
1674                 files = Directory.GetFiles (TempFolder, "*File*.*");\r
1675                 Assert.IsNotNull (files, "#E1");\r
1676                 Assert.AreEqual (3, files.Length, "#E2");\r
1677 \r
1678                 files = Directory.GetFiles (TempFolder, "*File*.tmp");\r
1679                 Assert.IsNotNull (files, "#F1");\r
1680                 Assert.AreEqual (1, files.Length, "#F2");\r
1681                 Assert.AreEqual (tempFile2, files [0], "#F3");\r
1682 \r
1683                 files = Directory.GetFiles (TempFolder, "*tempFile*");\r
1684                 Assert.IsNotNull (files, "#G1");\r
1685                 Assert.AreEqual (2, files.Length, "#G2");\r
1686 \r
1687                 files = Directory.GetFiles (TempFolder, "*tempFile1");\r
1688                 Assert.IsNotNull (files, "#H1");\r
1689                 Assert.AreEqual (1, files.Length, "#H2");\r
1690                 Assert.AreEqual (tempFile1, files [0], "#H3");\r
1691 \r
1692                 files = Directory.GetFiles (TempFolder, "*.txt");\r
1693                 Assert.IsNotNull (files, "#I1");\r
1694                 Assert.AreEqual (1, files.Length, "#I2");\r
1695                 Assert.AreEqual (tempFile3, files [0], "#I3");\r
1696 \r
1697                 files = Directory.GetFiles (TempFolder, "*.t*");\r
1698                 Assert.IsNotNull (files, "#J1");\r
1699                 Assert.AreEqual (2, files.Length, "#J2");\r
1700 \r
1701                 files = Directory.GetFiles (TempFolder, "temp*.*");\r
1702                 Assert.IsNotNull (files, "#K1");\r
1703                 Assert.AreEqual (2, files.Length, "#K2");\r
1704 \r
1705                 File.Delete (tempFile1);\r
1706 \r
1707                 files = Directory.GetFiles (TempFolder, "temp*.*");\r
1708                 Assert.IsNotNull (files, "#L1");\r
1709                 Assert.AreEqual (1, files.Length, "#L2");\r
1710                 Assert.AreEqual (tempFile3, files [0], "#L3");\r
1711 \r
1712                 files = Directory.GetFiles (TempFolder, ".*");\r
1713                 Assert.IsNotNull (files, "#M1");\r
1714                 Assert.AreEqual (0, files.Length, "#M2");\r
1715 \r
1716                 string tempFile4 = Path.Combine (TempFolder, "tempFile4.");\r
1717                 File.Create (tempFile4).Close ();\r
1718 \r
1719                 files = Directory.GetFiles (TempFolder, "temp*.");\r
1720                 Assert.IsNotNull (files, "#N1");\r
1721                 Assert.AreEqual (1, files.Length, "#N2");\r
1722                 if (RunningOnUnix)\r
1723                         Assert.AreEqual (tempFile4, files [0], "#N3");\r
1724                 else // on Windows, the trailing dot is automatically trimmed\r
1725                         Assert.AreEqual (Path.Combine (TempFolder, "tempFile4"), files [0], "#N3");\r
1726         }\r
1727 \r
1728         [Test]\r
1729         public void GetFiles_580090 ()\r
1730         {\r
1731                 string cwd = Directory.GetCurrentDirectory ();\r
1732                 Directory.SetCurrentDirectory (Path.GetTempPath ());\r
1733 \r
1734                 string tempFile = Path.Combine (TempFolder, "tempFile.txt");\r
1735                 File.Create (tempFile).Close ();\r
1736 \r
1737                 try {\r
1738                         string [] files = Directory.GetFiles (".", TempSubFolder + DSC + "*.t*");\r
1739                         Assert.IsNotNull (files, "#J1");\r
1740                         Assert.AreEqual (1, files.Length, "#J2");\r
1741                 }\r
1742                 finally {\r
1743                         Directory.SetCurrentDirectory (cwd);\r
1744                 }\r
1745         }\r
1746 \r
1747 \r
1748         [Test]\r
1749         [ExpectedException (typeof (ArgumentNullException))]\r
1750         public void SetCurrentDirectoryNull ()\r
1751         {\r
1752                 Directory.SetCurrentDirectory (null);\r
1753         }\r
1754 \r
1755         [Test]\r
1756         [ExpectedException (typeof (ArgumentException))]\r
1757         public void SetCurrentDirectoryEmpty ()\r
1758         {\r
1759                 Directory.SetCurrentDirectory (String.Empty);\r
1760         }\r
1761 \r
1762         [Test]\r
1763         [ExpectedException (typeof (ArgumentException))]\r
1764         public void SetCurrentDirectoryWhitespace ()\r
1765         {\r
1766                 Directory.SetCurrentDirectory (" ");\r
1767         }\r
1768 \r
1769 \r
1770         [Test]\r
1771         public void GetNoFiles () // Bug 58875. This throwed an exception on windows.\r
1772         {\r
1773                 DirectoryInfo dir = new DirectoryInfo (".");\r
1774                 dir.GetFiles ("*.nonext");\r
1775         }\r
1776 \r
1777         [Test]\r
1778         public void FilenameOnly () // bug 78209\r
1779         {\r
1780                 Directory.GetParent ("somefile");\r
1781         }\r
1782 \r
1783         private static bool RunningOnUnix {\r
1784                 get {\r
1785                         // check for Unix platforms - see FAQ for more details\r
1786                         // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F\r
1787                         int platform = (int) Environment.OSVersion.Platform;\r
1788                         return ((platform == 4) || (platform == 128) || (platform == 6));\r
1789                 }\r
1790         }\r
1791 \r
1792         private void DeleteDirectory (string path)\r
1793         {\r
1794                 if (Directory.Exists (path))\r
1795                         Directory.Delete (path, true);\r
1796         }\r
1797 \r
1798         private void DeleteFile (string path)\r
1799         {\r
1800                 if (File.Exists (path))\r
1801                         File.Delete (path);\r
1802         }\r
1803 }\r
1804 }\r