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