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