mcs/class/corlib/Test/System.IO/DirectoryInfoTest.cs

   1 // DirectoryInfoTest.cs - NUnit Test Cases for System.IO.DirectoryInfo class\r
   2 //\r
   3 // Ville Palo (vi64pa@koti.soon.fi)\r
   4 // \r
   5 // (C) 2003 Ville Palo\r
   6 // \r
   7 using NUnit.Framework;\r
   8 using System;\r
   9 using System.IO;\r
  10 namespace MonoTests.System.IO\r
  11 {\r
  12         [TestFixture]\r
  13         public class DirectoryInfoTest : Assertion\r
  14         {\r
  15                 string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");\r
  16 \r
  17                 static readonly char DSC = Path.DirectorySeparatorChar;\r
  18 \r
  19                 [SetUp]\r
  20                 protected void SetUp() {\r
  21                         if (Directory.Exists (TempFolder))\r
  22                                 Directory.Delete (TempFolder, true);\r
  23                         Directory.CreateDirectory (TempFolder);\r
  24                 }\r
  25         \r
  26                 [TearDown]\r
  27                 protected void TearDown() {\r
  28                         if (Directory.Exists (TempFolder))\r
  29                                 Directory.Delete (TempFolder, true);\r
  30                 }\r
  31         \r
  32                 [Test]\r
  33                 public void Ctr ()\r
  34                 {\r
  35                         string path = TempFolder + DSC + "DIT.Ctr.Test";\r
  36                         DeleteDir (path);\r
  37                 \r
  38                         FileInfo info = new FileInfo (path);\r
  39                         AssertEquals ("test#01", true, info.DirectoryName.EndsWith (".Tests"));\r
  40                         AssertEquals ("test#02", false, info.Exists);\r
  41                         AssertEquals ("test#03", ".Test", info.Extension);\r
  42                         AssertEquals ("test#05", "DIT.Ctr.Test", info.Name);            \r
  43                 }\r
  44 \r
  45                 [Test]\r
  46                 [ExpectedException(typeof(ArgumentNullException))]\r
  47                 public void CtorArgumentNullException ()\r
  48                 {\r
  49                         DirectoryInfo info = new DirectoryInfo (null);            \r
  50                 }\r
  51 \r
  52                 [Test]\r
  53                 [ExpectedException(typeof(ArgumentException))]\r
  54                 public void CtorArgumentException1 ()\r
  55                 {\r
  56                         DirectoryInfo info = new DirectoryInfo ("");            \r
  57                 }\r
  58 \r
  59                 [Test]\r
  60                 [ExpectedException(typeof(ArgumentException))]\r
  61                 public void CtorArgumentException2 ()\r
  62                 {\r
  63                         DirectoryInfo info = new DirectoryInfo ("   ");            \r
  64                 }\r
  65 \r
  66                 [Test]\r
  67                 [ExpectedException(typeof(ArgumentException))]\r
  68                 public void CtorArgumentException3 ()\r
  69                 {\r
  70                 string path = "";\r
  71                 foreach (char c in Path.InvalidPathChars) {\r
  72                         path += c;\r
  73                 }\r
  74                 DirectoryInfo info = new DirectoryInfo (path);\r
  75                 }\r
  76                                 \r
  77                 [Test]\r
  78                 public void Exists ()\r
  79                 {\r
  80                 string path = TempFolder + DSC + "DIT.Exists.Test";\r
  81                 DeleteDir (path);\r
  82             \r
  83                 try {\r
  84                         DirectoryInfo info = new DirectoryInfo (path);\r
  85                         AssertEquals ("test#01", false, info.Exists);\r
  86             \r
  87                         Directory.CreateDirectory (path);\r
  88                         AssertEquals ("test#02", false, info.Exists);\r
  89                         info = new DirectoryInfo (path);\r
  90                         AssertEquals ("test#03", true, info.Exists);            \r
  91                 } finally {\r
  92                         DeleteDir (path);\r
  93                 }\r
  94                 }\r
  95                 \r
  96                 [Test]\r
  97                 public void Name ()\r
  98                 {\r
  99                         string path = TempFolder + DSC + "DIT.Name.Test";\r
 100                         DeleteDir (path);\r
 101                         \r
 102                         try {\r
 103                                 DirectoryInfo info = new DirectoryInfo (path);                          \r
 104                                 AssertEquals ("test#01", "DIT.Name.Test", info.Name);\r
 105                                 \r
 106                                 info = Directory.CreateDirectory (path);\r
 107                                 AssertEquals ("test#02", "DIT.Name.Test", info.Name);\r
 108                                 \r
 109                                 \r
 110                         } finally {\r
 111                                 DeleteDir (path);\r
 112                         }                                  \r
 113                 }\r
 114                 \r
 115                 [Test]\r
 116                 public void Parent ()\r
 117                 {\r
 118                         string path = TempFolder + DSC + "DIT.Parent.Test";\r
 119                         DeleteDir (path);\r
 120                         \r
 121                         try {\r
 122                                 DirectoryInfo info = new DirectoryInfo (path);\r
 123                                 AssertEquals ("test#01", "MonoTests.System.IO.Tests", info.Parent.Name);\r
 124                                 \r
 125                                 info = Directory.CreateDirectory (path);\r
 126                                 AssertEquals ("test#02", "MonoTests.System.IO.Tests", info.Parent.Name);\r
 127                                                                 \r
 128                         } finally {\r
 129                                 DeleteDir (path);\r
 130                         }                                               \r
 131                 }\r
 132 \r
 133                 [Test]\r
 134                 public void Create ()\r
 135                 {\r
 136                 string path = TempFolder + DSC + "DIT.Create.Test";\r
 137                 DeleteDir (path);\r
 138             \r
 139                 try {\r
 140                         DirectoryInfo info = new DirectoryInfo (path);\r
 141                         AssertEquals ("test#01", false, info.Exists);\r
 142                         info.Create ();                \r
 143                         AssertEquals ("test#02", false, info.Exists);\r
 144                         info = new DirectoryInfo (path);\r
 145                         AssertEquals ("test#03", true, info.Exists);\r
 146                 } finally {\r
 147                         DeleteDir (path);\r
 148                 }\r
 149                 }\r
 150 \r
 151                 [Test]\r
 152                 public void CreateSubdirectory ()\r
 153                 {\r
 154                         string sub_path = Path.Combine ("test01", "test02");\r
 155                         try {\r
 156                                 DirectoryInfo info = new DirectoryInfo (TempFolder);\r
 157                                 info.CreateSubdirectory (sub_path);\r
 158                                 Assert ("test#01", Directory.Exists (Path.Combine (TempFolder, sub_path)));\r
 159                         } finally {\r
 160                                 DeleteDir (Path.Combine (TempFolder, sub_path));\r
 161                         }\r
 162                                 \r
 163                 }
 164
 165                 [Test]
 166                 [ExpectedException(typeof(ArgumentException))]
 167                 public void CreateSubdirectoryEmptyString ()
 168                 {
 169                         new DirectoryInfo (".").CreateSubdirectory ("");
 170                 }\r
 171 \r
 172                 [Test]\r
 173                 public void Delete1 ()\r
 174                 {\r
 175                 string path = TempFolder + DSC + "DIT.Delete1.Test";\r
 176                 DeleteDir (path);\r
 177                         \r
 178                         try {\r
 179                                 Directory.CreateDirectory (path);\r
 180                                 DirectoryInfo info = new DirectoryInfo (path);\r
 181                                 AssertEquals ("test#01", true, info.Exists);\r
 182                                 \r
 183                                 info.Delete ();\r
 184                                 AssertEquals ("test#02", true, info.Exists);\r
 185                                 \r
 186                                 info = new DirectoryInfo (path);\r
 187                                 AssertEquals ("test#03", false, info.Exists);\r
 188                         } finally {\r
 189                                 DeleteDir (path);\r
 190                         }\r
 191                 }\r
 192 \r
 193                 [Test]\r
 194                 public void Delete2 ()\r
 195                 {\r
 196                 string path = TempFolder + DSC + "DIT.Delete2.Test";\r
 197                 DeleteDir (path);\r
 198                         \r
 199                         try {\r
 200                                 Directory.CreateDirectory (path);\r
 201                                 File.Create (path + DSC + "test").Close ();\r
 202                                 DirectoryInfo info = new DirectoryInfo (path);\r
 203                                 AssertEquals ("test#01", true, info.Exists);\r
 204                                 \r
 205                                 info.Delete (true);\r
 206                                 AssertEquals ("test#02", true, info.Exists);\r
 207                                 \r
 208                                 info = new DirectoryInfo (path);\r
 209                                 AssertEquals ("test#03", false, info.Exists);\r
 210                         } finally {\r
 211                                 DeleteDir (path);\r
 212                         }\r
 213                 }\r
 214                 \r
 215                 [Test]\r
 216                 [ExpectedException (typeof (IOException))]\r
 217                 public void DeleteIOException1 ()\r
 218                 {\r
 219                 string path = TempFolder + DSC + "DIT.DeleteIOException1.Test";\r
 220                 DeleteDir (path);                       \r
 221                         \r
 222                         try {\r
 223                                 Directory.CreateDirectory (path);\r
 224                                 File.Create (path + DSC + "test").Close ();\r
 225                                 DirectoryInfo info = new DirectoryInfo (path);\r
 226                                 info.Delete ();\r
 227                         } finally {\r
 228                                 DeleteDir (path);\r
 229                         }\r
 230                 }\r
 231 \r
 232                 [Test]\r
 233                 [ExpectedException (typeof (IOException))]\r
 234                 public void DeleteIOException2 ()\r
 235                 {\r
 236                 string path = TempFolder + DSC + "DIT.DeleteIOException2.Test";\r
 237                 DeleteDir (path);                       \r
 238                         \r
 239                         try {\r
 240                                 Directory.CreateDirectory (path);\r
 241                                 File.Create (path + DSC + "test").Close ();\r
 242                                 DirectoryInfo info = new DirectoryInfo (path);\r
 243                                 info.Delete (false);\r
 244                         } finally {\r
 245                                 DeleteDir (path);\r
 246                         }\r
 247                 }
 248
 249                 [Test]
 250                 // from bug #75443
 251                 public void FullName ()
 252                 {
 253                         DirectoryInfo di = new DirectoryInfo ("something");
 254                         Assert ("Exists", !di.Exists);
 255                         Assert ("FullName", di.FullName.EndsWith ("something"));
 256
 257                         di = new DirectoryInfo ("something" + Path.DirectorySeparatorChar);
 258                         AssertEquals ("DirectorySeparatorChar", Path.DirectorySeparatorChar, di.FullName [di.FullName.Length - 1]);
 259
 260                         di = new DirectoryInfo ("something" + Path.AltDirectorySeparatorChar);
 261                         AssertEquals ("AltDirectorySeparatorChar", Path.DirectorySeparatorChar, di.FullName [di.FullName.Length - 1]);
 262                 }\r
 263
 264                 [Test]
 265                 public void FullName_RootDirectory ()
 266                 {
 267                         DirectoryInfo di = new DirectoryInfo (String.Empty + Path.DirectorySeparatorChar);
 268                         if (Path.DirectorySeparatorChar == '/') {
 269                                 // can't be sure of the root drive under windows
 270                                 AssertEquals ("FullName", di.FullName, "/");
 271                         }
 272                         AssertNull ("Parent", di.Parent);
 273
 274                         di = new DirectoryInfo (String.Empty + Path.AltDirectorySeparatorChar);
 275                         if (Path.DirectorySeparatorChar == '/') {
 276                                 // can't be sure of the root drive under windows
 277                                 AssertEquals ("FullName-Alt", di.FullName, "/");
 278                         }
 279                         AssertNull ("Parent-Alt", di.Parent);
 280                 }\r
 281                 \r
 282                 [Test]\r
 283                 public void GetDirectories1 ()\r
 284                 {\r
 285                         string path = TempFolder + DSC + "DIT.GetDirectories1.Test";\r
 286                         \r
 287                         try {\r
 288                                 DirectoryInfo info = Directory.CreateDirectory (path);\r
 289                                 AssertEquals ("test#01", 0, info.GetDirectories ().Length);\r
 290                                 \r
 291                                 Directory.CreateDirectory (path + DSC + "1");\r
 292                                 Directory.CreateDirectory (path + DSC + "2");                           \r
 293                                 File.Create (path + DSC + "filetest").Close ();\r
 294                                 AssertEquals ("test#02", 2, info.GetDirectories ().Length);\r
 295                                 \r
 296                                 Directory.Delete (path + DSC + 2);\r
 297                                 AssertEquals ("test#02", 1, info.GetDirectories ().Length);                             \r
 298                                 \r
 299                         } finally {\r
 300                                 DeleteDir (path);\r
 301                         }\r
 302                 }\r
 303                 \r
 304                 [Test]\r
 305                 public void GetDirectories2 ()\r
 306                 {\r
 307                         string path = TempFolder + DSC + "DIT.GetDirectories2.Test";\r
 308                         \r
 309                         try {\r
 310                                 DirectoryInfo info = Directory.CreateDirectory (path);\r
 311                                 AssertEquals ("test#01", 0, info.GetDirectories ("*").Length);\r
 312                                 \r
 313                                 Directory.CreateDirectory (path + DSC + "test120");\r
 314                                 Directory.CreateDirectory (path + DSC + "test210");\r
 315                                 Directory.CreateDirectory (path + DSC + "atest330");\r
 316                                 Directory.CreateDirectory (path + DSC + "test220");\r
 317                                 File.Create (path + DSC + "filetest").Close ();\r
 318                                 \r
 319                                 AssertEquals ("test#02", 4, info.GetDirectories ("*").Length);\r
 320                                 AssertEquals ("test#03", 3, info.GetDirectories ("test*").Length);\r
 321                                 AssertEquals ("test#04", 2, info.GetDirectories ("test?20").Length);\r
 322                                 AssertEquals ("test#05", 0, info.GetDirectories ("test?").Length);\r
 323                                 AssertEquals ("test#06", 0, info.GetDirectories ("test[12]*").Length);\r
 324                                 AssertEquals ("test#07", 2, info.GetDirectories ("test2*0").Length);\r
 325                                 AssertEquals ("test#08", 4, info.GetDirectories ("*test*").Length);\r
 326                                 \r
 327                         } finally {\r
 328                                 DeleteDir (path);\r
 329                         }\r
 330                 }\r
 331                 \r
 332                 [Test]\r
 333                 [ExpectedException (typeof (DirectoryNotFoundException))]               \r
 334                 public void GetDirectoriesDirectoryNotFoundException1 ()\r
 335                 {\r
 336                 string path = TempFolder + DSC + "DIT.GetDirectoriesDirectoryNotFoundException1.Test";\r
 337                 DeleteDir (path);\r
 338                         \r
 339                         try {\r
 340                                 DirectoryInfo info = new DirectoryInfo (path);\r
 341                                 info.GetDirectories ();\r
 342                         } finally {\r
 343                                 DeleteDir (path);\r
 344                         }\r
 345                 }\r
 346 \r
 347                 [Test]\r
 348                 [ExpectedException (typeof (DirectoryNotFoundException))]               \r
 349                 public void GetDirectoriesDirectoryNotFoundException2 ()\r
 350                 {\r
 351                 string path = TempFolder + DSC + "DIT.GetDirectoriesDirectoryNotFoundException2.Test";\r
 352                 DeleteDir (path);\r
 353                         \r
 354                         try {\r
 355                                 DirectoryInfo info = new DirectoryInfo (path);\r
 356                                 info.GetDirectories ("*");\r
 357                         } finally {\r
 358                                 DeleteDir (path);\r
 359                         }\r
 360                 }\r
 361                 \r
 362                 [Test]\r
 363                 [ExpectedException (typeof (ArgumentNullException))]\r
 364                 public void GetDirectoriesArgumentNullException ()\r
 365                 {\r
 366                 string path = TempFolder + DSC + "DIT.GetDirectoriesArgumentNullException.Test";\r
 367                 DeleteDir (path);\r
 368                         \r
 369                         try {\r
 370                                 DirectoryInfo info = new DirectoryInfo (path);\r
 371                                 info.GetDirectories (null);\r
 372                         } finally {\r
 373                                 DeleteDir (path);\r
 374                         }                       \r
 375                 }\r
 376 \r
 377                 [Test]\r
 378                 public void GetFiles1 ()\r
 379                 {\r
 380                 string path = TempFolder + DSC + "DIT.GetFiles1.Test";\r
 381                 DeleteDir (path);\r
 382                         \r
 383                         try {\r
 384                                 DirectoryInfo info = Directory.CreateDirectory (path);\r
 385                                 AssertEquals ("test#01", 0, info.GetFiles ().Length);\r
 386                                 File.Create (path + DSC + "file1").Close ();\r
 387                                 File.Create (path + DSC + "file2").Close ();\r
 388                                 Directory.CreateDirectory (path + DSC + "directory1");\r
 389                                 AssertEquals ("test#02", 2, info.GetFiles ().Length);\r
 390                                                         \r
 391                         } finally {\r
 392                                 DeleteDir (path);\r
 393                         }\r
 394                 }\r
 395                 \r
 396                 [Test]\r
 397                 public void GetFiles2()\r
 398                 {\r
 399                 string path = TempFolder + DSC + "DIT.GetFiles2.Test";\r
 400                 DeleteDir (path);\r
 401                         \r
 402                         try {\r
 403                                 DirectoryInfo info = Directory.CreateDirectory (path);\r
 404                                 AssertEquals ("test#01", 0, info.GetFiles ("*").Length);\r
 405                                 File.Create (path + DSC + "file120file").Close ();\r
 406                                 File.Create (path + DSC + "file220file").Close ();\r
 407                                 File.Create (path + DSC + "afile330file").Close ();\r
 408                                 File.Create (path + DSC + "test.abc").Close ();\r
 409                                 File.Create (path + DSC + "test.abcd").Close ();\r
 410                                 File.Create (path + DSC + "test.abcdef").Close ();                              \r
 411                                 Directory.CreateDirectory (path + DSC + "dir");\r
 412                                 \r
 413                                 AssertEquals ("test#02", 6, info.GetFiles ("*").Length);\r
 414                                 AssertEquals ("test#03", 2, info.GetFiles ("file*file").Length);\r
 415                                 AssertEquals ("test#04", 3, info.GetFiles ("*file*").Length);\r
 416                                 AssertEquals ("test#05", 2, info.GetFiles ("file?20file").Length);\r
 417                                 AssertEquals ("test#07", 1, info.GetFiles ("*.abcd").Length);\r
 418                                 AssertEquals ("test#08", 2, info.GetFiles ("*.abcd*").Length);                                                  \r
 419                         } finally {\r
 420                                 DeleteDir (path);\r
 421                         }\r
 422                 }\r
 423                 \r
 424                 [Test]\r
 425                 [ExpectedException (typeof (DirectoryNotFoundException))]\r
 426                 public void GetFilesDirectoryNotFoundException1 ()\r
 427                 {\r
 428                         string path = TempFolder + DSC + "DIT.GetFilesDirectoryNotFoundException1.Test";\r
 429                         DeleteDir (path);\r
 430                         \r
 431                         try {\r
 432                                 DirectoryInfo info = new DirectoryInfo (path);\r
 433                                 info.GetFiles ();\r
 434                                 \r
 435                         } finally {\r
 436                                 DeleteDir (path);\r
 437                         }\r
 438                 }\r
 439 \r
 440                 [Test]\r
 441                 [ExpectedException (typeof (DirectoryNotFoundException))]\r
 442                 public void GetFilesDirectoryNotFoundException2 ()\r
 443                 {\r
 444                         string path = TempFolder + DSC + "DIT.GetFilesDirectoryNotFoundException2.Test";\r
 445                         DeleteDir (path);\r
 446                         \r
 447                         try {\r
 448                                 DirectoryInfo info = new DirectoryInfo (path);\r
 449                                 info.GetFiles ("*");\r
 450                                 \r
 451                         } finally {\r
 452                                 DeleteDir (path);\r
 453                         }\r
 454                 }\r
 455                 \r
 456                 [Test]\r
 457                 [ExpectedException (typeof (ArgumentNullException))]\r
 458                 public void GetFilesArgumentNullException ()\r
 459                 {\r
 460                         string path = TempFolder + DSC + "DIT.GetFilesArgumentNullException.Test";\r
 461                         DeleteDir (path);\r
 462                         \r
 463                         try {\r
 464                                 DirectoryInfo info = new DirectoryInfo (path);\r
 465                                 info.GetFiles (null);                           \r
 466                         } finally {\r
 467                                 DeleteDir (path);\r
 468                         }\r
 469                 }\r
 470                 \r
 471                 [Test]\r
 472                 public void MoveTo ()\r
 473                 {\r
 474                         string path1 = TempFolder + DSC + "DIT.MoveTo.Soucre.Test";\r
 475                         string path2 = TempFolder + DSC + "DIT.MoveTo.Dest.Test";\r
 476                         DeleteDir (path1);\r
 477                         DeleteDir (path2);\r
 478                         \r
 479                         try {\r
 480                                 DirectoryInfo info1 = Directory.CreateDirectory (path1);\r
 481                                 DirectoryInfo info2 = new DirectoryInfo (path2);\r
 482                                 \r
 483                                 AssertEquals ("test#01", true, info1.Exists);\r
 484                                 AssertEquals ("test#02", false, info2.Exists);\r
 485                                                                                                 \r
 486                                 info1.MoveTo (path2);                           \r
 487                                 AssertEquals ("test#03", true, info1.Exists);\r
 488                                 AssertEquals ("test#04", false, info2.Exists);\r
 489                                 \r
 490                                 info1 = new DirectoryInfo (path1);\r
 491                                 info2 = new DirectoryInfo (path2);\r
 492                                 AssertEquals ("test#05", false, info1.Exists);\r
 493                                 AssertEquals ("test#06", true, info2.Exists);\r
 494                                 \r
 495                         } finally {\r
 496                                 DeleteDir (path1);\r
 497                                 DeleteDir (path2);\r
 498                         }\r
 499                 }\r
 500 \r
 501                 [Test]\r
 502                 [ExpectedException (typeof (ArgumentNullException))]\r
 503                 public void MoveToArgumentNullException ()\r
 504                 {\r
 505                         string path = TempFolder + DSC + "DIT.MoveToArgumentNullException.Test";\r
 506                         DeleteDir (path);\r
 507                         \r
 508                         try {\r
 509                                 DirectoryInfo info = Directory.CreateDirectory (path);\r
 510                                 info.MoveTo (null);\r
 511                         } finally {\r
 512                                 DeleteDir (path);\r
 513                         }\r
 514                         \r
 515                 }\r
 516 \r
 517                 [Test]\r
 518                 [ExpectedException (typeof (IOException))]\r
 519                 public void MoveToIOException1 ()\r
 520                 {\r
 521                         string path = TempFolder + DSC + "DIT.MoveToIOException1.Test";\r
 522                         DeleteDir (path);\r
 523                         \r
 524                         try {\r
 525                                 DirectoryInfo info = Directory.CreateDirectory (path);\r
 526                                 info.MoveTo (path);\r
 527                         } finally {\r
 528                                 DeleteDir (path);\r
 529                         }                       \r
 530                 }\r
 531 \r
 532                 [Test]\r
 533                 [ExpectedException (typeof (ArgumentException))]\r
 534                 public void MoveToArgumentException1 ()\r
 535                 {\r
 536                         string path = TempFolder + DSC + "DIT.MoveToArgumentException1.Test";\r
 537                         DeleteDir (path);\r
 538                         \r
 539                         try {\r
 540                                 DirectoryInfo info = Directory.CreateDirectory (path);\r
 541                                 info.MoveTo ("");\r
 542                         } finally {\r
 543                                 DeleteDir (path);\r
 544                         }                       \r
 545                 }\r
 546 \r
 547                 [Test]\r
 548                 [ExpectedException (typeof (ArgumentException))]\r
 549                 public void MoveToArgumentException2 ()\r
 550                 {\r
 551                         string path = TempFolder + DSC + "DIT.MoveToArgumentException2.Test";\r
 552                         DeleteDir (path);\r
 553                         \r
 554                         try {\r
 555                                 DirectoryInfo info = Directory.CreateDirectory (path);\r
 556                                 info.MoveTo ("    ");\r
 557                         } finally {\r
 558                                 DeleteDir (path);\r
 559                         }                       \r
 560                 }\r
 561 \r
 562                 [Test]\r
 563                 [ExpectedException (typeof (ArgumentException))]\r
 564                 public void MoveToArgumentException3 ()\r
 565                 {\r
 566                         string path = TempFolder + DSC + "DIT.MoveToArgumentException3.Test";\r
 567                         DeleteDir (path);\r
 568                         \r
 569                         try {\r
 570                                 DirectoryInfo info = Directory.CreateDirectory (path);\r
 571                                 info.MoveTo (Path.InvalidPathChars [0].ToString ());\r
 572                         } finally {\r
 573                                 DeleteDir (path);\r
 574                         }                       \r
 575                 }\r
 576 \r
 577                 [Test]\r
 578                 [ExpectedException (typeof (IOException))]\r
 579                 public void MoveToIOException2 ()\r
 580                 {\r
 581                         string path = TempFolder + DSC + "DIT.MoveToIOException2.Test";\r
 582                         DeleteDir (path);\r
 583                         \r
 584                         try {\r
 585                                 DirectoryInfo info = new DirectoryInfo (path);\r
 586                                 info.MoveTo (path);\r
 587                         } finally {\r
 588                                 DeleteDir (path);\r
 589                         }                       \r
 590                 }\r
 591 \r
 592                 private void DeleteDir (string path)\r
 593                 {\r
 594                         if (Directory.Exists (path))\r
 595                                 Directory.Delete (path, true);\r
 596                 }\r
 597
 598                 [Test]
 599                 public void DirectoryNameWithSpace ()
 600                 {
 601                         // check for Unix platforms - see FAQ for more details
 602                         // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
 603                         int platform = (int) Environment.OSVersion.Platform;
 604                         if ((platform == 4) || (platform == 128)) {
 605                                 DeleteDir ("this has a space at the end ");
 606                                 string path = Path.Combine (TempFolder, "this has a space at the end ");
 607                                 Directory.CreateDirectory (path);
 608                                 DirectoryInfo i = new DirectoryInfo (path);
 609                                 string dummy = null;
 610                                 foreach (FileInfo f in i.GetFiles ()) // This used to throw
 611                                         dummy = f.Name;
 612                         }
 613                 }\r
 614 \r
 615                         [Test]\r
 616                         public void LastWriteTime ()\r
 617                         {\r
 618                                 DirectoryInfo info = new DirectoryInfo (TempFolder);\r
 619                                 info.LastWriteTime = new DateTime (2003, 6, 4, 6, 4, 0);\r
 620 \r
 621                                 DateTime time = Directory.GetLastWriteTime (TempFolder);\r
 622                                 AssertEquals ("test#01", 2003, time.Year);\r
 623                                 AssertEquals ("test#02", 6, time.Month);\r
 624                                 AssertEquals ("test#03", 4, time.Day);\r
 625                                 AssertEquals ("test#04", 6, time.Hour);\r
 626                                 AssertEquals ("test#05", 4, time.Minute);\r
 627                                 AssertEquals ("test#06", 0, time.Second);\r
 628 \r
 629                                 time = TimeZone.CurrentTimeZone.ToLocalTime (\r
 630                                         Directory.GetLastWriteTimeUtc (TempFolder));\r
 631                                 AssertEquals ("test#07", 2003, time.Year);\r
 632                                 AssertEquals ("test#08", 6, time.Month);\r
 633                                 AssertEquals ("test#09", 4, time.Day);\r
 634                                 AssertEquals ("test#10", 6, time.Hour);\r
 635                                 AssertEquals ("test#11", 4, time.Minute);\r
 636                                 AssertEquals ("test#12", 0, time.Second);\r
 637                         }\r
 638 \r
 639                         [Test]\r
 640                         public void LastWriteTimeUtc ()\r
 641                         {\r
 642                                 DirectoryInfo info = new DirectoryInfo (TempFolder);\r
 643                                 info.LastWriteTimeUtc = new DateTime (2003, 6, 4, 6, 4, 0);\r
 644 \r
 645                                 DateTime time = TimeZone.CurrentTimeZone.ToUniversalTime (\r
 646                                         Directory.GetLastWriteTime (TempFolder));\r
 647                                 AssertEquals ("test#1", 2003, time.Year);\r
 648                                 AssertEquals ("test#2", 6, time.Month);\r
 649                                 AssertEquals ("test#3", 4, time.Day);\r
 650                                 AssertEquals ("test#4", 6, time.Hour);\r
 651                                 AssertEquals ("test#5", 4, time.Minute);\r
 652                                 AssertEquals ("test#6", 0, time.Second);\r
 653 \r
 654                                 time = Directory.GetLastWriteTimeUtc (TempFolder);\r
 655                                 AssertEquals ("test#7", 2003, time.Year);\r
 656                                 AssertEquals ("test#8", 6, time.Month);\r
 657                                 AssertEquals ("test#9", 4, time.Day);\r
 658                                 AssertEquals ("test#10", 6, time.Hour);\r
 659                                 AssertEquals ("test#11", 4, time.Minute);\r
 660                                 AssertEquals ("test#12", 0, time.Second);\r
 661                         }\r
 662 \r
 663                         [Test]\r
 664                         public void LastAccessTime ()\r
 665                         {\r
 666                                 DirectoryInfo info = new DirectoryInfo (TempFolder);\r
 667                                 info.LastAccessTime = DateTime.Now;\r
 668                         }\r
 669 \r
 670                         [Test]\r
 671                         public void LastAccessTimeUtc ()\r
 672                         {\r
 673                                 DirectoryInfo info = new DirectoryInfo (TempFolder);\r
 674                                 info.LastAccessTimeUtc = DateTime.Now;\r
 675                         }\r
 676 \r
 677                         [Test]\r
 678                         public void CreationTime ()\r
 679                         {\r
 680                                 DirectoryInfo info = new DirectoryInfo (TempFolder);\r
 681                                 info.CreationTime = DateTime.Now;\r
 682                         }\r
 683 \r
 684                         [Test]\r
 685                         public void CreationTimeUtc ()\r
 686                         {\r
 687                                 DirectoryInfo info = new DirectoryInfo (TempFolder);\r
 688                                 info.CreationTimeUtc = DateTime.Now;\r
 689                         }
 690         }\r
 691 }\r