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