2 // System.IO.Directory
\r
5 // Ville Palo (vi64pa@kolumbus.fi)
\r
7 // (C) 2003 Ville Palo
\r
9 // TODO: Find out why ArgumentOutOfRange tests does not release directories properly
\r
13 using System.Collections.Generic;
\r
14 using System.Diagnostics;
\r
15 using System.Globalization;
\r
18 using System.Threading;
\r
20 #if !MONOTOUCH && !MOBILE_STATIC
\r
23 using NUnit.Framework;
\r
25 namespace MonoTests.System.IO
\r
29 public class DirectoryTest
\r
31 static readonly string TempSubFolder = "MonoTests.System.IO.Tests";
\r
32 string TempFolder = Path.Combine (Path.GetTempPath (), TempSubFolder);
\r
33 static readonly char DSC = Path.DirectorySeparatorChar;
\r
36 public void SetUp ()
\r
38 if (!Directory.Exists (TempFolder))
\r
39 Directory.CreateDirectory (TempFolder);
\r
41 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
\r
45 public void TearDown ()
\r
47 if (Directory.Exists (TempFolder))
\r
48 Directory.Delete (TempFolder, true);
\r
50 #if !MONOTOUCH && !MOBILE_STATIC
\r
52 public void EnumerateFilesListSymlinks ()
\r
55 Assert.Ignore ("Not running on Unix.");
\r
57 var afile = Path.Combine (TempFolder, "afile.src");
\r
58 var bfile = Path.Combine (TempFolder, "bfile.src");
\r
59 var cdir = Path.Combine (TempFolder, "cdir.src");
\r
61 File.AppendAllText (afile, "hello");
\r
62 var info = new UnixFileInfo (afile);
\r
63 info.CreateSymbolicLink (bfile);
\r
64 Directory.CreateDirectory (cdir);
\r
66 var files0 = Directory.GetFiles (TempFolder, "*.src");
\r
67 Array.Sort (files0);
\r
68 Assert.AreEqual (2, files0.Length, "#1");
\r
69 Assert.AreEqual (afile, files0 [0], "#2");
\r
70 Assert.AreEqual (bfile, files0 [1], "#3");
\r
72 var files1 = new List<string> (Directory.EnumerateFiles (TempFolder, "*.src")).ToArray ();
\r
73 Array.Sort (files1);
\r
74 Assert.AreEqual (2, files1.Length, "#1.b");
\r
75 Assert.AreEqual (afile, files1 [0], "#2.b");
\r
76 Assert.AreEqual (bfile, files1 [1], "#3.b");
\r
78 var files2 = Directory.GetFileSystemEntries (TempFolder, "*.src");
\r
79 Array.Sort (files2);
\r
80 Assert.AreEqual (3, files2.Length, "#1.c");
\r
81 Assert.AreEqual (afile, files2 [0], "#2.c");
\r
82 Assert.AreEqual (bfile, files2 [1], "#3.c");
\r
83 Assert.AreEqual (cdir, files2 [2], "#4.c");
\r
85 var files3 = new List<string> (Directory.EnumerateFileSystemEntries (TempFolder, "*.src")).ToArray ();
\r
86 Array.Sort (files3);
\r
87 Assert.AreEqual (3, files3.Length, "#1.d");
\r
88 Assert.AreEqual (afile, files3 [0], "#2.d");
\r
89 Assert.AreEqual (bfile, files3 [1], "#3.d");
\r
90 Assert.AreEqual (cdir, files3 [2], "#4.d");
\r
94 public void CreateDirectory ()
\r
96 string path = TempFolder + DSC + "DirectoryTest.Test.1";
\r
97 DeleteDirectory (path);
\r
99 DirectoryInfo info = Directory.CreateDirectory (path);
\r
100 Assert.IsTrue (info.Exists, "#1");
\r
101 Assert.AreEqual (".1", info.Extension, "#2");
\r
102 Assert.IsTrue (info.FullName.EndsWith ("DirectoryTest.Test.1"), "#3");
\r
103 Assert.AreEqual ("DirectoryTest.Test.1", info.Name, "#4");
\r
105 DeleteDirectory (path);
\r
109 /* Commented out: a directory named ":" is legal in unix
\r
111 public void CreateDirectoryNotSupportedException ()
\r
113 DeleteDirectory (":");
\r
115 DirectoryInfo info = Directory.CreateDirectory (":");
\r
116 Assert.Fail ("#1");
\r
117 } catch (ArgumentException ex) {
\r
118 // The path is not of a legal form
\r
119 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
\r
120 Assert.IsNull (ex.InnerException, "#3");
\r
121 Assert.IsNotNull (ex.Message, "#4");
\r
122 Assert.IsNull (ex.ParamName, "#5");
\r
124 DeleteDirectory (":");
\r
129 public void CreateDirectory_Path_Null ()
\r
132 Directory.CreateDirectory (null as string);
\r
133 Assert.Fail ("#1");
\r
134 } catch (ArgumentNullException ex) {
\r
135 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
\r
136 Assert.IsNull (ex.InnerException, "#3");
\r
137 Assert.IsNotNull (ex.Message, "#4");
\r
138 Assert.AreEqual ("path", ex.ParamName, "#5");
\r
143 public void CreateDirectory_Path_Empty ()
\r
146 Directory.CreateDirectory (string.Empty);
\r
147 Assert.Fail ("#1");
\r
148 } catch (ArgumentException ex) {
\r
149 // Path cannot be the empty string or all whitespace
\r
150 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
\r
151 Assert.IsNull (ex.InnerException, "#3");
\r
152 Assert.IsNotNull (ex.Message, "#4");
\r
153 Assert.IsNull (ex.ParamName, "#5");
\r
158 public void CreateDirectory_Path_Whitespace ()
\r
161 Directory.CreateDirectory (" ");
\r
162 Assert.Fail ("#1");
\r
163 } catch (ArgumentException ex) {
\r
164 // The path is not of a legal form
\r
165 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
\r
166 Assert.IsNull (ex.InnerException, "#3");
\r
167 Assert.IsNotNull (ex.Message, "#4");
\r
168 Assert.IsNull (ex.ParamName, "#5");
\r
173 public void CreateDirectory_Path_InvalidChars ()
\r
175 string path = TempFolder + DSC + "DirectoryTest.Test";
\r
176 DeleteDirectory (path);
\r
180 DirectoryInfo info = Directory.CreateDirectory (path);
\r
181 Assert.Fail ("#1");
\r
182 } catch (ArgumentException ex) {
\r
183 // The path contains illegal characters
\r
184 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
\r
185 Assert.IsNull (ex.InnerException, "#3");
\r
186 Assert.IsNotNull (ex.Message, "#4");
\r
187 Assert.IsNull (ex.ParamName, "#5");
\r
189 DeleteDirectory (path);
\r
194 public void CreateDirectoryAlreadyExists ()
\r
196 string path = TempFolder + DSC + "DirectoryTest.Test.Exists";
\r
197 DeleteDirectory (path);
\r
199 DirectoryInfo info1 = Directory.CreateDirectory (path);
\r
200 DirectoryInfo info2 = Directory.CreateDirectory (path);
\r
202 Assert.IsTrue (info2.Exists, "#1");
\r
203 Assert.IsTrue (info2.FullName.EndsWith ("DirectoryTest.Test.Exists"), "#2");
\r
204 Assert.AreEqual ("DirectoryTest.Test.Exists", info2.Name, "#3");
\r
206 DeleteDirectory (path);
\r
211 public void CreateDirectoryAlreadyExistsAsFile ()
\r
213 string path = TempFolder + DSC + "DirectoryTest.Test.ExistsAsFile";
\r
214 DeleteDirectory (path);
\r
217 FileStream fstream = File.Create (path);
\r
220 DirectoryInfo dinfo = Directory.CreateDirectory (path);
\r
221 Assert.Fail ("#1");
\r
222 } catch (IOException ex) {
\r
223 Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
\r
224 // exception message contains the path
\r
225 Assert.IsTrue (ex.Message.Contains (path), "#3");
\r
226 Assert.IsNull (ex.InnerException, "#4");
\r
228 DeleteDirectory (path);
\r
234 public void Delete ()
\r
236 string path = TempFolder + DSC + "DirectoryTest.Test.Delete.1";
\r
237 DeleteDirectory (path);
\r
239 Directory.CreateDirectory (path);
\r
240 Assert.IsTrue (Directory.Exists (path), "#1");
\r
242 Directory.CreateDirectory (path + DSC + "DirectoryTest.Test.Delete.1.2");
\r
243 Assert.IsTrue (Directory.Exists (path + DSC + "DirectoryTest.Test.Delete.1.2"), "#2");
\r
245 Directory.Delete (path + DSC + "DirectoryTest.Test.Delete.1.2");
\r
246 Assert.IsFalse (Directory.Exists (path + DSC + "DirectoryTest.Test.Delete.1.2"), "#3");
\r
247 Assert.IsTrue (Directory.Exists (path), "#4");
\r
249 Directory.Delete (path);
\r
250 Assert.IsFalse (Directory.Exists (path + DSC + "DirectoryTest.Test.Delete.1.2"), "#5");
\r
251 Assert.IsFalse (Directory.Exists (path), "#6");
\r
253 Directory.CreateDirectory (path);
\r
254 Directory.CreateDirectory (path + DSC + "DirectoryTest.Test.Delete.1.2");
\r
255 Assert.IsTrue (Directory.Exists (path + DSC + "DirectoryTest.Test.Delete.1.2"), "#7");
\r
256 Assert.IsTrue (Directory.Exists (path), "#8");
\r
258 Directory.Delete (path, true);
\r
259 Assert.IsFalse (Directory.Exists (path + DSC + "DirectoryTest.Test.Delete.1.2"), "#9");
\r
260 Assert.IsFalse (Directory.Exists (path), "#10");
\r
262 DeleteDirectory (path);
\r
267 [ExpectedException(typeof(ArgumentException))]
\r
268 public void DeleteArgumentException ()
\r
270 Directory.Delete (string.Empty);
\r
274 [ExpectedException(typeof(ArgumentException))]
\r
275 public void DeleteArgumentException2 ()
\r
277 Directory.Delete (" ");
\r
281 [ExpectedException(typeof(ArgumentException))]
\r
282 public void DeleteArgumentException3 ()
\r
284 string path = TempFolder + DSC + "DirectoryTest.Test.4";
\r
285 DeleteDirectory (path);
\r
287 path += Path.InvalidPathChars [0];
\r
288 Directory.Delete (path);
\r
292 [ExpectedException(typeof(ArgumentNullException))]
\r
293 public void DeleteArgumentNullException ()
\r
295 Directory.Delete (null as string);
\r
299 [ExpectedException(typeof(DirectoryNotFoundException))]
\r
300 public void DeleteDirectoryNotFoundException ()
\r
302 string path = TempFolder + DSC + "DirectoryTest.Test.5";
\r
303 DeleteDirectory (path);
\r
305 Directory.Delete (path);
\r
309 [ExpectedException(typeof(IOException))]
\r
310 public void DeleteArgumentException4 ()
\r
312 string path = TempFolder + DSC + "DirectoryTest.Test.6";
\r
313 DeleteDirectory (path);
\r
314 FileStream s = null;
\r
315 Directory.CreateDirectory (path);
\r
317 s = File.Create (path + DSC + "DirectoryTest.Test.6");
\r
318 Directory.Delete (path);
\r
322 DeleteDirectory (path);
\r
327 public void DeleteDirectoryOnExistingFileName ()
\r
329 string path = TempFolder + DSC + "DirectoryTest.Test.ExistsAsFile";
\r
330 DeleteDirectory (path);
\r
333 FileStream fstream = File.Create (path);
\r
336 Directory.Delete (path);
\r
337 Assert.Fail ("#1");
\r
339 catch (IOException ex) {
\r
340 Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
\r
341 // exception message DOES NOT contains the path
\r
342 Assert.IsFalse (ex.Message.IndexOf (path) >= 0, "#3");
\r
343 Assert.IsNull (ex.InnerException, "#4");
\r
346 DeleteDirectory (path);
\r
352 public void Exists ()
\r
354 Assert.IsFalse (Directory.Exists (null as string));
\r
357 #if !MOBILE // We don't support yet the Process class.
\r
358 [Test] // bug #78239
\r
359 public void ExistsAccessDenied ()
\r
361 if (!RunningOnUnix)
\r
362 Assert.Ignore ("Not running on Unix."); // this test does not work on Windows.
\r
364 string path = TempFolder + DSC + "ExistsAccessDenied";
\r
366 Directory.CreateDirectory (path);
\r
367 global::Mono.Posix.Syscall.chmod (path, 0);
\r
369 Assert.IsFalse (Directory.Exists(path + DSC + "b"));
\r
371 global::Mono.Posix.Syscall.chmod (path, (global::Mono.Posix.FileMode) 755);
\r
372 Directory.Delete (path);
\r
378 [ExpectedException(typeof(ArgumentNullException))]
\r
379 public void GetCreationTimeException1 ()
\r
381 Directory.GetCreationTime (null as string);
\r
385 [ExpectedException(typeof(ArgumentException))]
\r
386 public void GetCreationTimeException2 ()
\r
388 Directory.GetCreationTime (string.Empty);
\r
392 public void GetCreationTimeException_NonExistingPath ()
\r
394 string path = TempFolder + DSC + "DirectoryTest.GetCreationTime.1";
\r
395 DeleteDirectory (path);
\r
397 DateTime time = Directory.GetCreationTime (path);
\r
399 DateTime expectedTime = (new DateTime (1601, 1, 1)).ToLocalTime ();
\r
400 Assert.AreEqual (expectedTime.Year, time.Year, "#1");
\r
401 Assert.AreEqual (expectedTime.Month, time.Month, "#2");
\r
402 Assert.AreEqual (expectedTime.Day, time.Day, "#3");
\r
403 Assert.AreEqual (expectedTime.Hour, time.Hour, "#4");
\r
404 Assert.AreEqual (expectedTime.Second, time.Second, "#5");
\r
405 Assert.AreEqual (expectedTime.Millisecond, time.Millisecond, "#6");
\r
407 DeleteDirectory (path);
\r
412 [ExpectedException(typeof(ArgumentException))]
\r
413 public void GetCreationTimeException4 ()
\r
415 Directory.GetCreationTime (" ");
\r
419 [ExpectedException(typeof(ArgumentException))]
\r
420 public void GetCreationTimeException5 ()
\r
422 Directory.GetCreationTime (Path.InvalidPathChars [0].ToString ());
\r
426 [ExpectedException(typeof(ArgumentNullException))]
\r
427 public void GetCreationTimeUtcException1 ()
\r
429 Directory.GetCreationTimeUtc (null as string);
\r
433 [ExpectedException(typeof(ArgumentException))]
\r
434 public void GetCreationTimeUtcException2 ()
\r
436 Directory.GetCreationTimeUtc (string.Empty);
\r
440 public void GetCreationTimeUtc_NonExistingPath ()
\r
442 string path = TempFolder + DSC + "DirectoryTest.GetCreationTimeUtc.1";
\r
443 DeleteDirectory (path);
\r
446 DateTime time = Directory.GetCreationTimeUtc (path);
\r
448 Assert.AreEqual (1601, time.Year, "#1");
\r
449 Assert.AreEqual (1, time.Month, "#2");
\r
450 Assert.AreEqual (1, time.Day, "#3");
\r
451 Assert.AreEqual (0, time.Hour, "#4");
\r
452 Assert.AreEqual (0, time.Second, "#5");
\r
453 Assert.AreEqual (0, time.Millisecond, "#6");
\r
455 DeleteDirectory (path);
\r
460 [ExpectedException(typeof(ArgumentException))]
\r
461 public void GetCreationTimeUtcException4 ()
\r
463 Directory.GetCreationTimeUtc (" ");
\r
467 [ExpectedException(typeof(ArgumentException))]
\r
468 public void GetCreationTimeUtcException5 ()
\r
470 Directory.GetCreationTime (Path.InvalidPathChars [0].ToString ());
\r
474 [ExpectedException(typeof(ArgumentNullException))]
\r
475 public void GetLastAccessTime_Null ()
\r
477 Directory.GetLastAccessTime (null as string);
\r
481 [ExpectedException(typeof(ArgumentException))]
\r
482 public void GetLastAccessTimeException2 ()
\r
484 Directory.GetLastAccessTime (string.Empty);
\r
488 public void GetLastAccessTime_NonExistingPath ()
\r
490 string path = TempFolder + DSC + "DirectoryTest.GetLastAccessTime.1";
\r
491 DeleteDirectory (path);
\r
494 DateTime time = Directory.GetLastAccessTime (path);
\r
496 DateTime expectedTime = (new DateTime (1601, 1, 1)).ToLocalTime ();
\r
497 Assert.AreEqual (expectedTime.Year, time.Year, "#1");
\r
498 Assert.AreEqual (expectedTime.Month, time.Month, "#2");
\r
499 Assert.AreEqual (expectedTime.Day, time.Day, "#3");
\r
500 Assert.AreEqual (expectedTime.Hour, time.Hour, "#4");
\r
501 Assert.AreEqual (expectedTime.Second, time.Second, "#5");
\r
502 Assert.AreEqual (expectedTime.Millisecond, time.Millisecond, "#6");
\r
504 DeleteDirectory (path);
\r
509 [ExpectedException(typeof(ArgumentException))]
\r
510 public void GetLastAccessTimeException4 ()
\r
512 Directory.GetLastAccessTime (" ");
\r
516 [ExpectedException(typeof(ArgumentException))]
\r
517 public void GetLastAccessTimeException5 ()
\r
519 Directory.GetLastAccessTime (Path.InvalidPathChars [0].ToString ());
\r
523 [ExpectedException(typeof(ArgumentNullException))]
\r
524 public void GetLastAccessTimeUtc_Null ()
\r
526 Directory.GetLastAccessTimeUtc (null as string);
\r
530 [ExpectedException(typeof(ArgumentException))]
\r
531 public void GetLastAccessTimeUtcException2 ()
\r
533 Directory.GetLastAccessTimeUtc (string.Empty);
\r
537 public void GetLastAccessTimeUtc_NonExistingPath ()
\r
539 string path = TempFolder + DSC + "DirectoryTest.GetLastAccessTimeUtc.1";
\r
540 DeleteDirectory (path);
\r
542 DateTime time = Directory.GetLastAccessTimeUtc (path);
\r
544 Assert.AreEqual (1601, time.Year, "#1");
\r
545 Assert.AreEqual (1, time.Month, "#2");
\r
546 Assert.AreEqual (1, time.Day, "#3");
\r
547 Assert.AreEqual (0, time.Hour, "#4");
\r
548 Assert.AreEqual (0, time.Second, "#5");
\r
549 Assert.AreEqual (0, time.Millisecond, "#6");
\r
551 DeleteDirectory (path);
\r
556 [ExpectedException(typeof(ArgumentException))]
\r
557 public void GetLastAccessTimeUtcException4 ()
\r
559 Directory.GetLastAccessTimeUtc (" ");
\r
563 [ExpectedException(typeof(ArgumentException))]
\r
564 public void GetLastAccessTimeUtcException5 ()
\r
566 Directory.GetLastAccessTimeUtc (Path.InvalidPathChars [0].ToString ());
\r
570 [ExpectedException(typeof(ArgumentNullException))]
\r
571 public void GetLastWriteTimeException1 ()
\r
573 Directory.GetLastWriteTime (null as string);
\r
577 [ExpectedException(typeof(ArgumentException))]
\r
578 public void GetLastWriteTimeException2 ()
\r
580 Directory.GetLastWriteTime (string.Empty);
\r
584 public void GetLastWriteTime_NonExistingPath ()
\r
586 string path = TempFolder + DSC + "DirectoryTest.GetLastWriteTime.1";
\r
587 DeleteDirectory (path);
\r
589 DateTime time = Directory.GetLastWriteTime (path);
\r
591 DateTime expectedTime = (new DateTime (1601, 1, 1)).ToLocalTime ();
\r
592 Assert.AreEqual (expectedTime.Year, time.Year, "#1");
\r
593 Assert.AreEqual (expectedTime.Month, time.Month, "#2");
\r
594 Assert.AreEqual (expectedTime.Day, time.Day, "#3");
\r
595 Assert.AreEqual (expectedTime.Hour, time.Hour, "#4");
\r
596 Assert.AreEqual (expectedTime.Second, time.Second, "#5");
\r
597 Assert.AreEqual (expectedTime.Millisecond, time.Millisecond, "#6");
\r
599 DeleteDirectory (path);
\r
604 [ExpectedException(typeof(ArgumentException))]
\r
605 public void GetLastWriteTimeException4 ()
\r
607 Directory.GetLastWriteTime (" ");
\r
611 [ExpectedException(typeof(ArgumentException))]
\r
612 public void GetLastWriteTimeException5 ()
\r
614 Directory.GetLastWriteTime (Path.InvalidPathChars [0].ToString ());
\r
618 [ExpectedException(typeof(ArgumentNullException))]
\r
619 public void GetLastWriteTimeUtcException1 ()
\r
621 Directory.GetLastWriteTimeUtc (null as string);
\r
625 [ExpectedException(typeof(ArgumentException))]
\r
626 public void GetLastWriteTimeUtcException2 ()
\r
628 Directory.GetLastWriteTimeUtc (string.Empty);
\r
632 public void GetLastWriteTimeUtc_NonExistingPath ()
\r
634 string path = TempFolder + DSC + "DirectoryTest.GetLastWriteTimeUtc.1";
\r
635 DeleteDirectory (path);
\r
637 DateTime time = Directory.GetLastWriteTimeUtc (path);
\r
639 Assert.AreEqual (1601, time.Year, "#1");
\r
640 Assert.AreEqual (1, time.Month, "#2");
\r
641 Assert.AreEqual (1, time.Day, "#3");
\r
642 Assert.AreEqual (0, time.Hour, "#4");
\r
643 Assert.AreEqual (0, time.Second, "#5");
\r
644 Assert.AreEqual (0, time.Millisecond, "#6");
\r
646 DeleteDirectory (path);
\r
652 [ExpectedException(typeof(ArgumentException))]
\r
653 public void GetLastWriteTimeUtcException4 ()
\r
655 Directory.GetLastWriteTimeUtc (" ");
\r
659 [ExpectedException(typeof(ArgumentException))]
\r
660 public void GetLastWriteTimeUtcException5 ()
\r
662 Directory.GetLastWriteTimeUtc (Path.InvalidPathChars[0].ToString ());
\r
666 public void Move_DestDirName_Empty ()
\r
669 Directory.Move (TempFolder, string.Empty);
\r
670 Assert.Fail ("#A1");
\r
671 } catch (ArgumentException ex) {
\r
672 // Empty file name is not legal
\r
673 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
\r
674 Assert.IsNull (ex.InnerException, "#A3");
\r
675 Assert.IsNotNull (ex.Message, "#A4");
\r
676 Assert.IsNotNull (ex.ParamName, "#A5");
\r
677 Assert.AreEqual ("destDirName", ex.ParamName, "#A6");
\r
681 Directory.Move (TempFolder, " ");
\r
682 Assert.Fail ("#B1");
\r
683 } catch (ArgumentException ex) {
\r
684 // The path is not of a legal form
\r
685 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
\r
686 Assert.IsNull (ex.InnerException, "#B3");
\r
687 Assert.IsNotNull (ex.Message, "#B4");
\r
692 public void Move_DestDirName_Null ()
\r
695 Directory.Move (TempFolder, (string) null);
\r
696 Assert.Fail ("#1");
\r
697 } catch (ArgumentNullException ex) {
\r
698 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
\r
699 Assert.IsNull (ex.InnerException, "#3");
\r
700 Assert.IsNotNull (ex.Message, "#4");
\r
701 Assert.IsNotNull (ex.ParamName, "#5");
\r
702 Assert.AreEqual ("destDirName", ex.ParamName, "#6");
\r
707 public void Move_SourceDirName_Empty ()
\r
710 Directory.Move (string.Empty, TempFolder);
\r
711 Assert.Fail ("#A1");
\r
712 } catch (ArgumentException ex) {
\r
713 // Empty file name is not legal
\r
714 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
\r
715 Assert.IsNull (ex.InnerException, "#A3");
\r
716 Assert.IsNotNull (ex.Message, "#A4");
\r
717 Assert.IsNotNull (ex.ParamName, "#A5");
\r
718 Assert.AreEqual ("sourceDirName", ex.ParamName, "#A6");
\r
722 Directory.Move (" ", TempFolder);
\r
723 Assert.Fail ("#B1");
\r
724 } catch (ArgumentException ex) {
\r
725 // The path is not of a legal form
\r
726 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
\r
727 Assert.IsNull (ex.InnerException, "#B3");
\r
728 Assert.IsNotNull (ex.Message, "#B4");
\r
733 public void Move_SourceDirName_Null ()
\r
736 Directory.Move ((string) null, TempFolder);
\r
737 Assert.Fail ("#1");
\r
738 } catch (ArgumentNullException ex) {
\r
739 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
\r
740 Assert.IsNull (ex.InnerException, "#3");
\r
741 Assert.IsNotNull (ex.Message, "#4");
\r
742 Assert.IsNotNull (ex.ParamName, "#5");
\r
743 Assert.AreEqual ("sourceDirName", ex.ParamName, "#6");
\r
748 public void MoveDirectory ()
\r
750 string path = TempFolder + DSC + "DirectoryTest.Test.9";
\r
751 string path2 = TempFolder + DSC + "DirectoryTest.Test.10";
\r
752 DeleteDirectory (path);
\r
753 DeleteDirectory (path2);
\r
755 Directory.CreateDirectory (path);
\r
756 Directory.CreateDirectory (path + DSC + "dir");
\r
757 Assert.IsTrue (Directory.Exists (path + DSC + "dir"), "#1");
\r
759 Directory.Move (path, path2);
\r
760 Assert.IsFalse (Directory.Exists (path + DSC + "dir"), "#2");
\r
761 Assert.IsTrue (Directory.Exists (path2 + DSC + "dir"), "#3");
\r
763 DeleteDirectory (path);
\r
764 DeleteDirectory (path2);
\r
765 if (Directory.Exists (path2 + DSC + "dir"))
\r
766 Directory.Delete (path2 + DSC + "dir", true);
\r
771 [ExpectedException (typeof (IOException))]
\r
772 public void MoveDirectory_Same ()
\r
774 string path = TempFolder + DSC + "DirectoryTest.Test.8";
\r
775 DeleteDirectory (path);
\r
777 Directory.Move (path, path);
\r
779 DeleteDirectory (path);
\r
784 public void MoveFile ()
\r
786 string tempFile1 = Path.Combine (TempFolder, "temp1.txt");
\r
787 string tempFile2 = Path.Combine (TempFolder, "temp2.txt");
\r
789 using (StreamWriter sw = File.CreateText (tempFile1)) {
\r
790 sw.Write ("temp1");
\r
792 Assert.IsFalse (File.Exists (tempFile2), "#1");
\r
793 Directory.Move (tempFile1, tempFile2);
\r
794 Assert.IsFalse (File.Exists (tempFile1), "#2");
\r
795 Assert.IsTrue (File.Exists (tempFile2), "#3");
\r
796 using (StreamReader sr = File.OpenText (tempFile2)) {
\r
797 Assert.AreEqual ("temp1", sr.ReadToEnd (), "#4");
\r
802 public void MoveFile_DestDir_Exists ()
\r
804 string tempFile = Path.Combine (TempFolder, "temp1.txt");
\r
805 string tempDir = Path.Combine (TempFolder, "temp2");
\r
807 using (StreamWriter sw = File.CreateText (tempFile)) {
\r
808 sw.Write ("temp1");
\r
810 Directory.CreateDirectory (tempDir);
\r
813 Directory.Move (tempFile, tempDir);
\r
814 Assert.Fail ("#A1");
\r
815 } catch (IOException ex) {
\r
816 // Cannot create a file when that file already exists
\r
817 Assert.AreEqual (typeof (IOException), ex.GetType (), "#A2");
\r
818 Assert.IsNull (ex.InnerException, "#A3");
\r
819 Assert.IsNotNull (ex.Message, "#A4");
\r
822 Assert.IsTrue (File.Exists (tempFile), "#B1");
\r
823 Assert.IsFalse (File.Exists (tempDir), "#B2");
\r
824 Assert.IsTrue (Directory.Exists (tempDir), "#B3");
\r
828 public void MoveFile_DestFile_Exists ()
\r
830 string tempFile1 = Path.Combine (TempFolder, "temp1.txt");
\r
831 string tempFile2 = Path.Combine (TempFolder, "temp2.txt");
\r
833 using (StreamWriter sw = File.CreateText (tempFile1)) {
\r
834 sw.Write ("temp1");
\r
836 using (StreamWriter sw = File.CreateText (tempFile2)) {
\r
837 sw.Write ("temp2");
\r
841 Directory.Move (tempFile1, tempFile2);
\r
842 Assert.Fail ("#A1");
\r
843 } catch (IOException ex) {
\r
844 // Cannot create a file when that file already exists
\r
845 Assert.AreEqual (typeof (IOException), ex.GetType (), "#A2");
\r
846 Assert.IsNull (ex.InnerException, "#A3");
\r
847 Assert.IsNotNull (ex.Message, "#A4");
\r
850 Assert.IsTrue (File.Exists (tempFile1), "#B1");
\r
851 using (StreamReader sr = File.OpenText (tempFile1)) {
\r
852 Assert.AreEqual ("temp1", sr.ReadToEnd (), "#B2");
\r
855 Assert.IsTrue (File.Exists (tempFile2), "#C1");
\r
856 using (StreamReader sr = File.OpenText (tempFile2)) {
\r
857 Assert.AreEqual ("temp2", sr.ReadToEnd (), "#C2");
\r
862 public void MoveFile_Same ()
\r
864 string tempFile = Path.Combine (TempFolder, "temp.txt");
\r
867 Directory.Move (tempFile, tempFile);
\r
868 Assert.Fail ("#1");
\r
869 } catch (IOException ex) {
\r
870 // Source and destination path must be different
\r
871 Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
\r
872 Assert.IsNull (ex.InnerException, "#3");
\r
873 Assert.IsNotNull (ex.Message, "#4");
\r
878 [ExpectedException(typeof(ArgumentException))]
\r
879 [Ignore ("On IA64, causes nunit to abort due to bug #76388")]
\r
880 public void MoveException4 ()
\r
882 string path = TempFolder + DSC + "DirectoryTest.Test.13";
\r
883 path += Path.InvalidPathChars [0];
\r
884 string path2 = TempFolder + DSC + "DirectoryTest.Test.13";
\r
885 DeleteDirectory (path);
\r
886 DeleteDirectory (path2);
\r
888 Directory.CreateDirectory (path2);
\r
889 Directory.Move (path2, path);
\r
891 DeleteDirectory (path);
\r
892 DeleteDirectory (path2);
\r
897 [ExpectedException(typeof(DirectoryNotFoundException))]
\r
898 public void MoveException5 ()
\r
900 string path = TempFolder + DSC + "DirectoryTest.Test.14";
\r
901 DeleteDirectory (path);
\r
903 Directory.Move (path, path + "Test.Test");
\r
905 DeleteDirectory (path);
\r
906 DeleteDirectory (path + "Test.Test");
\r
911 [ExpectedException(typeof(IOException))]
\r
912 public void MoveDirectory_Dest_SubDir ()
\r
914 string path = TempFolder + DSC + "DirectoryTest.Test.15";
\r
915 DeleteDirectory (path);
\r
917 Directory.CreateDirectory (path);
\r
918 Directory.Move (path, path + DSC + "dir");
\r
920 DeleteDirectory (path);
\r
921 DeleteDirectory (path + DSC + "dir");
\r
926 [ExpectedException (typeof (IOException))]
\r
927 public void MoveDirectory_Dest_Exists ()
\r
929 string path = TempFolder + DSC + "DirectoryTest.Test.16";
\r
930 string path2 = TempFolder + DSC + "DirectoryTest.Test.17";
\r
932 DeleteDirectory (path);
\r
933 DeleteDirectory (path2);
\r
935 Directory.CreateDirectory (path);
\r
936 Directory.CreateDirectory (path2);
\r
937 Directory.Move (path, path2);
\r
939 DeleteDirectory (path);
\r
940 DeleteDirectory (path2);
\r
945 public void CreationTime ()
\r
948 Assert.Ignore ("Unix doesn't support CreationTime");
\r
950 string path = TempFolder + DSC + "DirectoryTest.CreationTime.1";
\r
951 DeleteDirectory (path);
\r
954 Directory.CreateDirectory (path);
\r
955 Directory.SetCreationTime (path, new DateTime (2003, 6, 4, 6, 4, 0));
\r
957 DateTime time = Directory.GetCreationTime (path);
\r
958 Assert.AreEqual (2003, time.Year, "#A1");
\r
959 Assert.AreEqual (6, time.Month, "#A2");
\r
960 Assert.AreEqual (4, time.Day, "#A3");
\r
961 Assert.AreEqual (6, time.Hour, "#A4");
\r
962 Assert.AreEqual (4, time.Minute, "#A5");
\r
963 Assert.AreEqual (0, time.Second, "#A6");
\r
965 time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetCreationTimeUtc (path));
\r
966 Assert.AreEqual (2003, time.Year, "#B1");
\r
967 Assert.AreEqual (6, time.Month, "#B2");
\r
968 Assert.AreEqual (4, time.Day, "#B3");
\r
969 Assert.AreEqual (6, time.Hour, "#B4");
\r
970 Assert.AreEqual (4, time.Minute, "#B5");
\r
971 Assert.AreEqual (0, time.Second, "#B6");
\r
973 Directory.SetCreationTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));
\r
974 time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetCreationTime (path));
\r
975 Assert.AreEqual (2003, time.Year, "#C1");
\r
976 Assert.AreEqual (6, time.Month, "#C2");
\r
977 Assert.AreEqual (4, time.Day, "#C3");
\r
978 Assert.AreEqual (6, time.Hour, "#C4");
\r
979 Assert.AreEqual (4, time.Minute, "#C5");
\r
980 Assert.AreEqual (0, time.Second, "#C6");
\r
982 time = Directory.GetCreationTimeUtc (path);
\r
983 Assert.AreEqual (2003, time.Year, "#D1");
\r
984 Assert.AreEqual (6, time.Month, "#D2");
\r
985 Assert.AreEqual (4, time.Day, "#D3");
\r
986 Assert.AreEqual (6, time.Hour, "#D4");
\r
987 Assert.AreEqual (4, time.Minute, "#D5");
\r
988 Assert.AreEqual (0, time.Second, "#D6");
\r
990 DeleteDirectory (path);
\r
995 public void LastAccessTime ()
\r
997 string path = TempFolder + DSC + "DirectoryTest.AccessTime.1";
\r
998 DeleteDirectory (path);
\r
1001 Directory.CreateDirectory (path);
\r
1002 Directory.SetLastAccessTime (path, new DateTime (2003, 6, 4, 6, 4, 0));
\r
1004 DateTime time = Directory.GetLastAccessTime (path);
\r
1005 Assert.AreEqual (2003, time.Year, "#A1");
\r
1006 Assert.AreEqual (6, time.Month, "#A2");
\r
1007 Assert.AreEqual (4, time.Day, "#A3");
\r
1008 Assert.AreEqual (6, time.Hour, "#A4");
\r
1009 Assert.AreEqual (4, time.Minute, "#A5");
\r
1010 Assert.AreEqual (0, time.Second, "#A6");
\r
1012 time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetLastAccessTimeUtc (path));
\r
1013 Assert.AreEqual (2003, time.Year, "#B1");
\r
1014 Assert.AreEqual (6, time.Month, "#B2");
\r
1015 Assert.AreEqual (4, time.Day, "#B3");
\r
1016 Assert.AreEqual (6, time.Hour, "#B4");
\r
1017 Assert.AreEqual (4, time.Minute, "#B5");
\r
1018 Assert.AreEqual (0, time.Second, "#B6");
\r
1020 Directory.SetLastAccessTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));
\r
1021 time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetLastAccessTime (path));
\r
1022 Assert.AreEqual (2003, time.Year, "#C1");
\r
1023 Assert.AreEqual (6, time.Month, "#C2");
\r
1024 Assert.AreEqual (4, time.Day, "#C3");
\r
1025 Assert.AreEqual (6, time.Hour, "#C4");
\r
1026 Assert.AreEqual (4, time.Minute, "#C5");
\r
1027 Assert.AreEqual (0, time.Second, "#C6");
\r
1029 time = Directory.GetLastAccessTimeUtc (path);
\r
1030 Assert.AreEqual (2003, time.Year, "#D1");
\r
1031 Assert.AreEqual (6, time.Month, "#D2");
\r
1032 Assert.AreEqual (4, time.Day, "#D3");
\r
1033 Assert.AreEqual (6, time.Hour, "#D4");
\r
1034 Assert.AreEqual (4, time.Minute, "#D5");
\r
1035 Assert.AreEqual (0, time.Second, "#D6");
\r
1037 DeleteDirectory (path);
\r
1042 public void LastWriteTime ()
\r
1044 string path = TempFolder + DSC + "DirectoryTest.WriteTime.1";
\r
1045 DeleteDirectory (path);
\r
1048 Directory.CreateDirectory (path);
\r
1049 Directory.SetLastWriteTime (path, new DateTime (2003, 6, 4, 6, 4, 0));
\r
1051 DateTime time = Directory.GetLastWriteTime (path);
\r
1052 Assert.AreEqual (2003, time.Year, "#A1");
\r
1053 Assert.AreEqual (6, time.Month, "#A2");
\r
1054 Assert.AreEqual (4, time.Day, "#A3");
\r
1055 Assert.AreEqual (6, time.Hour, "#A4");
\r
1056 Assert.AreEqual (4, time.Minute, "#A5");
\r
1057 Assert.AreEqual (0, time.Second, "#A6");
\r
1059 time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetLastWriteTimeUtc (path));
\r
1060 Assert.AreEqual (2003, time.Year, "#B1");
\r
1061 Assert.AreEqual (6, time.Month, "#B2");
\r
1062 Assert.AreEqual (4, time.Day, "#B3");
\r
1063 Assert.AreEqual (6, time.Hour, "#B4");
\r
1064 Assert.AreEqual (4, time.Minute, "#B5");
\r
1065 Assert.AreEqual (0, time.Second, "#B6");
\r
1067 Directory.SetLastWriteTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));
\r
1068 time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetLastWriteTime (path));
\r
1069 Assert.AreEqual (2003, time.Year, "#C1");
\r
1070 Assert.AreEqual (6, time.Month, "#C2");
\r
1071 Assert.AreEqual (4, time.Day, "#C3");
\r
1072 Assert.AreEqual (6, time.Hour, "#C4");
\r
1073 Assert.AreEqual (4, time.Minute, "#C5");
\r
1074 Assert.AreEqual (0, time.Second, "#C6");
\r
1076 time = Directory.GetLastWriteTimeUtc (path);
\r
1077 Assert.AreEqual (2003, time.Year, "#D1");
\r
1078 Assert.AreEqual (6, time.Month, "#D2");
\r
1079 Assert.AreEqual (4, time.Day, "#D3");
\r
1080 Assert.AreEqual (6, time.Hour, "#D4");
\r
1081 Assert.AreEqual (4, time.Minute, "#D5");
\r
1082 Assert.AreEqual (0, time.Second, "#D6");
\r
1084 DeleteDirectory (path);
\r
1089 [ExpectedException(typeof(ArgumentNullException))]
\r
1090 public void SetLastWriteTimeException1 ()
\r
1092 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1093 Directory.SetLastWriteTime (null as string, time);
\r
1097 [ExpectedException(typeof(ArgumentException))]
\r
1098 public void SetLastWriteTimeException2 ()
\r
1100 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1101 Directory.SetLastWriteTime (string.Empty, time);
\r
1105 [ExpectedException(typeof(FileNotFoundException))]
\r
1106 public void SetLastWriteTimeException3 ()
\r
1108 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1109 string path = TempFolder + DSC + "DirectoryTest.SetLastWriteTime.2";
\r
1110 DeleteDirectory (path);
\r
1112 Directory.SetLastWriteTime (path, time);
\r
1114 DeleteDirectory (path);
\r
1119 [ExpectedException(typeof(ArgumentException))]
\r
1120 public void SetLastWriteTimeException4 ()
\r
1122 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1123 Directory.SetLastWriteTime (" ", time);
\r
1127 [ExpectedException(typeof(ArgumentException))]
\r
1128 public void SetLastWriteTimeException5 ()
\r
1130 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1131 Directory.SetLastWriteTime (Path.InvalidPathChars [0].ToString (), time);
\r
1135 // [ExpectedException(typeof(ArgumentOutOfRangeException))]
\r
1136 // public void SetLastWriteTimeException6 ()
\r
1138 // DateTime time = new DateTime (1003, 4, 6, 6, 4, 2);
\r
1139 // string path = TempFolder + Path.DirectorySeparatorChar + "DirectoryTest.SetLastWriteTime.1";
\r
1142 // if (!Directory.Exists (path))
\r
1143 // Directory.CreateDirectory (path);
\r
1145 // Directory.SetLastWriteTime (path, time);
\r
1147 // DeleteDirectory (path);
\r
1153 [ExpectedException(typeof(ArgumentNullException))]
\r
1154 public void SetLastWriteTimeUtcException1 ()
\r
1156 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1157 Directory.SetLastWriteTimeUtc (null as string, time);
\r
1161 [ExpectedException(typeof(ArgumentException))]
\r
1162 public void SetLastWriteTimeUtcException2 ()
\r
1164 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1165 Directory.SetLastWriteTimeUtc (string.Empty, time);
\r
1169 [ExpectedException(typeof(FileNotFoundException))]
\r
1170 public void SetLastWriteTimeUtcException3 ()
\r
1172 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1173 string path = TempFolder + DSC + "DirectoryTest.SetLastWriteTimeUtc.2";
\r
1174 DeleteDirectory (path);
\r
1176 Directory.SetLastWriteTimeUtc (path, time);
\r
1178 DeleteDirectory (path);
\r
1183 [ExpectedException(typeof(ArgumentException))]
\r
1184 public void SetLastWriteTimeUtcException4 ()
\r
1186 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1187 Directory.SetLastWriteTimeUtc (" ", time);
\r
1191 [ExpectedException(typeof(ArgumentException))]
\r
1192 public void SetLastWriteTimeUtcException5 ()
\r
1194 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1195 Directory.SetLastWriteTimeUtc (Path.InvalidPathChars [0].ToString (), time);
\r
1199 // [ExpectedException(typeof(ArgumentOutOfRangeException))]
\r
1200 // public void SetLastWriteTimeUtcException6 ()
\r
1202 // DateTime time = new DateTime (1000, 4, 6, 6, 4, 2);
\r
1203 // string path = TempFolder + DSC + "DirectoryTest.SetLastWriteTimeUtc.1";
\r
1205 // if (!Directory.Exists (path))
\r
1206 // Directory.CreateDirectory (path);
\r
1208 // Directory.SetLastWriteTimeUtc (path, time);
\r
1210 // DeleteDirectory (path);
\r
1215 [ExpectedException(typeof(ArgumentNullException))]
\r
1216 public void SetLastAccessTimeException1 ()
\r
1218 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1219 Directory.SetLastAccessTime (null as string, time);
\r
1223 [ExpectedException(typeof(ArgumentException))]
\r
1224 public void SetLastAccessTimeException2 ()
\r
1226 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1227 Directory.SetLastAccessTime (string.Empty, time);
\r
1231 [ExpectedException(typeof(FileNotFoundException))]
\r
1232 public void SetLastAccessTimeException3 ()
\r
1234 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1235 string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTime.2";
\r
1236 DeleteDirectory (path);
\r
1238 Directory.SetLastAccessTime (path, time);
\r
1240 DeleteDirectory (path);
\r
1245 [ExpectedException(typeof(ArgumentException))]
\r
1246 public void SetLastAccessTimeException4 ()
\r
1248 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1249 Directory.SetLastAccessTime (" ", time);
\r
1253 [ExpectedException(typeof(ArgumentException))]
\r
1254 public void SetLastAccessTimeException5 ()
\r
1256 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1257 Directory.SetLastAccessTime (Path.InvalidPathChars [0].ToString (), time);
\r
1261 // [ExpectedException(typeof(ArgumentOutOfRangeException))]
\r
1262 // public void SetLastAccessTimeException6 ()
\r
1264 // DateTime time = new DateTime (1003, 4, 6, 6, 4, 2);
\r
1265 // string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTime.1";
\r
1267 // if (!Directory.Exists (path))
\r
1268 // Directory.CreateDirectory (path);
\r
1270 // Directory.SetLastAccessTime (path, time);
\r
1272 // DeleteDirectory (path);
\r
1278 [ExpectedException(typeof(ArgumentNullException))]
\r
1279 public void SetLastAccessTimeUtcException1 ()
\r
1281 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1282 Directory.SetLastAccessTimeUtc (null as string, time);
\r
1286 [ExpectedException(typeof(ArgumentException))]
\r
1287 public void SetLastAccessTimeUtcException2 ()
\r
1289 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1290 Directory.SetLastAccessTimeUtc (string.Empty, time);
\r
1294 [ExpectedException(typeof(FileNotFoundException))]
\r
1295 public void SetLastAccessTimeUtcException3 ()
\r
1297 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1298 string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTimeUtc.2";
\r
1299 DeleteDirectory (path);
\r
1301 Directory.SetLastAccessTimeUtc (path, time);
\r
1303 DeleteDirectory (path);
\r
1308 [ExpectedException(typeof(ArgumentException))]
\r
1309 public void SetLastAccessTimeUtcException4 ()
\r
1311 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1312 Directory.SetLastAccessTimeUtc (" ", time);
\r
1316 [ExpectedException(typeof(ArgumentException))]
\r
1317 public void SetLastAccessTimeUtcException5 ()
\r
1319 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1320 Directory.SetLastAccessTimeUtc (Path.InvalidPathChars [0].ToString (), time);
\r
1324 // [ExpectedException(typeof(ArgumentOutOfRangeException))]
\r
1325 // public void SetLastAccessTimeUtcException6 ()
\r
1327 // DateTime time = new DateTime (1000, 4, 6, 6, 4, 2);
\r
1328 // string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTimeUtc.1";
\r
1330 // if (!Directory.Exists (path))
\r
1331 // Directory.CreateDirectory (path);
\r
1333 // Directory.SetLastAccessTimeUtc (path, time);
\r
1335 // DeleteDirectory (path);
\r
1340 [ExpectedException(typeof(ArgumentNullException))]
\r
1341 public void SetCreationTimeException1 ()
\r
1343 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1344 Directory.SetCreationTime (null as string, time);
\r
1348 [ExpectedException(typeof(ArgumentException))]
\r
1349 public void SetCreationTimeException2 ()
\r
1351 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1352 Directory.SetCreationTime (string.Empty, time);
\r
1356 [ExpectedException(typeof(FileNotFoundException))]
\r
1357 public void SetCreationTimeException3 ()
\r
1359 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1360 string path = TempFolder + DSC + "DirectoryTest.SetCreationTime.2";
\r
1361 DeleteDirectory (path);
\r
1364 Directory.SetCreationTime (path, time);
\r
1366 DeleteDirectory (path);
\r
1371 [ExpectedException(typeof(ArgumentException))]
\r
1372 public void SetCreationTimeException4 ()
\r
1374 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1375 Directory.SetCreationTime (" ", time);
\r
1379 [ExpectedException(typeof(ArgumentException))]
\r
1380 public void SetCreationTimeException5 ()
\r
1382 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1383 Directory.SetCreationTime (Path.InvalidPathChars [0].ToString (), time);
\r
1387 // [ExpectedException(typeof(ArgumentOutOfRangeException))]
\r
1388 // public void SetCreationTimeException6 ()
\r
1390 // DateTime time = new DateTime (1003, 4, 6, 6, 4, 2);
\r
1391 // string path = TempFolder + DSC + "DirectoryTest.SetCreationTime.1";
\r
1393 // if (!Directory.Exists (path))
\r
1394 // Directory.CreateDirectory (path);
\r
1396 // Directory.SetCreationTime (path, time);
\r
1397 // DeleteDirectory (path);
\r
1399 // DeleteDirectory (path);
\r
1405 [ExpectedException(typeof(ArgumentNullException))]
\r
1406 public void SetCreationTimeUtcException1 ()
\r
1408 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1409 Directory.SetCreationTimeUtc (null as string, time);
\r
1413 [ExpectedException(typeof(ArgumentException))]
\r
1414 public void SetCreationTimeUtcException2 ()
\r
1416 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1417 Directory.SetCreationTimeUtc (string.Empty, time);
\r
1421 [ExpectedException(typeof(FileNotFoundException))]
\r
1422 public void SetCreationTimeUtcException3 ()
\r
1424 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1425 string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTimeUtc.2";
\r
1426 DeleteDirectory (path);
\r
1429 Directory.SetCreationTimeUtc (path, time);
\r
1430 DeleteDirectory (path);
\r
1432 DeleteDirectory (path);
\r
1437 [ExpectedException(typeof(ArgumentException))]
\r
1438 public void SetCreationTimeUtcException4 ()
\r
1440 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1441 Directory.SetCreationTimeUtc (" ", time);
\r
1445 [ExpectedException(typeof(ArgumentException))]
\r
1446 public void SetCreationTimeUtcException5 ()
\r
1448 DateTime time = new DateTime (2003, 4, 6, 6, 4, 2);
\r
1449 Directory.SetCreationTimeUtc (Path.InvalidPathChars [0].ToString (), time);
\r
1453 // [ExpectedException(typeof(ArgumentOutOfRangeException))]
\r
1454 // public void SetCreationTimeUtcException6 ()
\r
1456 // DateTime time = new DateTime (1000, 4, 6, 6, 4, 2);
\r
1457 // string path = TempFolder + DSC + "DirectoryTest.SetLastAccessTimeUtc.1";
\r
1459 // if (!Directory.Exists (path))
\r
1460 // Directory.CreateDirectory (path);
\r
1462 // Directory.SetCreationTimeUtc (path, time);
\r
1463 // DeleteDirectory (path);
\r
1465 // DeleteDirectory (path);
\r
1470 public void GetDirectories ()
\r
1472 string path = TempFolder;
\r
1473 string DirPath = TempFolder + Path.DirectorySeparatorChar + ".GetDirectories";
\r
1474 DeleteDirectory (DirPath);
\r
1477 Directory.CreateDirectory (DirPath);
\r
1479 string [] dirs = Directory.GetDirectories (path);
\r
1481 foreach (string directory in dirs) {
\r
1483 if (directory == DirPath)
\r
1487 Assert.Fail ("Directory Not Found");
\r
1489 DeleteDirectory (DirPath);
\r
1493 [Test] // bug #346123
\r
1494 public void GetDirectories_Backslash ()
\r
1496 if (!RunningOnUnix)
\r
1497 // on Windows, backslash is used as directory separator
\r
1498 Assert.Ignore ("Not running on Unix.");
\r
1500 string dir = Path.Combine (TempFolder, @"sub\dir");
\r
1501 Directory.CreateDirectory (dir);
\r
1503 Assert.IsTrue (Directory.Exists (dir), "#A1");
\r
1504 Assert.IsFalse (Directory.Exists (Path.Combine (TempFolder, "dir")), "#A2");
\r
1506 string [] dirs = Directory.GetDirectories (TempFolder);
\r
1507 Assert.AreEqual (1, dirs.Length, "#B1");
\r
1508 Assert.AreEqual (dir, dirs [0], "#B2");
\r
1512 public void GetParentOfRootDirectory ()
\r
1514 DirectoryInfo info;
\r
1516 info = Directory.GetParent (Path.GetPathRoot (Path.GetTempPath ()));
\r
1517 Assert.IsNull (info);
\r
1521 public void GetFiles ()
\r
1523 string path = TempFolder;
\r
1524 string DirPath = TempFolder + Path.DirectorySeparatorChar + ".GetFiles";
\r
1525 if (File.Exists (DirPath))
\r
1526 File.Delete (DirPath);
\r
1529 File.Create (DirPath).Close ();
\r
1530 string [] files = Directory.GetFiles (TempFolder);
\r
1531 foreach (string directory in files) {
\r
1533 if (directory == DirPath)
\r
1537 Assert.Fail ("File Not Found");
\r
1539 if (File.Exists (DirPath))
\r
1540 File.Delete (DirPath);
\r
1544 [Test] // bug #346123
\r
1545 public void GetFiles_Backslash ()
\r
1547 if (!RunningOnUnix)
\r
1548 // on Windows, backslash is used as directory separator
\r
1549 Assert.Ignore ("Not running on Unix.");
\r
1551 string file = Path.Combine (TempFolder, @"doc\temp1.file");
\r
1552 File.Create (file).Close ();
\r
1554 Assert.IsTrue (File.Exists (file), "#A1");
\r
1555 Assert.IsFalse (File.Exists (Path.Combine (TempFolder, "temp1.file")), "#A2");
\r
1557 string [] files = Directory.GetFiles (TempFolder);
\r
1558 Assert.AreEqual (1, files.Length, "#B1");
\r
1559 Assert.AreEqual (file, files [0], "#B2");
\r
1562 [Test] // bug #82212 and bug #325107
\r
1563 public void GetFiles_Pattern ()
\r
1565 string [] files = Directory.GetFiles (TempFolder, "*.*");
\r
1566 Assert.IsNotNull (files, "#A1");
\r
1567 Assert.AreEqual (0, files.Length, "#A2");
\r
1569 string tempFile1 = Path.Combine (TempFolder, "tempFile1");
\r
1570 File.Create (tempFile1).Close ();
\r
1572 files = Directory.GetFiles (TempFolder, "*.*");
\r
1573 Assert.IsNotNull (files, "#B1");
\r
1574 Assert.AreEqual (1, files.Length, "#B2");
\r
1575 Assert.AreEqual (tempFile1, files [0], "#B3");
\r
1577 string tempFile2 = Path.Combine (TempFolder, "FileTemp2.tmp");
\r
1578 File.Create (tempFile2).Close ();
\r
1580 files = Directory.GetFiles (TempFolder, "*.*");
\r
1581 Assert.IsNotNull (files, "#C1");
\r
1582 Assert.AreEqual (2, files.Length, "#C2");
\r
1584 files = Directory.GetFiles (TempFolder, "temp*.*");
\r
1585 Assert.IsNotNull (files, "#D1");
\r
1586 Assert.AreEqual (1, files.Length, "#D2");
\r
1587 Assert.AreEqual (tempFile1, files [0], "#D3");
\r
1589 string tempFile3 = Path.Combine (TempFolder, "tempFile3.txt");
\r
1590 File.Create (tempFile3).Close ();
\r
1592 files = Directory.GetFiles (TempFolder, "*File*.*");
\r
1593 Assert.IsNotNull (files, "#E1");
\r
1594 Assert.AreEqual (3, files.Length, "#E2");
\r
1596 files = Directory.GetFiles (TempFolder, "*File*.tmp");
\r
1597 Assert.IsNotNull (files, "#F1");
\r
1598 Assert.AreEqual (1, files.Length, "#F2");
\r
1599 Assert.AreEqual (tempFile2, files [0], "#F3");
\r
1601 files = Directory.GetFiles (TempFolder, "*tempFile*");
\r
1602 Assert.IsNotNull (files, "#G1");
\r
1603 Assert.AreEqual (2, files.Length, "#G2");
\r
1605 files = Directory.GetFiles (TempFolder, "*tempFile1");
\r
1606 Assert.IsNotNull (files, "#H1");
\r
1607 Assert.AreEqual (1, files.Length, "#H2");
\r
1608 Assert.AreEqual (tempFile1, files [0], "#H3");
\r
1610 files = Directory.GetFiles (TempFolder, "*.txt");
\r
1611 Assert.IsNotNull (files, "#I1");
\r
1612 Assert.AreEqual (1, files.Length, "#I2");
\r
1613 Assert.AreEqual (tempFile3, files [0], "#I3");
\r
1615 files = Directory.GetFiles (TempFolder, "*.t*");
\r
1616 Assert.IsNotNull (files, "#J1");
\r
1617 Assert.AreEqual (2, files.Length, "#J2");
\r
1619 files = Directory.GetFiles (TempFolder, "temp*.*");
\r
1620 Assert.IsNotNull (files, "#K1");
\r
1621 Assert.AreEqual (2, files.Length, "#K2");
\r
1623 File.Delete (tempFile1);
\r
1625 files = Directory.GetFiles (TempFolder, "temp*.*");
\r
1626 Assert.IsNotNull (files, "#L1");
\r
1627 Assert.AreEqual (1, files.Length, "#L2");
\r
1628 Assert.AreEqual (tempFile3, files [0], "#L3");
\r
1630 files = Directory.GetFiles (TempFolder, ".*");
\r
1631 Assert.IsNotNull (files, "#M1");
\r
1632 Assert.AreEqual (0, files.Length, "#M2");
\r
1634 string tempFile4 = Path.Combine (TempFolder, "tempFile4.");
\r
1635 File.Create (tempFile4).Close ();
\r
1637 files = Directory.GetFiles (TempFolder, "temp*.");
\r
1638 Assert.IsNotNull (files, "#N1");
\r
1639 Assert.AreEqual (1, files.Length, "#N2");
\r
1640 if (RunningOnUnix)
\r
1641 Assert.AreEqual (tempFile4, files [0], "#N3");
\r
1642 else // on Windows, the trailing dot is automatically trimmed
\r
1643 Assert.AreEqual (Path.Combine (TempFolder, "tempFile4"), files [0], "#N3");
\r
1647 public void GetFiles_580090 ()
\r
1649 string cwd = Directory.GetCurrentDirectory ();
\r
1650 Directory.SetCurrentDirectory (Path.GetTempPath ());
\r
1652 string tempFile = Path.Combine (TempFolder, "tempFile.txt");
\r
1653 File.Create (tempFile).Close ();
\r
1656 string [] files = Directory.GetFiles (".", TempSubFolder + DSC + "*.t*");
\r
1657 Assert.IsNotNull (files, "#J1");
\r
1658 Assert.AreEqual (1, files.Length, "#J2");
\r
1661 Directory.SetCurrentDirectory (cwd);
\r
1667 [ExpectedException (typeof (ArgumentNullException))]
\r
1668 public void SetCurrentDirectoryNull ()
\r
1670 Directory.SetCurrentDirectory (null);
\r
1674 [ExpectedException (typeof (ArgumentException))]
\r
1675 public void SetCurrentDirectoryEmpty ()
\r
1677 Directory.SetCurrentDirectory (String.Empty);
\r
1681 [ExpectedException (typeof (ArgumentException))]
\r
1682 public void SetCurrentDirectoryWhitespace ()
\r
1684 Directory.SetCurrentDirectory (" ");
\r
1689 public void GetNoFiles () // Bug 58875. This throwed an exception on windows.
\r
1691 DirectoryInfo dir = new DirectoryInfo (".");
\r
1692 dir.GetFiles ("*.nonext");
\r
1696 public void FilenameOnly () // bug 78209
\r
1698 Directory.GetParent ("somefile");
\r
1701 private static bool RunningOnUnix {
\r
1703 // check for Unix platforms - see FAQ for more details
\r
1704 // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
\r
1705 int platform = (int) Environment.OSVersion.Platform;
\r
1706 return ((platform == 4) || (platform == 128) || (platform == 6));
\r
1710 private void DeleteDirectory (string path)
\r
1712 if (Directory.Exists (path))
\r
1713 Directory.Delete (path, true);
\r
1716 private void DeleteFile (string path)
\r
1718 if (File.Exists (path))
\r
1719 File.Delete (path);
\r