2 // System.IO.Path Test Cases
5 // Marcin Szczepanski (marcins@zipworld.com.au)
6 // Gonzalo Paniagua Javier (gonzalo@ximian.com)
7 // Ben Maurer (bmaurer@users.sf.net)
8 // Gilles Freart (gfr@skynet.be)
9 // Atsushi Enomoto (atsushi@ximian.com)
10 // Sebastien Pouliot <sebastien@ximian.com>
12 // (c) Marcin Szczepanski
13 // (c) 2002 Ximian, Inc. (http://www.ximian.com)
14 // (c) 2003 Ben Maurer
15 // (c) 2003 Gilles Freart
16 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
19 using NUnit.Framework;
24 namespace MonoTests.System.IO
39 static char DSC = Path.DirectorySeparatorChar;
46 path1 = "/foo/test.txt";
49 } else if ('\\' == DSC) {
51 path1 = "c:\\foo\\test.txt";
52 path2 = Environment.GetEnvironmentVariable ("SYSTEMROOT");
56 //FIXME: For Mac. figure this out when we need it
57 path1 = "foo:test.txt";
66 return OS == OsType.Windows;
73 return OS == OsType.Unix;
80 return OS == OsType.Mac;
85 public void ChangeExtension ()
87 string [] files = new string [3];
88 files [(int) OsType.Unix] = "/foo/test.doc";
89 files [(int) OsType.Windows] = "c:\\foo\\test.doc";
90 files [(int) OsType.Mac] = "foo:test.doc";
92 string testPath = Path.ChangeExtension (path1, "doc");
93 Assert.AreEqual (files [(int) OS], testPath, "ChangeExtension #01");
95 testPath = Path.ChangeExtension (String.Empty, ".extension");
96 Assert.AreEqual (String.Empty, testPath, "ChangeExtension #02");
98 testPath = Path.ChangeExtension (null, ".extension");
99 Assert.AreEqual (null, testPath, "ChangeExtension #03");
101 testPath = Path.ChangeExtension ("path", null);
102 Assert.AreEqual ("path", testPath, "ChangeExtension #04");
104 testPath = Path.ChangeExtension ("path.ext", "doc");
105 Assert.AreEqual ("path.doc", testPath, "ChangeExtension #05");
107 testPath = Path.ChangeExtension ("path.ext1.ext2", "doc");
108 Assert.AreEqual ("path.ext1.doc", testPath, "ChangeExtension #06");
110 testPath = Path.ChangeExtension ("hogehoge.xml", ".xsl");
111 Assert.AreEqual ("hogehoge.xsl", testPath, "ChangeExtension #07");
112 testPath = Path.ChangeExtension ("hogehoge", ".xsl");
113 Assert.AreEqual ("hogehoge.xsl", testPath, "ChangeExtension #08");
114 testPath = Path.ChangeExtension ("hogehoge.xml", "xsl");
115 Assert.AreEqual ("hogehoge.xsl", testPath, "ChangeExtension #09");
116 testPath = Path.ChangeExtension ("hogehoge", "xsl");
117 Assert.AreEqual ("hogehoge.xsl", testPath, "ChangeExtension #10");
118 testPath = Path.ChangeExtension ("hogehoge.xml", String.Empty);
119 Assert.AreEqual ("hogehoge.", testPath, "ChangeExtension #11");
120 testPath = Path.ChangeExtension ("hogehoge", String.Empty);
121 Assert.AreEqual ("hogehoge.", testPath, "ChangeExtension #12");
122 testPath = Path.ChangeExtension ("hogehoge.", null);
123 Assert.AreEqual ("hogehoge", testPath, "ChangeExtension #13");
124 testPath = Path.ChangeExtension ("hogehoge", null);
125 Assert.AreEqual ("hogehoge", testPath, "ChangeExtension #14");
126 testPath = Path.ChangeExtension (String.Empty, null);
127 Assert.AreEqual (String.Empty, testPath, "ChangeExtension #15");
128 testPath = Path.ChangeExtension (String.Empty, "bashrc");
129 Assert.AreEqual (String.Empty, testPath, "ChangeExtension #16");
130 testPath = Path.ChangeExtension (String.Empty, ".bashrc");
131 Assert.AreEqual (String.Empty, testPath, "ChangeExtension #17");
132 testPath = Path.ChangeExtension (null, null);
133 Assert.IsNull (testPath, "ChangeExtension #18");
137 public void ChangeExtension_Extension_InvalidPathChars ()
139 string fn = Path.ChangeExtension ("file.ext", "<");
140 Assert.AreEqual ("file.<", fn, "Invalid filename");
144 public void ChangeExtension_Path_InvalidPathChars ()
147 Path.ChangeExtension ("fi\0le.ext", ".extension");
149 } catch (ArgumentException ex) {
150 // Illegal characters in path
151 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
152 Assert.IsNull (ex.InnerException, "#3");
153 Assert.IsNotNull (ex.Message, "#4");
154 Assert.IsNull (ex.ParamName, "#5");
159 public void Combine ()
161 string [] files = new string [3];
162 files [(int) OsType.Unix] = "/etc/init.d";
163 files [(int) OsType.Windows] = Environment.GetEnvironmentVariable ("SYSTEMROOT") + @"\system32";
164 files [(int) OsType.Mac] = "foo:bar";
166 string testPath = Path.Combine (path2, path3);
167 Assert.AreEqual (files [(int) OS], testPath, "Combine #01");
169 testPath = Path.Combine ("one", String.Empty);
170 Assert.AreEqual ("one", testPath, "Combine #02");
172 testPath = Path.Combine (String.Empty, "one");
173 Assert.AreEqual ("one", testPath, "Combine #03");
175 string current = Directory.GetCurrentDirectory ();
176 testPath = Path.Combine (current, "one");
178 string expected = current + DSC + "one";
179 Assert.AreEqual (expected, testPath, "Combine #04");
181 testPath = Path.Combine ("one", current);
182 // LAMESPEC noted in Path.cs
183 Assert.AreEqual (current, testPath, "Combine #05");
185 testPath = Path.Combine (current, expected);
186 Assert.AreEqual (expected, testPath, "Combine #06");
188 testPath = DSC + "one";
189 testPath = Path.Combine (testPath, "two" + DSC);
190 expected = DSC + "one" + DSC + "two" + DSC;
191 Assert.AreEqual (expected, testPath, "Combine #06");
193 testPath = "one" + DSC;
194 testPath = Path.Combine (testPath, DSC + "two");
195 expected = DSC + "two";
196 Assert.AreEqual (expected, testPath, "Combine #06");
198 testPath = "one" + DSC;
199 testPath = Path.Combine (testPath, "two" + DSC);
200 expected = "one" + DSC + "two" + DSC;
201 Assert.AreEqual (expected, testPath, "Combine #07");
204 Assert.AreEqual ("a", Path.Combine (new [] { "a", "" }), "Combine #08");
209 public void Combine_Path1_InvalidPathChars ()
212 Path.Combine ("a\0", "one");
214 } catch (ArgumentException ex) {
215 // Illegal characters in path
216 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
217 Assert.IsNull (ex.InnerException, "#3");
218 Assert.IsNotNull (ex.Message, "#4");
219 Assert.IsNull (ex.ParamName, "#5");
224 public void Combine_Path1_Null ()
227 Path.Combine (null, "one");
229 } catch (ArgumentNullException ex) {
230 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
231 Assert.IsNull (ex.InnerException, "#3");
232 Assert.IsNotNull (ex.Message, "#4");
233 Assert.AreEqual ("path1", ex.ParamName, "#5");
238 public void Combine_Path2_InvalidPathChars ()
241 Path.Combine ("one", "a\0");
243 } catch (ArgumentException ex) {
244 // Illegal characters in path
245 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
246 Assert.IsNull (ex.InnerException, "#3");
247 Assert.IsNotNull (ex.Message, "#4");
248 Assert.IsNull (ex.ParamName, "#5");
253 public void Combine_Path2_Null ()
256 Path.Combine ("one", null);
258 } catch (ArgumentNullException ex) {
259 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
260 Assert.IsNull (ex.InnerException, "#3");
261 Assert.IsNotNull (ex.Message, "#4");
262 Assert.AreEqual ("path2", ex.ParamName, "#5");
267 public void GetDirectoryName ()
269 string [] files = new string [3];
270 files [(int) OsType.Unix] = "/foo";
271 files [(int) OsType.Windows] = "c:\\foo";
272 files [(int) OsType.Mac] = "foo";
274 string testDirName = Path.GetDirectoryName (path1);
275 Assert.AreEqual (files [(int) OS], testDirName, "#A1");
276 testDirName = Path.GetDirectoryName (files [(int) OS] + DSC);
277 Assert.AreEqual (files [(int) OS], testDirName, "#A2");
280 Assert.AreEqual ("C:\\foo", Path.GetDirectoryName ("C:\\foo\\foo.txt"), "#B1");
281 Assert.AreEqual (null, Path.GetDirectoryName ("C:"), "#B2");
282 Assert.AreEqual (null, Path.GetDirectoryName (@"C:\"), "#B3");
283 Assert.AreEqual (@"C:\", Path.GetDirectoryName (@"C:\dir"), "#B4");
284 Assert.AreEqual (@"C:\dir", Path.GetDirectoryName (@"C:\dir\"), "#B5");
285 Assert.AreEqual (@"C:\dir", Path.GetDirectoryName (@"C:\dir\dir"), "#B6");
286 Assert.AreEqual (@"C:\dir\dir", Path.GetDirectoryName (@"C:\dir\dir\"), "#B7");
287 Assert.AreEqual (@"C:", Path.GetDirectoryName (@"C:foo.txt"), "#B8");
288 Assert.AreEqual (@"C:dir", Path.GetDirectoryName (@"C:dir\"), "#B9");
290 Assert.AreEqual ("\\foo\\bar", Path.GetDirectoryName ("/foo//bar/dingus"), "#C1");
291 Assert.AreEqual ("foo\\bar", Path.GetDirectoryName ("foo/bar/"), "#C2");
292 Assert.AreEqual ("foo\\bar", Path.GetDirectoryName ("foo/bar\\xxx"), "#C3");
293 Assert.AreEqual ("\\\\host\\dir\\dir2", Path.GetDirectoryName ("\\\\host\\dir\\\\dir2\\path"), "#C4");
296 Assert.AreEqual (null, Path.GetDirectoryName (@"\\"), "#D1");
297 Assert.AreEqual (null, Path.GetDirectoryName (@"\\server"), "#D2");
298 Assert.AreEqual (null, Path.GetDirectoryName (@"\\server\share"), "#D3");
299 Assert.AreEqual (@"\\server\share", Path.GetDirectoryName (@"\\server\share\"), "#D4");
300 Assert.AreEqual (@"\\server\share", Path.GetDirectoryName (@"\\server\share\dir"), "#D5");
301 Assert.AreEqual (@"\\server\share\dir", Path.GetDirectoryName (@"\\server\share\dir\subdir"), "#D6");
303 Assert.AreEqual ("/etc", Path.GetDirectoryName ("/etc/hostname"), "#B1");
304 Assert.AreEqual ("/foo/bar", Path.GetDirectoryName ("/foo//bar/dingus"), "#B2");
305 Assert.AreEqual ("foo/bar", Path.GetDirectoryName ("foo/bar/"), "#B3");
306 Assert.AreEqual ("/", Path.GetDirectoryName ("/tmp"), "#B4");
307 Assert.IsNull (Path.GetDirectoryName ("/"), "#B5");
308 Assert.AreEqual ("a", Path.GetDirectoryName ("a//b"), "#B6");
313 public void GetDirectoryName_Path_Empty ()
316 Path.GetDirectoryName (String.Empty);
318 } catch (ArgumentException ex) {
319 // The path is not of a legal form
320 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
321 Assert.IsNull (ex.InnerException, "#3");
322 Assert.IsNotNull (ex.Message, "#4");
323 Assert.IsNull (ex.ParamName, "#5");
328 public void GetDirectoryName_Path_InvalidPathChars ()
331 Path.GetDirectoryName ("hi\0world");
333 } catch (ArgumentException ex) {
334 // Illegal characters in path
335 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
336 Assert.IsNull (ex.InnerException, "#3");
337 Assert.IsNotNull (ex.Message, "#4");
338 Assert.IsNull (ex.ParamName, "#5");
343 public void GetDirectoryName_Path_Null ()
345 Assert.IsNull (Path.GetDirectoryName (null));
349 public void GetDirectoryName_Path_Whitespace ()
352 Path.GetDirectoryName (" ");
354 } catch (ArgumentException ex) {
355 // The path is not of a legal form
356 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
357 Assert.IsNull (ex.InnerException, "#3");
358 Assert.IsNotNull (ex.Message, "#4");
359 Assert.IsNull (ex.ParamName, "#5");
364 public void GetExtension ()
366 string testExtn = Path.GetExtension (path1);
368 Assert.AreEqual (".txt", testExtn, "GetExtension #01");
370 testExtn = Path.GetExtension (path2);
371 Assert.AreEqual (String.Empty, testExtn, "GetExtension #02");
373 testExtn = Path.GetExtension (String.Empty);
374 Assert.AreEqual (String.Empty, testExtn, "GetExtension #03");
376 testExtn = Path.GetExtension (null);
377 Assert.AreEqual (null, testExtn, "GetExtension #04");
379 testExtn = Path.GetExtension (" ");
380 Assert.AreEqual (String.Empty, testExtn, "GetExtension #05");
382 testExtn = Path.GetExtension (path1 + ".doc");
383 Assert.AreEqual (".doc", testExtn, "GetExtension #06");
385 testExtn = Path.GetExtension (path1 + ".doc" + DSC + "a.txt");
386 Assert.AreEqual (".txt", testExtn, "GetExtension #07");
388 testExtn = Path.GetExtension (".");
389 Assert.AreEqual (String.Empty, testExtn, "GetExtension #08");
391 testExtn = Path.GetExtension ("end.");
392 Assert.AreEqual (String.Empty, testExtn, "GetExtension #09");
394 testExtn = Path.GetExtension (".start");
395 Assert.AreEqual (".start", testExtn, "GetExtension #10");
397 testExtn = Path.GetExtension (".a");
398 Assert.AreEqual (".a", testExtn, "GetExtension #11");
400 testExtn = Path.GetExtension ("a.");
401 Assert.AreEqual (String.Empty, testExtn, "GetExtension #12");
403 testExtn = Path.GetExtension ("a");
404 Assert.AreEqual (String.Empty, testExtn, "GetExtension #13");
406 testExtn = Path.GetExtension ("makefile");
407 Assert.AreEqual (String.Empty, testExtn, "GetExtension #14");
411 public void GetExtension_Path_InvalidPathChars ()
414 Path.GetExtension ("hi\0world.txt");
416 } catch (ArgumentException ex) {
417 // Illegal characters in path.
418 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
419 Assert.IsNull (ex.InnerException, "#3");
420 Assert.IsNotNull (ex.Message, "#4");
421 Assert.IsNull (ex.ParamName, "#5");
426 public void GetFileName ()
428 string testFileName = Path.GetFileName (path1);
430 Assert.AreEqual ("test.txt", testFileName, "#1");
431 testFileName = Path.GetFileName (null);
432 Assert.AreEqual (null, testFileName, "#2");
433 testFileName = Path.GetFileName (String.Empty);
434 Assert.AreEqual (String.Empty, testFileName, "#3");
435 testFileName = Path.GetFileName (" ");
436 Assert.AreEqual (" ", testFileName, "#4");
440 public void GetFileName_Path_InvalidPathChars ()
443 Path.GetFileName ("hi\0world");
445 } catch (ArgumentException ex) {
446 // Illegal characters in path
447 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
448 Assert.IsNull (ex.InnerException, "#3");
449 Assert.IsNotNull (ex.Message, "#4");
450 Assert.IsNull (ex.ParamName, "#5");
455 public void GetFileNameWithoutExtension ()
457 string testFileName = Path.GetFileNameWithoutExtension (path1);
459 Assert.AreEqual ("test", testFileName, "GetFileNameWithoutExtension #01");
461 testFileName = Path.GetFileNameWithoutExtension (null);
462 Assert.AreEqual (null, testFileName, "GetFileNameWithoutExtension #02");
464 testFileName = Path.GetFileNameWithoutExtension (String.Empty);
465 Assert.AreEqual (String.Empty, testFileName, "GetFileNameWithoutExtension #03");
469 public void GetFileNameWithoutExtension_Path_InvalidPathChars ()
472 Path.GetFileNameWithoutExtension ("hi\0world");
474 } catch (ArgumentException ex) {
475 // Illegal characters in path
476 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
477 Assert.IsNull (ex.InnerException, "#3");
478 Assert.IsNotNull (ex.Message, "#4");
479 Assert.IsNull (ex.ParamName, "#5");
484 public void GetFullPath ()
486 string current = Directory.GetCurrentDirectory ();
488 string testFullPath = Path.GetFullPath ("foo.txt");
489 string expected = current + DSC + "foo.txt";
490 Assert.AreEqual (expected, testFullPath, "GetFullPath #01");
492 testFullPath = Path.GetFullPath ("a//./.././foo.txt");
493 Assert.AreEqual (expected, testFullPath, "GetFullPath #02");
497 public void GetFullPath_Unix ()
503 string [,] test = new string [,] {
504 {"root////././././././../root/././../root", "root"},
506 {"root/./", "root/"},
507 {"root/./", "root/"},
508 {"root/../", String.Empty},
509 {"root/../", String.Empty},
510 {"root/../..", String.Empty},
511 {"root/.hiddenfile", "root/.hiddenfile"},
512 {"root/. /", "root/. /"},
513 {"root/.. /", "root/.. /"},
514 {"root/..weirdname", "root/..weirdname"},
515 {"root/..", String.Empty},
516 {"root/../a/b/../../..", String.Empty},
517 {"root/./..", String.Empty},
518 {"..", String.Empty},
520 {"root//dir", "root/dir"},
521 {"root/. /", "root/. /"},
522 {"root/.. /", "root/.. /"},
523 {"root/ . /", "root/ . /"},
524 {"root/ .. /", "root/ .. /"},
525 {"root/./", "root/"},
526 //ERROR! Paths are trimmed
527 // I don't understand this comment^^.
528 // No trimming occurs but the paths are not equal. That's why the test fails. Commented out.
529 //{"root/.. /", "root/.. /"},
530 {".//", String.Empty}
533 for (int i = 0; i < test.GetUpperBound (0); i++) {
534 Assert.AreEqual (root + test [i, 1], Path.GetFullPath (root + test [i, 0]),
535 String.Format ("GetFullPathUnix #{0}", i));
538 Assert.AreEqual ("/", Path.GetFullPath ("/"), "#01");
539 Assert.AreEqual ("/hey", Path.GetFullPath ("/hey"), "#02");
540 Assert.AreEqual (Environment.CurrentDirectory, Path.GetFullPath ("."), "#03");
541 Assert.AreEqual (Path.Combine (Environment.CurrentDirectory, "hey"),
542 Path.GetFullPath ("hey"), "#04");
546 public void GetFullPath_Windows ()
551 string root = "C:\\";
552 string [,] test = new string [,] {
553 {"root////././././././../root/././../root", "root"},
555 {"root/./", "root\\"},
556 {"root/./", "root\\"},
560 {"root/.hiddenfile", "root\\.hiddenfile"},
561 {"root/. /", "root\\"},
563 {"root/..weirdname", "root\\..weirdname"},
565 {"root/../a/b/../../..", ""},
569 {"root//dir", "root\\dir"},
570 {"root/. /", "root\\"},
573 {"root/ . /", "root\\"},
576 {"root/./", "root\\"},
581 for (int i = 0; i < test.GetUpperBound (0); i++) {
583 Assert.AreEqual (root + test [i, 1], Path.GetFullPath (root + test [i, 0]),
584 String.Format ("GetFullPathWindows #{0}", i));
585 } catch (Exception ex) {
586 Assert.Fail (String.Format ("GetFullPathWindows #{0} (\"{1}\") failed: {2}",
587 i, root + test [i, 0], ex.GetType ()));
592 string root2 = @"\\server\share";
593 root = @"\\server\share\";
594 test = new string [,] {
595 {"root////././././././../root/././../root", "root"},
597 {"root/./", "root\\"},
598 {"root/./", "root\\"},
601 {"root/../..", null},
602 {"root/.hiddenfile", "root\\.hiddenfile"},
603 {"root/. /", "root\\"},
605 {"root/..weirdname", "root\\..weirdname"},
607 {"root/../a/b/../../..", null},
611 {"root//dir", "root\\dir"},
612 {"root/. /", "root\\"},
615 {"root/ . /", "root\\"},
618 {"root/./", "root\\"},
623 for (int i = 0; i < test.GetUpperBound (0); i++) {
624 // "null" means we have to compare against "root2"
625 string res = test [i, 1] != null
629 Assert.AreEqual (res, Path.GetFullPath (root + test [i, 0]),
630 String.Format ("GetFullPathWindows UNC #{0}", i));
631 } catch (AssertionException) {
633 } catch (Exception ex) {
634 Assert.Fail (String.Format ("GetFullPathWindows UNC #{0} (\"{1}\") failed: {2}",
635 i, root + test [i, 0], ex.GetType ()));
639 test = new string [,] {
640 {"root////././././././../root/././../root", "root"},
642 {"root/./", "root\\"},
643 {"root/./", "root\\"},
646 {"root/../..", null},
647 {"root/.hiddenfile", "root\\.hiddenfile"},
648 {"root/. /", "root\\"},
650 {"root/..weirdname", "root\\..weirdname"},
652 {"root/../a/b/../../..", null},
656 {"root//dir", "root\\dir"},
657 {"root/. /", "root\\"},
660 {"root/ . /", "root\\"},
663 {"root/./", "root\\"},
668 string root3 = @"//server/share";
669 root = @"//server/share/";
670 bool needSlashConvert = Path.DirectorySeparatorChar != '/';
672 for (int i = 0; i < test.GetUpperBound (0); i++) {
673 // "null" means we have to compare against "root2"
674 string res = test [i, 1] != null
677 if (needSlashConvert)
678 res = res.Replace ('/', Path.DirectorySeparatorChar);
680 Assert.AreEqual (res, Path.GetFullPath (root + test [i, 0]),
681 String.Format ("GetFullPathWindows UNC[2] #{0}", i));
682 } catch (AssertionException) {
684 } catch (Exception ex) {
685 Assert.Fail (String.Format ("GetFullPathWindows UNC[2] #{0} (\"{1}\") failed: {2}",
686 i, root + test [i, 0], ex.GetType ()));
692 public void GetFullPath_Path_Empty ()
695 Path.GetFullPath (String.Empty);
697 } catch (ArgumentException ex) {
698 // The path is not of a legal form
699 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
700 Assert.IsNull (ex.InnerException, "#3");
701 Assert.IsNotNull (ex.Message, "#4");
702 Assert.IsNull (ex.ParamName, "#5");
707 public void GetFullPath_Path_EndingSeparator ()
709 string fp = Path.GetFullPath ("something/");
710 char end = fp [fp.Length - 1];
711 Assert.IsTrue (end == Path.DirectorySeparatorChar);
715 public void GetFullPath_Path_InvalidPathChars ()
718 Path.GetFullPath ("hi\0world");
720 } catch (ArgumentException ex) {
721 // Illegal characters in path
722 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
723 Assert.IsNull (ex.InnerException, "#3");
724 Assert.IsNotNull (ex.Message, "#4");
725 Assert.IsNull (ex.ParamName, "#5");
730 public void GetFullPath_Path_Null ()
733 Path.GetFullPath (null);
735 } catch (ArgumentNullException ex) {
736 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
737 Assert.IsNull (ex.InnerException, "#3");
738 Assert.IsNotNull (ex.Message, "#4");
739 Assert.AreEqual ("path", ex.ParamName, "#5");
744 public void GetFullPath_Path_Whitespace ()
747 Path.GetFullPath (" ");
749 } catch (ArgumentException ex) {
750 // The path is not of a legal form
751 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
752 Assert.IsNull (ex.InnerException, "#3");
753 Assert.IsNotNull (ex.Message, "#4");
754 Assert.IsNull (ex.ParamName, "#5");
759 public void GetFullPath2 ()
762 Assert.AreEqual (@"Z:\", Path.GetFullPath ("Z:"), "GetFullPath w#01");
763 #if !TARGET_JVM // Java full (canonical) path always starts with caps drive letter
764 Assert.AreEqual (@"c:\abc\def", Path.GetFullPath (@"c:\abc\def"), "GetFullPath w#02");
766 Assert.IsTrue (Path.GetFullPath (@"\").EndsWith (@"\"), "GetFullPath w#03");
767 // "\\\\" is not allowed
768 Assert.IsTrue (Path.GetFullPath ("/").EndsWith (@"\"), "GetFullPath w#05");
769 // "//" is not allowed
770 Assert.IsTrue (Path.GetFullPath ("readme.txt").EndsWith (@"\readme.txt"), "GetFullPath w#07");
771 Assert.IsTrue (Path.GetFullPath ("c").EndsWith (@"\c"), "GetFullPath w#08");
772 Assert.IsTrue (Path.GetFullPath (@"abc\def").EndsWith (@"abc\def"), "GetFullPath w#09");
773 Assert.IsTrue (Path.GetFullPath (@"\abc\def").EndsWith (@"\abc\def"), "GetFullPath w#10");
774 Assert.AreEqual (@"\\abc\def", Path.GetFullPath (@"\\abc\def"), "GetFullPath w#11");
775 Assert.AreEqual (Directory.GetCurrentDirectory () + @"\abc\def", Path.GetFullPath (@"abc//def"), "GetFullPath w#12");
776 Assert.AreEqual (Directory.GetCurrentDirectory ().Substring (0, 2) + @"\abc\def", Path.GetFullPath ("/abc/def"), "GetFullPath w#13");
777 Assert.AreEqual (@"\\abc\def", Path.GetFullPath ("//abc/def"), "GetFullPath w#14");
779 Assert.AreEqual ("/", Path.GetFullPath ("/"), "#01");
780 Assert.AreEqual ("/hey", Path.GetFullPath ("/hey"), "#02");
781 Assert.AreEqual (Environment.CurrentDirectory, Path.GetFullPath ("."), "#03");
782 Assert.AreEqual (Path.Combine (Environment.CurrentDirectory, "hey"),
783 Path.GetFullPath ("hey"), "#04");
788 public void GetPathRoot ()
793 current = Directory.GetCurrentDirectory ();
794 expected = current [0].ToString ();
796 current = @"J:\Some\Strange Directory\Name";
800 string pathRoot = Path.GetPathRoot (current);
801 Assert.AreEqual (expected, pathRoot, "GetPathRoot #01");
805 public void GetPathRoot2 ()
807 // note: this method doesn't call Directory.GetCurrentDirectory so it can be
808 // reused for partial trust unit tests in PathCas.cs
812 pathRoot = Path.GetPathRoot ("hola");
813 Assert.AreEqual (String.Empty, pathRoot, "#A1");
814 pathRoot = Path.GetPathRoot (null);
815 Assert.AreEqual (null, pathRoot, "#A2");
818 Assert.AreEqual ("z:", Path.GetPathRoot ("z:"), "GetPathRoot w#01");
819 Assert.AreEqual ("c:\\", Path.GetPathRoot ("c:\\abc\\def"), "GetPathRoot w#02");
820 Assert.AreEqual ("\\", Path.GetPathRoot ("\\"), "GetPathRoot w#03");
821 Assert.AreEqual ("\\\\", Path.GetPathRoot ("\\\\"), "GetPathRoot w#04");
822 Assert.AreEqual ("\\", Path.GetPathRoot ("/"), "GetPathRoot w#05");
823 Assert.AreEqual ("\\\\", Path.GetPathRoot ("//"), "GetPathRoot w#06");
824 Assert.AreEqual (String.Empty, Path.GetPathRoot ("readme.txt"), "GetPathRoot w#07");
825 Assert.AreEqual (String.Empty, Path.GetPathRoot ("c"), "GetPathRoot w#08");
826 Assert.AreEqual (String.Empty, Path.GetPathRoot ("abc\\def"), "GetPathRoot w#09");
827 Assert.AreEqual ("\\", Path.GetPathRoot ("\\abc\\def"), "GetPathRoot w#10");
828 Assert.AreEqual ("\\\\abc\\def", Path.GetPathRoot ("\\\\abc\\def"), "GetPathRoot w#11");
829 Assert.AreEqual (String.Empty, Path.GetPathRoot ("abc//def"), "GetPathRoot w#12");
830 Assert.AreEqual ("\\", Path.GetPathRoot ("/abc/def"), "GetPathRoot w#13");
831 Assert.AreEqual ("\\\\abc\\def", Path.GetPathRoot ("//abc/def"), "GetPathRoot w#14");
832 Assert.AreEqual (@"C:\", Path.GetPathRoot (@"C:\"), "GetPathRoot w#15");
833 Assert.AreEqual (@"C:\", Path.GetPathRoot (@"C:\\"), "GetPathRoot w#16");
834 Assert.AreEqual ("\\\\abc\\def", Path.GetPathRoot ("\\\\abc\\def\\ghi"), "GetPathRoot w#17");
836 // TODO: Same tests for Unix.
841 public void GetPathRoot_Path_Empty ()
844 Path.GetPathRoot (String.Empty);
846 } catch (ArgumentException ex) {
847 // The path is not of a legal form
848 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
849 Assert.IsNull (ex.InnerException, "#3");
850 Assert.IsNotNull (ex.Message, "#4");
851 Assert.IsNull (ex.ParamName, "#5");
857 [Category ("NotWorking")] // we also throw ArgumentException on 1.0 profile
859 public void GetPathRoot_Path_InvalidPathChars ()
863 Path.GetPathRoot ("hi\0world");
865 } catch (ArgumentException ex) {
866 // Illegal characters in path
867 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
868 Assert.IsNull (ex.InnerException, "#3");
869 Assert.IsNotNull (ex.Message, "#4");
870 Assert.IsNull (ex.ParamName, "#5");
873 Assert.AreEqual (String.Empty, Path.GetPathRoot ("hi\0world"));
878 public void GetPathRoot_Path_Whitespace ()
881 Path.GetPathRoot (" ");
883 } catch (ArgumentException ex) {
884 // The path is not of a legal form
885 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
886 Assert.IsNull (ex.InnerException, "#3");
887 Assert.IsNotNull (ex.Message, "#4");
888 Assert.IsNull (ex.ParamName, "#5");
893 public void GetTempPath ()
895 string getTempPath = Path.GetTempPath ();
896 Assert.IsTrue (getTempPath != String.Empty, "GetTempPath #01");
897 Assert.IsTrue (Path.IsPathRooted (getTempPath), "GetTempPath #02");
898 Assert.AreEqual (Path.DirectorySeparatorChar, getTempPath [getTempPath.Length - 1], "GetTempPath #03");
902 public void GetTempFileName ()
904 string getTempFileName = null;
906 getTempFileName = Path.GetTempFileName ();
907 Assert.IsTrue (getTempFileName != String.Empty, "GetTempFileName #01");
908 Assert.IsTrue (File.Exists (getTempFileName), "GetTempFileName #02");
910 if (getTempFileName != null && getTempFileName != String.Empty){
911 File.Delete (getTempFileName);
917 public void HasExtension ()
919 Assert.AreEqual (true, Path.HasExtension ("foo.txt"), "HasExtension #01");
920 Assert.AreEqual (false, Path.HasExtension ("foo"), "HasExtension #02");
921 Assert.AreEqual (true, Path.HasExtension (path1), "HasExtension #03");
922 Assert.AreEqual (false, Path.HasExtension (path2), "HasExtension #04");
923 Assert.AreEqual (false, Path.HasExtension (null), "HasExtension #05");
924 Assert.AreEqual (false, Path.HasExtension (String.Empty), "HasExtension #06");
925 Assert.AreEqual (false, Path.HasExtension (" "), "HasExtension #07");
926 Assert.AreEqual (false, Path.HasExtension ("."), "HasExtension #08");
927 Assert.AreEqual (false, Path.HasExtension ("end."), "HasExtension #09");
928 Assert.AreEqual (true, Path.HasExtension (".start"), "HasExtension #10");
929 Assert.AreEqual (true, Path.HasExtension (".a"), "HasExtension #11");
930 Assert.AreEqual (false, Path.HasExtension ("a."), "HasExtension #12");
931 Assert.AreEqual (false, Path.HasExtension ("Makefile"), "HasExtension #13");
935 public void HasExtension_Path_InvalidPathChars ()
938 Path.HasExtension ("hi\0world.txt");
940 } catch (ArgumentException ex) {
941 // Illegal characters in path
942 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
943 Assert.IsNull (ex.InnerException, "#3");
944 Assert.IsNotNull (ex.Message, "#4");
945 Assert.IsNull (ex.ParamName, "#5");
950 public void IsPathRooted ()
952 Assert.IsTrue (Path.IsPathRooted (path2), "IsPathRooted #01");
953 Assert.IsTrue (!Path.IsPathRooted (path3), "IsPathRooted #02");
954 Assert.IsTrue (!Path.IsPathRooted (null), "IsPathRooted #03");
955 Assert.IsTrue (!Path.IsPathRooted (String.Empty), "IsPathRooted #04");
956 Assert.IsTrue (!Path.IsPathRooted (" "), "IsPathRooted #05");
957 Assert.IsTrue (Path.IsPathRooted ("/"), "IsPathRooted #06");
958 Assert.IsTrue (Path.IsPathRooted ("//"), "IsPathRooted #07");
959 Assert.IsTrue (!Path.IsPathRooted (":"), "IsPathRooted #08");
962 Assert.IsTrue (Path.IsPathRooted ("\\"), "IsPathRooted #09");
963 Assert.IsTrue (Path.IsPathRooted ("\\\\"), "IsPathRooted #10");
964 Assert.IsTrue (Path.IsPathRooted ("z:"), "IsPathRooted #11");
965 Assert.IsTrue (Path.IsPathRooted ("z:\\"), "IsPathRooted #12");
966 Assert.IsTrue (Path.IsPathRooted ("z:\\topdir"), "IsPathRooted #13");
967 // This looks MS BUG. It is treated as absolute path
968 Assert.IsTrue (Path.IsPathRooted ("z:curdir"), "IsPathRooted #14");
969 Assert.IsTrue (Path.IsPathRooted ("\\abc\\def"), "IsPathRooted #15");
971 if (Environment.GetEnvironmentVariable ("MONO_IOMAP") == "all"){
972 Assert.IsTrue (Path.IsPathRooted ("\\"), "IsPathRooted #16");
973 Assert.IsTrue (Path.IsPathRooted ("\\\\"), "IsPathRooted #17");
975 Assert.IsTrue (!Path.IsPathRooted ("\\"), "IsPathRooted #09");
976 Assert.IsTrue (!Path.IsPathRooted ("\\\\"), "IsPathRooted #10");
977 Assert.IsTrue (!Path.IsPathRooted ("z:"), "IsPathRooted #11");
983 public void IsPathRooted_Path_Empty ()
985 Assert.IsTrue (!Path.IsPathRooted (String.Empty));
989 public void IsPathRooted_Path_InvalidPathChars ()
992 Path.IsPathRooted ("hi\0world");
994 } catch (ArgumentException ex) {
995 // Illegal characters in path.
996 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
997 Assert.IsNull (ex.InnerException, "#3");
998 Assert.IsNotNull (ex.Message, "#4");
999 Assert.IsNull (ex.ParamName, "#5");
1004 public void IsPathRooted_Path_Null ()
1006 Assert.IsTrue (!Path.IsPathRooted (null));
1010 public void IsPathRooted_Path_Whitespace ()
1012 Assert.IsTrue (!Path.IsPathRooted (" "));
1016 public void CanonicalizeDots ()
1018 string current = Path.GetFullPath (".");
1019 Assert.IsTrue (!current.EndsWith ("."), "TestCanonicalizeDotst #01");
1020 string parent = Path.GetFullPath ("..");
1021 Assert.IsTrue (!current.EndsWith (".."), "TestCanonicalizeDotst #02");
1025 public void WindowsSystem32_76191 ()
1027 // check for Unix platforms - see FAQ for more details
1028 // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
1029 int platform = (int) Environment.OSVersion.Platform;
1030 if ((platform == 4) || (platform == 128) || (platform == 6))
1033 string curdir = Directory.GetCurrentDirectory ();
1036 string system = "C:\\WINDOWS\\system32\\";
1038 string system = Environment.SystemDirectory;
1040 Directory.SetCurrentDirectory (system);
1041 string drive = system.Substring (0, 2);
1042 Assert.AreEqual (system, Path.GetFullPath (drive), "current dir");
1045 Directory.SetCurrentDirectory (curdir);
1050 public void WindowsSystem32_77007 ()
1052 // check for Unix platforms - see FAQ for more details
1053 // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
1054 int platform = (int) Environment.OSVersion.Platform;
1055 if ((platform == 4) || (platform == 128) || (platform == 6))
1058 string curdir = Directory.GetCurrentDirectory ();
1061 string system = "C:\\WINDOWS\\system32\\";
1063 string system = Environment.SystemDirectory;
1065 Directory.SetCurrentDirectory (system);
1066 // e.g. C:dir (no backslash) will return CurrentDirectory + dir
1067 string dir = system.Substring (0, 2) + "dir";
1068 Assert.AreEqual (Path.Combine (system, "dir"), Path.GetFullPath (dir), "current dir");
1071 Directory.SetCurrentDirectory (curdir);
1077 [Ignore("Java full (canonical) path always returns windows dir in caps")]
1079 public void WindowsDriveC14N_77058 ()
1081 // check for Unix platforms - see FAQ for more details
1082 // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
1083 int platform = (int) Environment.OSVersion.Platform;
1084 if ((platform == 4) || (platform == 128) || (platform == 6))
1087 Assert.AreEqual (@"C:\Windows\dir", Path.GetFullPath (@"C:\Windows\System32\..\dir"), "1");
1088 Assert.AreEqual (@"C:\dir", Path.GetFullPath (@"C:\Windows\System32\..\..\dir"), "2");
1089 Assert.AreEqual (@"C:\dir", Path.GetFullPath (@"C:\Windows\System32\..\..\..\dir"), "3");
1090 Assert.AreEqual (@"C:\dir", Path.GetFullPath (@"C:\Windows\System32\..\..\..\..\dir"), "4");
1091 Assert.AreEqual (@"C:\dir\", Path.GetFullPath (@"C:\Windows\System32\..\.\..\.\..\dir\"), "5");
1095 public void InvalidPathChars_Values ()
1097 char[] invalid = Path.InvalidPathChars;
1100 Assert.AreEqual (36, invalid.Length, "Length");
1102 Assert.AreEqual (15, invalid.Length, "Length");
1104 foreach (char c in invalid) {
1110 if ((i == 0) || (i == 8) || ((i > 15) && (i < 19)) || ((i > 19) && (i < 26)))
1113 // in both 1.1 SP1 and 2.0
1114 if ((i == 34) || (i == 60) || (i == 62) || (i == 124))
1116 Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1119 foreach (char c in invalid) {
1123 Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1129 public void InvalidPathChars_Modify ()
1131 char[] expected = Path.InvalidPathChars;
1132 char[] invalid = Path.InvalidPathChars;
1133 char original = invalid[0];
1137 Assert.IsTrue (expected[0] == 'a', "expected");
1138 Assert.AreEqual (expected[0], Path.InvalidPathChars[0], "readonly");
1140 invalid[0] = original;
1146 public void GetInvalidFileNameChars_Values ()
1148 char[] invalid = Path.GetInvalidFileNameChars ();
1150 Assert.AreEqual (41, invalid.Length);
1151 foreach (char c in invalid) {
1155 if ((i == 34) || (i == 60) || (i == 62) || (i == 124))
1157 // ':', '*', '?', '\', '/'
1158 if ((i == 58) || (i == 42) || (i == 63) || (i == 92) || (i == 47))
1160 Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1163 foreach (char c in invalid) {
1166 if ((i == 0) || (i == 47))
1168 Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1174 public void GetInvalidFileNameChars_Modify ()
1176 char[] expected = Path.GetInvalidFileNameChars ();
1177 char[] invalid = Path.GetInvalidFileNameChars ();
1179 Assert.IsTrue (expected[0] != 'a', "expected");
1180 Assert.AreEqual (expected[0], Path.GetInvalidFileNameChars ()[0], "readonly");
1184 public void GetInvalidPathChars_Values ()
1186 char[] invalid = Path.GetInvalidPathChars ();
1188 Assert.AreEqual (36, invalid.Length);
1189 foreach (char c in invalid) {
1193 if ((i == 34) || (i == 60) || (i == 62) || (i == 124))
1195 Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1198 foreach (char c in invalid) {
1202 Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1208 public void GetInvalidPathChars_Order ()
1211 char [] invalid = Path.GetInvalidPathChars ();
1212 char [] expected = new char [36] { '\x22', '\x3C', '\x3E', '\x7C', '\x00', '\x01', '\x02',
1213 '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D',
1214 '\x0E', '\x0F', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18',
1215 '\x19', '\x1A', '\x1B', '\x1C', '\x1D', '\x1E', '\x1F' };
1216 Assert.AreEqual (expected.Length, invalid.Length);
1217 for (int i = 0; i < expected.Length; i++ ) {
1218 Assert.AreEqual (expected [i], invalid [i], "Character at position " + i);
1224 public void GetInvalidPathChars_Modify ()
1226 char[] expected = Path.GetInvalidPathChars ();
1227 char[] invalid = Path.GetInvalidPathChars ();
1229 Assert.IsTrue (expected[0] != 'a', "expected");
1230 Assert.AreEqual (expected[0], Path.GetInvalidPathChars ()[0], "readonly");
1234 public void GetRandomFileName ()
1236 string s = Path.GetRandomFileName ();
1237 Assert.AreEqual (12, s.Length, "Length");
1238 char[] invalid = Path.GetInvalidFileNameChars ();
1239 for (int i=0; i < s.Length; i++) {
1241 Assert.AreEqual ('.', s[i], "8");
1243 Assert.IsTrue (Array.IndexOf (invalid, s[i]) == -1, i.ToString ());
1248 public void GetRandomFileNameIsAlphaNumerical ()
1250 string [] names = new string [1000];
1251 for (int i = 0; i < names.Length; i++)
1252 names [i] = Path.GetRandomFileName ();
1254 foreach (string name in names) {
1255 Assert.AreEqual (12, name.Length);
1256 Assert.AreEqual ('.', name [8]);
1258 for (int i = 0; i < 12; i++) {
1263 Assert.IsTrue (('a' <= c && c <= 'z') || ('0' <= c && c <= '9'));
1269 string Concat (string sep, params string [] parms)
1271 return String.Join (sep, parms);
1275 public void Combine_3Params ()
1277 string sep = Path.DirectorySeparatorChar.ToString ();
1280 Path.Combine (null, "two", "three");
1281 Assert.Fail ("#A1-1");
1287 Path.Combine ("one", null, "three");
1288 Assert.Fail ("#A1-2");
1294 Path.Combine ("one", "two", null);
1295 Assert.Fail ("#A1-3");
1300 Assert.AreEqual (Concat (sep, "one", "two", "three"), Path.Combine ("one", "two", "three"), "#A2-1");
1301 Assert.AreEqual (Concat (sep, sep + "one", "two", "three"), Path.Combine (sep + "one", "two", "three"), "#A2-2");
1302 Assert.AreEqual (Concat (sep, sep + "one", "two", "three"), Path.Combine (sep + "one" + sep, "two", "three"), "#A2-3");
1303 Assert.AreEqual (Concat (sep, sep + "two", "three"), Path.Combine (sep + "one" + sep, sep + "two", "three"), "#A2-4");
1304 Assert.AreEqual (Concat (sep, sep + "three"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three"), "#A2-5");
1306 Assert.AreEqual (Concat (sep, sep + "one" + sep, "two", "three"), Path.Combine (sep + "one" + sep + sep, "two", "three"), "#A3");
1308 Assert.AreEqual ("", Path.Combine ("", "", ""), "#A4");
1312 public void Combine_4Params ()
1314 string sep = Path.DirectorySeparatorChar.ToString ();
1317 Path.Combine (null, "two", "three", "four");
1318 Assert.Fail ("#A1-1");
1324 Path.Combine ("one", null, "three", "four");
1325 Assert.Fail ("#A1-2");
1331 Path.Combine ("one", "two", null, "four");
1332 Assert.Fail ("#A1-3");
1338 Path.Combine ("one", "two", "three", null);
1339 Assert.Fail ("#A1-4");
1344 Assert.AreEqual (Concat (sep, "one", "two", "three", "four"), Path.Combine ("one", "two", "three", "four"), "#A2-1");
1345 Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four"), Path.Combine (sep + "one", "two", "three", "four"), "#A2-2");
1346 Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four"), Path.Combine (sep + "one" + sep, "two", "three", "four"), "#A2-3");
1347 Assert.AreEqual (Concat (sep, sep + "two", "three", "four"), Path.Combine (sep + "one" + sep, sep + "two", "three", "four"), "#A2-4");
1348 Assert.AreEqual (Concat (sep, sep + "three", "four"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", "four"), "#A2-5");
1349 Assert.AreEqual (Concat (sep, sep + "four"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", sep + "four"), "#A2-6");
1351 Assert.AreEqual (Concat (sep, sep + "one" + sep, "two", "three", "four"), Path.Combine (sep + "one" + sep + sep, "two", "three", "four"), "#A3");
1353 Assert.AreEqual ("", Path.Combine ("", "", "", ""), "#A4");
1357 public void Combine_ManyParams ()
1359 string sep = Path.DirectorySeparatorChar.ToString ();
1362 Path.Combine (null, "two", "three", "four", "five");
1363 Assert.Fail ("#A1-1");
1369 Path.Combine ("one", null, "three", "four", "five");
1370 Assert.Fail ("#A1-2");
1376 Path.Combine ("one", "two", null, "four", "five");
1377 Assert.Fail ("#A1-3");
1383 Path.Combine ("one", "two", "three", null, "five");
1384 Assert.Fail ("#A1-4");
1390 Path.Combine ("one", "two", "three", "four", null);
1391 Assert.Fail ("#A1-5");
1396 Assert.AreEqual (Concat (sep, "one", "two", "three", "four", "five"), Path.Combine ("one", "two", "three", "four", "five"), "#A2-1");
1397 Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four", "five"), Path.Combine (sep + "one", "two", "three", "four", "five"), "#A2-2");
1398 Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four", "five"), Path.Combine (sep + "one" + sep, "two", "three", "four", "five"), "#A2-3");
1399 Assert.AreEqual (Concat (sep, sep + "two", "three", "four", "five"), Path.Combine (sep + "one" + sep, sep + "two", "three", "four", "five"), "#A2-4");
1400 Assert.AreEqual (Concat (sep, sep + "three", "four", "five"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", "four", "five"), "#A2-5");
1401 Assert.AreEqual (Concat (sep, sep + "four", "five"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", sep + "four", "five"), "#A2-6");
1402 Assert.AreEqual (Concat (sep, sep + "five"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", sep + "four", sep + "five"), "#A2-6");
1404 Assert.AreEqual (Concat (sep, sep + "one" + sep, "two", "three", "four", "five"), Path.Combine (sep + "one" + sep + sep, "two", "three", "four", "five"), "#A3");
1406 Assert.AreEqual ("", Path.Combine ("", "", "", "", ""), "#A4");