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 NUnit.Framework;\r
  13 using System.IO;\r
  14 using System.Text;\r
  15 using System;\r
  16 using System.Globalization;\r
  17 using System.Threading;\r
  18 \r
  19 namespace MonoTests.System.IO {\r
  20 \r
  21 [TestFixture]\r
  22 public class DirectoryTest : Assertion {\r
  23         \r
  24         string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");\r
  25         \r
  26         [SetUp]\r
  27         public void SetUp ()\r
  28         {\r
  29                 if (!Directory.Exists (TempFolder))\r
  30                         Directory.CreateDirectory (TempFolder);\r
  31 \r
  32                 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");\r
  33         }\r
  34         \r
  35         [TearDown]\r
  36         public void TearDown () {\r
  37                 if (Directory.Exists (TempFolder))\r
  38                         Directory.Delete (TempFolder, true);\r
  39         }\r
  40 \r
  41         [Test]\r
  42         public void CreateDirectory ()\r
  43         {\r
  44                 string path = TempFolder + "/DirectoryTest.Test.1";\r
  45                 DeleteDirectory (path);\r
  46                 try {\r
  47                         DirectoryInfo info = Directory.CreateDirectory (path);\r
  48                         AssertEquals ("test#01", true, info.Exists);\r
  49                         AssertEquals ("test#02", ".1", info.Extension);\r
  50                         AssertEquals ("test#03", true, info.FullName.EndsWith ("DirectoryTest.Test.1"));\r
  51                         AssertEquals ("test#04", "DirectoryTest.Test.1", info.Name);\r
  52                 } finally {\r
  53                         DeleteDirectory (path);         \r
  54                 }\r
  55         }\r
  56         \r
  57         [Test]\r
  58         [ExpectedException(typeof(ArgumentException))]  \r
  59         public void CreateDirectoryNotSupportedException ()\r
  60         {\r
  61                 DeleteDirectory (":");\r
  62                 DirectoryInfo info = Directory.CreateDirectory (":");\r
  63                 DeleteDirectory (":");\r
  64         }\r
  65 \r
  66         [Test]\r
  67         [ExpectedException(typeof(ArgumentNullException))]\r
  68         public void CreateDirectoryArgumentNullException ()\r
  69         {\r
  70                 DirectoryInfo info = Directory.CreateDirectory (null as string);                \r
  71         }\r
  72 \r
  73         [Test]\r
  74         [ExpectedException(typeof(ArgumentException))]\r
  75         public void CreateDirectoryArgumentException1 ()\r
  76         {\r
  77                 DirectoryInfo info = Directory.CreateDirectory ("");\r
  78         }\r
  79 \r
  80         [Test]\r
  81         [ExpectedException(typeof(ArgumentException))]\r
  82         public void CreateDirectoryArgumentException2 ()\r
  83         {\r
  84                 DirectoryInfo info = Directory.CreateDirectory ("            ");                \r
  85         }\r
  86 \r
  87         [Test]\r
  88         [ExpectedException(typeof(ArgumentException))]\r
  89         public void CreateDirectoryArgumentException3 ()\r
  90         {\r
  91                 string path = TempFolder + "/DirectoryTest.Test";\r
  92                 DeleteDirectory (path);\r
  93                 try {\r
  94                         path += Path.InvalidPathChars [0];\r
  95                         path += ".2";\r
  96                         DirectoryInfo info = Directory.CreateDirectory (path);          \r
  97                 } finally {\r
  98                         DeleteDirectory (path);\r
  99                 }\r
 100         }\r
 101 \r
 102         [Test]\r
 103         public void Delete ()\r
 104         {\r
 105                 string path = TempFolder + "/DirectoryTest.Test.Delete.1";\r
 106                 DeleteDirectory (path);\r
 107                 try {\r
 108                         Directory.CreateDirectory (path);\r
 109                         AssertEquals ("test#01", true, Directory.Exists (path));\r
 110                 \r
 111                         Directory.CreateDirectory (path + "/DirectoryTest.Test.Delete.1.2");\r
 112                         AssertEquals ("test#02", true, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));\r
 113                 \r
 114                         Directory.Delete (path + "/DirectoryTest.Test.Delete.1.2");\r
 115                         AssertEquals ("test#03", false, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));\r
 116                         AssertEquals ("test#04", true, Directory.Exists (path));\r
 117                 \r
 118                         Directory.Delete (path);\r
 119                         AssertEquals ("test#05", false, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));\r
 120                         AssertEquals ("test#06", false, Directory.Exists (path));               \r
 121         \r
 122                         Directory.CreateDirectory (path);\r
 123                         Directory.CreateDirectory (path + "/DirectoryTest.Test.Delete.1.2");\r
 124                         AssertEquals ("test#07", true, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));\r
 125                         AssertEquals ("test#08", true, Directory.Exists (path));\r
 126                 \r
 127                         Directory.Delete (path, true);\r
 128                         AssertEquals ("test#09", false, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));\r
 129                         AssertEquals ("test#10", false, Directory.Exists (path));\r
 130                 } finally {\r
 131                         DeleteDirectory (path);\r
 132                 }\r
 133         }\r
 134 \r
 135         [Test]  \r
 136         [ExpectedException(typeof(ArgumentException))]\r
 137         public void DeleteArgumentException ()\r
 138         {\r
 139                 Directory.Delete ("");          \r
 140         }\r
 141 \r
 142         [Test]  \r
 143         [ExpectedException(typeof(ArgumentException))]\r
 144         public void DeleteArgumentException2 ()\r
 145         {\r
 146                 Directory.Delete ("     ");             \r
 147         }\r
 148 \r
 149         [Test]  \r
 150         [ExpectedException(typeof(ArgumentException))]\r
 151         public void DeleteArgumentException3 ()\r
 152         {\r
 153                 string path = TempFolder + "/DirectoryTest.Test.4";\r
 154                 DeleteDirectory (path);\r
 155                 \r
 156                 path += Path.InvalidPathChars [0];\r
 157                 Directory.Delete (path);\r
 158         }\r
 159 \r
 160         [Test]  \r
 161         [ExpectedException(typeof(ArgumentNullException))]\r
 162         public void DeleteArgumentNullException ()\r
 163         {\r
 164                 Directory.Delete (null as string);              \r
 165         }\r
 166 \r
 167         [Test]  \r
 168         [ExpectedException(typeof(DirectoryNotFoundException))]\r
 169         public void DeleteDirectoryNotFoundException ()\r
 170         {\r
 171                 string path = TempFolder + "/DirectoryTest.Test.5";\r
 172                 DeleteDirectory (path);\r
 173                 \r
 174                 Directory.Delete (path);                \r
 175         }\r
 176 \r
 177         [Test]  \r
 178         [ExpectedException(typeof(IOException))]\r
 179         public void DeleteArgumentException4 ()\r
 180         {\r
 181                 string path = TempFolder + "/DirectoryTest.Test.6";\r
 182                 DeleteDirectory (path);\r
 183                 FileStream s = null;\r
 184                 Directory.CreateDirectory (path);\r
 185                 try {\r
 186                         s = File.Create (path + "/DirectoryTest.Test.6");\r
 187                         Directory.Delete (path);\r
 188                 } finally {\r
 189                         if (s != null)\r
 190                                 s.Close ();\r
 191                         DeleteDirectory (path); \r
 192                 };\r
 193         }\r
 194 \r
 195         [Test]\r
 196         public void Exists ()\r
 197         {\r
 198                 AssertEquals ("test#01", false, Directory.Exists (null as string));\r
 199         }\r
 200         \r
 201         [Test]\r
 202         [ExpectedException(typeof(ArgumentNullException))]      \r
 203         public void GetCreationTimeException1 ()\r
 204         {\r
 205                 Directory.GetCreationTime (null as string);\r
 206         }\r
 207 \r
 208         [Test]\r
 209         [ExpectedException(typeof(ArgumentException))]  \r
 210         public void GetCreationTimeException2 ()\r
 211         {\r
 212                 Directory.GetCreationTime ("");\r
 213         }\r
 214         \r
 215         [Test]\r
 216         [ExpectedException(typeof(IOException))]\r
 217         public void GetCreationTimeException3 ()\r
 218         {\r
 219                 string path = TempFolder + "/DirectoryTest.GetCreationTime.1";\r
 220                 DeleteDirectory (path);\r
 221                 try {\r
 222                         Directory.GetCreationTime (path);\r
 223                 } finally {\r
 224                         DeleteDirectory (path);\r
 225                 }\r
 226         }\r
 227 \r
 228         [Test]\r
 229         [ExpectedException(typeof(ArgumentException))]  \r
 230         public void GetCreationTimeException4 ()\r
 231         {\r
 232                 Directory.GetCreationTime ("    ");\r
 233         }\r
 234 \r
 235         [Test]\r
 236         [ExpectedException(typeof(ArgumentException))]  \r
 237         public void GetCreationTimeException5 ()\r
 238         {\r
 239                 Directory.GetCreationTime (Path.InvalidPathChars [0].ToString ());\r
 240         }\r
 241 \r
 242         [Test]\r
 243         [ExpectedException(typeof(ArgumentNullException))]      \r
 244         public void GetCreationTimeUtcException1 ()\r
 245         {\r
 246                 Directory.GetCreationTimeUtc (null as string);\r
 247         }\r
 248 \r
 249         [Test]\r
 250         [ExpectedException(typeof(ArgumentException))]  \r
 251         public void GetCreationTimeUtcException2 ()\r
 252         {\r
 253                 Directory.GetCreationTimeUtc ("");\r
 254         }\r
 255         \r
 256         [Test]\r
 257         [ExpectedException(typeof(IOException))]\r
 258         public void GetCreationTimeUtcException3 ()\r
 259         {\r
 260                 string path = TempFolder + "/DirectoryTest.GetCreationTimeUtc.1";\r
 261                 DeleteDirectory (path);\r
 262                 \r
 263                 try {\r
 264                         Directory.GetCreationTimeUtc (path);\r
 265                 } finally {\r
 266                         DeleteDirectory (path);\r
 267                 }\r
 268         }\r
 269 \r
 270         [Test]\r
 271         [ExpectedException(typeof(ArgumentException))]  \r
 272         public void GetCreationTimeUtcException4 ()\r
 273         {\r
 274                 Directory.GetCreationTimeUtc ("    ");\r
 275         }\r
 276 \r
 277         [Test]\r
 278         [ExpectedException(typeof(ArgumentException))]  \r
 279         public void GetCreationTimeUtcException5 ()\r
 280         {\r
 281                 Directory.GetCreationTime (Path.InvalidPathChars [0].ToString ());\r
 282         }\r
 283 \r
 284         [Test]\r
 285         [ExpectedException(typeof(ArgumentNullException))]      \r
 286         public void GetLastAccessTimeException1 ()\r
 287         {\r
 288                 Directory.GetLastAccessTime (null as string);\r
 289         }\r
 290 \r
 291         [Test]\r
 292         [ExpectedException(typeof(ArgumentException))]  \r
 293         public void GetLastAccessTimeException2 ()\r
 294         {\r
 295                 Directory.GetLastAccessTime ("");\r
 296         }\r
 297         \r
 298         [Test]\r
 299         [ExpectedException(typeof(IOException))]\r
 300         public void GetLastAccessTimeException3 ()\r
 301         {\r
 302                 string path = TempFolder + "/DirectoryTest.GetLastAccessTime.1";\r
 303                 DeleteDirectory (path);\r
 304                 \r
 305                 try {\r
 306                         Directory.GetLastAccessTime (path);\r
 307                 } finally {\r
 308                         DeleteDirectory (path);\r
 309                 }\r
 310         }\r
 311 \r
 312         [Test]\r
 313         [ExpectedException(typeof(ArgumentException))]  \r
 314         public void GetLastAccessTimeException4 ()\r
 315         {\r
 316                 Directory.GetLastAccessTime ("    ");\r
 317         }\r
 318 \r
 319         [Test]\r
 320         [ExpectedException(typeof(ArgumentException))]  \r
 321         public void GetLastAccessTimeException5 ()\r
 322         {\r
 323                 Directory.GetLastAccessTime (Path.InvalidPathChars [0].ToString ());\r
 324         }\r
 325 \r
 326         [Test]\r
 327         [ExpectedException(typeof(ArgumentNullException))]      \r
 328         public void GetLastAccessTimeUtcException1 ()\r
 329         {\r
 330                 Directory.GetLastAccessTimeUtc (null as string);\r
 331         }\r
 332 \r
 333         [Test]\r
 334         [ExpectedException(typeof(ArgumentException))]  \r
 335         public void GetLastAccessTimeUtcException2 ()\r
 336         {\r
 337                 Directory.GetLastAccessTimeUtc ("");\r
 338         }\r
 339         \r
 340         [Test]\r
 341         [ExpectedException(typeof(IOException))]\r
 342         public void GetLastAccessTimeUtcException3 ()\r
 343         {\r
 344                 string path = TempFolder + "/DirectoryTest.GetLastAccessTimeUtc.1";\r
 345                 DeleteDirectory (path);\r
 346                 try {\r
 347                         Directory.GetLastAccessTimeUtc (path);\r
 348                 } finally {\r
 349                         DeleteDirectory (path);\r
 350                 }\r
 351         }\r
 352 \r
 353         [Test]\r
 354         [ExpectedException(typeof(ArgumentException))]  \r
 355         public void GetLastAccessTimeUtcException4 ()\r
 356         {\r
 357                 Directory.GetLastAccessTimeUtc ("    ");\r
 358         }\r
 359 \r
 360         [Test]\r
 361         [ExpectedException(typeof(ArgumentException))]  \r
 362         public void GetLastAccessTimeUtcException5 ()\r
 363         {\r
 364                 Directory.GetLastAccessTimeUtc (Path.InvalidPathChars [0].ToString ());\r
 365         }\r
 366 \r
 367         [Test]\r
 368         [ExpectedException(typeof(ArgumentNullException))]      \r
 369         public void GetLastWriteTimeException1 ()\r
 370         {\r
 371                 Directory.GetLastWriteTime (null as string);\r
 372         }\r
 373 \r
 374         [Test]\r
 375         [ExpectedException(typeof(ArgumentException))]  \r
 376         public void GetLastWriteTimeException2 ()\r
 377         {\r
 378                 Directory.GetLastWriteTime ("");\r
 379         }\r
 380         \r
 381         [Test]\r
 382         [ExpectedException(typeof(IOException))]\r
 383         public void GetLastWriteTimeException3 ()\r
 384         {\r
 385                 string path = TempFolder + "/DirectoryTest.GetLastWriteTime.1";\r
 386                 DeleteDirectory (path);\r
 387                 try {\r
 388                         Directory.GetLastWriteTime (path);\r
 389                 } finally {\r
 390                         DeleteDirectory (path);\r
 391                 }\r
 392         }\r
 393 \r
 394         [Test]\r
 395         [ExpectedException(typeof(ArgumentException))]  \r
 396         public void GetLastWriteTimeException4 ()\r
 397         {\r
 398                 Directory.GetLastWriteTime ("    ");\r
 399         }\r
 400 \r
 401         [Test]\r
 402         [ExpectedException(typeof(ArgumentException))]  \r
 403         public void GetLastWriteTimeException5 ()\r
 404         {\r
 405                 Directory.GetLastWriteTime (Path.InvalidPathChars [0].ToString ());\r
 406         }\r
 407 \r
 408         [Test]\r
 409         [ExpectedException(typeof(ArgumentNullException))]      \r
 410         public void GetLastWriteTimeUtcException1 ()\r
 411         {\r
 412                 Directory.GetLastWriteTimeUtc (null as string);\r
 413         }\r
 414 \r
 415         [Test]\r
 416         [ExpectedException(typeof(ArgumentException))]  \r
 417         public void GetLastWriteTimeUtcException2 ()\r
 418         {\r
 419                 Directory.GetLastAccessTimeUtc ("");\r
 420         }\r
 421         \r
 422         [Test]\r
 423         [ExpectedException(typeof(IOException))]\r
 424         public void GetLastWriteTimeUtcException3 ()\r
 425         {\r
 426                 string path = TempFolder + "/DirectoryTest.GetLastWriteTimeUtc.1";\r
 427                 DeleteDirectory (path);\r
 428                 try {\r
 429                         Directory.GetLastAccessTimeUtc (path);\r
 430                 } finally {\r
 431                         DeleteDirectory (path);\r
 432                 }\r
 433                 \r
 434         }\r
 435 \r
 436         [Test]\r
 437         [ExpectedException(typeof(ArgumentException))]  \r
 438         public void GetLastWriteTimeUtcException4 ()\r
 439         {\r
 440                 Directory.GetLastAccessTimeUtc ("    ");\r
 441         }\r
 442 \r
 443         [Test]\r
 444         [ExpectedException(typeof(ArgumentException))]  \r
 445         public void GetLastWriteTimeUtcException5 ()\r
 446         {\r
 447                 Directory.GetLastAccessTimeUtc (Path.InvalidPathChars [0].ToString ());\r
 448         }\r
 449 \r
 450         [Test]\r
 451         public void Move ()\r
 452         {\r
 453                 string path = TempFolder + "/DirectoryTest.Test.9";\r
 454                 string path2 = TempFolder + "/DirectoryTest.Test.10";\r
 455                 DeleteDirectory (path);\r
 456                 DeleteDirectory (path2);\r
 457                 try {\r
 458                         Directory.CreateDirectory (path);\r
 459                         Directory.CreateDirectory (path + "/" + "dir");\r
 460                         AssertEquals ("test#01", true, Directory.Exists (path + "/" + "dir"));\r
 461                 \r
 462                         Directory.Move (path, path2);\r
 463                         AssertEquals ("test#02", false, Directory.Exists (path + "/" + "dir"));         \r
 464                         AssertEquals ("test#03", true, Directory.Exists (path2 + "/" + "dir"));\r
 465                 \r
 466                 } finally {\r
 467                         DeleteDirectory (path);\r
 468                         DeleteDirectory (path2);\r
 469                         if (Directory.Exists (path2 + "/" + "dir"))\r
 470                                 Directory.Delete (path2 + "/" + "dir", true);                   \r
 471                 }\r
 472         }\r
 473         \r
 474         [Test]\r
 475         [ExpectedException(typeof(IOException))]\r
 476         public void MoveException1 ()\r
 477         {\r
 478                 string path = TempFolder + "/DirectoryTest.Test.8";\r
 479                 DeleteDirectory (path);         \r
 480                 try {\r
 481                         Directory.Move (path, path);            \r
 482                 } finally {\r
 483                         DeleteDirectory (path);\r
 484                 }\r
 485         }\r
 486 \r
 487         [Test]\r
 488         [ExpectedException(typeof(ArgumentException))]\r
 489         public void MoveException2 ()\r
 490         {\r
 491                 string path = TempFolder + "/DirectoryTest.Test.11";\r
 492                 DeleteDirectory (path);         \r
 493                 try {\r
 494                         Directory.Move ("", path);              \r
 495                 } finally {\r
 496                         DeleteDirectory (path);\r
 497                 }\r
 498         }\r
 499 \r
 500         [Test]\r
 501         [ExpectedException(typeof(ArgumentException))]\r
 502         public void MoveException3 ()\r
 503         {\r
 504                 string path = TempFolder + "/DirectoryTest.Test.12";\r
 505                 DeleteDirectory (path);         \r
 506                 try {\r
 507                         Directory.Move ("             ", path);\r
 508                 } finally {\r
 509                         DeleteDirectory (path);\r
 510                 }\r
 511         }\r
 512 \r
 513         [Test]\r
 514         [ExpectedException(typeof(ArgumentException))]\r
 515         public void MoveException4 ()\r
 516         {\r
 517                 string path = TempFolder + "/DirectoryTest.Test.13";\r
 518                 path += Path.InvalidPathChars [0];\r
 519                 string path2 = TempFolder + "/DirectoryTest.Test.13";           \r
 520                 DeleteDirectory (path);\r
 521                 DeleteDirectory (path2);\r
 522                 try {\r
 523                         Directory.CreateDirectory (path2);              \r
 524                         Directory.Move (path2, path);\r
 525                 } finally {\r
 526                         DeleteDirectory (path);\r
 527                         DeleteDirectory (path2);\r
 528                 }\r
 529         }\r
 530 \r
 531         [Test]\r
 532         [ExpectedException(typeof(DirectoryNotFoundException))]\r
 533         public void MoveException5 ()\r
 534         {\r
 535                 string path = TempFolder + "/DirectoryTest.Test.14";\r
 536                 DeleteDirectory (path);\r
 537                 try {\r
 538                         Directory.Move (path, path + "Test.Test");              \r
 539                 } finally {\r
 540                         DeleteDirectory (path);\r
 541                         DeleteDirectory (path + "Test.Test");\r
 542                 }\r
 543         }\r
 544 \r
 545         [Test]\r
 546         [ExpectedException(typeof(IOException))]\r
 547         public void MoveException6 ()\r
 548         {\r
 549                 string path = TempFolder + "/DirectoryTest.Test.15";\r
 550                 DeleteDirectory (path);\r
 551                 try {\r
 552                         Directory.CreateDirectory (path);               \r
 553                         Directory.Move (path, path + "/" + "dir");\r
 554                 } finally {\r
 555                         DeleteDirectory (path);\r
 556                         DeleteDirectory (path + "/" + "dir");                   \r
 557                 }\r
 558         }\r
 559 \r
 560         [Test]\r
 561         [ExpectedException(typeof(IOException))]\r
 562         public void MoveException7 ()\r
 563         {\r
 564                 string path = TempFolder + "/DirectoryTest.Test.16";\r
 565                 string path2 = TempFolder + "/DirectoryTest.Test.17";\r
 566                 \r
 567                 DeleteDirectory (path);\r
 568                 DeleteDirectory (path2);                \r
 569                 try {\r
 570                         Directory.CreateDirectory (path);\r
 571                         Directory.CreateDirectory (path2);\r
 572                         Directory.Move (path, path2);\r
 573                 } finally {\r
 574                         DeleteDirectory (path);\r
 575                         DeleteDirectory (path2);                \r
 576                 }\r
 577         }\r
 578         \r
 579         [Test]\r
 580         [Ignore("Unix doesnt support CreationTime")]\r
 581         public void CreationTime ()\r
 582         {\r
 583                 string path = TempFolder + "/DirectoryTest.CreationTime.1";\r
 584                 DeleteDirectory (path);\r
 585                 \r
 586                 try {\r
 587                         Directory.CreateDirectory (path);\r
 588                         Directory.SetCreationTime (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
 589 \r
 590                         DateTime time = Directory.GetCreationTime (path);               \r
 591                         AssertEquals ("test#01", 2003, time.Year);\r
 592                         AssertEquals ("test#02", 6, time.Month);\r
 593                         AssertEquals ("test#03", 4, time.Day);\r
 594                         AssertEquals ("test#04", 6, time.Hour);\r
 595                         AssertEquals ("test#05", 4, time.Minute);\r
 596                         AssertEquals ("test#06", 0, time.Second);\r
 597                 \r
 598                         time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetCreationTimeUtc (path));\r
 599                         AssertEquals ("test#07", 2003, time.Year);\r
 600                         AssertEquals ("test#08", 6, time.Month);\r
 601                         AssertEquals ("test#09", 4, time.Day);\r
 602                         AssertEquals ("test#10", 6, time.Hour);\r
 603                         AssertEquals ("test#11", 4, time.Minute);\r
 604                         AssertEquals ("test#12", 0, time.Second);\r
 605 \r
 606                         Directory.SetCreationTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
 607                         time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetCreationTime (path));\r
 608                         AssertEquals ("test#13", 2003, time.Year);\r
 609                         AssertEquals ("test#14", 6, time.Month);\r
 610                         AssertEquals ("test#15", 4, time.Day);\r
 611                         AssertEquals ("test#16", 6, time.Hour);\r
 612                         AssertEquals ("test#17", 4, time.Minute);\r
 613                         AssertEquals ("test#18", 0, time.Second);\r
 614 \r
 615                         time = Directory.GetCreationTimeUtc (path);             \r
 616                         AssertEquals ("test#19", 2003, time.Year);\r
 617                         AssertEquals ("test#20", 6, time.Month);\r
 618                         AssertEquals ("test#21", 4, time.Day);\r
 619                         AssertEquals ("test#22", 6, time.Hour);\r
 620                         AssertEquals ("test#23", 4, time.Minute);\r
 621                         AssertEquals ("test#24", 0, time.Second);\r
 622                 } finally {\r
 623                         DeleteDirectory (path); \r
 624                 }\r
 625         }\r
 626 \r
 627         [Test]\r
 628         public void LastAccessTime ()\r
 629         {\r
 630                 string path = TempFolder + "/DirectoryTest.AccessTime.1";\r
 631                 DeleteDirectory (path);\r
 632                 \r
 633                 try {\r
 634                         Directory.CreateDirectory (path);\r
 635                         Directory.SetLastAccessTime (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
 636 \r
 637                         DateTime time = Directory.GetLastAccessTime (path);             \r
 638                         AssertEquals ("test#01", 2003, time.Year);\r
 639                         AssertEquals ("test#02", 6, time.Month);\r
 640                         AssertEquals ("test#03", 4, time.Day);\r
 641                         AssertEquals ("test#04", 6, time.Hour);\r
 642                         AssertEquals ("test#05", 4, time.Minute);\r
 643                         AssertEquals ("test#06", 0, time.Second);\r
 644                 \r
 645                         time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetLastAccessTimeUtc (path));\r
 646                         AssertEquals ("test#07", 2003, time.Year);\r
 647                         AssertEquals ("test#08", 6, time.Month);\r
 648                         AssertEquals ("test#09", 4, time.Day);\r
 649                         AssertEquals ("test#10", 6, time.Hour);\r
 650                         AssertEquals ("test#11", 4, time.Minute);\r
 651                         AssertEquals ("test#12", 0, time.Second);\r
 652 \r
 653                         Directory.SetLastAccessTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
 654                         time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetLastAccessTime (path));\r
 655                         AssertEquals ("test#13", 2003, time.Year);\r
 656                         AssertEquals ("test#14", 6, time.Month);\r
 657                         AssertEquals ("test#15", 4, time.Day);\r
 658                         AssertEquals ("test#16", 6, time.Hour);\r
 659                         AssertEquals ("test#17", 4, time.Minute);\r
 660                         AssertEquals ("test#18", 0, time.Second);\r
 661 \r
 662                         time = Directory.GetLastAccessTimeUtc (path);           \r
 663                         AssertEquals ("test#19", 2003, time.Year);\r
 664                         AssertEquals ("test#20", 6, time.Month);\r
 665                         AssertEquals ("test#21", 4, time.Day);\r
 666                         AssertEquals ("test#22", 6, time.Hour);\r
 667                         AssertEquals ("test#23", 4, time.Minute);\r
 668                         AssertEquals ("test#24", 0, time.Second);\r
 669                 } finally {\r
 670                         DeleteDirectory (path);\r
 671                 }\r
 672         }\r
 673 \r
 674         [Test]\r
 675         public void LastWriteTime ()\r
 676         {\r
 677                 string path = TempFolder + "/DirectoryTest.WriteTime.1";\r
 678                 DeleteDirectory (path);         \r
 679                 \r
 680                 try {\r
 681                         Directory.CreateDirectory (path);\r
 682                         Directory.SetLastWriteTime (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
 683 \r
 684                         DateTime time = Directory.GetLastWriteTime (path);              \r
 685                         AssertEquals ("test#01", 2003, time.Year);\r
 686                         AssertEquals ("test#02", 6, time.Month);\r
 687                         AssertEquals ("test#03", 4, time.Day);\r
 688                         AssertEquals ("test#04", 6, time.Hour);\r
 689                         AssertEquals ("test#05", 4, time.Minute);\r
 690                         AssertEquals ("test#06", 0, time.Second);\r
 691                 \r
 692                         time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetLastWriteTimeUtc (path));\r
 693                         AssertEquals ("test#07", 2003, time.Year);\r
 694                         AssertEquals ("test#08", 6, time.Month);\r
 695                         AssertEquals ("test#09", 4, time.Day);\r
 696                         AssertEquals ("test#10", 6, time.Hour);\r
 697                         AssertEquals ("test#11", 4, time.Minute);\r
 698                         AssertEquals ("test#12", 0, time.Second);\r
 699 \r
 700                         Directory.SetLastWriteTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));\r
 701                         time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetLastWriteTime (path));\r
 702                         AssertEquals ("test#13", 2003, time.Year);\r
 703                         AssertEquals ("test#14", 6, time.Month);\r
 704                         AssertEquals ("test#15", 4, time.Day);\r
 705                         AssertEquals ("test#16", 6, time.Hour);\r
 706                         AssertEquals ("test#17", 4, time.Minute);\r
 707                         AssertEquals ("test#18", 0, time.Second);\r
 708 \r
 709                         time = Directory.GetLastWriteTimeUtc (path);            \r
 710                         AssertEquals ("test#19", 2003, time.Year);\r
 711                         AssertEquals ("test#20", 6, time.Month);\r
 712                         AssertEquals ("test#21", 4, time.Day);\r
 713                         AssertEquals ("test#22", 6, time.Hour);\r
 714                         AssertEquals ("test#23", 4, time.Minute);\r
 715                         AssertEquals ("test#24", 0, time.Second);\r
 716                 } finally {\r
 717                         DeleteDirectory (path);         \r
 718                 }\r
 719         }\r
 720 \r
 721         [Test]\r
 722         [ExpectedException(typeof(ArgumentNullException))]      \r
 723         public void SetLastWriteTimeException1 ()\r
 724         {\r
 725                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
 726                 Directory.SetLastWriteTime (null as string, time);\r
 727         }\r
 728 \r
 729         [Test]\r
 730         [ExpectedException(typeof(ArgumentException))]  \r
 731         public void SetLastWriteTimeException2 ()\r
 732         {\r
 733                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 734                 Directory.SetLastWriteTime ("", time);\r
 735         }\r
 736         \r
 737         [Test]\r
 738         [ExpectedException(typeof(FileNotFoundException))]\r
 739         public void SetLastWriteTimeException3 ()\r
 740         {\r
 741                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 742                 string path = TempFolder + "/DirectoryTest.SetLastWriteTime.2";\r
 743                 DeleteDirectory (path);\r
 744                 try {\r
 745                         Directory.SetLastWriteTime (path, time);\r
 746                 } finally {\r
 747                         DeleteDirectory (path);\r
 748                 }\r
 749         }\r
 750 \r
 751         [Test]\r
 752         [ExpectedException(typeof(ArgumentException))]  \r
 753         public void SetLastWriteTimeException4 ()\r
 754         {\r
 755                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 756                 Directory.SetLastWriteTime ("    ", time);\r
 757         }\r
 758 \r
 759         [Test]\r
 760         [ExpectedException(typeof(ArgumentException))]  \r
 761         public void SetLastWriteTimeException5 ()\r
 762         {\r
 763                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 764                 Directory.SetLastWriteTime (Path.InvalidPathChars [0].ToString (), time);\r
 765         }\r
 766 \r
 767 //      [Test]\r
 768 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]        \r
 769 //      public void SetLastWriteTimeException6 ()\r
 770 //      {\r
 771 //              DateTime time = new DateTime (1003, 4, 6, 6, 4, 2);\r
 772 //              string path = TempFolder + Path.DirectorySeparatorChar + "DirectoryTest.SetLastWriteTime.1";\r
 773 //\r
 774 //              try {\r
 775 //                      if (!Directory.Exists (path))                   \r
 776 //                              Directory.CreateDirectory (path);\r
 777 //              \r
 778 //                      Directory.SetLastWriteTime (path, time);\r
 779 //              } finally {\r
 780 //                      DeleteDirectory (path);\r
 781 //              }\r
 782 //\r
 783 //      }\r
 784 \r
 785         [Test]\r
 786         [ExpectedException(typeof(ArgumentNullException))]      \r
 787         public void SetLastWriteTimeUtcException1 ()\r
 788         {\r
 789                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 790                 Directory.SetLastWriteTimeUtc (null as string, time);\r
 791         }\r
 792 \r
 793         [Test]\r
 794         [ExpectedException(typeof(ArgumentException))]  \r
 795         public void SetLastWriteTimeUtcException2 ()\r
 796         {\r
 797                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 798                 Directory.SetLastWriteTimeUtc ("", time);\r
 799         }\r
 800         \r
 801         [Test]\r
 802         [ExpectedException(typeof(FileNotFoundException))]\r
 803         public void SetLastWriteTimeUtcException3 ()\r
 804         {\r
 805                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 806                 string path = TempFolder + "/DirectoryTest.SetLastWriteTimeUtc.2";\r
 807                 DeleteDirectory (path);\r
 808                 try {\r
 809                         Directory.SetLastWriteTimeUtc (path, time);\r
 810                 } finally {\r
 811                         DeleteDirectory (path);\r
 812                 }\r
 813         }\r
 814 \r
 815         [Test]\r
 816         [ExpectedException(typeof(ArgumentException))]  \r
 817         public void SetLastWriteTimeUtcException4 ()\r
 818         {\r
 819                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 820                 Directory.SetLastWriteTimeUtc ("    ", time);\r
 821         }\r
 822 \r
 823         [Test]\r
 824         [ExpectedException(typeof(ArgumentException))]  \r
 825         public void SetLastWriteTimeUtcException5 ()\r
 826         {\r
 827                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 828                 Directory.SetLastWriteTimeUtc (Path.InvalidPathChars [0].ToString (), time);\r
 829         }\r
 830 \r
 831 //      [Test]\r
 832 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]        \r
 833 //      public void SetLastWriteTimeUtcException6 ()\r
 834 //      {\r
 835 //              DateTime time = new DateTime (1000, 4, 6, 6, 4, 2);\r
 836 //              string path = TempFolder + "/DirectoryTest.SetLastWriteTimeUtc.1";\r
 837 //\r
 838 //              if (!Directory.Exists (path))\r
 839 //                      Directory.CreateDirectory (path);\r
 840 //              try {\r
 841 //                      Directory.SetLastWriteTimeUtc (path, time);\r
 842 //              } finally {\r
 843 //                      DeleteDirectory (path);\r
 844 //              }\r
 845 //      }\r
 846 \r
 847         [Test]\r
 848         [ExpectedException(typeof(ArgumentNullException))]      \r
 849         public void SetLastAccessTimeException1 ()\r
 850         {\r
 851                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
 852                 Directory.SetLastAccessTime (null as string, time);\r
 853         }\r
 854 \r
 855         [Test]\r
 856         [ExpectedException(typeof(ArgumentException))]  \r
 857         public void SetLastAccessTimeException2 ()\r
 858         {\r
 859                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 860                 Directory.SetLastAccessTime ("", time);\r
 861         }\r
 862         \r
 863         [Test]\r
 864         [ExpectedException(typeof(FileNotFoundException))]\r
 865         public void SetLastAccessTimeException3 ()\r
 866         {\r
 867                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 868                 string path = TempFolder + "/DirectoryTest.SetLastAccessTime.2";\r
 869                 DeleteDirectory (path);\r
 870                 try {\r
 871                         Directory.SetLastAccessTime (path, time);\r
 872                 } finally {\r
 873                         DeleteDirectory (path);\r
 874                 }\r
 875         }\r
 876 \r
 877         [Test]\r
 878         [ExpectedException(typeof(ArgumentException))]  \r
 879         public void SetLastAccessTimeException4 ()\r
 880         {\r
 881                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 882                 Directory.SetLastAccessTime ("    ", time);\r
 883         }\r
 884 \r
 885         [Test]\r
 886         [ExpectedException(typeof(ArgumentException))]  \r
 887         public void SetLastAccessTimeException5 ()\r
 888         {\r
 889                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 890                 Directory.SetLastAccessTime (Path.InvalidPathChars [0].ToString (), time);\r
 891         }\r
 892 \r
 893 //      [Test]\r
 894 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]        \r
 895 //      public void SetLastAccessTimeException6 ()\r
 896 //      {\r
 897 //              DateTime time = new DateTime (1003, 4, 6, 6, 4, 2);\r
 898 //              string path = TempFolder + "/DirectoryTest.SetLastAccessTime.1";\r
 899 //\r
 900 //              if (!Directory.Exists (path))                   \r
 901 //                      Directory.CreateDirectory (path);\r
 902 //              try {\r
 903 //                      Directory.SetLastAccessTime (path, time);\r
 904 //              } finally {\r
 905 //                      DeleteDirectory (path);\r
 906 //              }\r
 907 //\r
 908 //      }\r
 909 \r
 910         [Test]\r
 911         [ExpectedException(typeof(ArgumentNullException))]      \r
 912         public void SetLastAccessTimeUtcException1 ()\r
 913         {\r
 914                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 915                 Directory.SetLastAccessTimeUtc (null as string, time);\r
 916         }\r
 917 \r
 918         [Test]\r
 919         [ExpectedException(typeof(ArgumentException))]  \r
 920         public void SetLastAccessTimeUtcException2 ()\r
 921         {\r
 922                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 923                 Directory.SetLastAccessTimeUtc ("", time);\r
 924         }\r
 925         \r
 926         [Test]\r
 927         [ExpectedException(typeof(FileNotFoundException))]\r
 928         public void SetLastAccessTimeUtcException3 ()\r
 929         {\r
 930                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 931                 string path = TempFolder + "/DirectoryTest.SetLastAccessTimeUtc.2";\r
 932                 DeleteDirectory (path);\r
 933                 try {\r
 934                         Directory.SetLastAccessTimeUtc (path, time);\r
 935                 } finally {\r
 936                         DeleteDirectory (path);\r
 937                 }\r
 938         }\r
 939 \r
 940         [Test]\r
 941         [ExpectedException(typeof(ArgumentException))]  \r
 942         public void SetLastAccessTimeUtcException4 ()\r
 943         {\r
 944                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 945                 Directory.SetLastAccessTimeUtc ("    ", time);\r
 946         }\r
 947 \r
 948         [Test]\r
 949         [ExpectedException(typeof(ArgumentException))]  \r
 950         public void SetLastAccessTimeUtcException5 ()\r
 951         {\r
 952                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 953                 Directory.SetLastAccessTimeUtc (Path.InvalidPathChars [0].ToString (), time);\r
 954         }\r
 955 \r
 956 //      [Test]\r
 957 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]        \r
 958 //      public void SetLastAccessTimeUtcException6 ()\r
 959 //      {\r
 960 //              DateTime time = new DateTime (1000, 4, 6, 6, 4, 2);\r
 961 //              string path = TempFolder + "/DirectoryTest.SetLastAccessTimeUtc.1";\r
 962 //\r
 963 //              if (!Directory.Exists (path))\r
 964 //                      Directory.CreateDirectory (path);\r
 965 //              try {\r
 966 //                      Directory.SetLastAccessTimeUtc (path, time);\r
 967 //              } finally {\r
 968 //                      DeleteDirectory (path);\r
 969 //              }\r
 970 //      }\r
 971 \r
 972         [ExpectedException(typeof(ArgumentNullException))]      \r
 973         public void SetCreationTimeException1 ()\r
 974         {\r
 975                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);\r
 976                 Directory.SetCreationTime (null as string, time);\r
 977         }\r
 978 \r
 979         [Test]\r
 980         [ExpectedException(typeof(ArgumentException))]  \r
 981         public void SetCreationTimeException2 ()\r
 982         {\r
 983                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 984                 Directory.SetCreationTime ("", time);\r
 985         }\r
 986         \r
 987         [Test]\r
 988         [ExpectedException(typeof(FileNotFoundException))]\r
 989         public void SetCreationTimeException3 ()\r
 990         {\r
 991                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
 992                 string path = TempFolder + "/DirectoryTest.SetCreationTime.2";\r
 993                 DeleteDirectory (path);\r
 994                 \r
 995                 try {\r
 996                         Directory.SetCreationTime (path, time);\r
 997                 } finally {\r
 998                         DeleteDirectory (path);\r
 999                 }\r
1000         }\r
1001 \r
1002         [Test]\r
1003         [ExpectedException(typeof(ArgumentException))]  \r
1004         public void SetCreationTimeException4 ()\r
1005         {\r
1006                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
1007                 Directory.SetCreationTime ("    ", time);\r
1008         }\r
1009 \r
1010         [Test]\r
1011         [ExpectedException(typeof(ArgumentException))]  \r
1012         public void SetCreationTimeException5 ()\r
1013         {\r
1014                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
1015                 Directory.SetCreationTime (Path.InvalidPathChars [0].ToString (), time);\r
1016         }\r
1017 \r
1018 //      [Test]\r
1019 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]        \r
1020 //      public void SetCreationTimeException6 ()\r
1021 //      {\r
1022 //              DateTime time = new DateTime (1003, 4, 6, 6, 4, 2);\r
1023 //              string path = TempFolder + "/DirectoryTest.SetCreationTime.1";\r
1024 //\r
1025 //              if (!Directory.Exists (path))                   \r
1026 //                      Directory.CreateDirectory (path);\r
1027 //              try {\r
1028 //                      Directory.SetCreationTime (path, time);\r
1029 //                      DeleteDirectory (path);                 \r
1030 //              } finally {\r
1031 //                      DeleteDirectory (path);\r
1032 //              }\r
1033 //\r
1034 //      }\r
1035 \r
1036         [Test]\r
1037         [ExpectedException(typeof(ArgumentNullException))]      \r
1038         public void SetCreationTimeUtcException1 ()\r
1039         {\r
1040                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
1041                 Directory.SetCreationTimeUtc (null as string, time);\r
1042         }\r
1043 \r
1044         [Test]\r
1045         [ExpectedException(typeof(ArgumentException))]  \r
1046         public void SetCreationTimeUtcException2 ()\r
1047         {\r
1048                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
1049                 Directory.SetCreationTimeUtc ("", time);\r
1050         }\r
1051         \r
1052         [Test]\r
1053         [ExpectedException(typeof(FileNotFoundException))]\r
1054         public void SetCreationTimeUtcException3 ()\r
1055         {\r
1056                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
1057                 string path = TempFolder + "/DirectoryTest.SetLastAccessTimeUtc.2";\r
1058                 DeleteDirectory (path);\r
1059                 \r
1060                 try {\r
1061                         Directory.SetCreationTimeUtc (path, time);\r
1062                         DeleteDirectory (path);\r
1063                 } finally {\r
1064                         DeleteDirectory (path);\r
1065                 }\r
1066         }\r
1067 \r
1068         [Test]\r
1069         [ExpectedException(typeof(ArgumentException))]  \r
1070         public void SetCreationTimeUtcException4 ()\r
1071         {\r
1072                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
1073                 Directory.SetCreationTimeUtc ("    ", time);\r
1074         }\r
1075 \r
1076         [Test]\r
1077         [ExpectedException(typeof(ArgumentException))]  \r
1078         public void SetCreationTimeUtcException5 ()\r
1079         {\r
1080                 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);             \r
1081                 Directory.SetCreationTimeUtc (Path.InvalidPathChars [0].ToString (), time);\r
1082         }\r
1083 \r
1084 //      [Test]\r
1085 //      [ExpectedException(typeof(ArgumentOutOfRangeException))]        \r
1086 //      public void SetCreationTimeUtcException6 ()\r
1087 //      {\r
1088 //              DateTime time = new DateTime (1000, 4, 6, 6, 4, 2);\r
1089 //              string path = TempFolder + "/DirectoryTest.SetLastAccessTimeUtc.1";\r
1090 //\r
1091 //              if (!Directory.Exists (path))\r
1092 //                      Directory.CreateDirectory (path);\r
1093 //              try {\r
1094 //                      Directory.SetCreationTimeUtc (path, time);\r
1095 //                      DeleteDirectory (path);\r
1096 //              } finally {\r
1097 //                      DeleteDirectory (path);\r
1098 //              }\r
1099 //      }\r
1100 \r
1101         [Test]\r
1102         public void GetDirectories ()\r
1103         {\r
1104                 string path = TempFolder;\r
1105                 string DirPath = TempFolder + Path.DirectorySeparatorChar + ".GetDirectories";\r
1106                 DeleteDirectory (DirPath);\r
1107                 \r
1108                 try {\r
1109                         Directory.CreateDirectory (DirPath);\r
1110                 \r
1111                         string [] dirs = Directory.GetDirectories (path);\r
1112                 \r
1113                         foreach (string directory in dirs) {\r
1114                         \r
1115                                 if (directory == DirPath)\r
1116                                         return;\r
1117                         }\r
1118                 \r
1119                         Assert ("Directory Not Found", false);\r
1120                 } finally {\r
1121                         DeleteDirectory (DirPath);\r
1122                 }\r
1123         }\r
1124 \r
1125         [Test]\r
1126         public void GetParentOfRootDirectory ()\r
1127         {\r
1128                 DirectoryInfo info;\r
1129 \r
1130                 info = Directory.GetParent (Path.GetPathRoot (Path.GetTempPath ()));\r
1131                 AssertEquals (null, info);\r
1132         }\r
1133         \r
1134         [Test]\r
1135         public void GetFiles ()\r
1136         {\r
1137                 string path = TempFolder;\r
1138                 string DirPath = TempFolder + Path.DirectorySeparatorChar + ".GetFiles";\r
1139                 if (File.Exists (DirPath))\r
1140                         File.Delete (DirPath);\r
1141                 \r
1142                 try {\r
1143                         File.Create (DirPath).Close ();\r
1144                         string [] files = Directory.GetFiles (TempFolder);\r
1145                         foreach (string directory in files) {\r
1146                         \r
1147                                 if (directory == DirPath)\r
1148                                         return;\r
1149                         }\r
1150                 \r
1151                         Assert ("File Not Found", false);\r
1152                 } finally {\r
1153                         if (File.Exists (DirPath))\r
1154                                 File.Delete (DirPath);\r
1155                         \r
1156                 }                                                               \r
1157         }\r
1158 \r
1159         [Test]\r
1160         [ExpectedException (typeof (ArgumentNullException))]\r
1161         public void SetCurrentDirectoryNull ()\r
1162         {\r
1163                 Directory.SetCurrentDirectory (null);\r
1164         }\r
1165 \r
1166         [Test]\r
1167         [ExpectedException (typeof (ArgumentException))]\r
1168         public void SetCurrentDirectoryEmpty ()\r
1169         {\r
1170                 Directory.SetCurrentDirectory (String.Empty);\r
1171         }\r
1172 \r
1173         [Test]\r
1174         [ExpectedException (typeof (ArgumentException))]\r
1175         public void SetCurrentDirectoryWhitespace ()\r
1176         {\r
1177                 Directory.SetCurrentDirectory (" ");\r
1178         }\r
1179 \r
1180 \r
1181         [Test]\r
1182         public void GetNoFiles () // Bug 58875. This throwed an exception on windows.\r
1183         {\r
1184                 DirectoryInfo dir = new DirectoryInfo (".");\r
1185                 dir.GetFiles ("*.nonext");\r
1186         }\r
1187 \r
1188         private void DeleteDirectory (string path)\r
1189         {\r
1190                 if (Directory.Exists (path))\r
1191                         Directory.Delete (path, true);          \r
1192         }\r
1193 }\r
1194 }\r