-// DirectoryInfoTest.cs - NUnit Test Cases for System.IO.DirectoryInfo class\r
-//\r
-// Authors\r
-// Ville Palo (vi64pa@koti.soon.fi)\r
-// Sebastien Pouliot <sebastien@ximian.com>\r
-// \r
-// (C) 2003 Ville Palo\r
-// Copyright (C) 2005 Novell, Inc (http://www.novell.com)\r
-// \r
-\r
-using NUnit.Framework;\r
-using System;\r
-using System.Collections;\r
-using System.IO;\r
-\r
-namespace MonoTests.System.IO\r
-{\r
- [TestFixture]\r
- public class DirectoryInfoTest : Assertion\r
- {\r
- string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");\r
-\r
- static readonly char DSC = Path.DirectorySeparatorChar;\r
- string current;\r
-\r
- [SetUp]\r
- protected void SetUp ()\r
- {\r
- current = Directory.GetCurrentDirectory ();\r
- if (Directory.Exists (TempFolder))\r
- Directory.Delete (TempFolder, true);\r
- Directory.CreateDirectory (TempFolder);\r
- }\r
- \r
- [TearDown]\r
- protected void TearDown ()\r
- {\r
- if (Directory.Exists (TempFolder))\r
- Directory.Delete (TempFolder, true);\r
- Directory.SetCurrentDirectory (current);\r
- }\r
- \r
- [Test]\r
- public void Ctr ()\r
- {\r
- string path = TempFolder + DSC + "DIT.Ctr.Test";\r
- DeleteDir (path);\r
- \r
- FileInfo info = new FileInfo (path);\r
- AssertEquals ("test#01", true, info.DirectoryName.EndsWith (".Tests"));\r
- AssertEquals ("test#02", false, info.Exists);\r
- AssertEquals ("test#03", ".Test", info.Extension);\r
- AssertEquals ("test#05", "DIT.Ctr.Test", info.Name); \r
- }\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentNullException))]\r
- public void CtorArgumentNullException ()\r
- {\r
- DirectoryInfo info = new DirectoryInfo (null); \r
- }\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException))]\r
- public void CtorArgumentException1 ()\r
- {\r
- DirectoryInfo info = new DirectoryInfo (""); \r
- }\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException))]\r
- public void CtorArgumentException2 ()\r
- {\r
- DirectoryInfo info = new DirectoryInfo (" "); \r
- }\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException))]\r
- public void CtorArgumentException3 ()\r
- {\r
- string path = "";\r
- foreach (char c in Path.InvalidPathChars) {\r
- path += c;\r
- }\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- }\r
- \r
- [Test]\r
- public void Exists ()\r
- {\r
- string path = TempFolder + DSC + "DIT.Exists.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- AssertEquals ("test#01", false, info.Exists);\r
- \r
- Directory.CreateDirectory (path);\r
- AssertEquals ("test#02", false, info.Exists);\r
- info = new DirectoryInfo (path);\r
- AssertEquals ("test#03", true, info.Exists); \r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
- \r
- [Test]\r
- public void Name ()\r
- {\r
- string path = TempFolder + DSC + "DIT.Name.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = new DirectoryInfo (path); \r
- AssertEquals ("test#01", "DIT.Name.Test", info.Name);\r
- \r
- info = Directory.CreateDirectory (path);\r
- AssertEquals ("test#02", "DIT.Name.Test", info.Name);\r
- \r
- \r
- } finally {\r
- DeleteDir (path);\r
- } \r
- }\r
- \r
- [Test]\r
- public void Parent ()\r
- {\r
- string path = TempFolder + DSC + "DIT.Parent.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- AssertEquals ("test#01", "MonoTests.System.IO.Tests", info.Parent.Name);\r
- \r
- info = Directory.CreateDirectory (path);\r
- AssertEquals ("test#02", "MonoTests.System.IO.Tests", info.Parent.Name);\r
- \r
- } finally {\r
- DeleteDir (path);\r
- } \r
- }\r
-\r
- [Test]\r
- public void Create ()\r
- {\r
- string path = TempFolder + DSC + "DIT.Create.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- AssertEquals ("test#01", false, info.Exists);\r
- info.Create (); \r
- AssertEquals ("test#02", false, info.Exists);\r
- info = new DirectoryInfo (path);\r
- AssertEquals ("test#03", true, info.Exists);\r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
-\r
- [Test]\r
- public void CreateSubdirectory ()\r
- {\r
- string sub_path = Path.Combine ("test01", "test02");\r
- try {\r
- DirectoryInfo info = new DirectoryInfo (TempFolder);\r
- info.CreateSubdirectory (sub_path);\r
- Assert ("test#01", Directory.Exists (Path.Combine (TempFolder, sub_path)));\r
- } finally {\r
- DeleteDir (Path.Combine (TempFolder, sub_path));\r
- }\r
- \r
+// DirectoryInfoTest.cs - NUnit Test Cases for System.IO.DirectoryInfo class
+//
+// Authors
+// Ville Palo (vi64pa@koti.soon.fi)
+// Sebastien Pouliot <sebastien@ximian.com>
+//
+// (C) 2003 Ville Palo
+// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
+//
+
+using System;
+using System.Collections;
+using System.IO;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters.Binary;
+
+using NUnit.Framework;
+
+namespace MonoTests.System.IO
+{
+ [TestFixture]
+ public class DirectoryInfoTest
+ {
+ string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
+
+ static readonly char DSC = Path.DirectorySeparatorChar;
+ string current;
+
+ [SetUp]
+ protected void SetUp ()
+ {
+ current = Directory.GetCurrentDirectory ();
+ if (Directory.Exists (TempFolder))
+ Directory.Delete (TempFolder, true);
+ Directory.CreateDirectory (TempFolder);
}
-
+
+ [TearDown]
+ protected void TearDown ()
+ {
+ if (Directory.Exists (TempFolder))
+ Directory.Delete (TempFolder, true);
+ Directory.SetCurrentDirectory (current);
+ }
+
+ [Test] // ctor (String)
+ public void Constructor1 ()
+ {
+ string path = TempFolder + DSC + "DIT.Ctr.Test";
+ DeleteDir (path);
+
+ DirectoryInfo info = new DirectoryInfo (path);
+ Assert.AreEqual ("DIT.Ctr.Test", info.Name, "#1");
+ Assert.IsFalse (info.Exists, "#2");
+ Assert.AreEqual (".Test", info.Extension, "#3");
+ Assert.AreEqual ("DIT.Ctr.Test", info.Name, "#4");
+ }
+
+ [Test] // ctor (String)
+ public void Constructor1_Path_Null ()
+ {
+ try {
+ new DirectoryInfo (null);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("path", ex.ParamName, "#5");
+ }
+ }
+
+ [Test] // ctor (String)
+ public void Constructor1_Path_Empty ()
+ {
+ try {
+ new DirectoryInfo (string.Empty);
+ Assert.Fail ("#1");
+ } catch (ArgumentException ex) {
+ // Empty file name is not legal
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+ }
+ }
+
+ [Test] // ctor (String)
+ public void Constructor1_Path_Whitespace ()
+ {
+ try {
+ new DirectoryInfo (" ");
+ Assert.Fail ("#1");
+ } catch (ArgumentException ex) {
+ // The path is not of a legal form
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+ }
+ }
+
+ [Test] // ctor (String)
+ public void Constructor1_Path_InvalidPathChars ()
+ {
+ string path = string.Empty;
+ foreach (char c in Path.InvalidPathChars)
+ path += c;
+ try {
+ new DirectoryInfo (path);
+ Assert.Fail ("#1");
+ } catch (ArgumentException ex) {
+ // The path contains illegal characters
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+ }
+ }
+
[Test]
- [ExpectedException(typeof(ArgumentException))]
- public void CreateSubdirectoryEmptyString ()
- {
- new DirectoryInfo (".").CreateSubdirectory ("");
- }\r
-\r
- [Test]\r
- public void Delete1 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.Delete1.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- Directory.CreateDirectory (path);\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- AssertEquals ("test#01", true, info.Exists);\r
- \r
- info.Delete ();\r
- AssertEquals ("test#02", true, info.Exists);\r
- \r
- info = new DirectoryInfo (path);\r
- AssertEquals ("test#03", false, info.Exists);\r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
-\r
- [Test]\r
- public void Delete2 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.Delete2.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- Directory.CreateDirectory (path);\r
- File.Create (path + DSC + "test").Close ();\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- AssertEquals ("test#01", true, info.Exists);\r
- \r
- info.Delete (true);\r
- AssertEquals ("test#02", true, info.Exists);\r
- \r
- info = new DirectoryInfo (path);\r
- AssertEquals ("test#03", false, info.Exists);\r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
- \r
- [Test]\r
- [ExpectedException (typeof (IOException))]\r
- public void DeleteIOException1 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.DeleteIOException1.Test";\r
- DeleteDir (path); \r
- \r
- try {\r
- Directory.CreateDirectory (path);\r
- File.Create (path + DSC + "test").Close ();\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- info.Delete ();\r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (IOException))]\r
- public void DeleteIOException2 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.DeleteIOException2.Test";\r
- DeleteDir (path); \r
- \r
- try {\r
- Directory.CreateDirectory (path);\r
- File.Create (path + DSC + "test").Close ();\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- info.Delete (false);\r
- } finally {\r
- DeleteDir (path);\r
- }\r
+ public void Exists ()
+ {
+ string path = TempFolder + DSC + "DIT.Exists.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = new DirectoryInfo (path);
+ Assert.IsFalse (info.Exists, "#1");
+
+ Directory.CreateDirectory (path);
+ Assert.IsFalse (info.Exists, "#2");
+ info = new DirectoryInfo (path);
+ Assert.IsTrue (info.Exists, "#3");
+ } finally {
+ DeleteDir (path);
+ }
}
[Test]
- // from bug #75443
+ public void Name ()
+ {
+ string path = TempFolder + DSC + "DIT.Name.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = new DirectoryInfo (path);
+ Assert.AreEqual ("DIT.Name.Test", info.Name, "#1");
+
+ info = Directory.CreateDirectory (path);
+ Assert.AreEqual ("DIT.Name.Test", info.Name, "#2");
+
+ info = Directory.CreateDirectory ("whatever");
+ Assert.AreEqual ("whatever", info.Name, "#3");
+
+ if (RunningOnUnix) {
+ info = new DirectoryInfo ("/");
+ Assert.AreEqual ("/", info.Name, "#4");
+
+ info = new DirectoryInfo ("test/");
+ Assert.AreEqual ("test", info.Name, "#5");
+
+ info = new DirectoryInfo ("/test");
+ Assert.AreEqual ("test", info.Name, "#4");
+
+ info = new DirectoryInfo ("/test/");
+ Assert.AreEqual ("test", info.Name, "#4");
+ } else {
+ info = new DirectoryInfo (@"c:");
+ Assert.AreEqual (@"C:\", info.Name, "#4");
+
+ info = new DirectoryInfo (@"c:\");
+ Assert.AreEqual (@"c:\", info.Name, "#5");
+
+ info = new DirectoryInfo (@"c:\test");
+ Assert.AreEqual ("test", info.Name, "#6");
+
+ info = new DirectoryInfo (@"c:\test\");
+ Assert.AreEqual ("test", info.Name, "#7");
+ }
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test]
+ public void Parent ()
+ {
+ string path = TempFolder + DSC + "DIT.Parent.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = new DirectoryInfo (path);
+ Assert.AreEqual ("MonoTests.System.IO.Tests", info.Parent.Name, "#1");
+
+ info = Directory.CreateDirectory (path);
+ Assert.AreEqual ("MonoTests.System.IO.Tests", info.Parent.Name, "#2");
+
+ info = new DirectoryInfo ("test");
+ Assert.AreEqual (Directory.GetCurrentDirectory (), info.Parent.FullName, "#3");
+
+ if (RunningOnUnix) {
+ info = new DirectoryInfo ("/");
+ Assert.IsNull (info.Parent, "#4");
+
+ info = new DirectoryInfo ("test/");
+ Assert.IsNotNull (info.Parent, "#5a");
+ Assert.AreEqual (Directory.GetCurrentDirectory (), info.Parent.FullName, "#5b");
+
+ info = new DirectoryInfo ("/test");
+ Assert.IsNotNull (info.Parent, "#6a");
+ Assert.AreEqual ("/", info.Parent.FullName, "#6b");
+
+ info = new DirectoryInfo ("/test/");
+ Assert.IsNotNull (info.Parent, "#7a");
+ Assert.AreEqual ("/", info.Parent.FullName, "#7b");
+ } else {
+ info = new DirectoryInfo (@"c:");
+ Assert.IsNull (info.Parent, "#4");
+
+ info = new DirectoryInfo (@"c:\");
+ Assert.IsNull (info.Parent, "#5");
+
+ info = new DirectoryInfo (@"c:\test");
+ Assert.IsNotNull (info.Parent, "#6a");
+ Assert.AreEqual (@"c:\", info.Parent.FullName, "#6b");
+
+ info = new DirectoryInfo (@"c:\test\");
+ Assert.IsNotNull (info.Parent, "#7a");
+ Assert.AreEqual (@"c:\", info.Parent.FullName, "#7b");
+ }
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test]
+ public void Create ()
+ {
+ string path = TempFolder + DSC + "DIT.Create.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = new DirectoryInfo (path);
+ Assert.IsFalse (info.Exists, "#1");
+ info.Create ();
+ Assert.IsFalse (info.Exists, "#2");
+ info = new DirectoryInfo (path);
+ Assert.IsTrue (info.Exists, "#3");
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test]
+ public void CreateSubdirectory ()
+ {
+ string sub_path = Path.Combine ("test01", "test02");
+ try {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ DirectoryInfo sub = info.CreateSubdirectory (sub_path);
+ Assert.IsNotNull (sub, "#1");
+ Assert.AreEqual (Path.Combine (TempFolder, sub_path), sub.FullName, "#2");
+ Assert.IsTrue (Directory.Exists (sub.FullName), "#3");
+ } finally {
+ DeleteDir (Path.Combine (TempFolder, sub_path));
+ }
+ }
+
+ [Test]
+ public void CreateSubdirectory_Path_Null ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ try {
+ info.CreateSubdirectory (null);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("path", ex.ParamName, "#5");
+ }
+ }
+
+ [Test]
+ public void CreateSubdirectory_Path_Empty ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ try {
+ info.CreateSubdirectory (string.Empty);
+ Assert.Fail ("#1");
+ } catch (ArgumentException ex) {
+ // Empty file name is not legal
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ }
+ }
+
+ [Test] // Delete ()
+ public void Delete1 ()
+ {
+ string path = TempFolder + DSC + "DIT.Delete1.Test";
+ DeleteDir (path);
+
+ try {
+ Directory.CreateDirectory (path);
+ DirectoryInfo info = new DirectoryInfo (path);
+ Assert.IsTrue (info.Exists, "#1");
+
+ info.Delete ();
+ Assert.IsTrue (info.Exists, "#2");
+
+ info = new DirectoryInfo (path);
+ Assert.IsFalse (info.Exists, "#3");
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // Delete ()
+ public void Delete1_DirectoryNotEmpty ()
+ {
+ string path = TempFolder + DSC + "DIT.DeleteIOException1.Test";
+ DeleteDir (path);
+
+ try {
+ Directory.CreateDirectory (path);
+ File.Create (path + DSC + "test").Close ();
+ DirectoryInfo info = new DirectoryInfo (path);
+ try {
+ info.Delete ();
+ Assert.Fail ("#1");
+ } catch (IOException ex) {
+ // The directory is not empty
+ Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ }
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // Delete (Boolean)
+ public void Delete2 ()
+ {
+ string path = TempFolder + DSC + "DIT.Delete2.Test";
+ DeleteDir (path);
+
+ try {
+ Directory.CreateDirectory (path);
+ File.Create (path + DSC + "test").Close ();
+ DirectoryInfo info = new DirectoryInfo (path);
+ Assert.IsTrue (info.Exists, "#1");
+
+ info.Delete (true);
+ Assert.IsTrue (info.Exists, "#2");
+
+ info = new DirectoryInfo (path);
+ Assert.IsFalse (info.Exists, "#3");
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // Delete (Boolean)
+ public void Delete2_DirectoryNotEmpty ()
+ {
+ string path = TempFolder + DSC + "DIT.DeleteIOException2.Test";
+ DeleteDir (path);
+
+ try {
+ Directory.CreateDirectory (path);
+ File.Create (path + DSC + "test").Close ();
+ DirectoryInfo info = new DirectoryInfo (path);
+ try {
+ info.Delete (false);
+ Assert.Fail ("#1");
+ } catch (IOException ex) {
+ // The directory is not empty
+ Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ }
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // bug #75443
public void FullName ()
{
DirectoryInfo di = new DirectoryInfo ("something");
- Assert ("Exists", !di.Exists);
- Assert ("FullName", di.FullName.EndsWith ("something"));
+ Assert.IsFalse (di.Exists, "#A1");
+ Assert.AreEqual (Path.Combine (Directory.GetCurrentDirectory (), "something"), di.FullName, "#A2");
di = new DirectoryInfo ("something" + Path.DirectorySeparatorChar);
- AssertEquals ("DirectorySeparatorChar", Path.DirectorySeparatorChar, di.FullName [di.FullName.Length - 1]);
+ Assert.IsFalse (di.Exists, "#B1");
+ Assert.AreEqual (Path.DirectorySeparatorChar, di.FullName [di.FullName.Length - 1], "#B2");
di = new DirectoryInfo ("something" + Path.AltDirectorySeparatorChar);
- AssertEquals ("AltDirectorySeparatorChar", Path.DirectorySeparatorChar, di.FullName [di.FullName.Length - 1]);
- }\r
+ Assert.IsFalse (di.Exists, "#C1");
+ Assert.AreEqual (Path.DirectorySeparatorChar, di.FullName [di.FullName.Length - 1], "#C2");
+
+ if (RunningOnUnix) {
+ di = new DirectoryInfo ("/");
+ Assert.AreEqual ("/", di.FullName, "#D1");
+
+ di = new DirectoryInfo ("test/");
+ Assert.AreEqual (Path.Combine (Directory.GetCurrentDirectory (), "test/"), di.FullName, "#D2");
+
+ di = new DirectoryInfo ("/test");
+ Assert.AreEqual ("/test", di.FullName, "#D3");
+
+ di = new DirectoryInfo ("/test/");
+ Assert.AreEqual ("/test/", di.FullName, "#D4");
+ } else {
+ di = new DirectoryInfo (@"c:");
+ Assert.AreEqual (@"C:\", di.FullName, "#D1");
+
+ di = new DirectoryInfo (@"c:\");
+ Assert.AreEqual (@"c:\", di.FullName, "#D2");
+
+ di = new DirectoryInfo (@"c:\test");
+ Assert.AreEqual (@"c:\test", di.FullName, "#D3");
+
+ di = new DirectoryInfo (@"c:\test\");
+ Assert.AreEqual (@"c:\test\", di.FullName, "#D4");
+ }
+ }
[Test]
public void FullName_RootDirectory ()
{
DirectoryInfo di = new DirectoryInfo (String.Empty + Path.DirectorySeparatorChar);
- if (Path.DirectorySeparatorChar == '/') {
+ if (RunningOnUnix) {
// can't be sure of the root drive under windows
- AssertEquals ("FullName", "/", di.FullName);
+ Assert.AreEqual ("/", di.FullName, "#1");
}
- AssertNull ("Parent", di.Parent);
+ Assert.IsNull (di.Parent, "#2");
di = new DirectoryInfo (String.Empty + Path.AltDirectorySeparatorChar);
- if (Path.DirectorySeparatorChar == '/') {
+ if (RunningOnUnix) {
// can't be sure of the root drive under windows
- AssertEquals ("FullName-Alt", "/", di.FullName);
- }
- AssertNull ("Parent-Alt", di.Parent);
- }\r
- \r
- [Test]\r
- public void GetDirectories1 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.GetDirectories1.Test";\r
- \r
- try {\r
- DirectoryInfo info = Directory.CreateDirectory (path);\r
- AssertEquals ("test#01", 0, info.GetDirectories ().Length);\r
- \r
- Directory.CreateDirectory (path + DSC + "1");\r
- Directory.CreateDirectory (path + DSC + "2"); \r
- File.Create (path + DSC + "filetest").Close ();\r
- AssertEquals ("test#02", 2, info.GetDirectories ().Length);\r
- \r
- Directory.Delete (path + DSC + 2);\r
- AssertEquals ("test#02", 1, info.GetDirectories ().Length); \r
- \r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
- \r
- [Test]\r
- public void GetDirectories2 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.GetDirectories2.Test";\r
- \r
- try {\r
- DirectoryInfo info = Directory.CreateDirectory (path);\r
- AssertEquals ("test#01", 0, info.GetDirectories ("*").Length);\r
- \r
- Directory.CreateDirectory (path + DSC + "test120");\r
- Directory.CreateDirectory (path + DSC + "test210");\r
- Directory.CreateDirectory (path + DSC + "atest330");\r
- Directory.CreateDirectory (path + DSC + "test220");\r
- File.Create (path + DSC + "filetest").Close ();\r
- \r
- AssertEquals ("test#02", 4, info.GetDirectories ("*").Length);\r
- AssertEquals ("test#03", 3, info.GetDirectories ("test*").Length);\r
- AssertEquals ("test#04", 2, info.GetDirectories ("test?20").Length);\r
- AssertEquals ("test#05", 0, info.GetDirectories ("test?").Length);\r
- AssertEquals ("test#06", 0, info.GetDirectories ("test[12]*").Length);\r
- AssertEquals ("test#07", 2, info.GetDirectories ("test2*0").Length);\r
- AssertEquals ("test#08", 4, info.GetDirectories ("*test*").Length);\r
- \r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
- \r
- [Test]\r
- [ExpectedException (typeof (DirectoryNotFoundException))] \r
- public void GetDirectoriesDirectoryNotFoundException1 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.GetDirectoriesDirectoryNotFoundException1.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- info.GetDirectories ();\r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (DirectoryNotFoundException))] \r
- public void GetDirectoriesDirectoryNotFoundException2 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.GetDirectoriesDirectoryNotFoundException2.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- info.GetDirectories ("*");\r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
- \r
- [Test]\r
- [ExpectedException (typeof (ArgumentNullException))]\r
- public void GetDirectoriesArgumentNullException ()\r
- {\r
- string path = TempFolder + DSC + "DIT.GetDirectoriesArgumentNullException.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- info.GetDirectories (null);\r
- } finally {\r
- DeleteDir (path);\r
- } \r
- }\r
-\r
- [Test]\r
- public void GetFiles1 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.GetFiles1.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = Directory.CreateDirectory (path);\r
- AssertEquals ("test#01", 0, info.GetFiles ().Length);\r
- File.Create (path + DSC + "file1").Close ();\r
- File.Create (path + DSC + "file2").Close ();\r
- Directory.CreateDirectory (path + DSC + "directory1");\r
- AssertEquals ("test#02", 2, info.GetFiles ().Length);\r
- \r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
- \r
- [Test]\r
- public void GetFiles2()\r
- {\r
- string path = TempFolder + DSC + "DIT.GetFiles2.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = Directory.CreateDirectory (path);\r
- AssertEquals ("test#01", 0, info.GetFiles ("*").Length);\r
- File.Create (path + DSC + "file120file").Close ();\r
- File.Create (path + DSC + "file220file").Close ();\r
- File.Create (path + DSC + "afile330file").Close ();\r
- File.Create (path + DSC + "test.abc").Close ();\r
- File.Create (path + DSC + "test.abcd").Close ();\r
- File.Create (path + DSC + "test.abcdef").Close (); \r
- Directory.CreateDirectory (path + DSC + "dir");\r
- \r
- AssertEquals ("test#02", 6, info.GetFiles ("*").Length);\r
- AssertEquals ("test#03", 2, info.GetFiles ("file*file").Length);\r
- AssertEquals ("test#04", 3, info.GetFiles ("*file*").Length);\r
- AssertEquals ("test#05", 2, info.GetFiles ("file?20file").Length);\r
- AssertEquals ("test#07", 1, info.GetFiles ("*.abcd").Length);\r
- AssertEquals ("test#08", 2, info.GetFiles ("*.abcd*").Length); \r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
- \r
- [Test]\r
- [ExpectedException (typeof (DirectoryNotFoundException))]\r
- public void GetFilesDirectoryNotFoundException1 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.GetFilesDirectoryNotFoundException1.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- info.GetFiles ();\r
- \r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (DirectoryNotFoundException))]\r
- public void GetFilesDirectoryNotFoundException2 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.GetFilesDirectoryNotFoundException2.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- info.GetFiles ("*");\r
- \r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
- \r
- [Test]\r
- [ExpectedException (typeof (ArgumentNullException))]\r
- public void GetFilesArgumentNullException ()\r
- {\r
- string path = TempFolder + DSC + "DIT.GetFilesArgumentNullException.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- info.GetFiles (null); \r
- } finally {\r
- DeleteDir (path);\r
- }\r
- }\r
- \r
- [Test]\r
- public void MoveTo ()\r
- {\r
- string path1 = TempFolder + DSC + "DIT.MoveTo.Soucre.Test";\r
- string path2 = TempFolder + DSC + "DIT.MoveTo.Dest.Test";\r
- DeleteDir (path1);\r
- DeleteDir (path2);\r
- \r
- try {\r
- DirectoryInfo info1 = Directory.CreateDirectory (path1);\r
- DirectoryInfo info2 = new DirectoryInfo (path2);\r
- \r
- AssertEquals ("test#01", true, info1.Exists);\r
- AssertEquals ("test#02", false, info2.Exists);\r
- \r
- info1.MoveTo (path2); \r
- AssertEquals ("test#03", true, info1.Exists);\r
- AssertEquals ("test#04", false, info2.Exists);\r
- \r
- info1 = new DirectoryInfo (path1);\r
- info2 = new DirectoryInfo (path2);\r
- AssertEquals ("test#05", false, info1.Exists);\r
- AssertEquals ("test#06", true, info2.Exists);\r
- \r
- } finally {\r
- DeleteDir (path1);\r
- DeleteDir (path2);\r
- }\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentNullException))]\r
- public void MoveToArgumentNullException ()\r
- {\r
- string path = TempFolder + DSC + "DIT.MoveToArgumentNullException.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = Directory.CreateDirectory (path);\r
- info.MoveTo (null);\r
- } finally {\r
- DeleteDir (path);\r
- }\r
- \r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (IOException))]\r
- public void MoveToIOException1 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.MoveToIOException1.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = Directory.CreateDirectory (path);\r
- info.MoveTo (path);\r
- } finally {\r
- DeleteDir (path);\r
- } \r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void MoveToArgumentException1 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.MoveToArgumentException1.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = Directory.CreateDirectory (path);\r
- info.MoveTo ("");\r
- } finally {\r
- DeleteDir (path);\r
- } \r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void MoveToArgumentException2 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.MoveToArgumentException2.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = Directory.CreateDirectory (path);\r
- info.MoveTo (" ");\r
- } finally {\r
- DeleteDir (path);\r
- } \r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void MoveToArgumentException3 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.MoveToArgumentException3.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = Directory.CreateDirectory (path);\r
- info.MoveTo (Path.InvalidPathChars [0].ToString ());\r
- } finally {\r
- DeleteDir (path);\r
- } \r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (IOException))]\r
- public void MoveToIOException2 ()\r
- {\r
- string path = TempFolder + DSC + "DIT.MoveToIOException2.Test";\r
- DeleteDir (path);\r
- \r
- try {\r
- DirectoryInfo info = new DirectoryInfo (path);\r
- info.MoveTo (path);\r
- } finally {\r
- DeleteDir (path);\r
- } \r
- }\r
-\r
- private void DeleteDir (string path)\r
- {\r
- if (Directory.Exists (path))\r
- Directory.Delete (path, true);\r
- }\r
-
- [Test]
+ Assert.AreEqual ("/", di.FullName, "#3");
+ }
+ Assert.IsNull (di.Parent, "#4");
+ }
+
+ [Test] // GetDirectories ()
+ public void GetDirectories1 ()
+ {
+ string path = TempFolder + DSC + "DIT.GetDirectories1.Test";
+
+ try {
+ DirectoryInfo info = Directory.CreateDirectory (path);
+ Assert.AreEqual (0, info.GetDirectories ().Length, "#1");
+
+ Directory.CreateDirectory (path + DSC + "1");
+ Directory.CreateDirectory (path + DSC + "2");
+ File.Create (path + DSC + "filetest").Close ();
+ Assert.AreEqual (2, info.GetDirectories ().Length, "#2");
+
+ Directory.Delete (path + DSC + 2);
+ Assert.AreEqual (1, info.GetDirectories ().Length, "#3");
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // GetDirectories ()
+ public void GetDirectories1_DirectoryDoesNotExist ()
+ {
+ string path = TempFolder + DSC + "DIT.GetDirectoriesDirectoryNotFoundException1.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = new DirectoryInfo (path);
+ info.GetDirectories ();
+ Assert.Fail ("#1");
+ } catch (DirectoryNotFoundException ex) {
+ // Could not find a part of '...'
+ Assert.AreEqual (typeof (DirectoryNotFoundException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#5");
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // GetDirectories (String)
+ public void GetDirectories2 ()
+ {
+ string path = TempFolder + DSC + "DIT.GetDirectories2.Test";
+
+ try {
+ DirectoryInfo info = Directory.CreateDirectory (path);
+ Assert.AreEqual (0, info.GetDirectories ("*").Length, "#1");
+
+ Directory.CreateDirectory (path + DSC + "test120");
+ Directory.CreateDirectory (path + DSC + "test210");
+ Directory.CreateDirectory (path + DSC + "atest330");
+ Directory.CreateDirectory (path + DSC + "test220");
+ Directory.CreateDirectory (path + DSC + "rest");
+ Directory.CreateDirectory (path + DSC + "rest" + DSC + "subdir");
+ File.Create (path + DSC + "filetest").Close ();
+
+ Assert.AreEqual (5, info.GetDirectories ("*").Length, "#2");
+ Assert.AreEqual (3, info.GetDirectories ("test*").Length, "#3");
+ Assert.AreEqual (2, info.GetDirectories ("test?20").Length, "#4");
+ Assert.AreEqual (0, info.GetDirectories ("test?").Length, "#5");
+ Assert.AreEqual (0, info.GetDirectories ("test[12]*").Length, "#6");
+ Assert.AreEqual (2, info.GetDirectories ("test2*0").Length, "#7");
+ Assert.AreEqual (4, info.GetDirectories ("*test*").Length, "#8");
+#if NET_2_0
+ Assert.AreEqual (6, info.GetDirectories ("*", SearchOption.AllDirectories).Length, "#9");
+#endif
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // GetDirectories (String)
+ public void GetDirectories2_DirectoryDoesNotExist ()
+ {
+ string path = TempFolder + DSC + "DIT.GetDirectoriesDirectoryNotFoundException2.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = new DirectoryInfo (path);
+ info.GetDirectories ("*");
+ Assert.Fail ("#1");
+ } catch (DirectoryNotFoundException ex) {
+ // Could not find a part of '...'
+ Assert.AreEqual (typeof (DirectoryNotFoundException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#5");
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // GetDirectories (String)
+ public void GetDirectories2_SearchPattern_Null ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ try {
+ info.GetDirectories (null);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("searchPattern", ex.ParamName, "#5");
+ }
+ }
+
+#if NET_2_0
+ [Test] // GetDirectories (String, SearchOption)
+ public void GetDirectories3_SearchPattern_Null ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ try {
+ info.GetDirectories (null, SearchOption.AllDirectories);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("searchPattern", ex.ParamName, "#5");
+ }
+ }
+#endif
+
+ [Test] // GetFiles ()
+ public void GetFiles1 ()
+ {
+ string path = TempFolder + DSC + "DIT.GetFiles1.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = Directory.CreateDirectory (path);
+ Assert.AreEqual (0, info.GetFiles ().Length, "#1");
+ File.Create (path + DSC + "file1").Close ();
+ File.Create (path + DSC + "file2").Close ();
+ Directory.CreateDirectory (path + DSC + "directory1");
+ Assert.AreEqual (2, info.GetFiles ().Length, "#2");
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // GetFiles ()
+ public void GetFiles1_DirectoryDoesNotExist ()
+ {
+ string path = TempFolder + DSC + "DIT.GetFilesDirectoryNotFoundException1.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = new DirectoryInfo (path);
+ info.GetFiles ();
+ Assert.Fail ("#1");
+ } catch (DirectoryNotFoundException ex) {
+ // Could not find a part of '...'
+ Assert.AreEqual (typeof (DirectoryNotFoundException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#5");
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // GetFiles (String)
+ public void GetFiles2 ()
+ {
+ string path = TempFolder + DSC + "DIT.GetFiles2.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = Directory.CreateDirectory (path);
+ Assert.AreEqual (0, info.GetFiles ("*").Length, "#1");
+ File.Create (path + DSC + "file120file").Close ();
+ File.Create (path + DSC + "file220file").Close ();
+ File.Create (path + DSC + "afile330file").Close ();
+ File.Create (path + DSC + "test.abc").Close ();
+ File.Create (path + DSC + "test.abcd").Close ();
+ File.Create (path + DSC + "test.abcdef").Close ();
+ Directory.CreateDirectory (path + DSC + "dir");
+
+ Assert.AreEqual (6, info.GetFiles ("*").Length, "#2");
+ Assert.AreEqual (2, info.GetFiles ("file*file").Length, "#3");
+ Assert.AreEqual (3, info.GetFiles ("*file*").Length, "#4");
+ Assert.AreEqual (2, info.GetFiles ("file?20file").Length, "#5");
+ Assert.AreEqual (1, info.GetFiles ("*.abcd").Length, "#6");
+ Assert.AreEqual (2, info.GetFiles ("*.abcd*").Length, "#7");
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // GetFiles (String)
+ public void GetFiles2_DirectoryDoesNotExist ()
+ {
+ string path = TempFolder + DSC + "DIT.GetFilesDirectoryNotFoundException2.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = new DirectoryInfo (path);
+ info.GetFiles ("*");
+ Assert.Fail ("#1");
+ } catch (DirectoryNotFoundException ex) {
+ // Could not find a part of '...'
+ Assert.AreEqual (typeof (DirectoryNotFoundException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#5");
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test] // GetFiles (String)
+ public void GetFiles2_SearchPattern_Null ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ try {
+ info.GetFiles (null);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("searchPattern", ex.ParamName, "#5");
+ }
+ }
+
+#if NET_2_0
+ [Test] // GetFiles (String, SearchOption)
+ public void GetFiles3_SearchPattern_Null ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ try {
+ info.GetFiles (null, SearchOption.TopDirectoryOnly);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("searchPattern", ex.ParamName, "#5");
+ }
+ }
+#endif
+
+ [Test]
+ public void GetFileSystemInfos2_SearchPattern_Null ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ try {
+ info.GetFileSystemInfos (null);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("searchPattern", ex.ParamName, "#5");
+ }
+ }
+
+ [Test]
+ public void MoveTo ()
+ {
+ string path1 = TempFolder + DSC + "DIT.MoveTo.Soucre.Test";
+ string path2 = TempFolder + DSC + "DIT.MoveTo.Dest.Test";
+ DeleteDir (path1);
+ DeleteDir (path2);
+
+ try {
+ DirectoryInfo info1 = Directory.CreateDirectory (path1);
+ DirectoryInfo info2 = new DirectoryInfo (path2);
+
+ Assert.IsTrue (info1.Exists, "#A1");
+ Assert.IsFalse (info2.Exists, "#A2");
+
+ info1.MoveTo (path2);
+ Assert.IsTrue (info1.Exists, "#B1");
+ Assert.IsFalse (info2.Exists, "#B2");
+
+ info1 = new DirectoryInfo (path1);
+ info2 = new DirectoryInfo (path2);
+ Assert.IsFalse (info1.Exists, "#C1");
+ Assert.IsTrue (info2.Exists, "#C2");
+ } finally {
+ DeleteDir (path1);
+ DeleteDir (path2);
+ }
+ }
+
+ [Test]
+ public void MoveTo_DestDirName_Empty ()
+ {
+ string path = TempFolder + DSC + "DIT.MoveToArgumentException1.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = Directory.CreateDirectory (path);
+ try {
+ info.MoveTo (string.Empty);
+ Assert.Fail ("#1");
+ } catch (ArgumentException ex) {
+ // Empty file name is not legal
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("destDirName", ex.ParamName, "#5");
+ }
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test]
+ public void MoveTo_DestDirName_Null ()
+ {
+ string path = TempFolder + DSC + "DIT.MoveToArgumentNullException.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = Directory.CreateDirectory (path);
+ try {
+ info.MoveTo (null);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("destDirName", ex.ParamName, "#5");
+ }
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test]
+ public void MoveTo_DestDirName_InvalidPathChars ()
+ {
+ string path = TempFolder + DSC + "DIT.MoveToArgumentException3.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = Directory.CreateDirectory (path);
+ try {
+ info.MoveTo (Path.InvalidPathChars [0].ToString ());
+ Assert.Fail ("#1");
+ } catch (ArgumentException ex) {
+ // The path contains illegal characters
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+ }
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test]
+ public void MoveTo_DestDirName_Whitespace ()
+ {
+ string path = TempFolder + DSC + "DIT.MoveToArgumentException2.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = Directory.CreateDirectory (path);
+ try {
+ info.MoveTo (" ");
+ Assert.Fail ("#1");
+ } catch (ArgumentException ex) {
+ // The path is not of a legal form
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+ }
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test]
+ public void MoveTo_SourceDest_NotDifferent ()
+ {
+ string path = TempFolder + DSC + "DIT.MoveToIOException1.Test";
+ DeleteDir (path);
+
+ try {
+ DirectoryInfo info = Directory.CreateDirectory (path);
+ try {
+ info.MoveTo (path);
+ Assert.Fail ("#A1");
+ } catch (IOException ex) {
+ // Source and destination path must be different
+ Assert.AreEqual (typeof (IOException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ }
+ } finally {
+ DeleteDir (path);
+ }
+
+ try {
+ DirectoryInfo info = new DirectoryInfo (path);
+ try {
+ info.MoveTo (path);
+ Assert.Fail ("#B1");
+ } catch (IOException ex) {
+ // Source and destination path must be different
+ Assert.AreEqual (typeof (IOException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ }
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test]
public void DirectoryNameWithSpace ()
{
- // check for Unix platforms - see FAQ for more details
- // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
- int platform = (int) Environment.OSVersion.Platform;
- if ((platform == 4) || (platform == 128)) {
- DeleteDir ("this has a space at the end ");
- string path = Path.Combine (TempFolder, "this has a space at the end ");
+ DeleteDir ("this has a space at the end ");
+ string path = Path.Combine (TempFolder, "this has a space at the end ");
+ Directory.CreateDirectory (path);
+ DirectoryInfo i = new DirectoryInfo (path);
+ string dummy = null;
+ foreach (FileInfo f in i.GetFiles ())
+ dummy = f.Name;
+ }
+
+ [Test]
+ public void LastWriteTime ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ info.LastWriteTime = new DateTime (2003, 6, 4, 6, 4, 0);
+
+ DateTime time = Directory.GetLastWriteTime (TempFolder);
+ Assert.AreEqual (2003, time.Year, "#A1");
+ Assert.AreEqual (6, time.Month, "#A2");
+ Assert.AreEqual (4, time.Day, "#A3");
+ Assert.AreEqual (6, time.Hour, "#A4");
+ Assert.AreEqual (4, time.Minute, "#A5");
+ Assert.AreEqual (0, time.Second, "#A6");
+
+ time = TimeZone.CurrentTimeZone.ToLocalTime (
+ Directory.GetLastWriteTimeUtc (TempFolder));
+ Assert.AreEqual (2003, time.Year, "#B1");
+ Assert.AreEqual (6, time.Month, "#B2");
+ Assert.AreEqual (4, time.Day, "#B3");
+ Assert.AreEqual (6, time.Hour, "#B4");
+ Assert.AreEqual (4, time.Minute, "#B5");
+ Assert.AreEqual (0, time.Second, "#B6");
+ }
+
+ [Test]
+ public void LastWriteTimeUtc ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ info.LastWriteTimeUtc = new DateTime (2003, 6, 4, 6, 4, 0);
+
+ DateTime time = TimeZone.CurrentTimeZone.ToUniversalTime (
+ Directory.GetLastWriteTime (TempFolder));
+ Assert.AreEqual (2003, time.Year, "#A1");
+ Assert.AreEqual (6, time.Month, "#A2");
+ Assert.AreEqual (4, time.Day, "#A3");
+ Assert.AreEqual (6, time.Hour, "#A4");
+ Assert.AreEqual (4, time.Minute, "#A5");
+ Assert.AreEqual (0, time.Second, "#A6");
+
+ time = Directory.GetLastWriteTimeUtc (TempFolder);
+ Assert.AreEqual (2003, time.Year, "#B1");
+ Assert.AreEqual (6, time.Month, "#B2");
+ Assert.AreEqual (4, time.Day, "#B3");
+ Assert.AreEqual (6, time.Hour, "#B4");
+ Assert.AreEqual (4, time.Minute, "#B5");
+ Assert.AreEqual (0, time.Second, "#B6");
+ }
+
+ [Test]
+ [Category("TargetJvmNotSupported")] // LastAccessTime not supported for TARGET_JVM
+ public void LastAccessTime ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ info.LastAccessTime = DateTime.Now;
+ }
+
+ [Test]
+ [Category("TargetJvmNotSupported")] // LastAccessTime not supported for TARGET_JVM
+ public void LastAccessTimeUtc ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ info.LastAccessTimeUtc = DateTime.Now;
+ }
+
+ [Test]
+ [Category("TargetJvmNotSupported")] // CreationTime not supported for TARGET_JVM
+ public void CreationTime ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ info.CreationTime = DateTime.Now;
+ }
+
+ [Test]
+ [Category("TargetJvmNotSupported")] // CreationTime not supported for TARGET_JVM
+ public void CreationTimeUtc ()
+ {
+ DirectoryInfo info = new DirectoryInfo (TempFolder);
+ info.CreationTimeUtc = DateTime.Now;
+ }
+
+ [Test]
+ public void Name_Bug76903 ()
+ {
+ CheckName ("/usr/share");
+ CheckName ("/usr/share/");
+ CheckName ("/usr/share/.");
+ CheckName ("/usr/share/./");
+ CheckName ("/usr/share/blabla/../");
+ CheckName ("/usr/lib/../share/.");
+ }
+
+ [Test]
+ public void Hang_76191 ()
+ {
+ // from bug #76191 (hangs on Windows)
+ DirectoryInfo di = new DirectoryInfo (Environment.CurrentDirectory);
+ Stack s = new Stack ();
+ s.Push (di);
+ while (di.Parent != null) {
+ di = di.Parent;
+ s.Push (di);
+ }
+ while (s.Count > 0) {
+ di = (DirectoryInfo) s.Pop ();
+ Assert.IsTrue (di.Exists, di.Name);
+ }
+ }
+
+ [Test]
+ public void WindowsSystem32_76191 ()
+ {
+ if (RunningOnUnix)
+ return;
+
+ Directory.SetCurrentDirectory (@"C:\WINDOWS\system32");
+ WindowsParentFullName ("C:", "C:\\WINDOWS");
+ WindowsParentFullName ("C:\\", null);
+ WindowsParentFullName ("C:\\dir", "C:\\");
+ WindowsParentFullName ("C:\\dir\\", "C:\\");
+ WindowsParentFullName ("C:\\dir\\dir", "C:\\dir");
+ WindowsParentFullName ("C:\\dir\\dir\\", "C:\\dir");
+ }
+
+ [Test]
+ public void Parent_Bug77090 ()
+ {
+ DirectoryInfo di = new DirectoryInfo ("/home");
+ if (Path.DirectorySeparatorChar == '\\') {
+ Assert.IsTrue (di.Parent.Name.EndsWith (":\\"), "#1");
+ } else
+ Assert.AreEqual ("/", di.Parent.Name, "#1");
+ Assert.IsNull (di.Parent.Parent, "#2");
+ }
+
+ [Test]
+ public void ToStringTest ()
+ {
+ DirectoryInfo info;
+
+ info = new DirectoryInfo ("Test");
+ Assert.AreEqual ("Test", info.ToString (), "#1");
+ info = new DirectoryInfo (TempFolder + DSC + "ToString.Test");
+ Assert.AreEqual (TempFolder + DSC + "ToString.Test", info.ToString ());
+ }
+
+ [Test]
+ public void Serialization ()
+ {
+ DirectoryInfo info;
+ SerializationInfo si;
+
+ info = new DirectoryInfo ("Test");
+ si = new SerializationInfo (typeof (DirectoryInfo), new FormatterConverter ());
+ info.GetObjectData (si, new StreamingContext ());
+
+ Assert.AreEqual (2, si.MemberCount, "#A1");
+ Assert.AreEqual ("Test", si.GetString ("OriginalPath"), "#A2");
+ Assert.AreEqual (Path.Combine (Directory.GetCurrentDirectory (), "Test"), si.GetString ("FullPath"), "#A3");
+
+ info = new DirectoryInfo (TempFolder);
+ si = new SerializationInfo (typeof (DirectoryInfo), new FormatterConverter ());
+ info.GetObjectData (si, new StreamingContext ());
+
+ Assert.AreEqual (2, si.MemberCount, "#B1");
+ Assert.AreEqual (TempFolder, si.GetString ("OriginalPath"), "#B2");
+ Assert.AreEqual (TempFolder, si.GetString ("FullPath"), "#B3");
+ }
+
+ [Test]
+ public void Deserialization ()
+ {
+ DirectoryInfo info = new DirectoryInfo ("Test");
+
+ MemoryStream ms = new MemoryStream ();
+ BinaryFormatter bf = new BinaryFormatter ();
+ bf.Serialize (ms, info);
+ ms.Position = 0;
+
+ DirectoryInfo clone = (DirectoryInfo) bf.Deserialize (ms);
+ Assert.AreEqual (info.Name, clone.Name, "#1");
+ Assert.AreEqual (info.FullName, clone.FullName, "#2");
+ }
+
+ // Needed so that UnixSymbolicLinkInfo doesn't have to
+ // be JITted on windows
+ private void Symlink_helper ()
+ {
+ string path = TempFolder + DSC + "DIT.Symlink";
+ string dir = path + DSC + "dir";
+ string link = path + DSC + "link";
+
+ DeleteDir (path);
+
+ try {
Directory.CreateDirectory (path);
- DirectoryInfo i = new DirectoryInfo (path);
- string dummy = null;
- foreach (FileInfo f in i.GetFiles ()) // This used to throw
- dummy = f.Name;
- }
- }\r
-\r
- [Test]\r
- public void LastWriteTime ()\r
- {\r
- DirectoryInfo info = new DirectoryInfo (TempFolder);\r
- info.LastWriteTime = new DateTime (2003, 6, 4, 6, 4, 0);\r
-\r
- DateTime time = Directory.GetLastWriteTime (TempFolder);\r
- AssertEquals ("test#01", 2003, time.Year);\r
- AssertEquals ("test#02", 6, time.Month);\r
- AssertEquals ("test#03", 4, time.Day);\r
- AssertEquals ("test#04", 6, time.Hour);\r
- AssertEquals ("test#05", 4, time.Minute);\r
- AssertEquals ("test#06", 0, time.Second);\r
-\r
- time = TimeZone.CurrentTimeZone.ToLocalTime (\r
- Directory.GetLastWriteTimeUtc (TempFolder));\r
- AssertEquals ("test#07", 2003, time.Year);\r
- AssertEquals ("test#08", 6, time.Month);\r
- AssertEquals ("test#09", 4, time.Day);\r
- AssertEquals ("test#10", 6, time.Hour);\r
- AssertEquals ("test#11", 4, time.Minute);\r
- AssertEquals ("test#12", 0, time.Second);\r
- }\r
-\r
- [Test]\r
- public void LastWriteTimeUtc ()\r
- {\r
- DirectoryInfo info = new DirectoryInfo (TempFolder);\r
- info.LastWriteTimeUtc = new DateTime (2003, 6, 4, 6, 4, 0);\r
-\r
- DateTime time = TimeZone.CurrentTimeZone.ToUniversalTime (\r
- Directory.GetLastWriteTime (TempFolder));\r
- AssertEquals ("test#1", 2003, time.Year);\r
- AssertEquals ("test#2", 6, time.Month);\r
- AssertEquals ("test#3", 4, time.Day);\r
- AssertEquals ("test#4", 6, time.Hour);\r
- AssertEquals ("test#5", 4, time.Minute);\r
- AssertEquals ("test#6", 0, time.Second);\r
-\r
- time = Directory.GetLastWriteTimeUtc (TempFolder);\r
- AssertEquals ("test#7", 2003, time.Year);\r
- AssertEquals ("test#8", 6, time.Month);\r
- AssertEquals ("test#9", 4, time.Day);\r
- AssertEquals ("test#10", 6, time.Hour);\r
- AssertEquals ("test#11", 4, time.Minute);\r
- AssertEquals ("test#12", 0, time.Second);\r
- }\r
-\r
- [Test]\r
- public void LastAccessTime ()\r
- {\r
- DirectoryInfo info = new DirectoryInfo (TempFolder);\r
- info.LastAccessTime = DateTime.Now;\r
- }\r
-\r
- [Test]\r
- public void LastAccessTimeUtc ()\r
- {\r
- DirectoryInfo info = new DirectoryInfo (TempFolder);\r
- info.LastAccessTimeUtc = DateTime.Now;\r
- }\r
-\r
- [Test]\r
- public void CreationTime ()\r
- {\r
- DirectoryInfo info = new DirectoryInfo (TempFolder);\r
- info.CreationTime = DateTime.Now;\r
- }\r
-\r
- [Test]\r
- public void CreationTimeUtc ()\r
- {\r
- DirectoryInfo info = new DirectoryInfo (TempFolder);\r
- info.CreationTimeUtc = DateTime.Now;\r
- }\r
-\r
-\r
- private void CheckName (string name)\r
- {\r
- DirectoryInfo di = new DirectoryInfo (name);\r
- AssertEquals (name + ".Name", "share", di.Name);\r
- AssertEquals (name + ".Parent.Name", "usr", di.Parent.Name);\r
- }\r
-\r
- [Test]\r
- public void Name_Bug76903 ()\r
- {\r
- CheckName ("/usr/share");\r
- CheckName ("/usr/share/");\r
- CheckName ("/usr/share/.");\r
- CheckName ("/usr/share/./");\r
- CheckName ("/usr/share/blabla/../");\r
- CheckName ("/usr/lib/../share/.");\r
- }\r
-\r
- [Test]\r
- public void Hang_76191 ()\r
- {\r
- // from bug #76191 (hangs on Windows)\r
- DirectoryInfo di = new DirectoryInfo (Environment.CurrentDirectory);\r
- Stack s = new Stack ();\r
- s.Push (di);\r
- while (di.Parent != null) {\r
- di = di.Parent;\r
- s.Push (di);\r
- }\r
- while (s.Count > 0) {\r
- di = (DirectoryInfo) s.Pop ();\r
- Assert (di.Name, di.Exists);\r
- }\r
- }\r
-\r
- private void WindowsParentFullName (string name, string expected)\r
- {\r
- DirectoryInfo di = new DirectoryInfo (name);\r
- if (di.Parent == null)\r
- AssertNull (name, expected);\r
- else\r
- AssertEquals (name, expected, di.Parent.FullName);\r
- }\r
-\r
- [Test]\r
- public void WindowsSystem32_76191 ()\r
- {\r
- // check for Unix platforms - see FAQ for more details\r
- // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F\r
- int platform = (int) Environment.OSVersion.Platform;\r
- if ((platform == 4) || (platform == 128))\r
- return;\r
-\r
- Directory.SetCurrentDirectory (@"C:\WINDOWS\system32");\r
- WindowsParentFullName ("C:", "C:\\WINDOWS");\r
- WindowsParentFullName ("C:\\", null);\r
- WindowsParentFullName ("C:\\dir", "C:\\");\r
- WindowsParentFullName ("C:\\dir\\", "C:\\");\r
- WindowsParentFullName ("C:\\dir\\dir", "C:\\dir");\r
- WindowsParentFullName ("C:\\dir\\dir\\", "C:\\dir");\r
- }
-
- [Test]\r
- public void Parent_Bug77090 ()\r
- {
- DirectoryInfo di = new DirectoryInfo ("/home");\r
- if (Path.DirectorySeparatorChar == '\\') {\r
- Assert ("/home parent (Windows path)", di.Parent.Name.EndsWith (":\\"));\r
- }\r
- else\r
- AssertEquals ("/home parent", "/", di.Parent.Name);\r
- AssertNull ("/home parent parent", di.Parent.Parent);\r
- }\r
- }\r
-}\r
+ Directory.CreateDirectory (dir);
+ Mono.Unix.UnixSymbolicLinkInfo li = new Mono.Unix.UnixSymbolicLinkInfo (link);
+ li.CreateSymbolicLinkTo (dir);
+
+ DirectoryInfo info = new DirectoryInfo (path);
+ DirectoryInfo[] dirs = info.GetDirectories ();
+ Assert.AreEqual (2, dirs.Length, "#1");
+ } finally {
+ DeleteDir (path);
+ }
+ }
+
+ [Test]
+ [Category ("NotDotNet")]
+ public void Symlink ()
+ {
+ // This test only applies to Linux and
+ // Linux-like platforms but mono-on-windows
+ // doesn't set the NotDotNet category
+ if (!RunningOnUnix) {
+ return;
+ }
+
+ Symlink_helper ();
+ }
+
+ static bool RunningOnUnix {
+ get {
+ int p = (int) Environment.OSVersion.Platform;
+ return ((p == 4) || (p == 128) || (p == 6));
+ }
+ }
+
+ void WindowsParentFullName (string name, string expected)
+ {
+ DirectoryInfo di = new DirectoryInfo (name);
+ if (di.Parent == null)
+ Assert.IsNull (expected, name);
+ else
+ Assert.AreEqual (expected, di.Parent.FullName, name);
+ }
+
+ void CheckName (string name)
+ {
+ DirectoryInfo di = new DirectoryInfo (name);
+ Assert.AreEqual ("share", di.Name, name + ".Name");
+ Assert.AreEqual ("usr", di.Parent.Name, name + ".Parent.Name");
+ }
+
+ void DeleteDir (string path)
+ {
+ if (Directory.Exists (path))
+ Directory.Delete (path, true);
+ }
+ }
+}
projects / mono.git / blobdiff