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