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                                 return;
 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                 }
 549
 550                 [Test]
 551                 public void GetFullPath_Windows ()
 552                 {
 553                         if (!Windows)
 554                                 return;
 555
 556                         string root =  "C:\\";
 557                         string [,] test = new string [,] {
 558                                 {"root////././././././../root/././../root", "root"},
 559                                 {"root/", "root\\"},
 560                                 {"root/./", "root\\"},
 561                                 {"root/./", "root\\"},
 562                                 {"root/../", ""},
 563                                 {"root/../", ""},
 564                                 {"root/../..", ""},
 565                                 {"root/.hiddenfile", "root\\.hiddenfile"},
 566                                 {"root/. /", "root\\"},
 567                                 {"root/.. /", ""},
 568                                 {"root/..weirdname", "root\\..weirdname"},
 569                                 {"root/..", ""},
 570                                 {"root/../a/b/../../..", ""},
 571                                 {"root/./..", ""},
 572                                 {"..", ""},
 573                                 {".", ""},
 574                                 {"root//dir", "root\\dir"},
 575                                 {"root/.              /", "root\\"},
 576                                 {"root/..             /", ""},
 577 #if !NET_2_0
 578                                 {"root/      .              /", "root\\"},
 579                                 {"root/      ..             /", ""},
 580 #endif
 581                                 {"root/./", "root\\"},
 582                                 {"root/..                      /", ""},
 583                                 {".//", ""}
 584                         };
 585
 586                         for (int i = 0; i < test.GetUpperBound (0); i++) {
 587                                 try {
 588                                         Assert.AreEqual (root + test [i, 1], Path.GetFullPath (root + test [i, 0]),
 589                                                          String.Format ("GetFullPathWindows #{0}", i));
 590                                 } catch (Exception ex) {
 591                                         Assert.Fail (String.Format ("GetFullPathWindows #{0} (\"{1}\") failed: {2}",
 592                                                 i, root + test [i, 0], ex.GetType ()));
 593                                 }
 594                         }
 595
 596                         // UNC tests
 597                         string root2 = @"\\server\share";
 598                         root = @"\\server\share\";
 599                         test = new string [,] {
 600                                 {"root////././././././../root/././../root", "root"},
 601                                 {"root/", "root\\"},
 602                                 {"root/./", "root\\"},
 603                                 {"root/./", "root\\"},
 604                                 {"root/../", ""},
 605                                 {"root/../", ""},
 606                                 {"root/../..", null},
 607                                 {"root/.hiddenfile", "root\\.hiddenfile"},
 608                                 {"root/. /", "root\\"},
 609                                 {"root/.. /", ""},
 610                                 {"root/..weirdname", "root\\..weirdname"},
 611                                 {"root/..", null},
 612                                 {"root/../a/b/../../..", null},
 613                                 {"root/./..", null},
 614                                 {"..", null},
 615                                 {".", null},
 616                                 {"root//dir", "root\\dir"},
 617                                 {"root/.              /", "root\\"},
 618                                 {"root/..             /", ""},
 619 #if !NET_2_0
 620                                 {"root/      .              /", "root\\"},
 621                                 {"root/      ..             /", ""},
 622 #endif
 623                                 {"root/./", "root\\"},
 624                                 {"root/..                      /", ""},
 625                                 {".//", ""}
 626                         };
 627
 628                         for (int i = 0; i < test.GetUpperBound (0); i++) {
 629                                 // "null" means we have to compare against "root2"
 630                                 string res = test [i, 1] != null
 631                                         ? root + test [i, 1]
 632                                         : root2;
 633                                 try {
 634                                         Assert.AreEqual (res, Path.GetFullPath (root + test [i, 0]),
 635                                                          String.Format ("GetFullPathWindows UNC #{0}", i));
 636                                 } catch (AssertionException) {
 637                                         throw;
 638                                 } catch (Exception ex) {
 639                                         Assert.Fail (String.Format ("GetFullPathWindows UNC #{0} (\"{1}\") failed: {2}",
 640                                                 i, root + test [i, 0], ex.GetType ()));
 641                                 }
 642                         }
 643
 644                         test = new string [,] {
 645                                 {"root////././././././../root/././../root", "root"},
 646                                 {"root/", "root\\"},
 647                                 {"root/./", "root\\"},
 648                                 {"root/./", "root\\"},
 649                                 {"root/../", ""},
 650                                 {"root/../", ""},
 651                                 {"root/../..", null},
 652                                 {"root/.hiddenfile", "root\\.hiddenfile"},
 653                                 {"root/. /", "root\\"},
 654                                 {"root/.. /", ""},
 655                                 {"root/..weirdname", "root\\..weirdname"},
 656                                 {"root/..", null},
 657                                 {"root/../a/b/../../..", null},
 658                                 {"root/./..", null},
 659                                 {"..", null},
 660                                 {".", null},
 661                                 {"root//dir", "root\\dir"},
 662                                 {"root/.              /", "root\\"},
 663                                 {"root/..             /", ""},
 664 #if !NET_2_0
 665                                 {"root/      .              /", "root\\"},
 666                                 {"root/      ..             /", ""},
 667 #endif
 668                                 {"root/./", "root\\"},
 669                                 {"root/..                      /", ""},
 670                                 {".//", ""}
 671                         };
 672
 673                         string root3 = @"//server/share";
 674                         root = @"//server/share/";
 675                         bool needSlashConvert = Path.DirectorySeparatorChar != '/';
 676
 677                         for (int i = 0; i < test.GetUpperBound (0); i++) {
 678                                 // "null" means we have to compare against "root2"
 679                                 string res = test [i, 1] != null
 680                                         ? root + test [i, 1]
 681                                         : root3;
 682                                 if (needSlashConvert)
 683                                         res = res.Replace ('/', Path.DirectorySeparatorChar);
 684                                 try {
 685                                         Assert.AreEqual (res, Path.GetFullPath (root + test [i, 0]),
 686                                                          String.Format ("GetFullPathWindows UNC[2] #{0}", i));
 687                                 } catch (AssertionException) {
 688                                         throw;
 689                                 } catch (Exception ex) {
 690                                         Assert.Fail (String.Format ("GetFullPathWindows UNC[2] #{0} (\"{1}\") failed: {2}",
 691                                                 i, root + test [i, 0], ex.GetType ()));
 692                                 }
 693                         }
 694                 }
 695
 696                 [Test]
 697                 public void GetFullPath_Path_Empty ()
 698                 {
 699                         try {
 700                                 Path.GetFullPath (String.Empty);
 701                                 Assert.Fail ("#1");
 702                         } catch (ArgumentException ex) {
 703                                 // The path is not of a legal form
 704                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 705                                 Assert.IsNull (ex.InnerException, "#3");
 706                                 Assert.IsNotNull (ex.Message, "#4");
 707                                 Assert.IsNull (ex.ParamName, "#5");
 708                         }
 709                 }
 710
 711                 [Test]
 712                 public void GetFullPath_Path_EndingSeparator ()
 713                 {
 714                         string fp = Path.GetFullPath ("something/");
 715                         char end = fp [fp.Length - 1];
 716                         Assert.IsTrue (end == Path.DirectorySeparatorChar);
 717                 }
 718
 719                 [Test]
 720                 public void GetFullPath_Path_InvalidPathChars ()
 721                 {
 722                         try {
 723                                 Path.GetFullPath ("hi\0world");
 724                                 Assert.Fail ("#1");
 725                         } catch (ArgumentException ex) {
 726                                 // Illegal characters in path
 727                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 728                                 Assert.IsNull (ex.InnerException, "#3");
 729                                 Assert.IsNotNull (ex.Message, "#4");
 730                                 Assert.IsNull (ex.ParamName, "#5");
 731                         }
 732                 }
 733
 734                 [Test]
 735                 public void GetFullPath_Path_Null ()
 736                 {
 737                         try {
 738                                 Path.GetFullPath (null);
 739                                 Assert.Fail ("#1");
 740                         } catch (ArgumentNullException ex) {
 741                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 742                                 Assert.IsNull (ex.InnerException, "#3");
 743                                 Assert.IsNotNull (ex.Message, "#4");
 744                                 Assert.AreEqual ("path", ex.ParamName, "#5");
 745                         }
 746                 }
 747
 748                 [Test]
 749                 public void GetFullPath_Path_Whitespace ()
 750                 {
 751                         try {
 752                                 Path.GetFullPath ("  ");
 753                                 Assert.Fail ("#1");
 754                         } catch (ArgumentException ex) {
 755                                 // The path is not of a legal form
 756                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 757                                 Assert.IsNull (ex.InnerException, "#3");
 758                                 Assert.IsNotNull (ex.Message, "#4");
 759                                 Assert.IsNull (ex.ParamName, "#5");
 760                         }
 761                 }
 762
 763                 [Test]
 764                 public void GetFullPath2 ()
 765                 {
 766                         if (Windows) {
 767                                 Assert.AreEqual (@"Z:\", Path.GetFullPath ("Z:"), "GetFullPath w#01");
 768 #if !TARGET_JVM // Java full (canonical) path always starts with caps drive letter
 769                                 Assert.AreEqual (@"c:\abc\def", Path.GetFullPath (@"c:\abc\def"), "GetFullPath w#02");
 770 #endif
 771                                 Assert.IsTrue (Path.GetFullPath (@"\").EndsWith (@"\"), "GetFullPath w#03");
 772                                 // "\\\\" is not allowed
 773                                 Assert.IsTrue (Path.GetFullPath ("/").EndsWith (@"\"), "GetFullPath w#05");
 774                                 // "//" is not allowed
 775                                 Assert.IsTrue (Path.GetFullPath ("readme.txt").EndsWith (@"\readme.txt"), "GetFullPath w#07");
 776                                 Assert.IsTrue (Path.GetFullPath ("c").EndsWith (@"\c"), "GetFullPath w#08");
 777                                 Assert.IsTrue (Path.GetFullPath (@"abc\def").EndsWith (@"abc\def"), "GetFullPath w#09");
 778                                 Assert.IsTrue (Path.GetFullPath (@"\abc\def").EndsWith (@"\abc\def"), "GetFullPath w#10");
 779                                 Assert.AreEqual (@"\\abc\def", Path.GetFullPath (@"\\abc\def"), "GetFullPath w#11");
 780                                 Assert.AreEqual (Directory.GetCurrentDirectory () + @"\abc\def", Path.GetFullPath (@"abc//def"), "GetFullPath w#12");
 781                                 Assert.AreEqual (Directory.GetCurrentDirectory ().Substring (0, 2) + @"\abc\def", Path.GetFullPath ("/abc/def"), "GetFullPath w#13");
 782                                 Assert.AreEqual (@"\\abc\def", Path.GetFullPath ("//abc/def"), "GetFullPath w#14");
 783                         } else {
 784                                 Assert.AreEqual ("/", Path.GetFullPath ("/"), "#01");
 785                                 Assert.AreEqual ("/hey", Path.GetFullPath ("/hey"), "#02");
 786                                 Assert.AreEqual (Environment.CurrentDirectory, Path.GetFullPath ("."), "#03");
 787                                 Assert.AreEqual (Path.Combine (Environment.CurrentDirectory, "hey"),
 788                                                      Path.GetFullPath ("hey"), "#04");
 789                         }
 790                 }
 791
 792                 [Test]
 793                 public void GetPathRoot ()
 794                 {
 795                         string current;
 796                         string expected;
 797                         if (!Windows){
 798                                 current = Directory.GetCurrentDirectory ();
 799                                 expected = current [0].ToString ();
 800                         } else {
 801                                 current = @"J:\Some\Strange Directory\Name";
 802                                 expected = "J:\\";
 803                         }
 804
 805                         string pathRoot = Path.GetPathRoot (current);
 806                         Assert.AreEqual (expected, pathRoot, "GetPathRoot #01");
 807                 }
 808
 809                 [Test]
 810                 public void GetPathRoot2 ()
 811                 {
 812                         // note: this method doesn't call Directory.GetCurrentDirectory so it can be
 813                         // reused for partial trust unit tests in PathCas.cs
 814
 815                         string pathRoot;
 816
 817                         pathRoot = Path.GetPathRoot ("hola");
 818                         Assert.AreEqual (String.Empty, pathRoot, "#A1");
 819                         pathRoot = Path.GetPathRoot (null);
 820                         Assert.AreEqual (null, pathRoot, "#A2");
 821
 822                         if (Windows) {
 823                                 Assert.AreEqual ("z:", Path.GetPathRoot ("z:"), "GetPathRoot w#01");
 824                                 Assert.AreEqual ("c:\\", Path.GetPathRoot ("c:\\abc\\def"), "GetPathRoot w#02");
 825                                 Assert.AreEqual ("\\", Path.GetPathRoot ("\\"), "GetPathRoot w#03");
 826                                 Assert.AreEqual ("\\\\", Path.GetPathRoot ("\\\\"), "GetPathRoot w#04");
 827                                 Assert.AreEqual ("\\", Path.GetPathRoot ("/"), "GetPathRoot w#05");
 828                                 Assert.AreEqual ("\\\\", Path.GetPathRoot ("//"), "GetPathRoot w#06");
 829                                 Assert.AreEqual (String.Empty, Path.GetPathRoot ("readme.txt"), "GetPathRoot w#07");
 830                                 Assert.AreEqual (String.Empty, Path.GetPathRoot ("c"), "GetPathRoot w#08");
 831                                 Assert.AreEqual (String.Empty, Path.GetPathRoot ("abc\\def"), "GetPathRoot w#09");
 832                                 Assert.AreEqual ("\\", Path.GetPathRoot ("\\abc\\def"), "GetPathRoot w#10");
 833                                 Assert.AreEqual ("\\\\abc\\def", Path.GetPathRoot ("\\\\abc\\def"), "GetPathRoot w#11");
 834                                 Assert.AreEqual (String.Empty, Path.GetPathRoot ("abc//def"), "GetPathRoot w#12");
 835                                 Assert.AreEqual ("\\", Path.GetPathRoot ("/abc/def"), "GetPathRoot w#13");
 836                                 Assert.AreEqual ("\\\\abc\\def", Path.GetPathRoot ("//abc/def"), "GetPathRoot w#14");
 837                                 Assert.AreEqual (@"C:\", Path.GetPathRoot (@"C:\"), "GetPathRoot w#15");
 838                                 Assert.AreEqual (@"C:\", Path.GetPathRoot (@"C:\\"), "GetPathRoot w#16");
 839                                 Assert.AreEqual ("\\\\abc\\def", Path.GetPathRoot ("\\\\abc\\def\\ghi"), "GetPathRoot w#17");
 840                         } else {
 841                                 // TODO: Same tests for Unix.
 842                         }
 843                 }
 844
 845                 [Test]
 846                 public void GetPathRoot_Path_Empty ()
 847                 {
 848                         try {
 849                                 Path.GetPathRoot (String.Empty);
 850                                 Assert.Fail ("#1");
 851                         } catch (ArgumentException ex) {
 852                                 // The path is not of a legal form
 853                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 854                                 Assert.IsNull (ex.InnerException, "#3");
 855                                 Assert.IsNotNull (ex.Message, "#4");
 856                                 Assert.IsNull (ex.ParamName, "#5");
 857                         }
 858                 }
 859
 860                 [Test]
 861 #if ONLY_1_1
 862                 [Category ("NotWorking")] // we also throw ArgumentException on 1.0 profile
 863 #endif
 864                 public void GetPathRoot_Path_InvalidPathChars ()
 865                 {
 866 #if NET_2_0
 867                         try {
 868                                 Path.GetPathRoot ("hi\0world");
 869                                 Assert.Fail ("#1");
 870                         } catch (ArgumentException ex) {
 871                                 // Illegal characters in path
 872                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 873                                 Assert.IsNull (ex.InnerException, "#3");
 874                                 Assert.IsNotNull (ex.Message, "#4");
 875                                 Assert.IsNull (ex.ParamName, "#5");
 876                         }
 877 #else
 878                         Assert.AreEqual (String.Empty, Path.GetPathRoot ("hi\0world"));
 879 #endif
 880                 }
 881
 882                 [Test]
 883                 public void GetPathRoot_Path_Whitespace ()
 884                 {
 885                         try {
 886                                 Path.GetPathRoot ("  ");
 887                                 Assert.Fail ("#1");
 888                         } catch (ArgumentException ex) {
 889                                 // The path is not of a legal form
 890                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 891                                 Assert.IsNull (ex.InnerException, "#3");
 892                                 Assert.IsNotNull (ex.Message, "#4");
 893                                 Assert.IsNull (ex.ParamName, "#5");
 894                         }
 895                 }
 896
 897                 [Test]
 898                 public void GetTempPath ()
 899                 {
 900                         string getTempPath = Path.GetTempPath ();
 901                         Assert.IsTrue (getTempPath != String.Empty, "GetTempPath #01");
 902                         Assert.IsTrue (Path.IsPathRooted (getTempPath), "GetTempPath #02");
 903                         Assert.AreEqual (Path.DirectorySeparatorChar, getTempPath [getTempPath.Length - 1], "GetTempPath #03");
 904                 }
 905
 906                 [Test]
 907                 public void GetTempFileName ()
 908                 {
 909                         string getTempFileName = null;
 910                         try {
 911                                 getTempFileName = Path.GetTempFileName ();
 912                                 Assert.IsTrue (getTempFileName != String.Empty, "GetTempFileName #01");
 913                                 Assert.IsTrue (File.Exists (getTempFileName), "GetTempFileName #02");
 914                         } finally {
 915                                 if (getTempFileName != null && getTempFileName != String.Empty){
 916                                         File.Delete (getTempFileName);
 917                                 }
 918                         }
 919                 }
 920
 921                 [Test]
 922                 public void HasExtension ()
 923                 {
 924                         Assert.AreEqual (true, Path.HasExtension ("foo.txt"), "HasExtension #01");
 925                         Assert.AreEqual (false, Path.HasExtension ("foo"), "HasExtension #02");
 926                         Assert.AreEqual (true, Path.HasExtension (path1), "HasExtension #03");
 927                         Assert.AreEqual (false, Path.HasExtension (path2), "HasExtension #04");
 928                         Assert.AreEqual (false, Path.HasExtension (null), "HasExtension #05");
 929                         Assert.AreEqual (false, Path.HasExtension (String.Empty), "HasExtension #06");
 930                         Assert.AreEqual (false, Path.HasExtension (" "), "HasExtension #07");
 931                         Assert.AreEqual (false, Path.HasExtension ("."), "HasExtension #08");
 932                         Assert.AreEqual (false, Path.HasExtension ("end."), "HasExtension #09");
 933                         Assert.AreEqual (true, Path.HasExtension (".start"), "HasExtension #10");
 934                         Assert.AreEqual (true, Path.HasExtension (".a"), "HasExtension #11");
 935                         Assert.AreEqual (false, Path.HasExtension ("a."), "HasExtension #12");
 936                         Assert.AreEqual (false, Path.HasExtension ("Makefile"), "HasExtension #13");
 937                 }
 938
 939                 [Test]
 940                 public void HasExtension_Path_InvalidPathChars ()
 941                 {
 942                         try {
 943                                 Path.HasExtension ("hi\0world.txt");
 944                                 Assert.Fail ("#1");
 945                         } catch (ArgumentException ex) {
 946                                 // Illegal characters in path
 947                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 948                                 Assert.IsNull (ex.InnerException, "#3");
 949                                 Assert.IsNotNull (ex.Message, "#4");
 950                                 Assert.IsNull (ex.ParamName, "#5");
 951                         }
 952                 }
 953
 954                 [Test]
 955                 public void IsPathRooted ()
 956                 {
 957                         Assert.IsTrue (Path.IsPathRooted (path2), "IsPathRooted #01");
 958                         Assert.IsTrue (!Path.IsPathRooted (path3), "IsPathRooted #02");
 959                         Assert.IsTrue (!Path.IsPathRooted (null), "IsPathRooted #03");
 960                         Assert.IsTrue (!Path.IsPathRooted (String.Empty), "IsPathRooted #04");
 961                         Assert.IsTrue (!Path.IsPathRooted (" "), "IsPathRooted #05");
 962                         Assert.IsTrue (Path.IsPathRooted ("/"), "IsPathRooted #06");
 963                         Assert.IsTrue (Path.IsPathRooted ("//"), "IsPathRooted #07");
 964                         Assert.IsTrue (!Path.IsPathRooted (":"), "IsPathRooted #08");
 965
 966                         if (Windows) {
 967                                 Assert.IsTrue (Path.IsPathRooted ("\\"), "IsPathRooted #09");
 968                                 Assert.IsTrue (Path.IsPathRooted ("\\\\"), "IsPathRooted #10");
 969                                 Assert.IsTrue (Path.IsPathRooted ("z:"), "IsPathRooted #11");
 970                                 Assert.IsTrue (Path.IsPathRooted ("z:\\"), "IsPathRooted #12");
 971                                 Assert.IsTrue (Path.IsPathRooted ("z:\\topdir"), "IsPathRooted #13");
 972                                 // This looks MS BUG. It is treated as absolute path
 973                                 Assert.IsTrue (Path.IsPathRooted ("z:curdir"), "IsPathRooted #14");
 974                                 Assert.IsTrue (Path.IsPathRooted ("\\abc\\def"), "IsPathRooted #15");
 975                         } else {
 976                                 if (Environment.GetEnvironmentVariable ("MONO_IOMAP") == "all"){
 977                                         Assert.IsTrue (Path.IsPathRooted ("\\"), "IsPathRooted #16");
 978                                         Assert.IsTrue (Path.IsPathRooted ("\\\\"), "IsPathRooted #17");
 979                                 } else {
 980                                         Assert.IsTrue (!Path.IsPathRooted ("\\"), "IsPathRooted #09");
 981                                         Assert.IsTrue (!Path.IsPathRooted ("\\\\"), "IsPathRooted #10");
 982                                         Assert.IsTrue (!Path.IsPathRooted ("z:"), "IsPathRooted #11");
 983                                 }
 984                         }
 985                 }
 986
 987                 [Test]
 988                 public void IsPathRooted_Path_Empty ()
 989                 {
 990                         Assert.IsTrue (!Path.IsPathRooted (String.Empty));
 991                 }
 992
 993                 [Test]
 994                 public void IsPathRooted_Path_InvalidPathChars ()
 995                 {
 996                         try {
 997                                 Path.IsPathRooted ("hi\0world");
 998                                 Assert.Fail ("#1");
 999                         } catch (ArgumentException ex) {
1000                                 // Illegal characters in path.
1001                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1002                                 Assert.IsNull (ex.InnerException, "#3");
1003                                 Assert.IsNotNull (ex.Message, "#4");
1004                                 Assert.IsNull (ex.ParamName, "#5");
1005                         }
1006                 }
1007
1008                 [Test]
1009                 public void IsPathRooted_Path_Null ()
1010                 {
1011                         Assert.IsTrue (!Path.IsPathRooted (null));
1012                 }
1013
1014                 [Test]
1015                 public void IsPathRooted_Path_Whitespace ()
1016                 {
1017                         Assert.IsTrue (!Path.IsPathRooted ("  "));
1018                 }
1019
1020                 [Test]
1021                 public void CanonicalizeDots ()
1022                 {
1023                         string current = Path.GetFullPath (".");
1024                         Assert.IsTrue (!current.EndsWith ("."), "TestCanonicalizeDotst #01");
1025                         string parent = Path.GetFullPath ("..");
1026                         Assert.IsTrue (!current.EndsWith (".."), "TestCanonicalizeDotst #02");
1027                 }
1028 #if !MOBILE
1029                 [Test]
1030                 public void WindowsSystem32_76191 ()
1031                 {
1032                         // check for Unix platforms - see FAQ for more details
1033                         // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
1034                         int platform = (int) Environment.OSVersion.Platform;
1035                         if ((platform == 4) || (platform == 128) || (platform == 6))
1036                                 return;
1037
1038                         string curdir = Directory.GetCurrentDirectory ();
1039                         try {
1040 #if TARGET_JVM
1041                                 string system = "C:\\WINDOWS\\system32\\";
1042 #else
1043                                 string system = Environment.SystemDirectory;
1044 #endif
1045                                 Directory.SetCurrentDirectory (system);
1046                                 string drive = system.Substring (0, 2);
1047                                 Assert.AreEqual (system, Path.GetFullPath (drive), "current dir");
1048                         }
1049                         finally {
1050                                 Directory.SetCurrentDirectory (curdir);
1051                         }
1052                 }
1053
1054                 [Test]
1055                 public void WindowsSystem32_77007 ()
1056                 {
1057                         // check for Unix platforms - see FAQ for more details
1058                         // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
1059                         int platform = (int) Environment.OSVersion.Platform;
1060                         if ((platform == 4) || (platform == 128) || (platform == 6))
1061                                 return;
1062
1063                         string curdir = Directory.GetCurrentDirectory ();
1064                         try {
1065 #if TARGET_JVM
1066                                 string system = "C:\\WINDOWS\\system32\\";
1067 #else
1068                                 string system = Environment.SystemDirectory;
1069 #endif
1070                                 Directory.SetCurrentDirectory (system);
1071                                 // e.g. C:dir (no backslash) will return CurrentDirectory + dir
1072                                 string dir = system.Substring (0, 2) + "dir";
1073                                 Assert.AreEqual (Path.Combine (system, "dir"), Path.GetFullPath (dir), "current dir");
1074                         }
1075                         finally {
1076                                 Directory.SetCurrentDirectory (curdir);
1077                         }
1078                 }
1079 #endif
1080                 [Test]
1081 #if TARGET_JVM
1082                 [Ignore("Java full (canonical) path always returns windows dir in caps")]
1083 #endif
1084                 public void WindowsDriveC14N_77058 ()
1085                 {
1086                         // check for Unix platforms - see FAQ for more details
1087                         // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
1088                         int platform = (int) Environment.OSVersion.Platform;
1089                         if ((platform == 4) || (platform == 128) || (platform == 6))
1090                                 return;
1091
1092                         Assert.AreEqual (@"C:\Windows\dir", Path.GetFullPath (@"C:\Windows\System32\..\dir"), "1");
1093                         Assert.AreEqual (@"C:\dir", Path.GetFullPath (@"C:\Windows\System32\..\..\dir"), "2");
1094                         Assert.AreEqual (@"C:\dir", Path.GetFullPath (@"C:\Windows\System32\..\..\..\dir"), "3");
1095                         Assert.AreEqual (@"C:\dir", Path.GetFullPath (@"C:\Windows\System32\..\..\..\..\dir"), "4");
1096                         Assert.AreEqual (@"C:\dir\", Path.GetFullPath (@"C:\Windows\System32\..\.\..\.\..\dir\"), "5");
1097                 }
1098
1099                 [Test]
1100                 public void InvalidPathChars_Values ()
1101                 {
1102                         char[] invalid = Path.InvalidPathChars;
1103                         if (Windows) {
1104 #if NET_2_0
1105                                 Assert.AreEqual (36, invalid.Length, "Length");
1106 #else
1107                                 Assert.AreEqual (15, invalid.Length, "Length");
1108 #endif
1109                                 foreach (char c in invalid) {
1110                                         int i = (int) c;
1111 #if NET_2_0
1112                                         if (i < 32)
1113                                                 continue;
1114 #else
1115                                         if ((i == 0) || (i == 8) || ((i > 15) && (i < 19)) || ((i > 19) && (i < 26)))
1116                                                 continue;
1117 #endif
1118                                         // in both 1.1 SP1 and 2.0
1119                                         if ((i == 34) || (i == 60) || (i == 62) || (i == 124))
1120                                                 continue;
1121                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1122                                 }
1123                         } else {
1124                                 foreach (char c in invalid) {
1125                                         int i = (int) c;
1126                                         if (i == 0)
1127                                                 continue;
1128                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1129                                 }
1130                         }
1131                 }
1132
1133                 [Test]
1134                 public void InvalidPathChars_Modify ()
1135                 {
1136                         char[] expected = Path.InvalidPathChars;
1137                         char[] invalid = Path.InvalidPathChars;
1138                         char original = invalid[0];
1139                         try {
1140                                 invalid[0] = 'a';
1141                                 // kind of scary
1142                                 Assert.IsTrue (expected[0] == 'a', "expected");
1143                                 Assert.AreEqual (expected[0], Path.InvalidPathChars[0], "readonly");
1144                         } finally {
1145                                 invalid[0] = original;
1146                         }
1147                 }
1148
1149 #if NET_2_0
1150                 [Test]
1151                 public void GetInvalidFileNameChars_Values ()
1152                 {
1153                         char[] invalid = Path.GetInvalidFileNameChars ();
1154                         if (Windows) {
1155                                 Assert.AreEqual (41, invalid.Length);
1156                                 foreach (char c in invalid) {
1157                                         int i = (int) c;
1158                                         if (i < 32)
1159                                                 continue;
1160                                         if ((i == 34) || (i == 60) || (i == 62) || (i == 124))
1161                                                 continue;
1162                                         // ':', '*', '?', '\', '/'
1163                                         if ((i == 58) || (i == 42) || (i == 63) || (i == 92) || (i == 47))
1164                                                 continue;
1165                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1166                                 }
1167                         } else {
1168                                 foreach (char c in invalid) {
1169                                         int i = (int) c;
1170                                         // null or '/'
1171                                         if ((i == 0) || (i == 47))
1172                                                 continue;
1173                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1174                                 }
1175                         }
1176                 }
1177
1178                 [Test]
1179                 public void GetInvalidFileNameChars_Modify ()
1180                 {
1181                         char[] expected = Path.GetInvalidFileNameChars ();
1182                         char[] invalid = Path.GetInvalidFileNameChars ();
1183                         invalid[0] = 'a';
1184                         Assert.IsTrue (expected[0] != 'a', "expected");
1185                         Assert.AreEqual (expected[0], Path.GetInvalidFileNameChars ()[0], "readonly");
1186                 }
1187
1188                 [Test]
1189                 public void GetInvalidPathChars_Values ()
1190                 {
1191                         char[] invalid = Path.GetInvalidPathChars ();
1192                         if (Windows) {
1193                                 Assert.AreEqual (36, invalid.Length);
1194                                 foreach (char c in invalid) {
1195                                         int i = (int) c;
1196                                         if (i < 32)
1197                                                 continue;
1198                                         if ((i == 34) || (i == 60) || (i == 62) || (i == 124))
1199                                                 continue;
1200                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1201                                 }
1202                         } else {
1203                                 foreach (char c in invalid) {
1204                                         int i = (int) c;
1205                                         if (i == 0)
1206                                                 continue;
1207                                         Assert.Fail (String.Format ("'{0}' (#{1}) is invalid", c, i));
1208                                 }
1209                         }
1210                 }
1211
1212                 [Test]
1213                 public void GetInvalidPathChars_Order ()
1214                 {
1215                         if (Windows) {
1216                                 char [] invalid = Path.GetInvalidPathChars ();
1217                                 char [] expected = new char [36] { '\x22', '\x3C', '\x3E', '\x7C', '\x00', '\x01', '\x02',
1218                                         '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D',
1219                                         '\x0E', '\x0F', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18',
1220                                         '\x19', '\x1A', '\x1B', '\x1C', '\x1D', '\x1E', '\x1F' };
1221                                 Assert.AreEqual (expected.Length, invalid.Length);
1222                                 for (int i = 0; i < expected.Length; i++ ) {
1223                                         Assert.AreEqual (expected [i], invalid [i], "Character at position " + i);
1224                                 }
1225                         }
1226                 }
1227
1228                 [Test]
1229                 public void GetInvalidPathChars_Modify ()
1230                 {
1231                         char[] expected = Path.GetInvalidPathChars ();
1232                         char[] invalid = Path.GetInvalidPathChars ();
1233                         invalid[0] = 'a';
1234                         Assert.IsTrue (expected[0] != 'a', "expected");
1235                         Assert.AreEqual (expected[0], Path.GetInvalidPathChars ()[0], "readonly");
1236                 }
1237
1238                 [Test]
1239                 public void GetRandomFileName ()
1240                 {
1241                         string s = Path.GetRandomFileName ();
1242                         Assert.AreEqual (12, s.Length, "Length");
1243                         char[] invalid = Path.GetInvalidFileNameChars ();
1244                         for (int i=0; i < s.Length; i++) {
1245                                 if (i == 8)
1246                                         Assert.AreEqual ('.', s[i], "8");
1247                                 else
1248                                         Assert.IsTrue (Array.IndexOf (invalid, s[i]) == -1, i.ToString ());
1249                         }
1250                 }
1251
1252                 [Test]
1253                 public void GetRandomFileNameIsAlphaNumerical ()
1254                 {
1255                         string [] names = new string [1000];
1256                         for (int i = 0; i < names.Length; i++)
1257                                 names [i] = Path.GetRandomFileName ();
1258
1259                         foreach (string name in names) {
1260                                 Assert.AreEqual (12, name.Length);
1261                                 Assert.AreEqual ('.', name [8]);
1262
1263                                 for (int i = 0; i < 12; i++) {
1264                                         if (i == 8)
1265                                                 continue;
1266
1267                                         char c = name [i];
1268                                         Assert.IsTrue (('a' <= c && c <= 'z') || ('0' <= c && c <= '9'));
1269                                 }
1270                         }
1271                 }
1272 #endif
1273 #if NET_4_0
1274                 string Concat (string sep, params string [] parms)
1275                 {
1276                         return String.Join (sep, parms);
1277                 }
1278
1279                 [Test]
1280                 public void Combine_3Params ()
1281                 {
1282                         string sep = Path.DirectorySeparatorChar.ToString ();
1283
1284                         try {
1285                                 Path.Combine (null, "two", "three");
1286                                 Assert.Fail ("#A1-1");
1287                         } catch {
1288                                 // success
1289                         }
1290
1291                         try {
1292                                 Path.Combine ("one", null, "three");
1293                                 Assert.Fail ("#A1-2");
1294                         } catch {
1295                                 // success
1296                         }
1297
1298                         try {
1299                                 Path.Combine ("one", "two", null);
1300                                 Assert.Fail ("#A1-3");
1301                         } catch {
1302                                 // success
1303                         }
1304
1305                         Assert.AreEqual (Concat (sep, "one", "two", "three"), Path.Combine ("one", "two", "three"), "#A2-1");
1306                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three"), Path.Combine (sep + "one", "two", "three"), "#A2-2");
1307                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three"), Path.Combine (sep + "one" + sep, "two", "three"), "#A2-3");
1308                         Assert.AreEqual (Concat (sep, sep + "two", "three"), Path.Combine (sep + "one" + sep, sep + "two", "three"), "#A2-4");
1309                         Assert.AreEqual (Concat (sep, sep + "three"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three"), "#A2-5");
1310
1311                         Assert.AreEqual (Concat (sep, sep + "one" + sep, "two", "three"), Path.Combine (sep + "one" + sep + sep, "two", "three"), "#A3");
1312
1313                         Assert.AreEqual ("", Path.Combine ("", "", ""), "#A4");
1314                 }
1315
1316                 [Test]
1317                 public void Combine_4Params ()
1318                 {
1319                         string sep = Path.DirectorySeparatorChar.ToString ();
1320
1321                         try {
1322                                 Path.Combine (null, "two", "three", "four");
1323                                 Assert.Fail ("#A1-1");
1324                         } catch {
1325                                 // success
1326                         }
1327
1328                         try {
1329                                 Path.Combine ("one", null, "three", "four");
1330                                 Assert.Fail ("#A1-2");
1331                         } catch {
1332                                 // success
1333                         }
1334
1335                         try {
1336                                 Path.Combine ("one", "two", null, "four");
1337                                 Assert.Fail ("#A1-3");
1338                         } catch {
1339                                 // success
1340                         }
1341
1342                         try {
1343                                 Path.Combine ("one", "two", "three", null);
1344                                 Assert.Fail ("#A1-4");
1345                         } catch {
1346                                 // success
1347                         }
1348
1349                         Assert.AreEqual (Concat (sep, "one", "two", "three", "four"), Path.Combine ("one", "two", "three", "four"), "#A2-1");
1350                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four"), Path.Combine (sep + "one", "two", "three", "four"), "#A2-2");
1351                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four"), Path.Combine (sep + "one" + sep, "two", "three", "four"), "#A2-3");
1352                         Assert.AreEqual (Concat (sep, sep + "two", "three", "four"), Path.Combine (sep + "one" + sep, sep + "two", "three", "four"), "#A2-4");
1353                         Assert.AreEqual (Concat (sep, sep + "three", "four"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", "four"), "#A2-5");
1354                         Assert.AreEqual (Concat (sep, sep + "four"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", sep + "four"), "#A2-6");
1355
1356                         Assert.AreEqual (Concat (sep, sep + "one" + sep, "two", "three", "four"), Path.Combine (sep + "one" + sep + sep, "two", "three", "four"), "#A3");
1357
1358                         Assert.AreEqual ("", Path.Combine ("", "", "", ""), "#A4");
1359                 }
1360
1361                 [Test]
1362                 public void Combine_ManyParams ()
1363                 {
1364                         string sep = Path.DirectorySeparatorChar.ToString ();
1365
1366                         try {
1367                                 Path.Combine (null, "two", "three", "four", "five");
1368                                 Assert.Fail ("#A1-1");
1369                         } catch {
1370                                 // success
1371                         }
1372
1373                         try {
1374                                 Path.Combine ("one", null, "three", "four", "five");
1375                                 Assert.Fail ("#A1-2");
1376                         } catch {
1377                                 // success
1378                         }
1379
1380                         try {
1381                                 Path.Combine ("one", "two", null, "four", "five");
1382                                 Assert.Fail ("#A1-3");
1383                         } catch {
1384                                 // success
1385                         }
1386
1387                         try {
1388                                 Path.Combine ("one", "two", "three", null, "five");
1389                                 Assert.Fail ("#A1-4");
1390                         } catch {
1391                                 // success
1392                         }
1393
1394                         try {
1395                                 Path.Combine ("one", "two", "three", "four", null);
1396                                 Assert.Fail ("#A1-5");
1397                         } catch {
1398                                 // success
1399                         }
1400
1401                         Assert.AreEqual (Concat (sep, "one", "two", "three", "four", "five"), Path.Combine ("one", "two", "three", "four", "five"), "#A2-1");
1402                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four", "five"), Path.Combine (sep + "one", "two", "three", "four", "five"), "#A2-2");
1403                         Assert.AreEqual (Concat (sep, sep + "one", "two", "three", "four", "five"), Path.Combine (sep + "one" + sep, "two", "three", "four", "five"), "#A2-3");
1404                         Assert.AreEqual (Concat (sep, sep + "two", "three", "four", "five"), Path.Combine (sep + "one" + sep, sep + "two", "three", "four", "five"), "#A2-4");
1405                         Assert.AreEqual (Concat (sep, sep + "three", "four", "five"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", "four", "five"), "#A2-5");
1406                         Assert.AreEqual (Concat (sep, sep + "four", "five"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", sep + "four", "five"), "#A2-6");
1407                         Assert.AreEqual (Concat (sep, sep + "five"), Path.Combine (sep + "one" + sep, sep + "two", sep + "three", sep + "four", sep + "five"), "#A2-6");
1408
1409                         Assert.AreEqual (Concat (sep, sep + "one" + sep, "two", "three", "four", "five"), Path.Combine (sep + "one" + sep + sep, "two", "three", "four", "five"), "#A3");
1410
1411                         Assert.AreEqual ("", Path.Combine ("", "", "", "", ""), "#A4");
1412                 }
1413 #endif
1414         }
1415 }
1416