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

   1 //
   2 // System.IO.Path Test Cases
   3 //
   4 // Authors:
   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>
  11 //
  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)
  17 //
  18
  19 using NUnit.Framework;
  20 using System.IO;
  21 using System;
  22 using System.Text;
  23
  24 namespace MonoTests.System.IO
  25 {
  26         enum OsType {
  27                 Windows,
  28                 Unix,
  29                 Mac
  30         }
  31
  32         [TestFixture]
  33         public class PathTest
  34         {
  35                 static string path1;
  36                 static string path2;
  37                 static string path3;
  38                 static OsType OS;
  39                 static char DSC = Path.DirectorySeparatorChar;
  40
  41                 [SetUp]
  42                 public void SetUp ()
  43                 {
  44                         if ('/' == DSC) {
  45                                 OS = OsType.Unix;
  46                                 path1 = "/foo/test.txt";
  47                                 path2 = "/etc";
  48                                 path3 = "init.d";
  49                         } else if ('\\' == DSC) {
  50                                 OS = OsType.Windows;
  51                                 path1 = "c:\\foo\\test.txt";
  52                                 path2 = Environment.GetEnvironmentVariable ("SYSTEMROOT");
  53                                 path3 = "system32";
  54                         } else {
  55                                 OS = OsType.Mac;
  56                                 //FIXME: For Mac. figure this out when we need it
  57                                 path1 = "foo:test.txt";
  58                                 path2 = "foo";
  59                                 path3 = "bar";
  60                         }
  61                 }
  62
  63                 bool Windows
  64                 {
  65                         get {
  66                                 return OS == OsType.Windows;
  67                         }
  68                 }
  69
  70                 bool Unix
  71                 {
  72                         get {
  73                                 return OS == OsType.Unix;
  74                         }
  75                 }
  76
  77                 bool Mac
  78                 {
  79                         get {
  80                                 return OS == OsType.Mac;
  81                         }
  82                 }
  83
  84                 [Test]
  85                 public void ChangeExtension ()
  86                 {
  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";
  91
  92                         string testPath = Path.ChangeExtension (path1, "doc");
  93                         Assert.AreEqual (files [(int) OS], testPath, "ChangeExtension #01");
  94
  95                         testPath = Path.ChangeExtension (String.Empty, ".extension");
  96                         Assert.AreEqual (String.Empty, testPath, "ChangeExtension #02");
  97
  98                         testPath = Path.ChangeExtension (null, ".extension");
  99                         Assert.AreEqual (null, testPath, "ChangeExtension #03");
 100
 101                         testPath = Path.ChangeExtension ("path", null);
 102                         Assert.AreEqual ("path", testPath, "ChangeExtension #04");
 103
 104                         testPath = Path.ChangeExtension ("path.ext", "doc");
 105                         Assert.AreEqual ("path.doc", testPath, "ChangeExtension #05");
 106
 107                         testPath = Path.ChangeExtension ("path.ext1.ext2", "doc");
 108                         Assert.AreEqual ("path.ext1.doc", testPath, "ChangeExtension #06");
 109
 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");
 134                 }
 135
 136                 [Test]
 137                 public void ChangeExtension_Extension_InvalidPathChars ()
 138                 {
 139                         string fn = Path.ChangeExtension ("file.ext", "<");
 140                         Assert.AreEqual ("file.<", fn, "Invalid filename");
 141                 }
 142
 143                 [Test]
 144                 public void ChangeExtension_Path_InvalidPathChars ()
 145                 {
 146                         try {
 147                                 Path.ChangeExtension ("fi\0le.ext", ".extension");
 148                                 Assert.Fail ("#1");
 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");
 155                         }
 156                 }
 157
 158                 [Test]
 159                 public void Combine ()
 160                 {
 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";
 165
 166                         string testPath = Path.Combine (path2, path3);
 167                         Assert.AreEqual (files [(int) OS], testPath, "Combine #01");
 168
 169                         testPath = Path.Combine ("one", String.Empty);
 170                         Assert.AreEqual ("one", testPath, "Combine #02");
 171
 172                         testPath = Path.Combine (String.Empty, "one");
 173                         Assert.AreEqual ("one", testPath, "Combine #03");
 174
 175                         string current = Directory.GetCurrentDirectory ();
 176                         testPath = Path.Combine (current, "one");
 177
 178                         string expected = current + DSC + "one";
 179                         Assert.AreEqual (expected, testPath, "Combine #04");
 180
 181                         testPath = Path.Combine ("one", current);
 182                         // LAMESPEC noted in Path.cs
 183                         Assert.AreEqual (current, testPath, "Combine #05");
 184
 185                         testPath = Path.Combine (current, expected);
 186                         Assert.AreEqual (expected, testPath, "Combine #06");
 187
 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");
 192
 193                         testPath = "one" + DSC;
 194                         testPath = Path.Combine (testPath, DSC + "two");
 195                         expected = DSC + "two";
 196                         Assert.AreEqual (expected, testPath, "Combine #06");
 197
 198                         testPath = "one" + DSC;
 199                         testPath = Path.Combine (testPath, "two" + DSC);
 200                         expected = "one" + DSC + "two" + DSC;
 201                         Assert.AreEqual (expected, testPath, "Combine #07");
 202
 203 #if NET_4_0
 204                         Assert.AreEqual ("a", Path.Combine (new [] { "a", "" }), "Combine #08");
 205 #endif
 206                 }
 207
 208                 [Test]
 209                 public void Combine_Path1_InvalidPathChars ()
 210                 {
 211                         try {
 212                                 Path.Combine ("a\0", "one");
 213                                 Assert.Fail ("#1");
 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");
 220                         }
 221                 }
 222
 223                 [Test]
 224                 public void Combine_Path1_Null ()
 225                 {
 226                         try {
 227                                 Path.Combine (null, "one");
 228                                 Assert.Fail ("#1");
 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");
 234                         }
 235                 }
 236
 237                 [Test]
 238                 public void Combine_Path2_InvalidPathChars ()
 239                 {
 240                         try {
 241                                 Path.Combine ("one", "a\0");
 242                                 Assert.Fail ("#1");
 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");
 249                         }
 250                 }
 251
 252                 [Test]
 253                 public void Combine_Path2_Null ()
 254                 {
 255                         try {
 256                                 Path.Combine ("one", null);
 257                                 Assert.Fail ("#1");
 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");
 263                         }
 264                 }
 265
 266                 [Test]
 267                 public void GetDirectoryName ()
 268                 {
 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";
 273
 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");
 278
 279                         if (Windows) {
 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");
 289
 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");
 294
 295                                 // UNC tests
 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");
 302                         } else {
 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");
 309                         }
 310                 }
 311
 312                 [Test]
 313                 public void GetDirectoryName_Path_Empty ()
 314                 {
 315                         try {
 316                                 Path.GetDirectoryName (String.Empty);
 317                                 Assert.Fail ("#1");
 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");
 324                         }
 325                 }
 326
 327                 [Test]
 328                 public void GetDirectoryName_Path_InvalidPathChars ()
 329                 {
 330                         try {
 331                                 Path.GetDirectoryName ("hi\0world");
 332                                 Assert.Fail ("#1");
 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");
 339                         }
 340                 }
 341
 342                 [Test]
 343                 public void GetDirectoryName_Path_Null ()
 344                 {
 345                         Assert.IsNull (Path.GetDirectoryName (null));
 346                 }
 347
 348                 [Test]
 349                 public void GetDirectoryName_Path_Whitespace ()
 350                 {
 351                         try {
 352                                 Path.GetDirectoryName ("   ");
 353                                 Assert.Fail ("#1");
 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");
 360                         }
 361                 }
 362
 363                 [Test]
 364                 public void GetExtension ()
 365                 {
 366                         string testExtn = Path.GetExtension (path1);
 367
 368                         Assert.AreEqual (".txt", testExtn, "GetExtension #01");
 369
 370                         testExtn = Path.GetExtension (path2);
 371                         Assert.AreEqual (String.Empty, testExtn, "GetExtension #02");
 372
 373                         testExtn = Path.GetExtension (String.Empty);
 374                         Assert.AreEqual (String.Empty, testExtn, "GetExtension #03");
 375
 376                         testExtn = Path.GetExtension (null);
 377                         Assert.AreEqual (null, testExtn, "GetExtension #04");
 378
 379                         testExtn = Path.GetExtension (" ");
 380                         Assert.AreEqual (String.Empty, testExtn, "GetExtension #05");
 381
 382                         testExtn = Path.GetExtension (path1 + ".doc");
 383                         Assert.AreEqual (".doc", testExtn, "GetExtension #06");
 384
 385                         testExtn = Path.GetExtension (path1 + ".doc" + DSC + "a.txt");
 386                         Assert.AreEqual (".txt", testExtn, "GetExtension #07");
 387
 388                         testExtn = Path.GetExtension (".");
 389                         Assert.AreEqual (String.Empty, testExtn, "GetExtension #08");
 390
 391                         testExtn = Path.GetExtension ("end.");
 392                         Assert.AreEqual (String.Empty, testExtn, "GetExtension #09");
 393
 394                         testExtn = Path.GetExtension (".start");
 395                         Assert.AreEqual (".start", testExtn, "GetExtension #10");
 396
 397                         testExtn = Path.GetExtension (".a");
 398                         Assert.AreEqual (".a", testExtn, "GetExtension #11");
 399
 400                         testExtn = Path.GetExtension ("a.");
 401                         Assert.AreEqual (String.Empty, testExtn, "GetExtension #12");
 402
 403                         testExtn = Path.GetExtension ("a");
 404                         Assert.AreEqual (String.Empty, testExtn, "GetExtension #13");
 405
 406                         testExtn = Path.GetExtension ("makefile");
 407                         Assert.AreEqual (String.Empty, testExtn, "GetExtension #14");
 408                 }
 409
 410                 [Test]
 411                 public void GetExtension_Path_InvalidPathChars ()
 412                 {
 413                         try {
 414                                 Path.GetExtension ("hi\0world.txt");
 415                                 Assert.Fail ("#1");
 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");
 422                         }
 423                 }
 424
 425                 [Test]
 426                 public void GetFileName ()
 427                 {
 428                         string testFileName = Path.GetFileName (path1);
 429
 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");
 437                 }
 438
 439                 [Test]
 440                 public void GetFileName_Path_InvalidPathChars ()
 441                 {
 442                         try {
 443                                 Path.GetFileName ("hi\0world");
 444                                 Assert.Fail ("#1");
 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");
 451                         }
 452                 }
 453
 454                 [Test]
 455                 public void GetFileNameWithoutExtension ()
 456                 {
 457                         string testFileName = Path.GetFileNameWithoutExtension (path1);
 458
 459                         Assert.AreEqual ("test", testFileName, "GetFileNameWithoutExtension #01");
 460
 461                         testFileName = Path.GetFileNameWithoutExtension (null);
 462                         Assert.AreEqual (null, testFileName, "GetFileNameWithoutExtension #02");
 463
 464                         testFileName = Path.GetFileNameWithoutExtension (String.Empty);
 465                         Assert.AreEqual (String.Empty, testFileName, "GetFileNameWithoutExtension #03");
 466                 }
 467
 468                 [Test]
 469                 public void GetFileNameWithoutExtension_Path_InvalidPathChars ()
 470                 {
 471                         try {
 472                                 Path.GetFileNameWithoutExtension ("hi\0world");
 473                                 Assert.Fail ("#1");
 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");
 480                         }
 481                 }
 482
 483                 [Test]
 484                 public void GetFullPath ()
 485                 {
 486                         string current = Directory.GetCurrentDirectory ();
 487
 488                         string testFullPath = Path.GetFullPath ("foo.txt");
 489                         string expected = current + DSC + "foo.txt";
 490                         Assert.AreEqual (expected, testFullPath, "GetFullPath #01");
 491
 492                         testFullPath = Path.GetFullPath ("a//./.././foo.txt");
 493                         Assert.AreEqual (expected, testFullPath, "GetFullPath #02");
 494
 495                         if (!Windows){
 496                                 Assert.AreEqual ("/bin/bash", Path.GetFullPath ("/../bin/bash"));
 497                         }
 498
 499                 }
 500
 501                 [Test]
 502                 public void GetFullPath_Unix ()
 503                 {
 504                         if (Windows)
 505                                 Assert.Ignore ("Running on Windows.");
 506
 507                         string root =  "/";
 508                         string [,] test = new string [,] {
 509                                 {"root////././././././../root/././../root", "root"},
 510                                 {"root/", "root/"},
 511                                 {"root/./", "root/"},
 512                                 {"root/./", "root/"},
 513                                 {"root/../", String.Empty},
 514                                 {"root/../", String.Empty},
 515                                 {"root/../..", String.Empty},
 516                                 {"root/.hiddenfile", "root/.hiddenfile"},
 517                                 {"root/. /", "root/. /"},
 518                                 {"root/.. /", "root/.. /"},
 519                                 {"root/..weirdname", "root/..weirdname"},
 520                                 {"root/..", String.Empty},
 521                                 {"root/../a/b/../../..", String.Empty},
 522                                 {"root/./..", String.Empty},
 523                                 {"..", String.Empty},
 524                                 {".", String.Empty},
 525                                 {"root//dir", "root/dir"},
 526                                 {"root/.              /", "root/.              /"},
 527                                 {"root/..             /", "root/..             /"},
 528                                 {"root/      .              /", "root/      .              /"},
 529                                 {"root/      ..             /", "root/      ..             /"},
 530                                 {"root/./", "root/"},
 531                                 //ERROR! Paths are trimmed
 532                                 // I don't understand this comment^^.
 533                                 // No trimming occurs but the paths are not equal. That's why the test fails. Commented out.
 534                                 //{"root/..                      /", "root/..                   /"},
 535                                 {".//", String.Empty}
 536                         };
 537
 538                         for (int i = 0; i < test.GetUpperBound (0); i++) {
 539                                 Assert.AreEqual (root + test [i, 1], Path.GetFullPath (root + test [i, 0]),
 540                                                  String.Format ("GetFullPathUnix #{0}", i));
 541                         }
 542
 543                         Assert.AreEqual ("/", Path.GetFullPath ("/"), "#01");
 544                         Assert.AreEqual ("/hey", Path.GetFullPath ("/hey"), "#02");
 545                         Assert.AreEqual (Environment.CurrentDirectory, Path.GetFullPath ("."), "#03");
 546                         Assert.AreEqual (Path.Combine (Environment.CurrentDirectory, "hey"),
 547                                              Path.GetFullPath ("hey"), "#04");
 548                         Assert.AreEqual ("/", Path.GetFullPath ("/"), "#01");
 549
 550                         string curdir = Directory.GetCurrentDirectory ();
 551                         try {
 552                                 Directory.SetCurrentDirectory ("/");
 553                                 Assert.AreEqual ("/test.txt", Path.GetFullPath ("test.txt"), "xambug #833");
 554                         }
 555                         finally {
 556                                 Directory.SetCurrentDirectory (curdir);
 557                         }
 558                 }
 559
 560                 [Test]
 561                 public void GetFullPath_Windows ()
 562                 {
 563                         if (!Windows)
 564                                 Assert.Ignore ("Not running on Windows.");
 565
 566                         string root =  "C:\\";
 567                         string [,] test = new string [,] {
 568                                 {"root////././././././../root/././../root", "root"},
 569                                 {"root/", "root\\"},
 570                                 {"root/./", "root\\"},
 571                                 {"root/./", "root\\"},
 572                                 {"root/../", ""},
 573                                 {"root/../", ""},
 574                                 {"root/../..", ""},
 575                                 {"root/.hiddenfile", "root\\.hiddenfile"},
 576                                 {"root/. /", "root\\"},
 577                                 {"root/.. /", ""},
 578                                 {"root/..weirdname", "root\\..weirdname"},
 579                                 {"root/..", ""},
 580                                 {"root/../a/b/../../..", ""},
 581                                 {"root/./..", ""},
 582                                 {"..", ""},
 583                                 {".", ""},
 584                                 {"root//dir", "root\\dir"},
 585                                 {"root/.              /", "root\\"},
 586                                 {"root/..             /", ""},
 587                                 {"root/./", "root\\"},
 588                                 {"root/..                      /", ""},
 589                                 {".//", ""}
 590                         };
 591
 592                         for (int i = 0; i < test.GetUpperBound (0); i++) {
 593                                 try {
 594                                         Assert.AreEqual (root + test [i, 1], Path.GetFullPath (root + test [i, 0]),
 595                                                          String.Format ("GetFullPathWindows #{0}", i));
 596                                 } catch (Exception ex) {
 597                                         Assert.Fail (String.Format ("GetFullPathWindows #{0} (\"{1}\") failed: {2}",
 598                                                 i, root + test [i, 0], ex.GetType ()));
 599                                 }
 600                         }
 601
 602                         // UNC tests
 603                         string root2 = @"\\server\share";
 604                         root = @"\\server\share\";
 605                         test = new string [,] {
 606                                 {"root////././././././../root/././../root", "root"},
 607                                 {"root/", "root\\"},
 608                                 {"root/./", "root\\"},
 609                                 {"root/./", "root\\"},
 610                                 {"root/../", ""},
 611                                 {"root/../", ""},
 612                                 {"root/../..", null},
 613                                 {"root/.hiddenfile", "root\\.hiddenfile"},
 614                                 {"root/. /", "root\\"},
 615                                 {"root/.. /", ""},
 616                                 {"root/..weirdname", "root\\..weirdname"},
 617                                 {"root/..", null},
 618                                 {"root/../a/b/../../..", null},
 619                                 {"root/./..", null},
 620                                 {"..", null},
 621                                 {".", null},
 622                                 {"root//dir", "root\\dir"},
 623                                 {"root/.              /", "root\\"},
 624                                 {"root/..             /", ""},
 625                                 {"root/./", "root\\"},
 626                                 {"root/..                      /", ""},
 627                                 {".//", ""}
 628                         };
 629
 630                         for (int i = 0; i < test.GetUpperBound (0); i++) {
 631                                 // "null" means we have to compare against "root2"
 632                                 string res = test [i, 1] != null
 633                                         ? root + test [i, 1]
 634                                         : root2;
 635                                 try {
 636                                         Assert.AreEqual (res, Path.GetFullPath (root + test [i, 0]),
 637                                                          String.Format ("GetFullPathWindows UNC #{0}", i));
 638                                 } catch (AssertionException) {
 639                                         throw;
 640                                 } catch (Exception ex) {
 641                                         Assert.Fail (String.Format ("GetFullPathWindows UNC #{0} (\"{1}\") failed: {2}",
 642                                                 i, root + test [i, 0], ex.GetType ()));
 643                                 }
 644                         }
 645
 646                         test = new string [,] {
 647                                 {"root////././././././../root/././../root", "root"},
 648                                 {"root/", "root\\"},
 649                                 {"root/./", "root\\"},
 650                                 {"root/./", "root\\"},
 651                                 {"root/../", ""},
 652                                 {"root/../", ""},
 653                                 {"root/../..", null},
 654                                 {"root/.hiddenfile", "root\\.hiddenfile"},
 655                                 {"root/. /", "root\\"},
 656                                 {"root/.. /", ""},
 657                                 {"root/..weirdname", "root\\..weirdname"},
 658                                 {"root/..", null},
 659                                 {"root/../a/b/../../..", null},
 660                                 {"root/./..", null},
 661                                 {"..", null},
 662                                 {".", null},
 663                                 {"root//dir", "root\\dir"},
 664                                 {"root/.              /", "root\\"},
 665                                 {"root/..             /", ""},
 666                                 {"root/./", "root\\"},
 667                                 {"root/..                      /", ""},
 668                                 {".//", ""}
 669                         };
 670
 671                         string root3 = @"//server/share";
 672                         root = @"//server/share/";
 673                         bool needSlashConvert = Path.DirectorySeparatorChar != '/';
 674
 675                         for (int i = 0; i < test.GetUpperBound (0); i++) {
 676                                 // "null" means we have to compare against "root2"
 677                                 string res = test [i, 1] != null
 678                                         ? root + test [i, 1]
 679                                         : root3;
 680                                 if (needSlashConvert)
 681                                         res = res.Replace ('/', Path.DirectorySeparatorChar);
 682                                 try {
 683                                         Assert.AreEqual (res, Path.GetFullPath (root + test [i, 0]),
 684                                                          String.Format ("GetFullPathWindows UNC[2] #{0}", i));
 685                                 } catch (AssertionException) {
 686                                         throw;
 687                                 } catch (Exception ex) {
 688                                         Assert.Fail (String.Format ("GetFullPathWindows UNC[2] #{0} (\"{1}\") failed: {2}",
 689                                                 i, root + test [i, 0], ex.GetType ()));
 690                                 }
 691                         }
 692                 }
 693
 694                 [Test]
 695                 public void GetFullPath_Path_Empty ()
 696                 {
 697                         try {
 698                                 Path.GetFullPath (String.Empty);
 699                                 Assert.Fail ("#1");
 700                         } catch (ArgumentException ex) {
 701                                 // The path is not of a legal form
 702                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 703                                 Assert.IsNull (ex.InnerException, "#3");
 704                                 Assert.IsNotNull (ex.Message, "#4");
 705                                 Assert.IsNull (ex.ParamName, "#5");
 706                         }
 707                 }
 708
 709                 [Test]
 710                 public void GetFullPath_Path_EndingSeparator ()
 711                 {
 712                         string fp = Path.GetFullPath ("something/");
 713                         char end = fp [fp.Length - 1];
 714                         Assert.IsTrue (end == Path.DirectorySeparatorChar);
 715                 }
 716
 717                 [Test]
 718                 public void GetFullPath_Path_InvalidPathChars ()
 719                 {
 720                         try {
 721                                 Path.GetFullPath ("hi\0world");
 722                                 Assert.Fail ("#1");
 723                         } catch (ArgumentException ex) {
 724                                 // Illegal characters in path
 725                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 726                                 Assert.IsNull (ex.InnerException, "#3");
 727                                 Assert.IsNotNull (ex.Message, "#4");
 728                                 Assert.IsNull (ex.ParamName, "#5");
 729                         }
 730                 }
 731
 732                 [Test]
 733                 public void GetFullPath_Path_Null ()
 734                 {
 735                         try {
 736                                 Path.GetFullPath (null);
 737                                 Assert.Fail ("#1");
 738                         } catch (ArgumentNullException ex) {
 739                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 740                                 Assert.IsNull (ex.InnerException, "#3");
 741                                 Assert.IsNotNull (ex.Message, "#4");
 742                                 Assert.AreEqual ("path", ex.ParamName, "#5");
 743                         }
 744                 }
 745
 746                 [Test]
 747                 public void GetFullPath_Path_Whitespace ()
 748                 {
 749                         try {
 750                                 Path.GetFullPath ("  ");
 751                                 Assert.Fail ("#1");
 752                         } catch (ArgumentException ex) {
 753                                 // The path is not of a legal form
 754                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 755                                 Assert.IsNull (ex.InnerException, "#3");
 756                                 Assert.IsNotNull (ex.Message, "#4");
 757                                 Assert.IsNull (ex.ParamName, "#5");
 758                         }
 759                 }
 760
 761                 [Test]
 762                 public void GetFullPath2 ()
 763                 {
 764                         if (Windows) {
 765                                 Assert.AreEqual (@"Z:\", Path.GetFullPath ("Z:"), "GetFullPath w#01");
 766                                 Assert.AreEqual (@"c:\abc\def", Path.GetFullPath (@"c:\abc\def"), "GetFullPath w#02");
 767                                 Assert.IsTrue (Path.GetFullPath (@"\").EndsWith (@"\"), "GetFullPath w#03");
 768                                 // "\\\\" is not allowed
 769                                 Assert.IsTrue (Path.GetFullPath ("/").EndsWith (@"\"), "GetFullPath w#05");
 770                                 // "//" is not allowed
 771                                 Assert.IsTrue (Path.GetFullPath ("readme.txt").EndsWith (@"\readme.txt"), "GetFullPath w#07");
 772                                 Assert.IsTrue (Path.GetFullPath ("c").EndsWith (@"\c"), "GetFullPath w#08");
 773                                 Assert.IsTrue (Path.GetFullPath (@"abc\def").EndsWith (@"abc\def"), "GetFullPath w#09");
 774                                 Assert.IsTrue (Path.GetFullPath (@"\abc\def").EndsWith (@"\abc\def"), "GetFullPath w#10");
 775                                 Assert.AreEqual (@"\\abc\def", Path.GetFullPath (@"\\abc\def"), "GetFullPath w#11");
 776                                 Assert.AreEqual (Directory.GetCurrentDirectory () + @"\abc\def", Path.GetFullPath (@"abc//def"), "GetFullPath w#12");
 777                                 Assert.AreEqual (Directory.GetCurrentDirectory ().Substring (0, 2) + @"\abc\def", Path.GetFullPath ("/abc/def"), "GetFullPath w#13");
 778                                 Assert.AreEqual (@"\\abc\def", Path.GetFullPath ("//abc/def"), "GetFullPath w#14");
 779                         } else {
 780                                 Assert.AreEqual ("/", Path.GetFullPath ("/"), "#01");
 781                                 Assert.AreEqual ("/hey", Path.GetFullPath ("/hey"), "#02");
 782                                 Assert.AreEqual (Environment.CurrentDirectory, Path.GetFullPath ("."), "#03");
 783                                 Assert.AreEqual (Path.Combine (Environment.CurrentDirectory, "hey"),
 784                                                      Path.GetFullPath ("hey"), "#04");
 785                         }
 786                 }
 787
 788                 [Test]
 789                 public void GetPathRoot ()
 790                 {
 791                         string current;
 792                         string expected;
 793                         if (!Windows){
 794                                 current = Directory.GetCurrentDirectory ();
 795                                 expected = current [0].ToString ();
 796                         } else {
 797                                 current = @"J:\Some\Strange Directory\Name";
 798                                 expected = "J:\\";
 799                         }
 800
 801                         string pathRoot = Path.GetPathRoot (current);
 802                         Assert.AreEqual (expected, pathRoot, "GetPathRoot #01");
 803                 }
 804
 805                 [Test]
 806                 public void GetPathRoot2 ()
 807                 {
 808                         // note: this method doesn't call Directory.GetCurrentDirectory so it can be
 809                         // reused for partial trust unit tests in PathCas.cs
 810
 811                         string pathRoot;
 812
 813                         pathRoot = Path.GetPathRoot ("hola");
 814                         Assert.AreEqual (String.Empty, pathRoot, "#A1");
 815                         pathRoot = Path.GetPathRoot (null);
 816                         Assert.AreEqual (null, pathRoot, "#A2");
 817
 818                         if (Windows) {
 819                                 Assert.AreEqual ("z:", Path.GetPathRoot ("z:"), "GetPathRoot w#01");
 820                                 Assert.AreEqual ("c:\\", Path.GetPathRoot ("c:\\abc\\def"), "GetPathRoot w#02");
 821                                 Assert.AreEqual ("\\", Path.GetPathRoot ("\\"), "GetPathRoot w#03");
 822                                 Assert.AreEqual ("\\\\", Path.GetPathRoot ("\\\\"), "GetPathRoot w#04");
 823                                 Assert.AreEqual ("\\", Path.GetPathRoot ("/"), "GetPathRoot w#05");
 824                                 Assert.AreEqual ("\\\\", Path.GetPathRoot ("//"), "GetPathRoot w#06");
 825                                 Assert.AreEqual (String.Empty, Path.GetPathRoot ("readme.txt"), "GetPathRoot w#07");
 826                                 Assert.AreEqual (String.Empty, Path.GetPathRoot ("c"), "GetPathRoot w#08");
 827                                 Assert.AreEqual (String.Empty, Path.GetPathRoot ("abc\\def"), "GetPathRoot w#09");
 828                                 Assert.AreEqual ("\\", Path.GetPathRoot ("\\abc\\def"), "GetPathRoot w#10");
 829                                 Assert.AreEqual ("\\\\abc\\def", Path.GetPathRoot ("\\\\abc\\def"), "GetPathRoot w#11");
 830                                 Assert.AreEqual (String.Empty, Path.GetPathRoot ("abc//def"), "GetPathRoot w#12");
 831                                 Assert.AreEqual ("\\", Path.GetPathRoot ("/abc/def"), "GetPathRoot w#13");
 832                                 Assert.AreEqual ("\\\\abc\\def", Path.GetPathRoot ("//abc/def"), "GetPathRoot w#14");
 833                                 Assert.AreEqual (@"C:\", Path.GetPathRoot (@"C:\"), "GetPathRoot w#15");
 834                                 Assert.AreEqual (@"C:\", Path.GetPathRoot (@"C:\\"), "GetPathRoot w#16");
 835                                 Assert.AreEqual ("\\\\abc\\def", Path.GetPathRoot ("\\\\abc\\def\\ghi"), "GetPathRoot w#17");
 836                         } else {
 837                                 // TODO: Same tests for Unix.
 838                         }
 839                 }
 840
 841                 [Test]
 842                 public void GetPathRoot_Path_Empty ()
 843                 {
 844                         try {
 845                                 Path.GetPathRoot (String.Empty);
 846                                 Assert.Fail ("#1");
 847                         } catch (ArgumentException ex) {
 848                                 // The path is not of a legal form
 849                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 850                                 Assert.IsNull (ex.InnerException, "#3");
 851                                 Assert.IsNotNull (ex.Message, "#4");
 852                                 Assert.IsNull (ex.ParamName, "#5");
 853                         }
 854                 }
 855
 856                 [Test]
 857                 public void GetPathRoot_Path_InvalidPathChars ()
 858                 {
 859                         try {
 860                                 Path.GetPathRoot ("hi\0world");
 861                                 Assert.Fail ("#1");
 862                         } catch (ArgumentException ex) {
 863                                 // Illegal characters in path
 864                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 865                                 Assert.IsNull (ex.InnerException, "#3");
 866                                 Assert.IsNotNull (ex.Message, "#4");
 867                                 Assert.IsNull (ex.ParamName, "#5");
 868                         }
 869                 }
 870
 871                 [Test]
 872                 public void GetPathRoot_Path_Whitespace ()
 873                 {
 874                         try {
 875                                 Path.GetPathRoot ("  ");
 876                                 Assert.Fail ("#1");
 877                         } catch (ArgumentException ex) {
 878                                 // The path is not of a legal form
 879                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 880                                 Assert.IsNull (ex.InnerException, "#3");
 881                                 Assert.IsNotNull (ex.Message, "#4");
 882                                 Assert.IsNull (ex.ParamName, "#5");
 883                         }
 884                 }
 885
 886                 [Test]
 887                 public void GetTempPath ()
 888                 {
 889                         string getTempPath = Path.GetTempPath ();
 890                         Assert.IsTrue (getTempPath != String.Empty, "GetTempPath #01");
 891                         Assert.IsTrue (Path.IsPathRooted (getTempPath), "GetTempPath #02");
 892                         Assert.AreEqual (Path.DirectorySeparatorChar, getTempPath [getTempPath.Length - 1], "GetTempPath #03");
 893                 }
 894
 895                 [Test]
 896                 public void GetTempFileName ()
 897                 {
 898                         string getTempFileName = null;
 899                         try {
 900                                 getTempFileName = Path.GetTempFileName ();
 901                                 Assert.IsTrue (getTempFileName != String.Empty, "GetTempFileName #01");
 902                                 Assert.IsTrue (File.Exists (getTempFileName), "GetTempFileName #02");
 903                         } finally {
 904                                 if (getTempFileName != null && getTempFileName != String.Empty){
 905                                         File.Delete (getTempFileName);
 906                                 }
 907                         }
 908                 }
 909
 910                 [Test]
 911                 public void HasExtension ()
 912                 {
 913                         Assert.AreEqual (true, Path.HasExtension ("foo.txt"), "HasExtension #01");
 914                         Assert.AreEqual (false, Path.HasExtension ("foo"), "HasExtension #02");
 915                         Assert.AreEqual (true, Path.HasExtension (path1), "HasExtension #03");
 916                         Assert.AreEqual (false, Path.HasExtension (path2), "HasExtension #04");
 917                         Assert.AreEqual (false, Path.HasExtension (null), "HasExtension #05");
 918                         Assert.AreEqual (false, Path.HasExtension (String.Empty), "HasExtension #06");
 919                         Assert.AreEqual (false, Path.HasExtension (" "), "HasExtension #07");
 920                         Assert.AreEqual (false, Path.HasExtension ("."), "HasExtension #08");
 921                         Assert.AreEqual (false, Path.HasExtension ("end."), "HasExtension #09");
 922                         Assert.AreEqual (true, Path.HasExtension (".start"), "HasExtension #10");
 923                         Assert.AreEqual (true, Path.HasExtension (".a"), "HasExtension #11");
 924                         Assert.AreEqual (false, Path.HasExtension ("a."), "HasExtension #12");
 925                         Assert.AreEqual (false, Path.HasExtension ("Makefile"), "HasExtension #13");
 926                 }
 927
 928                 [Test]
 929                 public void HasExtension_Path_InvalidPathChars ()
 930                 {
 931                         try {
 932                                 Path.HasExtension ("hi\0world.txt");
 933                                 Assert.Fail ("#1");
 934                         } catch (ArgumentException ex) {
 935                                 // Illegal characters in path
 936                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 937                                 Assert.IsNull (ex.InnerException, "#3");
 938                                 Assert.IsNotNull (ex.Message, "#4");
 939                                 Assert.IsNull (ex.ParamName, "#5");
 940                         }
 941                 }
 942
 943                 [Test]
 944                 public void IsPathRooted ()
 945                 {
 946                         Assert.IsTrue (Path.IsPathRooted (path2), "IsPathRooted #01");
 947                         Assert.IsTrue (!Path.IsPathRooted (path3), "IsPathRooted #02");
 948                         Assert.IsTrue (!Path.IsPathRooted (null), "IsPathRooted #03");
 949                         Assert.IsTrue (!Path.IsPathRooted (String.Empty), "IsPathRooted #04");
 950                         Assert.IsTrue (!Path.IsPathRooted (" "), "IsPathRooted #05");
 951                         Assert.IsTrue (Path.IsPathRooted ("/"), "IsPathRooted #06");
 952                         Assert.IsTrue (Path.IsPathRooted ("//"), "IsPathRooted #07");
 953                         Assert.IsTrue (!Path.IsPathRooted (":"), "IsPathRooted #08");
 954
 955                         if (Windows) {
 956                                 Assert.IsTrue (Path.IsPathRooted ("\\"), "IsPathRooted #09");
 957                                 Assert.IsTrue (Path.IsPathRooted ("\\\\"), "IsPathRooted #10");
 958                                 Assert.IsTrue (Path.IsPathRooted ("z:"), "IsPathRooted #11");
 959                                 Assert.IsTrue (Path.IsPathRooted ("z:\\"), "IsPathRooted #12");
 960                                 Assert.IsTrue (Path.IsPathRooted ("z:\\topdir"), "IsPathRooted #13");
 961                                 // This looks MS BUG. It is treated as absolute path
 962                                 Assert.IsTrue (Path.IsPathRooted ("z:curdir"), "IsPathRooted #14");
 963                                 Assert.IsTrue (Path.IsPathRooted ("\\abc\\def"), "IsPathRooted #15");
 964                         } else {
 965                                 if (Environment.GetEnvironmentVariable ("MONO_IOMAP") == "all"){
 966                                         Assert.IsTrue (Path.IsPathRooted ("\\"), "IsPathRooted #16");
 967                                         Assert.IsTrue (Path.IsPathRooted ("\\\\"), "IsPathRooted #17");
 968                                 } else {
 969                                         Assert.IsTrue (!Path.IsPathRooted ("\\"), "IsPathRooted #09");
 970                                         Assert.IsTrue (!Path.IsPathRooted ("\\\\"), "IsPathRooted #10");
 971                                         Assert.IsTrue (!Path.IsPathRooted ("z:"), "IsPathRooted #11");
 972                                 }
 973                         }
 974                 }
 975
 976                 [Test]
 977                 public void IsPathRooted_Path_Empty ()
 978                 {
 979                         Assert.IsTrue (!Path.IsPathRooted (String.Empty));
 980                 }
 981
 982                 [Test]
 983                 public void IsPathRooted_Path_InvalidPathChars ()
 984                 {
 985                         try {
 986                                 Path.IsPathRooted ("hi\0world");
 987                                 Assert.Fail ("#1");
 988                         } catch (ArgumentException ex) {
 989                                 // Illegal characters in path.
 990                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 991                                 Assert.IsNull (ex.InnerException, "#3");
 992                                 Assert.IsNotNull (ex.Message, "#4");
 993                                 Assert.IsNull (ex.ParamName, "#5");
 994                         }
 995                 }
 996
 997                 [Test]
 998                 public void IsPathRooted_Path_Null ()
 999                 {
1000                         Assert.IsTrue (!Path.IsPathRooted (null));
1001                 }
1002
1003                 [Test]
1004                 public void IsPathRooted_Path_Whitespace ()
1005                 {
1006                         Assert.IsTrue (!Path.IsPathRooted ("  "));
1007                 }
1008
1009                 [Test]
1010                 public void CanonicalizeDots ()
1011                 {
1012                         string current = Path.GetFullPath (".");
1013                         Assert.IsTrue (!current.EndsWith ("."), "TestCanonicalizeDotst #01");
1014                         string parent = Path.GetFullPath ("..");
1015                         Assert.IsTrue (!current.EndsWith (".."), "TestCanonicalizeDotst #02");
1016                 }
1017 #if !MOBILE
1018                 [Test]
1019                 public void WindowsSystem32_76191 ()
1020                 {
1021                         // check for Unix platforms - see FAQ for more details
1022                         // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
1023                         int platform = (int) Environment.OSVersion.Platform;
1024                         if ((platform == 4) || (platform == 128) || (platform == 6))
1025                                 Assert.Ignore ("Running on Unix.");
1026
1027                         string curdir = Directory.GetCurrentDirectory ();
1028                         try {
1029                                 string system = Environment.SystemDirectory;
1030                                 Directory.SetCurrentDirectory (system);
1031                                 string drive = system.Substring (0, 2);
1032                                 Assert.AreEqual (system, Path.GetFullPath (drive), "current dir");
1033                         }
1034                         finally {
1035                                 Directory.SetCurrentDirectory (curdir);
1036                         }
1037                 }
1038
1039                 [Test]
1040                 public void WindowsSystem32_77007 ()
1041                 {
1042                         // check for Unix platforms - see FAQ for more details
1043                         // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
1044                         int platform = (int) Environment.OSVersion.Platform;
1045                         if ((platform == 4) || (platform == 128) || (platform == 6))
1046                                 Assert.Ignore ("Running on Unix.");
1047
1048                         string curdir = Directory.GetCurrentDirectory ();
1049                         try {
1050                                 string system = Environment.SystemDirectory;
1051                                 Directory.SetCurrentDirectory (system);
1052                                 // e.g. C:dir (no backslash) will return CurrentDirectory + dir
1053                                 string dir = system.Substring (0, 2) + "dir";
1054                                 Assert.AreEqual (Path.Combine (system, "dir"), Path.GetFullPath (dir), "current dir");
1055                         }
1056                         finally {
1057                                 Directory.SetCurrentDirectory (curdir);
1058                         }
1059                 }
1060 #endif
1061                 [Test]
1062                 public void WindowsDriveC14N_77058 ()
1063                 {
1064                         // check for Unix platforms - see FAQ for more details
1065                         // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
1066                         int platform = (int) Environment.OSVersion.Platform;
1067                         if ((platform == 4) || (platform == 128) || (platform == 6))
1068                                 Assert.Ignore ("Running on Unix.");
1069
1070                         Assert.AreEqual (@"C:\Windows\dir", Path.GetFullPath (@"C:\Windows\System32\..\dir"), "1");
1071                         Assert.AreEqual (@"C:\dir", Path.GetFullPath (@"C:\Windows\System32\..\..\dir"), "2");
1072                         Assert.AreEqual (@"C:\dir", Path.GetFullPath (@"C:\Windows\System32\..\..\..\dir"), "3");
1073                         Assert.AreEqual (@"C:\dir", Path.GetFullPath (@"C:\Windows\System32\..\..\..\..\dir"), "4");
1074                         Assert.AreEqual (@"C:\dir\", Path.GetFullPath (@"C:\Windows\System32\..\.\..\.\..\dir\"), "5");
1075                 }
1076
1077                 [Test]
1078                 public void InvalidPathChars_Values ()
1079                 {
1080                         char[] invalid = Path.InvalidPathChars;
1081                         if (Windows) {
1082                                 Assert.AreEqual (36, invalid.Length, "Length");
1083
1084                                 foreach (char c in invalid) {
1085                                         int i = (int) c;
1086
1087                                         if (i < 32)
1088                                                 continue;
1089
1090                                         // in both 1.1 SP1 and 2.0
1091                                         if ((i == 34) || (i == 60) || (i == 62) || (i == 124))
1092                                                 continue;
1093                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1094                                 }
1095                         } else {
1096                                 foreach (char c in invalid) {
1097                                         int i = (int) c;
1098                                         if (i == 0)
1099                                                 continue;
1100                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1101                                 }
1102                         }
1103                 }
1104
1105                 [Test]
1106                 public void InvalidPathChars_Modify ()
1107                 {
1108                         char[] expected = Path.InvalidPathChars;
1109                         char[] invalid = Path.InvalidPathChars;
1110                         char original = invalid[0];
1111                         try {
1112                                 invalid[0] = 'a';
1113                                 // kind of scary
1114                                 Assert.IsTrue (expected[0] == 'a', "expected");
1115                                 Assert.AreEqual (expected[0], Path.InvalidPathChars[0], "readonly");
1116                         } finally {
1117                                 invalid[0] = original;
1118                         }
1119                 }
1120
1121                 [Test]
1122                 public void GetInvalidFileNameChars_Values ()
1123                 {
1124                         char[] invalid = Path.GetInvalidFileNameChars ();
1125                         if (Windows) {
1126                                 Assert.AreEqual (41, invalid.Length);
1127                                 foreach (char c in invalid) {
1128                                         int i = (int) c;
1129                                         if (i < 32)
1130                                                 continue;
1131                                         if ((i == 34) || (i == 60) || (i == 62) || (i == 124))
1132                                                 continue;
1133                                         // ':', '*', '?', '\', '/'
1134                                         if ((i == 58) || (i == 42) || (i == 63) || (i == 92) || (i == 47))
1135                                                 continue;
1136                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1137                                 }
1138                         } else {
1139                                 foreach (char c in invalid) {
1140                                         int i = (int) c;
1141                                         // null or '/'
1142                                         if ((i == 0) || (i == 47))
1143                                                 continue;
1144                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1145                                 }
1146                         }
1147                 }
1148
1149                 [Test]
1150                 public void GetInvalidFileNameChars_Modify ()
1151                 {
1152                         char[] expected = Path.GetInvalidFileNameChars ();
1153                         char[] invalid = Path.GetInvalidFileNameChars ();
1154                         invalid[0] = 'a';
1155                         Assert.IsTrue (expected[0] != 'a', "expected");
1156                         Assert.AreEqual (expected[0], Path.GetInvalidFileNameChars ()[0], "readonly");
1157                 }
1158
1159                 [Test]
1160                 public void GetInvalidPathChars_Values ()
1161                 {
1162                         char[] invalid = Path.GetInvalidPathChars ();
1163                         if (Windows) {
1164                                 Assert.AreEqual (36, invalid.Length);
1165                                 foreach (char c in invalid) {
1166                                         int i = (int) c;
1167                                         if (i < 32)
1168                                                 continue;
1169                                         if ((i == 34) || (i == 60) || (i == 62) || (i == 124))
1170                                                 continue;
1171                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1172                                 }
1173                         } else {
1174                                 foreach (char c in invalid) {
1175                                         int i = (int) c;
1176                                         if (i == 0)
1177                                                 continue;
1178                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1179                                 }
1180                         }
1181                 }
1182
1183                 [Test]
1184                 public void GetInvalidPathChars_Order ()
1185                 {
1186                         if (Windows) {
1187                                 char [] invalid = Path.GetInvalidPathChars ();
1188                                 char [] expected = new char [36] { '\x22', '\x3C', '\x3E', '\x7C', '\x00', '\x01', '\x02',
1189                                         '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D',
1190                                         '\x0E', '\x0F', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18',
1191                                         '\x19', '\x1A', '\x1B', '\x1C', '\x1D', '\x1E', '\x1F' };
1192                                 Assert.AreEqual (expected.Length, invalid.Length);
1193                                 for (int i = 0; i < expected.Length; i++ ) {
1194                                         Assert.AreEqual (expected [i], invalid [i], "Character at position " + i);
1195                                 }
1196                         }
1197                 }
1198
1199                 [Test]
1200                 public void GetInvalidPathChars_Modify ()
1201                 {
1202                         char[] expected = Path.GetInvalidPathChars ();
1203                         char[] invalid = Path.GetInvalidPathChars ();
1204                         invalid[0] = 'a';
1205                         Assert.IsTrue (expected[0] != 'a', "expected");
1206                         Assert.AreEqual (expected[0], Path.GetInvalidPathChars ()[0], "readonly");
1207                 }
1208
1209                 [Test]
1210                 public void GetRandomFileName ()
1211                 {
1212                         string s = Path.GetRandomFileName ();
1213                         Assert.AreEqual (12, s.Length, "Length");
1214                         char[] invalid = Path.GetInvalidFileNameChars ();
1215                         for (int i=0; i < s.Length; i++) {
1216                                 if (i == 8)
1217                                         Assert.AreEqual ('.', s[i], "8");
1218                                 else
1219                                         Assert.IsTrue (Array.IndexOf (invalid, s[i]) == -1, i.ToString ());
1220                         }
1221                 }
1222
1223                 [Test]
1224                 public void GetRandomFileNameIsAlphaNumerical ()
1225                 {
1226                         string [] names = new string [1000];
1227                         for (int i = 0; i < names.Length; i++)
1228                                 names [i] = Path.GetRandomFileName ();
1229
1230                         foreach (string name in names) {
1231                                 Assert.AreEqual (12, name.Length);
1232                                 Assert.AreEqual ('.', name [8]);
1233
1234                                 for (int i = 0; i < 12; i++) {
1235                                         if (i == 8)
1236                                                 continue;
1237
1238                                         char c = name [i];
1239                                         Assert.IsTrue (('a' <= c && c <= 'z') || ('0' <= c && c <= '9'));
1240                                 }
1241                         }
1242                 }
1243
1244 #if NET_4_0
1245                 string Concat (string sep, params string [] parms)
1246                 {
1247                         return String.Join (sep, parms);
1248                 }
1249
1250                 [Test]
1251                 public void Combine_3Params ()
1252                 {
1253                         string sep = Path.DirectorySeparatorChar.ToString ();
1254
1255                         try {
1256                                 Path.Combine (null, "two", "three");
1257                                 Assert.Fail ("#A1-1");
1258                         } catch {
1259                                 // success
1260                         }
1261
1262                         try {
1263                                 Path.Combine ("one", null, "three");
1264                                 Assert.Fail ("#A1-2");
1265                         } catch {
1266                                 // success
1267                         }
1268
1269                         try {
1270                                 Path.Combine ("one", "two", null);
1271                                 Assert.Fail ("#A1-3");
1272                         } catch {
1273                                 // success
1274                         }
1275
1276                         Assert.AreEqual (Concat (sep, "one", "two", "three"), Path.Combine ("one", "two", "three"), "#A2-1");
1277                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three"), Path.Combine (sep + "one", "two", "three"), "#A2-2");
1278                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three"), Path.Combine (sep + "one" + sep, "two", "three"), "#A2-3");
1279                         Assert.AreEqual (Concat (sep, sep + "two", "three"), Path.Combine (sep + "one" + sep, sep + "two", "three"), "#A2-4");
1280                         Assert.AreEqual (Concat (sep, sep + "three"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three"), "#A2-5");
1281
1282                         Assert.AreEqual (Concat (sep, sep + "one" + sep, "two", "three"), Path.Combine (sep + "one" + sep + sep, "two", "three"), "#A3");
1283
1284                         Assert.AreEqual ("", Path.Combine ("", "", ""), "#A4");
1285                 }
1286
1287                 [Test]
1288                 public void Combine_4Params ()
1289                 {
1290                         string sep = Path.DirectorySeparatorChar.ToString ();
1291
1292                         try {
1293                                 Path.Combine (null, "two", "three", "four");
1294                                 Assert.Fail ("#A1-1");
1295                         } catch {
1296                                 // success
1297                         }
1298
1299                         try {
1300                                 Path.Combine ("one", null, "three", "four");
1301                                 Assert.Fail ("#A1-2");
1302                         } catch {
1303                                 // success
1304                         }
1305
1306                         try {
1307                                 Path.Combine ("one", "two", null, "four");
1308                                 Assert.Fail ("#A1-3");
1309                         } catch {
1310                                 // success
1311                         }
1312
1313                         try {
1314                                 Path.Combine ("one", "two", "three", null);
1315                                 Assert.Fail ("#A1-4");
1316                         } catch {
1317                                 // success
1318                         }
1319
1320                         Assert.AreEqual (Concat (sep, "one", "two", "three", "four"), Path.Combine ("one", "two", "three", "four"), "#A2-1");
1321                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four"), Path.Combine (sep + "one", "two", "three", "four"), "#A2-2");
1322                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four"), Path.Combine (sep + "one" + sep, "two", "three", "four"), "#A2-3");
1323                         Assert.AreEqual (Concat (sep, sep + "two", "three", "four"), Path.Combine (sep + "one" + sep, sep + "two", "three", "four"), "#A2-4");
1324                         Assert.AreEqual (Concat (sep, sep + "three", "four"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", "four"), "#A2-5");
1325                         Assert.AreEqual (Concat (sep, sep + "four"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", sep + "four"), "#A2-6");
1326
1327                         Assert.AreEqual (Concat (sep, sep + "one" + sep, "two", "three", "four"), Path.Combine (sep + "one" + sep + sep, "two", "three", "four"), "#A3");
1328
1329                         Assert.AreEqual ("", Path.Combine ("", "", "", ""), "#A4");
1330                 }
1331
1332                 [Test]
1333                 public void Combine_ManyParams ()
1334                 {
1335                         string sep = Path.DirectorySeparatorChar.ToString ();
1336
1337                         try {
1338                                 Path.Combine (null, "two", "three", "four", "five");
1339                                 Assert.Fail ("#A1-1");
1340                         } catch {
1341                                 // success
1342                         }
1343
1344                         try {
1345                                 Path.Combine ("one", null, "three", "four", "five");
1346                                 Assert.Fail ("#A1-2");
1347                         } catch {
1348                                 // success
1349                         }
1350
1351                         try {
1352                                 Path.Combine ("one", "two", null, "four", "five");
1353                                 Assert.Fail ("#A1-3");
1354                         } catch {
1355                                 // success
1356                         }
1357
1358                         try {
1359                                 Path.Combine ("one", "two", "three", null, "five");
1360                                 Assert.Fail ("#A1-4");
1361                         } catch {
1362                                 // success
1363                         }
1364
1365                         try {
1366                                 Path.Combine ("one", "two", "three", "four", null);
1367                                 Assert.Fail ("#A1-5");
1368                         } catch {
1369                                 // success
1370                         }
1371
1372                         Assert.AreEqual (Concat (sep, "one", "two", "three", "four", "five"), Path.Combine ("one", "two", "three", "four", "five"), "#A2-1");
1373                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four", "five"), Path.Combine (sep + "one", "two", "three", "four", "five"), "#A2-2");
1374                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four", "five"), Path.Combine (sep + "one" + sep, "two", "three", "four", "five"), "#A2-3");
1375                         Assert.AreEqual (Concat (sep, sep + "two", "three", "four", "five"), Path.Combine (sep + "one" + sep, sep + "two", "three", "four", "five"), "#A2-4");
1376                         Assert.AreEqual (Concat (sep, sep + "three", "four", "five"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", "four", "five"), "#A2-5");
1377                         Assert.AreEqual (Concat (sep, sep + "four", "five"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", sep + "four", "five"), "#A2-6");
1378                         Assert.AreEqual (Concat (sep, sep + "five"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", sep + "four", sep + "five"), "#A2-6");
1379
1380                         Assert.AreEqual (Concat (sep, sep + "one" + sep, "two", "three", "four", "five"), Path.Combine (sep + "one" + sep + sep, "two", "three", "four", "five"), "#A3");
1381
1382                         Assert.AreEqual ("", Path.Combine ("", "", "", "", ""), "#A4");
1383                 }
1384 #endif
1385         }
1386 }
1387