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

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