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

   1 // DirectoryInfoTest.cs - NUnit Test Cases for System.IO.DirectoryInfo class
   2 //
   3 // Authors
   4 //      Ville Palo (vi64pa@koti.soon.fi)
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) 2003 Ville Palo
   8 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   9 //
  10
  11 using System;
  12 using System.Collections;
  13 using System.Collections.Generic;
  14 using System.IO;
  15 using System.Runtime.Serialization;
  16 using System.Runtime.Serialization.Formatters.Binary;
  17
  18 using NUnit.Framework;
  19
  20 namespace MonoTests.System.IO
  21 {
  22         [TestFixture]
  23         public class DirectoryInfoTest
  24         {
  25                 string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
  26
  27                 static readonly char DSC = Path.DirectorySeparatorChar;
  28                 string current;
  29
  30                 [SetUp]
  31                 protected void SetUp ()
  32                 {
  33                         current = Directory.GetCurrentDirectory ();
  34                         if (Directory.Exists (TempFolder))
  35                                 Directory.Delete (TempFolder, true);
  36                         Directory.CreateDirectory (TempFolder);
  37                 }
  38
  39                 [TearDown]
  40                 protected void TearDown ()
  41                 {
  42                         if (Directory.Exists (TempFolder))
  43                                 Directory.Delete (TempFolder, true);
  44                         Directory.SetCurrentDirectory (current);
  45                 }
  46
  47                 [Test] // ctor (String)
  48                 public void Constructor1 ()
  49                 {
  50                         string path = TempFolder + DSC + "DIT.Ctr.Test";
  51                         DeleteDir (path);
  52
  53                         DirectoryInfo info = new DirectoryInfo (path);
  54                         Assert.AreEqual ("DIT.Ctr.Test", info.Name, "#1");
  55                         Assert.IsFalse (info.Exists, "#2");
  56                         Assert.AreEqual (".Test", info.Extension, "#3");
  57                         Assert.AreEqual ("DIT.Ctr.Test", info.Name, "#4");
  58                 }
  59
  60                 [Test] // ctor (String)
  61                 public void Constructor1_Path_Null ()
  62                 {
  63                         try {
  64                                 new DirectoryInfo (null);
  65                                 Assert.Fail ("#1");
  66                         } catch (ArgumentNullException ex) {
  67                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
  68                                 Assert.IsNull (ex.InnerException, "#3");
  69                                 Assert.IsNotNull (ex.Message, "#4");
  70                                 Assert.AreEqual ("path", ex.ParamName, "#5");
  71                         }
  72                 }
  73
  74                 [Test] // ctor (String)
  75                 public void Constructor1_Path_Empty ()
  76                 {
  77                         try {
  78                                 new DirectoryInfo (string.Empty);
  79                                 Assert.Fail ("#1");
  80                         } catch (ArgumentException ex) {
  81                                 // Empty file name is not legal
  82                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
  83                                 Assert.IsNull (ex.InnerException, "#3");
  84                                 Assert.IsNotNull (ex.Message, "#4");
  85                                 Assert.IsNull (ex.ParamName, "#5");
  86                         }
  87                 }
  88
  89                 [Test] // ctor (String)
  90                 public void Constructor1_Path_Whitespace ()
  91                 {
  92                         try {
  93                                 new DirectoryInfo ("   ");
  94                                 Assert.Fail ("#1");
  95                         } catch (ArgumentException ex) {
  96                                 // The path is not of a legal form
  97                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
  98                                 Assert.IsNull (ex.InnerException, "#3");
  99                                 Assert.IsNotNull (ex.Message, "#4");
 100                                 Assert.IsNull (ex.ParamName, "#5");
 101                         }
 102                 }
 103
 104                 [Test] // ctor (String)
 105                 public void Constructor1_Path_InvalidPathChars ()
 106                 {
 107                         string path = string.Empty;
 108                         foreach (char c in Path.InvalidPathChars)
 109                                 path += c;
 110                         try {
 111                                 new DirectoryInfo (path);
 112                                 Assert.Fail ("#1");
 113                         } catch (ArgumentException ex) {
 114                                 // The path contains illegal characters
 115                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 116                                 Assert.IsNull (ex.InnerException, "#3");
 117                                 Assert.IsNotNull (ex.Message, "#4");
 118                                 Assert.IsNull (ex.ParamName, "#5");
 119                         }
 120                 }
 121
 122                 [Test]
 123                 public void Exists ()
 124                 {
 125                         string path = TempFolder + DSC + "DIT.Exists.Test";
 126                         DeleteDir (path);
 127
 128                         try {
 129                                 DirectoryInfo info = new DirectoryInfo (path);
 130                                 Assert.IsFalse (info.Exists, "#1");
 131
 132                                 Directory.CreateDirectory (path);
 133                                 Assert.IsFalse (info.Exists, "#2");
 134                                 info = new DirectoryInfo (path);
 135                                 Assert.IsTrue (info.Exists, "#3");
 136                         } finally {
 137                                 DeleteDir (path);
 138                         }
 139                 }
 140
 141                 [Test]
 142                 [Category ("MobileNotWorking")]
 143                 public void Name ()
 144                 {
 145                         string path = TempFolder + DSC + "DIT.Name.Test";
 146                         DeleteDir (path);
 147
 148                         try {
 149                                 DirectoryInfo info = new DirectoryInfo (path);
 150                                 Assert.AreEqual ("DIT.Name.Test", info.Name, "#1");
 151
 152                                 info = Directory.CreateDirectory (path);
 153                                 Assert.AreEqual ("DIT.Name.Test", info.Name, "#2");
 154
 155                                 info = Directory.CreateDirectory ("whatever");
 156                                 Assert.AreEqual ("whatever", info.Name, "#3");
 157
 158                                 if (RunningOnUnix) {
 159                                         info = new DirectoryInfo ("/");
 160                                         Assert.AreEqual ("/", info.Name, "#4");
 161
 162                                         info = new DirectoryInfo ("test/");
 163                                         Assert.AreEqual ("test", info.Name, "#5");
 164
 165                                         info = new DirectoryInfo ("/test");
 166                                         Assert.AreEqual ("test", info.Name, "#4");
 167
 168                                         info = new DirectoryInfo ("/test/");
 169                                         Assert.AreEqual ("test", info.Name, "#4");
 170                                 } else {
 171                                         Directory.SetCurrentDirectory (@"C:\");
 172
 173                                         info = new DirectoryInfo (@"c:");
 174                                         Assert.AreEqual (@"C:\", info.Name, "#4");
 175
 176                                         info = new DirectoryInfo (@"c:\");
 177                                         Assert.AreEqual (@"c:\", info.Name, "#5");
 178
 179                                         info = new DirectoryInfo (@"c:\test");
 180                                         Assert.AreEqual ("test", info.Name, "#6");
 181
 182                                         info = new DirectoryInfo (@"c:\test\");
 183                                         Assert.AreEqual ("test", info.Name, "#7");
 184                                 }
 185                         } finally {
 186                                 DeleteDir (path);
 187                         }
 188                 }
 189
 190                 [Test]
 191                 public void Parent ()
 192                 {
 193                         string path = TempFolder + DSC + "DIT.Parent.Test";
 194                         DeleteDir (path);
 195
 196                         try {
 197                                 DirectoryInfo info = new DirectoryInfo (path);
 198                                 Assert.AreEqual ("MonoTests.System.IO.Tests", info.Parent.Name, "#1");
 199
 200                                 info = Directory.CreateDirectory (path);
 201                                 Assert.AreEqual ("MonoTests.System.IO.Tests", info.Parent.Name, "#2");
 202
 203                                 info = new DirectoryInfo ("test");
 204                                 Assert.AreEqual (Directory.GetCurrentDirectory (), info.Parent.FullName, "#3");
 205
 206                                 if (RunningOnUnix) {
 207                                         info = new DirectoryInfo ("/");
 208                                         Assert.IsNull (info.Parent, "#4");
 209
 210                                         info = new DirectoryInfo ("test/");
 211                                         Assert.IsNotNull (info.Parent, "#5a");
 212                                         Assert.AreEqual (Directory.GetCurrentDirectory (), info.Parent.FullName, "#5b");
 213
 214                                         info = new DirectoryInfo ("/test");
 215                                         Assert.IsNotNull (info.Parent, "#6a");
 216                                         Assert.AreEqual ("/", info.Parent.FullName, "#6b");
 217
 218                                         info = new DirectoryInfo ("/test/");
 219                                         Assert.IsNotNull (info.Parent, "#7a");
 220                                         Assert.AreEqual ("/", info.Parent.FullName, "#7b");
 221                                 } else {
 222                                         Directory.SetCurrentDirectory (@"C:\");
 223
 224                                         info = new DirectoryInfo (@"c:");
 225                                         Assert.IsNull (info.Parent, "#4");
 226
 227                                         info = new DirectoryInfo (@"c:\");
 228                                         Assert.IsNull (info.Parent, "#5");
 229
 230                                         info = new DirectoryInfo (@"c:\test");
 231                                         Assert.IsNotNull (info.Parent, "#6a");
 232                                         Assert.AreEqual (@"c:\", info.Parent.FullName, "#6b");
 233
 234                                         info = new DirectoryInfo (@"c:\test\");
 235                                         Assert.IsNotNull (info.Parent, "#7a");
 236                                         Assert.AreEqual (@"c:\", info.Parent.FullName, "#7b");
 237                                 }
 238                         } finally {
 239                                 DeleteDir (path);
 240                         }
 241                 }
 242
 243                 [Test]
 244                 public void Create ()
 245                 {
 246                         string path = TempFolder + DSC + "DIT.Create.Test";
 247                         DeleteDir (path);
 248
 249                         try {
 250                                 DirectoryInfo info = new DirectoryInfo (path);
 251                                 Assert.IsFalse (info.Exists, "#1");
 252                                 info.Create ();
 253                                 Assert.IsFalse (info.Exists, "#2");
 254                                 info = new DirectoryInfo (path);
 255                                 Assert.IsTrue (info.Exists, "#3");
 256                         } finally {
 257                                 DeleteDir (path);
 258                         }
 259                 }
 260
 261                 [Test]
 262                 public void CreateSubdirectory ()
 263                 {
 264                         string sub_path = Path.Combine ("test01", "test02");
 265                         try {
 266                                 DirectoryInfo info = new DirectoryInfo (TempFolder);
 267                                 DirectoryInfo sub = info.CreateSubdirectory (sub_path);
 268                                 Assert.IsNotNull (sub, "#1");
 269                                 Assert.AreEqual (Path.Combine (TempFolder, sub_path), sub.FullName, "#2");
 270                                 Assert.IsTrue (Directory.Exists (sub.FullName), "#3");
 271                         } finally {
 272                                 DeleteDir (Path.Combine (TempFolder, sub_path));
 273                         }
 274                 }
 275
 276                 [Test]
 277                 public void CreateSubdirectory_Path_Null ()
 278                 {
 279                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 280                         try {
 281                                 info.CreateSubdirectory (null);
 282                                 Assert.Fail ("#1");
 283                         } catch (ArgumentNullException ex) {
 284                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 285                                 Assert.IsNull (ex.InnerException, "#3");
 286                                 Assert.IsNotNull (ex.Message, "#4");
 287                                 Assert.AreEqual ("path", ex.ParamName, "#5");
 288                         }
 289                 }
 290
 291                 [Test]
 292                 public void CreateSubdirectory_Path_Empty ()
 293                 {
 294                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 295                         try {
 296                                 info.CreateSubdirectory (string.Empty);
 297                                 Assert.Fail ("#1");
 298                         } catch (ArgumentException ex) {
 299                                 // Empty file name is not legal
 300                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 301                                 Assert.IsNull (ex.InnerException, "#3");
 302                                 Assert.IsNotNull (ex.Message, "#4");
 303                         }
 304                 }
 305
 306                 [Test] // Delete ()
 307                 public void Delete1 ()
 308                 {
 309                         string path = TempFolder + DSC + "DIT.Delete1.Test";
 310                         DeleteDir (path);
 311
 312                         try {
 313                                 Directory.CreateDirectory (path);
 314                                 DirectoryInfo info = new DirectoryInfo (path);
 315                                 Assert.IsTrue (info.Exists, "#1");
 316
 317                                 info.Delete ();
 318                                 Assert.IsTrue (info.Exists, "#2");
 319
 320                                 info = new DirectoryInfo (path);
 321                                 Assert.IsFalse (info.Exists, "#3");
 322                         } finally {
 323                                 DeleteDir (path);
 324                         }
 325                 }
 326
 327                 [Test] // Delete ()
 328                 public void Delete1_DirectoryNotEmpty ()
 329                 {
 330                         string path = TempFolder + DSC + "DIT.DeleteIOException1.Test";
 331                         DeleteDir (path);
 332
 333                         try {
 334                                 Directory.CreateDirectory (path);
 335                                 File.Create (path + DSC + "test").Close ();
 336                                 DirectoryInfo info = new DirectoryInfo (path);
 337                                 try {
 338                                         info.Delete ();
 339                                         Assert.Fail ("#1");
 340                                 } catch (IOException ex) {
 341                                         // The directory is not empty
 342                                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
 343                                         Assert.IsNull (ex.InnerException, "#3");
 344                                         Assert.IsNotNull (ex.Message, "#4");
 345                                 }
 346                         } finally {
 347                                 DeleteDir (path);
 348                         }
 349                 }
 350
 351                 [Test] // Delete (Boolean)
 352                 public void Delete2 ()
 353                 {
 354                         string path = TempFolder + DSC + "DIT.Delete2.Test";
 355                         DeleteDir (path);
 356
 357                         try {
 358                                 Directory.CreateDirectory (path);
 359                                 File.Create (path + DSC + "test").Close ();
 360                                 DirectoryInfo info = new DirectoryInfo (path);
 361                                 Assert.IsTrue (info.Exists, "#1");
 362
 363                                 info.Delete (true);
 364                                 Assert.IsTrue (info.Exists, "#2");
 365
 366                                 info = new DirectoryInfo (path);
 367                                 Assert.IsFalse (info.Exists, "#3");
 368                         } finally {
 369                                 DeleteDir (path);
 370                         }
 371                 }
 372
 373                 [Test] // Delete (Boolean)
 374                 public void Delete2_DirectoryNotEmpty ()
 375                 {
 376                         string path = TempFolder + DSC + "DIT.DeleteIOException2.Test";
 377                         DeleteDir (path);
 378
 379                         try {
 380                                 Directory.CreateDirectory (path);
 381                                 File.Create (path + DSC + "test").Close ();
 382                                 DirectoryInfo info = new DirectoryInfo (path);
 383                                 try {
 384                                         info.Delete (false);
 385                                         Assert.Fail ("#1");
 386                                 } catch (IOException ex) {
 387                                         // The directory is not empty
 388                                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
 389                                         Assert.IsNull (ex.InnerException, "#3");
 390                                         Assert.IsNotNull (ex.Message, "#4");
 391                                 }
 392                         } finally {
 393                                 DeleteDir (path);
 394                         }
 395                 }
 396
 397                 [Test] // bug #75443
 398                 public void FullName ()
 399                 {
 400                         DirectoryInfo di = new DirectoryInfo ("something");
 401                         Assert.IsFalse (di.Exists, "#A1");
 402                         Assert.AreEqual (Path.Combine (Directory.GetCurrentDirectory (), "something"), di.FullName, "#A2");
 403
 404                         di = new DirectoryInfo ("something" + Path.DirectorySeparatorChar);
 405                         Assert.IsFalse (di.Exists, "#B1");
 406                         Assert.AreEqual (Path.DirectorySeparatorChar, di.FullName [di.FullName.Length - 1], "#B2");
 407
 408                         di = new DirectoryInfo ("something" + Path.AltDirectorySeparatorChar);
 409                         Assert.IsFalse (di.Exists, "#C1");
 410                         Assert.AreEqual (Path.DirectorySeparatorChar, di.FullName [di.FullName.Length - 1], "#C2");
 411
 412                         if (RunningOnUnix) {
 413                                 di = new DirectoryInfo ("/");
 414                                 Assert.AreEqual ("/", di.FullName, "#D1");
 415
 416                                 di = new DirectoryInfo ("test/");
 417                                 Assert.AreEqual (Path.Combine (Directory.GetCurrentDirectory (), "test/"), di.FullName, "#D2");
 418
 419                                 di = new DirectoryInfo ("/test");
 420                                 Assert.AreEqual ("/test", di.FullName, "#D3");
 421
 422                                 di = new DirectoryInfo ("/test/");
 423                                 Assert.AreEqual ("/test/", di.FullName, "#D4");
 424                         } else {
 425                                 Directory.SetCurrentDirectory (@"C:\");
 426
 427                                 di = new DirectoryInfo (@"c:");
 428                                 Assert.AreEqual (@"C:\", di.FullName, "#D1");
 429
 430                                 di = new DirectoryInfo (@"c:\");
 431                                 Assert.AreEqual (@"c:\", di.FullName, "#D2");
 432
 433                                 di = new DirectoryInfo (@"c:\test");
 434                                 Assert.AreEqual (@"c:\test", di.FullName, "#D3");
 435
 436                                 di = new DirectoryInfo (@"c:\test\");
 437                                 Assert.AreEqual (@"c:\test\", di.FullName, "#D4");
 438                         }
 439                 }
 440
 441                 [Test]
 442                 public void FullName_RootDirectory ()
 443                 {
 444                         DirectoryInfo di = new DirectoryInfo (String.Empty + Path.DirectorySeparatorChar);
 445                         if (RunningOnUnix) {
 446                                 // can't be sure of the root drive under windows
 447                                 Assert.AreEqual ("/", di.FullName, "#1");
 448                         }
 449                         Assert.IsNull (di.Parent, "#2");
 450
 451                         di = new DirectoryInfo (String.Empty + Path.AltDirectorySeparatorChar);
 452                         if (RunningOnUnix) {
 453                                 // can't be sure of the root drive under windows
 454                                 Assert.AreEqual ("/", di.FullName, "#3");
 455                         }
 456                         Assert.IsNull (di.Parent, "#4");
 457                 }
 458
 459                 [Test] // GetDirectories ()
 460                 public void GetDirectories1 ()
 461                 {
 462                         string path = TempFolder + DSC + "DIT.GetDirectories1.Test";
 463
 464                         try {
 465                                 DirectoryInfo info = Directory.CreateDirectory (path);
 466                                 Assert.AreEqual (0, info.GetDirectories ().Length, "#1");
 467
 468                                 Directory.CreateDirectory (path + DSC + "1");
 469                                 Directory.CreateDirectory (path + DSC + "2");
 470                                 File.Create (path + DSC + "filetest").Close ();
 471                                 Assert.AreEqual (2, info.GetDirectories ().Length, "#2");
 472
 473                                 Directory.Delete (path + DSC + 2);
 474                                 Assert.AreEqual (1, info.GetDirectories ().Length, "#3");
 475                         } finally {
 476                                 DeleteDir (path);
 477                         }
 478                 }
 479
 480                 [Test] // GetDirectories ()
 481                 public void GetDirectories1_DirectoryDoesNotExist ()
 482                 {
 483                         string path = TempFolder + DSC + "DIT.GetDirectoriesDirectoryNotFoundException1.Test";
 484                         DeleteDir (path);
 485
 486                         try {
 487                                 DirectoryInfo info = new DirectoryInfo (path);
 488                                 info.GetDirectories ();
 489                                 Assert.Fail ("#1");
 490                         } catch (DirectoryNotFoundException ex) {
 491                                 // Could not find a part of '...'
 492                                 Assert.AreEqual (typeof (DirectoryNotFoundException), ex.GetType (), "#2");
 493                                 Assert.IsNull (ex.InnerException, "#3");
 494                                 Assert.IsNotNull (ex.Message, "#4");
 495                                 Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#5");
 496                         } finally {
 497                                 DeleteDir (path);
 498                         }
 499                 }
 500
 501                 [Test] // GetDirectories (String)
 502                 public void GetDirectories2 ()
 503                 {
 504                         string path = TempFolder + DSC + "DIT.GetDirectories2.Test";
 505
 506                         try {
 507                                 DirectoryInfo info = Directory.CreateDirectory (path);
 508                                 Assert.AreEqual (0, info.GetDirectories ("*").Length, "#1");
 509
 510                                 Directory.CreateDirectory (path + DSC + "test120");
 511                                 Directory.CreateDirectory (path + DSC + "test210");
 512                                 Directory.CreateDirectory (path + DSC + "atest330");
 513                                 Directory.CreateDirectory (path + DSC + "test220");
 514                                 Directory.CreateDirectory (path + DSC + "rest");
 515                                 Directory.CreateDirectory (path + DSC + "rest" + DSC + "subdir");
 516                                 File.Create (path + DSC + "filetest").Close ();
 517
 518                                 Assert.AreEqual (5, info.GetDirectories ("*").Length, "#2");
 519                                 Assert.AreEqual (3, info.GetDirectories ("test*").Length, "#3");
 520                                 Assert.AreEqual (2, info.GetDirectories ("test?20").Length, "#4");
 521                                 Assert.AreEqual (0, info.GetDirectories ("test?").Length, "#5");
 522                                 Assert.AreEqual (0, info.GetDirectories ("test[12]*").Length, "#6");
 523                                 Assert.AreEqual (2, info.GetDirectories ("test2*0").Length, "#7");
 524                                 Assert.AreEqual (4, info.GetDirectories ("*test*").Length, "#8");
 525                                 Assert.AreEqual (6, info.GetDirectories ("*", SearchOption.AllDirectories).Length, "#9");
 526                         } finally {
 527                                 DeleteDir (path);
 528                         }
 529                 }
 530
 531                 [Test] // GetDirectories (String)
 532                 public void GetDirectories2_DirectoryDoesNotExist ()
 533                 {
 534                         string path = TempFolder + DSC + "DIT.GetDirectoriesDirectoryNotFoundException2.Test";
 535                         DeleteDir (path);
 536
 537                         try {
 538                                 DirectoryInfo info = new DirectoryInfo (path);
 539                                 info.GetDirectories ("*");
 540                                 Assert.Fail ("#1");
 541                         } catch (DirectoryNotFoundException ex) {
 542                                 // Could not find a part of '...'
 543                                 Assert.AreEqual (typeof (DirectoryNotFoundException), ex.GetType (), "#2");
 544                                 Assert.IsNull (ex.InnerException, "#3");
 545                                 Assert.IsNotNull (ex.Message, "#4");
 546                                 Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#5");
 547                         } finally {
 548                                 DeleteDir (path);
 549                         }
 550                 }
 551
 552                 [Test] // GetDirectories (String)
 553                 public void GetDirectories2_SearchPattern_Null ()
 554                 {
 555                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 556                         try {
 557                                 info.GetDirectories (null);
 558                                 Assert.Fail ("#1");
 559                         } catch (ArgumentNullException ex) {
 560                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 561                                 Assert.IsNull (ex.InnerException, "#3");
 562                                 Assert.IsNotNull (ex.Message, "#4");
 563                                 Assert.AreEqual ("searchPattern", ex.ParamName, "#5");
 564                         }
 565                 }
 566
 567                 [Test] //GetDirectories (String, SearchOptions)
 568                 public void GetDirectiories_SearchOptionAllDirectories ()
 569                 {
 570                         string directoryToBeLookedFor = "lookforme";
 571                         DirectoryInfo baseDir = Directory.CreateDirectory(Path.Combine(TempFolder, "GetDirectiories_SearchOptionAllDirectories"));
 572                         DirectoryInfo subdir = baseDir.CreateSubdirectory("subdir");
 573                         DirectoryInfo subsubdir = subdir.CreateSubdirectory(directoryToBeLookedFor);
 574                         DirectoryInfo[] directoriesFound = baseDir.GetDirectories(directoryToBeLookedFor, SearchOption.AllDirectories);
 575                         Assert.AreEqual(1, directoriesFound.Length, "There should be exactly one directory with the specified name.");
 576                         Assert.AreEqual(directoryToBeLookedFor, directoriesFound[0].Name, "The name of the directory found should match the expected one.");
 577                 }
 578
 579                 [Test] // GetDirectories (String, SearchOption)
 580                 public void GetDirectories3_SearchPattern_Null ()
 581                 {
 582                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 583                         try {
 584                                 info.GetDirectories (null, SearchOption.AllDirectories);
 585                                 Assert.Fail ("#1");
 586                         } catch (ArgumentNullException ex) {
 587                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 588                                 Assert.IsNull (ex.InnerException, "#3");
 589                                 Assert.IsNotNull (ex.Message, "#4");
 590                                 Assert.AreEqual ("searchPattern", ex.ParamName, "#5");
 591                         }
 592                 }
 593
 594                 [Test] // GetFiles ()
 595                 public void GetFiles1 ()
 596                 {
 597                         string path = TempFolder + DSC + "DIT.GetFiles1.Test";
 598                         DeleteDir (path);
 599
 600                         try {
 601                                 DirectoryInfo info = Directory.CreateDirectory (path);
 602                                 Assert.AreEqual (0, info.GetFiles ().Length, "#1");
 603                                 File.Create (path + DSC + "file1").Close ();
 604                                 File.Create (path + DSC + "file2").Close ();
 605                                 Directory.CreateDirectory (path + DSC + "directory1");
 606                                 Assert.AreEqual (2, info.GetFiles ().Length, "#2");
 607                         } finally {
 608                                 DeleteDir (path);
 609                         }
 610                 }
 611
 612                 [Test] // GetFiles ()
 613                 public void GetFiles1_DirectoryDoesNotExist ()
 614                 {
 615                         string path = TempFolder + DSC + "DIT.GetFilesDirectoryNotFoundException1.Test";
 616                         DeleteDir (path);
 617
 618                         try {
 619                                 DirectoryInfo info = new DirectoryInfo (path);
 620                                 info.GetFiles ();
 621                                 Assert.Fail ("#1");
 622                         } catch (DirectoryNotFoundException ex) {
 623                                 // Could not find a part of '...'
 624                                 Assert.AreEqual (typeof (DirectoryNotFoundException), ex.GetType (), "#2");
 625                                 Assert.IsNull (ex.InnerException, "#3");
 626                                 Assert.IsNotNull (ex.Message, "#4");
 627                                 Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#5");
 628                         } finally {
 629                                 DeleteDir (path);
 630                         }
 631                 }
 632
 633                 [Test] // GetFiles (String)
 634                 public void GetFiles2 ()
 635                 {
 636                         string path = TempFolder + DSC + "DIT.GetFiles2.Test";
 637                         DeleteDir (path);
 638
 639                         try {
 640                                 DirectoryInfo info = Directory.CreateDirectory (path);
 641                                 Assert.AreEqual (0, info.GetFiles ("*").Length, "#1");
 642                                 File.Create (path + DSC + "file120file").Close ();
 643                                 File.Create (path + DSC + "file220file").Close ();
 644                                 File.Create (path + DSC + "afile330file").Close ();
 645                                 File.Create (path + DSC + "test.abc").Close ();
 646                                 File.Create (path + DSC + "test.abcd").Close ();
 647                                 File.Create (path + DSC + "test.abcdef").Close ();
 648                                 Directory.CreateDirectory (path + DSC + "dir");
 649
 650                                 Assert.AreEqual (6, info.GetFiles ("*").Length, "#2");
 651                                 Assert.AreEqual (2, info.GetFiles ("file*file").Length, "#3");
 652                                 Assert.AreEqual (3, info.GetFiles ("*file*").Length, "#4");
 653                                 Assert.AreEqual (2, info.GetFiles ("file?20file").Length, "#5");
 654                                 Assert.AreEqual (1, info.GetFiles ("*.abcd").Length, "#6");
 655                                 Assert.AreEqual (2, info.GetFiles ("*.abcd*").Length, "#7");
 656                         } finally {
 657                                 DeleteDir (path);
 658                         }
 659                 }
 660
 661                 [Test] // GetFiles (String)
 662                 public void GetFiles2_DirectoryDoesNotExist ()
 663                 {
 664                         string path = TempFolder + DSC + "DIT.GetFilesDirectoryNotFoundException2.Test";
 665                         DeleteDir (path);
 666
 667                         try {
 668                                 DirectoryInfo info = new DirectoryInfo (path);
 669                                 info.GetFiles ("*");
 670                                 Assert.Fail ("#1");
 671                         } catch (DirectoryNotFoundException ex) {
 672                                 // Could not find a part of '...'
 673                                 Assert.AreEqual (typeof (DirectoryNotFoundException), ex.GetType (), "#2");
 674                                 Assert.IsNull (ex.InnerException, "#3");
 675                                 Assert.IsNotNull (ex.Message, "#4");
 676                                 Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#5");
 677                         } finally {
 678                                 DeleteDir (path);
 679                         }
 680                 }
 681
 682                 [Test] // GetFiles (String)
 683                 public void GetFiles2_SearchPattern_Null ()
 684                 {
 685                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 686                         try {
 687                                 info.GetFiles (null);
 688                                 Assert.Fail ("#1");
 689                         } catch (ArgumentNullException ex) {
 690                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 691                                 Assert.IsNull (ex.InnerException, "#3");
 692                                 Assert.IsNotNull (ex.Message, "#4");
 693                                 Assert.AreEqual ("searchPattern", ex.ParamName, "#5");
 694                         }
 695                 }
 696
 697                 [Test] // GetFiles (String, SearchOption)
 698                 public void GetFiles3_SearchPattern_Null ()
 699                 {
 700                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 701                         try {
 702                                 info.GetFiles (null, SearchOption.TopDirectoryOnly);
 703                                 Assert.Fail ("#1");
 704                         } catch (ArgumentNullException ex) {
 705                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 706                                 Assert.IsNull (ex.InnerException, "#3");
 707                                 Assert.IsNotNull (ex.Message, "#4");
 708                                 Assert.AreEqual ("searchPattern", ex.ParamName, "#5");
 709                         }
 710                 }
 711
 712                 [Test]
 713                 public void GetFileSystemInfos2_SearchPattern_Null ()
 714                 {
 715                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 716                         try {
 717                                 info.GetFileSystemInfos (null);
 718                                 Assert.Fail ("#1");
 719                         } catch (ArgumentNullException ex) {
 720                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 721                                 Assert.IsNull (ex.InnerException, "#3");
 722                                 Assert.IsNotNull (ex.Message, "#4");
 723                                 Assert.AreEqual ("searchPattern", ex.ParamName, "#5");
 724                         }
 725                 }
 726
 727                 [Test]
 728                 public void MoveTo ()
 729                 {
 730                         string path1 = TempFolder + DSC + "DIT.MoveTo.Soucre.Test";
 731                         string path2 = TempFolder + DSC + "DIT.MoveTo.Dest.Test";
 732                         DeleteDir (path1);
 733                         DeleteDir (path2);
 734
 735                         try {
 736                                 DirectoryInfo info1 = Directory.CreateDirectory (path1);
 737                                 DirectoryInfo info2 = new DirectoryInfo (path2);
 738
 739                                 Assert.IsTrue (info1.Exists, "#A1");
 740                                 Assert.IsFalse (info2.Exists, "#A2");
 741
 742                                 info1.MoveTo (path2);
 743                                 Assert.IsTrue (info1.Exists, "#B1");
 744                                 Assert.IsFalse (info2.Exists, "#B2");
 745
 746                                 info1 = new DirectoryInfo (path1);
 747                                 info2 = new DirectoryInfo (path2);
 748                                 Assert.IsFalse (info1.Exists, "#C1");
 749                                 Assert.IsTrue (info2.Exists, "#C2");
 750                         } finally {
 751                                 DeleteDir (path1);
 752                                 DeleteDir (path2);
 753                         }
 754                 }
 755
 756                 [Test]
 757                 public void MoveTo_DestDirName_Empty ()
 758                 {
 759                         string path = TempFolder + DSC + "DIT.MoveToArgumentException1.Test";
 760                         DeleteDir (path);
 761
 762                         try {
 763                                 DirectoryInfo info = Directory.CreateDirectory (path);
 764                                 try {
 765                                         info.MoveTo (string.Empty);
 766                                         Assert.Fail ("#1");
 767                                 } catch (ArgumentException ex) {
 768                                         // Empty file name is not legal
 769                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 770                                         Assert.IsNull (ex.InnerException, "#3");
 771                                         Assert.IsNotNull (ex.Message, "#4");
 772                                         Assert.AreEqual ("destDirName", ex.ParamName, "#5");
 773                                 }
 774                         } finally {
 775                                 DeleteDir (path);
 776                         }
 777                 }
 778
 779                 [Test]
 780                 public void MoveTo_DestDirName_Null ()
 781                 {
 782                         string path = TempFolder + DSC + "DIT.MoveToArgumentNullException.Test";
 783                         DeleteDir (path);
 784
 785                         try {
 786                                 DirectoryInfo info = Directory.CreateDirectory (path);
 787                                 try {
 788                                         info.MoveTo (null);
 789                                         Assert.Fail ("#1");
 790                                 } catch (ArgumentNullException ex) {
 791                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 792                                         Assert.IsNull (ex.InnerException, "#3");
 793                                         Assert.IsNotNull (ex.Message, "#4");
 794                                         Assert.AreEqual ("destDirName", ex.ParamName, "#5");
 795                                 }
 796                         } finally {
 797                                 DeleteDir (path);
 798                         }
 799                 }
 800
 801                 [Test]
 802                 public void MoveTo_DestDirName_InvalidPathChars ()
 803                 {
 804                         string path = TempFolder + DSC + "DIT.MoveToArgumentException3.Test";
 805                         DeleteDir (path);
 806
 807                         try {
 808                                 DirectoryInfo info = Directory.CreateDirectory (path);
 809                                 try {
 810                                         info.MoveTo (Path.InvalidPathChars [0].ToString ());
 811                                         Assert.Fail ("#1");
 812                                 } catch (ArgumentException ex) {
 813                                         // The path contains illegal characters
 814                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 815                                         Assert.IsNull (ex.InnerException, "#3");
 816                                         Assert.IsNotNull (ex.Message, "#4");
 817                                         Assert.IsNull (ex.ParamName, "#5");
 818                                 }
 819                         } finally {
 820                                 DeleteDir (path);
 821                         }
 822                 }
 823
 824                 [Test]
 825                 public void MoveTo_DestDirName_Whitespace ()
 826                 {
 827                         string path = TempFolder + DSC + "DIT.MoveToArgumentException2.Test";
 828                         DeleteDir (path);
 829
 830                         try {
 831                                 DirectoryInfo info = Directory.CreateDirectory (path);
 832                                 try {
 833                                         info.MoveTo ("    ");
 834                                         Assert.Fail ("#1");
 835                                 } catch (ArgumentException ex) {
 836                                         // The path is not of a legal form
 837                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 838                                         Assert.IsNull (ex.InnerException, "#3");
 839                                         Assert.IsNotNull (ex.Message, "#4");
 840                                         Assert.IsNull (ex.ParamName, "#5");
 841                                 }
 842                         } finally {
 843                                 DeleteDir (path);
 844                         }
 845                 }
 846
 847                 [Test]
 848                 public void MoveTo_SourceDest_NotDifferent ()
 849                 {
 850                         string path = TempFolder + DSC + "DIT.MoveToIOException1.Test";
 851                         DeleteDir (path);
 852
 853                         try {
 854                                 DirectoryInfo info = Directory.CreateDirectory (path);
 855                                 try {
 856                                         info.MoveTo (path);
 857                                         Assert.Fail ("#A1");
 858                                 } catch (IOException ex) {
 859                                         // Source and destination path must be different
 860                                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#A2");
 861                                         Assert.IsNull (ex.InnerException, "#A3");
 862                                         Assert.IsNotNull (ex.Message, "#A4");
 863                                 }
 864                         } finally {
 865                                 DeleteDir (path);
 866                         }
 867
 868                         try {
 869                                 DirectoryInfo info = new DirectoryInfo (path);
 870                                 try {
 871                                         info.MoveTo (path);
 872                                         Assert.Fail ("#B1");
 873                                 } catch (IOException ex) {
 874                                         // Source and destination path must be different
 875                                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#B2");
 876                                         Assert.IsNull (ex.InnerException, "#B3");
 877                                         Assert.IsNotNull (ex.Message, "#B4");
 878                                 }
 879                         } finally {
 880                                 DeleteDir (path);
 881                         }
 882                 }
 883
 884                 [Test]
 885                 public void MoveTo_UpdateProperties ()
 886                 {
 887                         string path = TempFolder + DSC + "DIT.MoveToUpdateProperties.Test";
 888                         string path2 = TempFolder + DSC + "DIT.MoveToUpdateProperties2.Test";
 889                         string path3 = path2 + DSC + "DIT.MoveToUpdateProperties3.Test";
 890                         DeleteDir (path);
 891                         Directory.CreateDirectory (path);
 892                         Directory.CreateDirectory (path2);
 893
 894                         DirectoryInfo info = new DirectoryInfo(path);
 895
 896                         Assert.IsTrue (Directory.Exists(info.FullName));
 897                         Assert.AreEqual (path, info.FullName);
 898                         Assert.AreEqual ("DIT.MoveToUpdateProperties.Test", info.Name);
 899                         Assert.AreEqual (TempFolder, info.Parent.FullName);
 900                         Assert.AreEqual (path, info.ToString ());
 901
 902                         info.MoveTo (path3);
 903                         Assert.IsTrue (Directory.Exists(info.FullName));
 904                         Assert.AreEqual (path3, info.FullName);
 905                         Assert.AreEqual ("DIT.MoveToUpdateProperties3.Test", info.Name);
 906                         Assert.AreEqual (path2, info.Parent.FullName);
 907                         Assert.AreEqual (path3, info.ToString ());
 908                 }
 909
 910                 [Test]
 911                 public void DirectoryNameWithSpace ()
 912                 {
 913                         DeleteDir ("this has a space at the end ");
 914                         string path = Path.Combine (TempFolder, "this has a space at the end ");
 915                         Directory.CreateDirectory (path);
 916                         DirectoryInfo i = new DirectoryInfo (path);
 917                         string dummy = null;
 918                         foreach (FileInfo f in i.GetFiles ())
 919                                 dummy = f.Name;
 920                 }
 921
 922                 [Test]
 923                 public void LastWriteTime ()
 924                 {
 925                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 926                         info.LastWriteTime = new DateTime (2003, 6, 4, 6, 4, 0);
 927
 928                         DateTime time = Directory.GetLastWriteTime (TempFolder);
 929                         Assert.AreEqual (2003, time.Year, "#A1");
 930                         Assert.AreEqual (6, time.Month, "#A2");
 931                         Assert.AreEqual (4, time.Day, "#A3");
 932                         Assert.AreEqual (6, time.Hour, "#A4");
 933                         Assert.AreEqual (4, time.Minute, "#A5");
 934                         Assert.AreEqual (0, time.Second, "#A6");
 935
 936                         time = TimeZone.CurrentTimeZone.ToLocalTime (
 937                                 Directory.GetLastWriteTimeUtc (TempFolder));
 938                         Assert.AreEqual (2003, time.Year, "#B1");
 939                         Assert.AreEqual (6, time.Month, "#B2");
 940                         Assert.AreEqual (4, time.Day, "#B3");
 941                         Assert.AreEqual (6, time.Hour, "#B4");
 942                         Assert.AreEqual (4, time.Minute, "#B5");
 943                         Assert.AreEqual (0, time.Second, "#B6");
 944                 }
 945
 946                 [Test]
 947                 public void LastWriteTimeUtc ()
 948                 {
 949                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 950                         info.LastWriteTimeUtc = new DateTime (2003, 6, 4, 6, 4, 0);
 951
 952                         DateTime time = TimeZone.CurrentTimeZone.ToUniversalTime (
 953                                 Directory.GetLastWriteTime (TempFolder));
 954                         Assert.AreEqual (2003, time.Year, "#A1");
 955                         Assert.AreEqual (6, time.Month, "#A2");
 956                         Assert.AreEqual (4, time.Day, "#A3");
 957                         Assert.AreEqual (6, time.Hour, "#A4");
 958                         Assert.AreEqual (4, time.Minute, "#A5");
 959                         Assert.AreEqual (0, time.Second, "#A6");
 960
 961                         time = Directory.GetLastWriteTimeUtc (TempFolder);
 962                         Assert.AreEqual (2003, time.Year, "#B1");
 963                         Assert.AreEqual (6, time.Month, "#B2");
 964                         Assert.AreEqual (4, time.Day, "#B3");
 965                         Assert.AreEqual (6, time.Hour, "#B4");
 966                         Assert.AreEqual (4, time.Minute, "#B5");
 967                         Assert.AreEqual (0, time.Second, "#B6");
 968                 }
 969
 970                 [Test]
 971                 public void LastAccessTime ()
 972                 {
 973                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 974                         info.LastAccessTime = DateTime.Now;
 975                 }
 976
 977                 [Test]
 978                 public void LastAccessTimeUtc ()
 979                 {
 980                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 981                         info.LastAccessTimeUtc = DateTime.Now;
 982                 }
 983
 984                 [Test]
 985                 public void CreationTime ()
 986                 {
 987                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 988                         info.CreationTime = DateTime.Now;
 989                 }
 990
 991                 [Test]
 992                 public void CreationTimeUtc ()
 993                 {
 994                         DirectoryInfo info = new DirectoryInfo (TempFolder);
 995                         info.CreationTimeUtc = DateTime.Now;
 996                 }
 997
 998                 [Test]
 999                 public void Name_Bug76903 ()
1000                 {
1001                         CheckName ("/usr/share");
1002                         CheckName ("/usr/share/");
1003                         CheckName ("/usr/share/.");
1004                         CheckName ("/usr/share/./");
1005                         CheckName ("/usr/share/blabla/../");
1006                         CheckName ("/usr/lib/../share/.");
1007                 }
1008
1009                 [Test]
1010                 public void Hang_76191 ()
1011                 {
1012                         // from bug #76191 (hangs on Windows)
1013                         DirectoryInfo di = new DirectoryInfo (Environment.CurrentDirectory);
1014                         Stack s = new Stack ();
1015                         s.Push (di);
1016                         while (di.Parent != null) {
1017                                 di = di.Parent;
1018                                 s.Push (di);
1019                         }
1020                         while (s.Count > 0) {
1021                                 di = (DirectoryInfo) s.Pop ();
1022                                 Assert.IsTrue (di.Exists, di.Name);
1023                         }
1024                 }
1025
1026                 [Test]
1027                 public void WindowsSystem32_76191 ()
1028                 {
1029                         if (RunningOnUnix)
1030                                 Assert.Ignore ("Running on Unix.");
1031
1032                         Directory.SetCurrentDirectory (@"C:\WINDOWS\system32");
1033                         WindowsParentFullName ("C:", "C:\\WINDOWS");
1034                         WindowsParentFullName ("C:\\", null);
1035                         WindowsParentFullName ("C:\\dir", "C:\\");
1036                         WindowsParentFullName ("C:\\dir\\", "C:\\");
1037                         WindowsParentFullName ("C:\\dir\\dir", "C:\\dir");
1038                         WindowsParentFullName ("C:\\dir\\dir\\", "C:\\dir");
1039                 }
1040
1041                 [Test]
1042                 public void Parent_Bug77090 ()
1043                 {
1044                         DirectoryInfo di = new DirectoryInfo ("/home");
1045                         if (Path.DirectorySeparatorChar == '\\') {
1046                                 Assert.IsTrue (di.Parent.Name.EndsWith (":\\"), "#1");
1047                         } else
1048                                 Assert.AreEqual ("/", di.Parent.Name, "#1");
1049                         Assert.IsNull (di.Parent.Parent, "#2");
1050                 }
1051
1052                 [Test]
1053                 public void ToStringTest ()
1054                 {
1055                         DirectoryInfo info;
1056
1057                         info = new DirectoryInfo ("Test");
1058                         Assert.AreEqual ("Test", info.ToString (), "#1");
1059                         info = new DirectoryInfo (TempFolder + DSC + "ToString.Test");
1060                         Assert.AreEqual (TempFolder + DSC + "ToString.Test", info.ToString ());
1061                 }
1062
1063                 [Test]
1064                 public void EnumerateFileSystemInfosTest ()
1065                 {
1066                         var dirInfo = new DirectoryInfo (TempFolder);
1067                         dirInfo.CreateSubdirectory ("1").CreateSubdirectory ("a");
1068                         dirInfo.CreateSubdirectory ("2").CreateSubdirectory ("b");
1069
1070                         var l = new List<string> ();
1071                         foreach (var info in dirInfo.EnumerateFileSystemInfos ("*", SearchOption.AllDirectories))
1072                                 l.Add (info.Name);
1073
1074                         l.Sort ();
1075                         Assert.AreEqual ("1,2,a,b", string.Join (",", l), "#1");
1076                 }
1077
1078 #if !MOBILE
1079                 [Test]
1080                 public void Serialization ()
1081                 {
1082                         DirectoryInfo info;
1083                         SerializationInfo si;
1084
1085                         info = new DirectoryInfo ("Test");
1086                         si = new SerializationInfo (typeof (DirectoryInfo), new FormatterConverter ());
1087                         info.GetObjectData (si, new StreamingContext ());
1088
1089                         Assert.AreEqual (2, si.MemberCount, "#A1");
1090                         Assert.AreEqual ("Test", si.GetString ("OriginalPath"), "#A2");
1091                         Assert.AreEqual (Path.Combine (Directory.GetCurrentDirectory (), "Test"), si.GetString ("FullPath"), "#A3");
1092
1093                         info = new DirectoryInfo (TempFolder);
1094                         si = new SerializationInfo (typeof (DirectoryInfo), new FormatterConverter ());
1095                         info.GetObjectData (si, new StreamingContext ());
1096
1097                         Assert.AreEqual (2, si.MemberCount, "#B1");
1098                         Assert.AreEqual (TempFolder, si.GetString ("OriginalPath"), "#B2");
1099                         Assert.AreEqual (TempFolder, si.GetString ("FullPath"), "#B3");
1100                 }
1101
1102                 [Test]
1103                 public void Deserialization ()
1104                 {
1105                         DirectoryInfo info = new DirectoryInfo ("Test");
1106
1107                         MemoryStream ms = new MemoryStream ();
1108                         BinaryFormatter bf = new BinaryFormatter ();
1109                         bf.Serialize (ms, info);
1110                         ms.Position = 0;
1111
1112                         DirectoryInfo clone = (DirectoryInfo) bf.Deserialize (ms);
1113                         Assert.AreEqual (info.Name, clone.Name, "#1");
1114                         Assert.AreEqual (info.FullName, clone.FullName, "#2");
1115                 }
1116
1117                 // Needed so that UnixSymbolicLinkInfo doesn't have to
1118                 // be JITted on windows
1119                 private void Symlink_helper ()
1120                 {
1121                         string path = TempFolder + DSC + "DIT.Symlink";
1122                         string dir = path + DSC + "dir";
1123                         string link = path + DSC + "link";
1124
1125                         DeleteDir (path);
1126
1127                         try {
1128                                 Directory.CreateDirectory (path);
1129                                 Directory.CreateDirectory (dir);
1130                                 global::Mono.Unix.UnixSymbolicLinkInfo li = new global::Mono.Unix.UnixSymbolicLinkInfo (link);
1131                                 li.CreateSymbolicLinkTo (dir);
1132
1133                                 DirectoryInfo info = new DirectoryInfo (path);
1134                                 DirectoryInfo[] dirs = info.GetDirectories ();
1135                                 Assert.AreEqual (2, dirs.Length, "#1");
1136                         } finally {
1137                                 DeleteDir (path);
1138                         }
1139                 }
1140
1141                 [Test]
1142                 [Category ("NotDotNet")]
1143                 public void Symlink ()
1144                 {
1145                         // This test only applies to Linux and
1146                         // Linux-like platforms but mono-on-windows
1147                         // doesn't set the NotDotNet category
1148                         if (!RunningOnUnix) {
1149                                 Assert.Ignore ("Not running on Unix.");
1150                         }
1151
1152                         Symlink_helper ();
1153                 }
1154 #endif
1155                 static bool RunningOnUnix {
1156                         get {
1157                                 int p = (int) Environment.OSVersion.Platform;
1158                                 return ((p == 4) || (p == 128) || (p == 6));
1159                         }
1160                 }
1161
1162                 void WindowsParentFullName (string name, string expected)
1163                 {
1164                         DirectoryInfo di = new DirectoryInfo (name);
1165                         if (di.Parent == null)
1166                                 Assert.IsNull (expected, name);
1167                         else
1168                                 Assert.AreEqual (expected, di.Parent.FullName, name);
1169                 }
1170
1171                 void CheckName (string name)
1172                 {
1173                         DirectoryInfo di = new DirectoryInfo (name);
1174                         Assert.AreEqual ("share", di.Name, name + ".Name");
1175                         Assert.AreEqual ("usr", di.Parent.Name, name + ".Parent.Name");
1176                 }
1177
1178                 void DeleteDir (string path)
1179                 {
1180                         if (Directory.Exists (path))
1181                                 Directory.Delete (path, true);
1182                 }
1183         }
1184 }