mcs/class/System/Test/System/UriTest.cs

   1 //
   2 // UriTest.cs - NUnit Test Cases for System.Uri
   3 //
   4 // Authors:
   5 //   Lawrence Pit (loz@cable.a2000.nl)
   6 //   Martin Willemoes Hansen (mwh@sysrq.dk)
   7 //   Ben Maurer (bmaurer@users.sourceforge.net)
   8 //
   9 // (C) 2003 Martin Willemoes Hansen
  10 // (C) 2003 Ben Maurer
  11 //
  12
  13 using NUnit.Framework;
  14 using System;
  15 using System.IO;
  16
  17 namespace MonoTests.System
  18 {
  19         [TestFixture]
  20         public class UriTest : Assertion
  21         {
  22                 protected bool isWin32 = false;
  23
  24                 [SetUp]
  25                 public void GetReady ()
  26                 {
  27                         isWin32 = (Path.DirectorySeparatorChar == '\\');
  28                 }
  29
  30                 [Test]
  31                 public void Constructors ()
  32                 {
  33                         Uri uri = null;
  34
  35                         /*
  36                         uri = new Uri ("http://www.ximian.com/foo" + ((char) 0xa9) + "/bar/index.cgi?a=1&b=" + ((char) 0xa9) + "left#fragm?ent2");
  37                         Print (uri);
  38
  39                         uri = new Uri ("http://www.ximian.com/foo/xxx\"()-._;<=>@{|}~-,.`_^]\\[xx/" + ((char) 0xa9) + "/bar/index.cgi#fra+\">=@[gg]~gment2");
  40                         Print (uri);
  41
  42                         uri = new Uri("http://11.22.33.588:9090");
  43                         Print (uri);
  44
  45                         uri = new Uri("http://[11:22:33::88]:9090");
  46                         Print (uri);
  47
  48                         uri = new Uri("http://[::127.11.22.33]:8080");
  49                         Print (uri);
  50
  51                         uri = new Uri("http://[abcde::127.11.22.33]:8080");
  52                         Print (uri);
  53                         */
  54
  55                         /*
  56                         uri = new Uri ("http://www.contoso.com:1234/foo/bar/");
  57                         Print (uri);
  58
  59                         uri = new Uri ("http://www.contoso.com:1234/foo/bar");
  60                         Print (uri);
  61
  62                         uri = new Uri ("http://www.contoso.com:1234/");
  63                         Print (uri);
  64
  65                         uri = new Uri ("http://www.contoso.com:1234");
  66                         Print (uri);
  67                         */
  68
  69                         uri = new Uri ("http://contoso.com?subject=uri");
  70                         AssertEquals ("#k1", "/", uri.AbsolutePath);
  71                         AssertEquals ("#k2", "http://contoso.com/?subject=uri", uri.AbsoluteUri);
  72                         AssertEquals ("#k3", "contoso.com", uri.Authority);
  73                         AssertEquals ("#k4", "", uri.Fragment);
  74                         AssertEquals ("#k5", "contoso.com", uri.Host);
  75                         AssertEquals ("#k6", UriHostNameType.Dns, uri.HostNameType);
  76                         AssertEquals ("#k7", true, uri.IsDefaultPort);
  77                         AssertEquals ("#k8", false, uri.IsFile);
  78                         AssertEquals ("#k9", false, uri.IsLoopback);
  79                         AssertEquals ("#k10", false, uri.IsUnc);
  80                         AssertEquals ("#k11", "/", uri.LocalPath);
  81                         AssertEquals ("#k12", "/?subject=uri", uri.PathAndQuery);
  82                         AssertEquals ("#k13", 80, uri.Port);
  83                         AssertEquals ("#k14", "?subject=uri", uri.Query);
  84                         AssertEquals ("#k15", "http", uri.Scheme);
  85                         AssertEquals ("#k16", false, uri.UserEscaped);
  86                         AssertEquals ("#k17", "", uri.UserInfo);
  87
  88                         uri = new Uri ("mailto:user:pwd@contoso.com?subject=uri");
  89                         AssertEquals ("#m1", "", uri.AbsolutePath);
  90                         AssertEquals ("#m2", "mailto:user:pwd@contoso.com?subject=uri", uri.AbsoluteUri);
  91                         AssertEquals ("#m3", "contoso.com", uri.Authority);
  92                         AssertEquals ("#m4", "", uri.Fragment);
  93                         AssertEquals ("#m5", "contoso.com", uri.Host);
  94                         AssertEquals ("#m6", UriHostNameType.Dns, uri.HostNameType);
  95                         AssertEquals ("#m7", true, uri.IsDefaultPort);
  96                         AssertEquals ("#m8", false, uri.IsFile);
  97                         AssertEquals ("#m9", false, uri.IsLoopback);
  98                         AssertEquals ("#m10", false, uri.IsUnc);
  99                         AssertEquals ("#m11", "", uri.LocalPath);
 100                         AssertEquals ("#m12", "?subject=uri", uri.PathAndQuery);
 101                         AssertEquals ("#m13", 25, uri.Port);
 102                         AssertEquals ("#m14", "?subject=uri", uri.Query);
 103                         AssertEquals ("#m15", "mailto", uri.Scheme);
 104                         AssertEquals ("#m16", false, uri.UserEscaped);
 105                         AssertEquals ("#m17", "user:pwd", uri.UserInfo);
 106
 107                         uri = new Uri (@"\\myserver\mydir\mysubdir\myfile.ext");
 108                         AssertEquals ("#n1", "/mydir/mysubdir/myfile.ext", uri.AbsolutePath);
 109                         AssertEquals ("#n2", "file://myserver/mydir/mysubdir/myfile.ext", uri.AbsoluteUri);
 110                         AssertEquals ("#n3", "myserver", uri.Authority);
 111                         AssertEquals ("#n4", "", uri.Fragment);
 112                         AssertEquals ("#n5", "myserver", uri.Host);
 113                         AssertEquals ("#n6", UriHostNameType.Dns, uri.HostNameType);
 114                         AssertEquals ("#n7", true, uri.IsDefaultPort);
 115                         AssertEquals ("#n8", true, uri.IsFile);
 116                         AssertEquals ("#n9", false, uri.IsLoopback);
 117                         AssertEquals ("#n10", true, uri.IsUnc);
 118
 119                         if (isWin32)
 120                                 AssertEquals ("#n11", @"\\myserver\mydir\mysubdir\myfile.ext", uri.LocalPath);
 121                         else
 122                                 // myserver never could be the part of Unix path.
 123                                 AssertEquals ("#n11", "/mydir/mysubdir/myfile.ext", uri.LocalPath);
 124
 125                         AssertEquals ("#n12", "/mydir/mysubdir/myfile.ext", uri.PathAndQuery);
 126                         AssertEquals ("#n13", -1, uri.Port);
 127                         AssertEquals ("#n14", "", uri.Query);
 128                         AssertEquals ("#n15", "file", uri.Scheme);
 129                         AssertEquals ("#n16", false, uri.UserEscaped);
 130                         AssertEquals ("#n17", "", uri.UserInfo);
 131
 132                         uri = new Uri (new Uri("http://www.contoso.com"), "Hello World.htm", true);
 133                         AssertEquals ("#rel1a", "http://www.contoso.com/Hello World.htm", uri.AbsoluteUri);
 134                         AssertEquals ("#rel1b", true, uri.UserEscaped);
 135                         uri = new Uri (new Uri("http://www.contoso.com"), "Hello World.htm", false);
 136                         AssertEquals ("#rel2a", "http://www.contoso.com/Hello%20World.htm", uri.AbsoluteUri);
 137                         AssertEquals ("#rel2b", false, uri.UserEscaped);
 138                         uri = new Uri (new Uri("http://www.contoso.com"), "http://www.xxx.com/Hello World.htm", false);
 139                         AssertEquals ("#rel3", "http://www.xxx.com/Hello%20World.htm", uri.AbsoluteUri);
 140                         //uri = new Uri (new Uri("http://www.contoso.com"), "foo:8080/bar/Hello World.htm", false);
 141                         //AssertEquals ("#rel4", "foo:8080/bar/Hello%20World.htm", uri.AbsoluteUri);
 142                         uri = new Uri (new Uri("http://www.contoso.com"), "foo/bar/Hello World.htm?x=0:8", false);
 143                         AssertEquals ("#rel5", "http://www.contoso.com/foo/bar/Hello%20World.htm?x=0:8", uri.AbsoluteUri);
 144                         uri = new Uri (new Uri("http://www.contoso.com/xxx/yyy/index.htm"), "foo/bar/Hello World.htm?x=0:8", false);
 145                         AssertEquals ("#rel6", "http://www.contoso.com/xxx/yyy/foo/bar/Hello%20World.htm?x=0:8", uri.AbsoluteUri);
 146                         uri = new Uri (new Uri("http://www.contoso.com/xxx/yyy/index.htm"), "/foo/bar/Hello World.htm?x=0:8", false);
 147                         AssertEquals ("#rel7", "http://www.contoso.com/foo/bar/Hello%20World.htm?x=0:8", uri.AbsoluteUri);
 148                         uri = new Uri (new Uri("http://www.contoso.com/xxx/yyy/index.htm"), "../foo/bar/Hello World.htm?x=0:8", false);
 149                         AssertEquals ("#rel8", "http://www.contoso.com/xxx/foo/bar/Hello%20World.htm?x=0:8", uri.AbsoluteUri);
 150                         uri = new Uri (new Uri("http://www.contoso.com/xxx/yyy/index.htm"), "../../../foo/bar/Hello World.htm?x=0:8", false);
 151                         AssertEquals ("#rel9", "http://www.contoso.com/../foo/bar/Hello%20World.htm?x=0:8", uri.AbsoluteUri);
 152                         uri = new Uri (new Uri("http://www.contoso.com/xxx/yyy/index.htm"), "./foo/bar/Hello World.htm?x=0:8", false);
 153                         AssertEquals ("#rel10", "http://www.contoso.com/xxx/yyy/foo/bar/Hello%20World.htm?x=0:8", uri.AbsoluteUri);
 154
 155                         try {
 156                                 uri = new Uri (null, "http://www.contoso.com/index.htm", false);
 157                                 Fail ("#rel20");
 158                         } catch (NullReferenceException) {
 159                         }
 160                         try {
 161                                 uri = new Uri (new Uri("http://www.contoso.com"), null, false);
 162                                 Fail ("#rel21");
 163                         } catch (NullReferenceException) {
 164                         }
 165                         try {
 166                                 uri = new Uri (new Uri("http://www.contoso.com/foo/bar/index.html?x=0"), String.Empty, false);
 167                                 AssertEquals("#22", "http://www.contoso.com/foo/bar/index.html?x=0", uri.ToString ());
 168                         } catch (NullReferenceException) {
 169                         }
 170
 171                         uri = new Uri (new Uri("http://www.xxx.com"), "?x=0");
 172                         AssertEquals ("#rel30", "http://www.xxx.com/?x=0", uri.ToString());
 173                         uri = new Uri (new Uri("http://www.xxx.com/index.htm"), "?x=0");
 174                         AssertEquals ("#rel31", "http://www.xxx.com/?x=0", uri.ToString());
 175                         uri = new Uri (new Uri("http://www.xxx.com/index.htm"), "#here");
 176                         AssertEquals ("#rel32", "http://www.xxx.com/index.htm#here", uri.ToString());
 177                 }
 178
 179                 // regression for bug #47573
 180                 [Test]
 181                 public void RelativeCtor ()
 182                 {
 183                         Uri b = new Uri ("http://a/b/c/d;p?q");
 184 //                      AssertEquals ("g:h", "g:h", new Uri (b, "g:h").ToString ()); this causes crash under MS.NET 1.1
 185                         AssertEquals ("#1", "http://a/g", new Uri (b, "/g").ToString ());
 186                         AssertEquals ("#2", "http://g/", new Uri (b, "//g").ToString ());
 187                         AssertEquals ("#3", "http://a/b/c/?y", new Uri (b, "?y").ToString ());
 188                         Assert ("#4", new Uri (b, "#s").ToString ().EndsWith ("#s"));
 189
 190                         Uri u = new Uri (b, "/g?q=r");
 191                         AssertEquals ("#5", "http://a/g?q=r", u.ToString ());
 192                         AssertEquals ("#6", "?q=r", u.Query);
 193
 194                         u = new Uri (b, "/g?q=r;. a");
 195                         AssertEquals ("#5", "http://a/g?q=r;. a", u.ToString ());
 196                         AssertEquals ("#6", "?q=r;.%20a", u.Query);
 197                 }
 198
 199                 [Test]
 200                 [ExpectedException (typeof (UriFormatException))]
 201                 public void InvalidScheme ()
 202                 {
 203                         new Uri ("_:/");
 204                 }
 205
 206                 [Test]
 207                 public void ConstructorsRejectRelativePath ()
 208                 {
 209                         string [] reluris = new string [] {
 210                                 "readme.txt",
 211                                 "thisdir/childdir/file",
 212                                 "./testfile"
 213                         };
 214                         string [] winRelUris = new string [] {
 215                                 "c:readme.txt"
 216                         };
 217
 218                         for (int i = 0; i < reluris.Length; i++) {
 219                                 try {
 220                                         new Uri (reluris [i]);
 221                                         Fail ("Should be failed: " + reluris [i]);
 222                                 } catch (UriFormatException) {
 223                                 }
 224                         }
 225
 226                         if (isWin32) {
 227                                 for (int i = 0; i < winRelUris.Length; i++) {
 228                                         try {
 229                                                 new Uri (winRelUris [i]);
 230                                                 Fail ("Should be failed: " + winRelUris [i]);
 231                                         } catch (UriFormatException) {
 232                                         }
 233                                 }
 234                         }
 235                 }
 236
 237
 238                 [Test]
 239                 public void LocalPath ()
 240                 {
 241                         Uri uri = new Uri ("c:\\tmp\\hello.txt");
 242                         AssertEquals ("#1a", "file:///c:/tmp/hello.txt", uri.ToString ());
 243                         AssertEquals ("#1b", "c:\\tmp\\hello.txt", uri.LocalPath);
 244                         AssertEquals ("#1c", "file", uri.Scheme);
 245                         AssertEquals ("#1d", "", uri.Host);
 246                         AssertEquals ("#1e", "c:/tmp/hello.txt", uri.AbsolutePath);
 247
 248                         uri = new Uri ("file:////////cygwin/tmp/hello.txt");
 249                         AssertEquals ("#3a", "file://cygwin/tmp/hello.txt", uri.ToString ());
 250                         if (isWin32)
 251                                 AssertEquals ("#3b win32", "\\\\cygwin\\tmp\\hello.txt", uri.LocalPath);
 252                         else
 253                                 AssertEquals ("#3b *nix", "/tmp/hello.txt", uri.LocalPath);
 254                         AssertEquals ("#3c", "file", uri.Scheme);
 255                         AssertEquals ("#3d", "cygwin", uri.Host);
 256                         AssertEquals ("#3e", "/tmp/hello.txt", uri.AbsolutePath);
 257
 258                         uri = new Uri ("file://mymachine/cygwin/tmp/hello.txt");
 259                         AssertEquals ("#4a", "file://mymachine/cygwin/tmp/hello.txt", uri.ToString ());
 260                         if (isWin32)
 261                                 AssertEquals ("#4b win32", "\\\\mymachine\\cygwin\\tmp\\hello.txt", uri.LocalPath);
 262                         else
 263                                 AssertEquals ("#4b *nix", "/cygwin/tmp/hello.txt", uri.LocalPath);
 264                         AssertEquals ("#4c", "file", uri.Scheme);
 265                         AssertEquals ("#4d", "mymachine", uri.Host);
 266                         AssertEquals ("#4e", "/cygwin/tmp/hello.txt", uri.AbsolutePath);
 267
 268                         uri = new Uri ("file://///c:/cygwin/tmp/hello.txt");
 269                         AssertEquals ("#5a", "file:///c:/cygwin/tmp/hello.txt", uri.ToString ());
 270                         AssertEquals ("#5b", "c:\\cygwin\\tmp\\hello.txt", uri.LocalPath);
 271                         AssertEquals ("#5c", "file", uri.Scheme);
 272                         AssertEquals ("#5d", "", uri.Host);
 273                         AssertEquals ("#5e", "c:/cygwin/tmp/hello.txt", uri.AbsolutePath);
 274                         // Hmm, they should be regarded just as a host name, since all URIs are base on absolute path.
 275                         uri = new Uri("file://one_file.txt");
 276                         AssertEquals("#6a", "file://one_file.txt", uri.ToString());
 277                         if (isWin32)
 278                                 AssertEquals("#6b", "\\\\one_file.txt", uri.LocalPath);
 279                         else
 280                                 AssertEquals("#6b", "/", uri.LocalPath);
 281                         AssertEquals("#6c", "file", uri.Scheme);
 282                         AssertEquals("#6d", "one_file.txt", uri.Host);
 283                         AssertEquals("#6e", "", uri.AbsolutePath);
 284                 }
 285
 286                 [Test]
 287                 public void UnixPath () {
 288                         if (!isWin32)
 289                                 AssertEquals ("#6a", "file:///cygwin/tmp/hello.txt", new Uri ("/cygwin/tmp/hello.txt").ToString ());
 290                 }
 291
 292                 [Test]
 293                 public void Unc ()
 294                 {
 295                         Uri uri = new Uri ("http://www.contoso.com");
 296                         Assert ("#1", !uri.IsUnc);
 297
 298                         uri = new Uri ("news:123456@contoso.com");
 299                         Assert ("#2", !uri.IsUnc);
 300
 301                         uri = new Uri ("file://server/filename.ext");
 302                         Assert ("#3", uri.IsUnc);
 303
 304                         uri = new Uri (@"\\server\share\filename.ext");
 305                         Assert ("#6", uri.IsUnc);
 306
 307                         uri = new Uri (@"a:\dir\filename.ext");
 308                         Assert ("#8", !uri.IsUnc);
 309                 }
 310
 311                 [Test]
 312 //              [ExpectedException (typeof (UriFormatException))]
 313                 public void UncFail ()
 314                 {
 315                         Uri uri = new Uri ("/home/user/dir/filename.ext");
 316                         Assert ("#7", !uri.IsUnc);
 317                 }
 318
 319                 [Test]
 320                 [Ignore ("Known to fail under MS runtime")]
 321                 public void Unc2 ()
 322                 {
 323                         try {
 324                                 Uri uri = new Uri ("file:/filename.ext");
 325                                 Assert ("#4", uri.IsUnc);
 326                         } catch (UriFormatException) {
 327                                 Fail ("#5: known to fail with ms.net");
 328                         }
 329                 }
 330
 331                 [Test]
 332                 public void FromHex ()
 333                 {
 334                         AssertEquals ("#1", 0, Uri.FromHex ('0'));
 335                         AssertEquals ("#2", 9, Uri.FromHex ('9'));
 336                         AssertEquals ("#3", 10, Uri.FromHex ('a'));
 337                         AssertEquals ("#4", 15, Uri.FromHex ('f'));
 338                         AssertEquals ("#5", 10, Uri.FromHex ('A'));
 339                         AssertEquals ("#6", 15, Uri.FromHex ('F'));
 340                         try {
 341                                 Uri.FromHex ('G');
 342                                 Fail ("#7");
 343                         } catch (ArgumentException) {}
 344                         try {
 345                                 Uri.FromHex (' ');
 346                                 Fail ("#8");
 347                         } catch (ArgumentException) {}
 348                         try {
 349                                 Uri.FromHex ('%');
 350                                 Fail ("#8");
 351                         } catch (ArgumentException) {}
 352                 }
 353
 354                 class UriEx : Uri
 355                 {
 356                         public UriEx (string s) : base (s)
 357                         {
 358                         }
 359
 360                         public string UnescapeString (string s)
 361                         {
 362                                 return Unescape (s);
 363                         }
 364
 365                         public static string UnescapeString (string uri, string target)
 366                         {
 367                                 return new UriEx (uri).UnescapeString (target);
 368                         }
 369                 }
 370
 371                 [Test]
 372                 public void Unescape ()
 373                 {
 374                         AssertEquals ("#1", "#", UriEx.UnescapeString ("file://localhost/c#", "%23"));
 375                         AssertEquals ("#2", "c#", UriEx.UnescapeString ("file://localhost/c#", "c%23"));
 376                         AssertEquals ("#3", "\xA9", UriEx.UnescapeString ("file://localhost/c#", "%A9"));
 377                         AssertEquals ("#1", "#", UriEx.UnescapeString ("http://localhost/c#", "%23"));
 378                         AssertEquals ("#2", "c#", UriEx.UnescapeString ("http://localhost/c#", "c%23"));
 379                         AssertEquals ("#3", "\xA9", UriEx.UnescapeString ("http://localhost/c#", "%A9"));
 380                 }
 381
 382                 [Test]
 383                 public void HexEscape ()
 384                 {
 385                         AssertEquals ("#1","%20", Uri.HexEscape (' '));
 386                         AssertEquals ("#2","%A9", Uri.HexEscape ((char) 0xa9));
 387                         AssertEquals ("#3","%41", Uri.HexEscape ('A'));
 388                         try {
 389                                 Uri.HexEscape ((char) 0x0369);
 390                                 Fail ("#4");
 391                         } catch (ArgumentOutOfRangeException) {}
 392                 }
 393
 394                 [Test]
 395                 public void HexUnescape ()
 396                 {
 397                         int i = 0;
 398                         AssertEquals ("#1", ' ', Uri.HexUnescape ("%20", ref i));
 399                         AssertEquals ("#2", 3, i);
 400                         i = 4;
 401                         AssertEquals ("#3", (char) 0xa9, Uri.HexUnescape ("test%a9test", ref i));
 402                         AssertEquals ("#4", 7, i);
 403                         AssertEquals ("#5", 't', Uri.HexUnescape ("test%a9test", ref i));
 404                         AssertEquals ("#6", 8, i);
 405                         i = 4;
 406                         AssertEquals ("#5", '%', Uri.HexUnescape ("test%a", ref i));
 407                         AssertEquals ("#6", 5, i);
 408                         AssertEquals ("#7", '%', Uri.HexUnescape ("testx%xx", ref i));
 409                         AssertEquals ("#8", 6, i);
 410                 }
 411
 412                 [Test]
 413                 public void IsHexDigit ()
 414                 {
 415                         Assert ("#1", Uri.IsHexDigit ('a'));
 416                         Assert ("#2", Uri.IsHexDigit ('f'));
 417                         Assert ("#3", !Uri.IsHexDigit ('g'));
 418                         Assert ("#4", Uri.IsHexDigit ('0'));
 419                         Assert ("#5", Uri.IsHexDigit ('9'));
 420                         Assert ("#6", Uri.IsHexDigit ('A'));
 421                         Assert ("#7", Uri.IsHexDigit ('F'));
 422                         Assert ("#8", !Uri.IsHexDigit ('G'));
 423                 }
 424
 425                 [Test]
 426                 public void IsHexEncoding ()
 427                 {
 428                         Assert ("#1", Uri.IsHexEncoding ("test%a9test", 4));
 429                         Assert ("#2", !Uri.IsHexEncoding ("test%a9test", 3));
 430                         Assert ("#3", Uri.IsHexEncoding ("test%a9", 4));
 431                         Assert ("#4", !Uri.IsHexEncoding ("test%a", 4));
 432                 }
 433
 434                 [Test]
 435                 public void GetLeftPart ()
 436                 {
 437                         Uri uri = new Uri ("http://www.contoso.com/index.htm#main");
 438                         AssertEquals ("#1", "http://", uri.GetLeftPart (UriPartial.Scheme));
 439                         AssertEquals ("#2", "http://www.contoso.com", uri.GetLeftPart (UriPartial.Authority));
 440                         AssertEquals ("#3", "http://www.contoso.com/index.htm", uri.GetLeftPart (UriPartial.Path));
 441
 442                         uri = new Uri ("mailto:user@contoso.com?subject=uri");
 443                         AssertEquals ("#4", "mailto:", uri.GetLeftPart (UriPartial.Scheme));
 444                         AssertEquals ("#5", "", uri.GetLeftPart (UriPartial.Authority));
 445                         AssertEquals ("#6", "mailto:user@contoso.com", uri.GetLeftPart (UriPartial.Path));
 446
 447                         uri = new Uri ("nntp://news.contoso.com/123456@contoso.com");
 448                         AssertEquals ("#7", "nntp://", uri.GetLeftPart (UriPartial.Scheme));
 449                         AssertEquals ("#8", "nntp://news.contoso.com", uri.GetLeftPart (UriPartial.Authority));
 450                         AssertEquals ("#9", "nntp://news.contoso.com/123456@contoso.com", uri.GetLeftPart (UriPartial.Path));
 451
 452                         uri = new Uri ("news:123456@contoso.com");
 453                         AssertEquals ("#10", "news:", uri.GetLeftPart (UriPartial.Scheme));
 454                         AssertEquals ("#11", "", uri.GetLeftPart (UriPartial.Authority));
 455                         AssertEquals ("#12", "news:123456@contoso.com", uri.GetLeftPart (UriPartial.Path));
 456
 457                         uri = new Uri ("file://server/filename.ext");
 458                         AssertEquals ("#13", "file://", uri.GetLeftPart (UriPartial.Scheme));
 459                         AssertEquals ("#14", "file://server", uri.GetLeftPart (UriPartial.Authority));
 460                         AssertEquals ("#15", "file://server/filename.ext", uri.GetLeftPart (UriPartial.Path));
 461
 462                         uri = new Uri (@"\\server\share\filename.ext");
 463                         AssertEquals ("#20", "file://", uri.GetLeftPart (UriPartial.Scheme));
 464                         AssertEquals ("#21", "file://server", uri.GetLeftPart (UriPartial.Authority));
 465                         AssertEquals ("#22", "file://server/share/filename.ext", uri.GetLeftPart (UriPartial.Path));
 466
 467                         uri = new Uri ("http://www.contoso.com:8080/index.htm#main");
 468                         AssertEquals ("#23", "http://", uri.GetLeftPart (UriPartial.Scheme));
 469                         AssertEquals ("#24", "http://www.contoso.com:8080", uri.GetLeftPart (UriPartial.Authority));
 470                         AssertEquals ("#25", "http://www.contoso.com:8080/index.htm", uri.GetLeftPart (UriPartial.Path));
 471                 }
 472
 473                 [Test]
 474                 [Ignore("Known to fail under MS runtime")]
 475                 public void GetLeftPart2 ()
 476                 {
 477                         try {
 478                                 Uri uri = new Uri ("file:/filename.ext");
 479                                 AssertEquals ("#16", "file://", uri.GetLeftPart (UriPartial.Scheme));
 480                                 AssertEquals ("#17", "", uri.GetLeftPart (UriPartial.Authority));
 481                                 AssertEquals ("#18", "file:///filename.ext", uri.GetLeftPart (UriPartial.Path));
 482                         } catch (UriFormatException) {
 483                                 Fail ("#19: known to fail with ms.net (it's their own example!)");
 484                         }
 485                 }
 486
 487                 [Test]
 488                 public void CheckHostName ()
 489                 {
 490                         AssertEquals ("#1", UriHostNameType.Unknown, Uri.CheckHostName (null));
 491                         AssertEquals ("#2", UriHostNameType.Unknown, Uri.CheckHostName (""));
 492                         AssertEquals ("#3", UriHostNameType.Unknown, Uri.CheckHostName ("^&()~`!@"));
 493                         AssertEquals ("#4", UriHostNameType.Dns, Uri.CheckHostName ("x"));
 494                         AssertEquals ("#5", UriHostNameType.IPv4, Uri.CheckHostName ("1.2.3.4"));
 495                         AssertEquals ("#6", UriHostNameType.IPv4, Uri.CheckHostName ("0001.002.03.4"));
 496                         AssertEquals ("#7", UriHostNameType.Dns, Uri.CheckHostName ("0001.002.03.256"));
 497                         AssertEquals ("#8", UriHostNameType.Dns, Uri.CheckHostName ("9001.002.03.4"));
 498                         AssertEquals ("#9", UriHostNameType.Dns, Uri.CheckHostName ("www.contoso.com"));
 499                         AssertEquals ("#10", UriHostNameType.Unknown, Uri.CheckHostName (".www.contoso.com"));
 500                         AssertEquals ("#11: known to fail with ms.net: this is not a valid domain address", UriHostNameType.Unknown, Uri.CheckHostName ("www.contoso.com."));
 501                         AssertEquals ("#12", UriHostNameType.Dns, Uri.CheckHostName ("www.con-toso.com"));
 502                         AssertEquals ("#13", UriHostNameType.Dns, Uri.CheckHostName ("www.con_toso.com"));
 503                         AssertEquals ("#14", UriHostNameType.Unknown, Uri.CheckHostName ("www.con,toso.com"));
 504
 505                         // test IPv6
 506                         AssertEquals ("#15", UriHostNameType.IPv6, Uri.CheckHostName ("11:22:33:44:55:66:77:88"));
 507                         AssertEquals ("#16", UriHostNameType.IPv6, Uri.CheckHostName ("11::33:44:55:66:77:88"));
 508                         AssertEquals ("#17", UriHostNameType.IPv6, Uri.CheckHostName ("::22:33:44:55:66:77:88"));
 509                         AssertEquals ("#18", UriHostNameType.IPv6, Uri.CheckHostName ("11:22:33:44:55:66:77::"));
 510                         AssertEquals ("#19", UriHostNameType.IPv6, Uri.CheckHostName ("11::88"));
 511                         AssertEquals ("#20", UriHostNameType.IPv6, Uri.CheckHostName ("11::77:88"));
 512                         AssertEquals ("#21", UriHostNameType.IPv6, Uri.CheckHostName ("11:22::88"));
 513                         AssertEquals ("#22", UriHostNameType.IPv6, Uri.CheckHostName ("11::"));
 514                         AssertEquals ("#23", UriHostNameType.IPv6, Uri.CheckHostName ("::88"));
 515                         AssertEquals ("#24", UriHostNameType.IPv6, Uri.CheckHostName ("::1"));
 516                         AssertEquals ("#25", UriHostNameType.IPv6, Uri.CheckHostName ("::"));
 517                         AssertEquals ("#26", UriHostNameType.IPv6, Uri.CheckHostName ("0:0:0:0:0:0:127.0.0.1"));
 518                         AssertEquals ("#27", UriHostNameType.IPv6, Uri.CheckHostName ("::127.0.0.1"));
 519                         AssertEquals ("#28", UriHostNameType.IPv6, Uri.CheckHostName ("::ffFF:169.32.14.5"));
 520                         AssertEquals ("#29", UriHostNameType.IPv6, Uri.CheckHostName ("2001:03A0::/35"));
 521                         AssertEquals ("#30", UriHostNameType.IPv6, Uri.CheckHostName ("[2001:03A0::/35]"));
 522
 523                         AssertEquals ("#31", UriHostNameType.Unknown, Uri.CheckHostName ("2001::03A0::/35"));
 524                         AssertEquals ("#32", UriHostNameType.Unknown, Uri.CheckHostName ("2001:03A0::/35a"));
 525                         AssertEquals ("#33 known to fail with ms.net: this is not a valid IPv6 address.", UriHostNameType.Unknown, Uri.CheckHostName ("2001::03A0:1.2.3.4"));
 526                         AssertEquals ("#34", UriHostNameType.Unknown, Uri.CheckHostName ("::ffff:123.256.155.43"));
 527                         AssertEquals ("#35", UriHostNameType.Unknown, Uri.CheckHostName (":127.0.0.1"));
 528                         AssertEquals ("#36 known to fail with ms.net: this is not a valid IPv6 address.", UriHostNameType.Unknown, Uri.CheckHostName (":11:22:33:44:55:66:77:88"));
 529                         AssertEquals ("#37", UriHostNameType.Unknown, Uri.CheckHostName ("::11:22:33:44:55:66:77:88"));
 530                         AssertEquals ("#38", UriHostNameType.Unknown, Uri.CheckHostName ("11:22:33:44:55:66:77:88::"));
 531                         AssertEquals ("#39", UriHostNameType.Unknown, Uri.CheckHostName ("11:22:33:44:55:66:77:88:"));
 532                         AssertEquals ("#40", UriHostNameType.Unknown, Uri.CheckHostName ("::acbde"));
 533                         AssertEquals ("#41", UriHostNameType.Unknown, Uri.CheckHostName ("::abce:"));
 534                         AssertEquals ("#42", UriHostNameType.Unknown, Uri.CheckHostName ("::abcg"));
 535                         AssertEquals ("#43", UriHostNameType.Unknown, Uri.CheckHostName (":::"));
 536                         AssertEquals ("#44", UriHostNameType.Unknown, Uri.CheckHostName (":"));
 537                 }
 538
 539                 [Test]
 540                 public void IsLoopback ()
 541                 {
 542                         Uri uri = new Uri("http://loopback:8080");
 543                         AssertEquals ("#1", true, uri.IsLoopback);
 544                         uri = new Uri("http://localhost:8080");
 545                         AssertEquals ("#2", true, uri.IsLoopback);
 546                         uri = new Uri("http://127.0.0.1:8080");
 547                         AssertEquals ("#3", true, uri.IsLoopback);
 548                         uri = new Uri("http://127.0.0.001:8080");
 549                         AssertEquals ("#4", true, uri.IsLoopback);
 550                         uri = new Uri("http://[::1]");
 551                         AssertEquals ("#5", true, uri.IsLoopback);
 552                         uri = new Uri("http://[::1]:8080");
 553                         AssertEquals ("#6", true, uri.IsLoopback);
 554                         uri = new Uri("http://[::0001]:8080");
 555                         AssertEquals ("#7", true, uri.IsLoopback);
 556                         uri = new Uri("http://[0:0:0:0::1]:8080");
 557                         AssertEquals ("#8", true, uri.IsLoopback);
 558                         uri = new Uri("http://[0:0:0:0::127.0.0.1]:8080");
 559                         AssertEquals ("#9", true, uri.IsLoopback);
 560                         uri = new Uri("http://[0:0:0:0::127.11.22.33]:8080");
 561                         AssertEquals ("#10: known to fail with ms.net", true, uri.IsLoopback);
 562                         uri = new Uri("http://[::ffff:127.11.22.33]:8080");
 563                         AssertEquals ("#11: known to fail with ms.net", true, uri.IsLoopback);
 564                         uri = new Uri("http://[::ff00:7f11:2233]:8080");
 565                         AssertEquals ("#12", false, uri.IsLoopback);
 566                         uri = new Uri("http://[1:0:0:0::1]:8080");
 567                         AssertEquals ("#13", false, uri.IsLoopback);
 568                 }
 569
 570                 [Test]
 571                 public void Equals ()
 572                 {
 573                         Uri uri1 = new Uri ("http://www.contoso.com/index.htm#main");
 574                         Uri uri2 = new Uri ("http://www.contoso.com/index.htm#fragment");
 575                         Assert ("#1", uri1.Equals (uri2));
 576                         uri2 = new Uri ("http://www.contoso.com/index.htm?x=1");
 577                         Assert ("#2 known to fail with ms.net", !uri1.Equals (uri2));
 578                         Assert ("#3", !uri2.Equals ("http://www.contoso.com/index.html?x=1"));
 579                         Assert ("#4: known to fail with ms.net", !uri1.Equals ("http://www.contoso.com:8080/index.htm?x=1"));
 580                 }
 581
 582                 [Test]
 583                 public void TestEquals2 ()
 584                 {
 585                         Uri a = new Uri ("http://www.go-mono.com");
 586                         Uri b = new Uri ("http://www.go-mono.com");
 587
 588                         AssertEquals ("#1", a, b);
 589
 590                         a = new Uri ("mailto:user:pwd@go-mono.com?subject=uri");
 591                         b = new Uri ("MAILTO:USER:PWD@GO-MONO.COM?SUBJECT=URI");
 592
 593                         AssertEquals ("#2", a, b);
 594
 595                         a = new Uri ("http://www.go-mono.com/ports/");
 596                         b = new Uri ("http://www.go-mono.com/PORTS/");
 597
 598                         Assert ("#3", !a.Equals (b));
 599                 }
 600
 601                 [Test]
 602                 public void GetHashCodeTest ()
 603                 {
 604                         Uri uri1 = new Uri ("http://www.contoso.com/index.htm#main");
 605                         Uri uri2 = new Uri ("http://www.contoso.com/index.htm#fragment");
 606                         AssertEquals ("#1", uri1.GetHashCode (), uri2.GetHashCode ());
 607                         uri2 = new Uri ("http://www.contoso.com/index.htm?x=1");
 608                         Assert ("#2", uri1.GetHashCode () != uri2.GetHashCode ());
 609                         uri2 = new Uri ("http://www.contoso.com:80/index.htm");
 610                         AssertEquals ("#3", uri1.GetHashCode (), uri2.GetHashCode ());
 611                         uri2 = new Uri ("http://www.contoso.com:8080/index.htm");
 612                         Assert ("#4", uri1.GetHashCode () != uri2.GetHashCode ());
 613                 }
 614
 615                 [Test]
 616                 public void MakeRelative ()
 617                 {
 618                         Uri uri1 = new Uri ("http://www.contoso.com/index.htm?x=2");
 619                         Uri uri2 = new Uri ("http://www.contoso.com/foo/bar/index.htm#fragment");
 620                         Uri uri3 = new Uri ("http://www.contoso.com/bar/foo/index.htm?y=1");
 621                         Uri uri4 = new Uri ("http://www.contoso.com/bar/foo2/index.htm?x=0");
 622                         Uri uri5 = new Uri ("https://www.contoso.com/bar/foo/index.htm?y=1");
 623                         Uri uri6 = new Uri ("http://www.contoso2.com/bar/foo/index.htm?x=0");
 624                         Uri uri7 = new Uri ("http://www.contoso2.com/bar/foo/foobar.htm?z=0&y=5");
 625                         Uri uri8 = new Uri ("http://www.xxx.com/bar/foo/foobar.htm?z=0&y=5" + (char) 0xa9);
 626
 627                         AssertEquals ("#1", "foo/bar/index.htm", uri1.MakeRelative (uri2));
 628                         AssertEquals ("#2", "../../index.htm", uri2.MakeRelative (uri1));
 629
 630                         AssertEquals ("#3", "../../bar/foo/index.htm", uri2.MakeRelative (uri3));
 631                         AssertEquals ("#4", "../../foo/bar/index.htm", uri3.MakeRelative (uri2));
 632
 633                         AssertEquals ("#5", "../foo2/index.htm", uri3.MakeRelative (uri4));
 634                         AssertEquals ("#6", "../foo/index.htm", uri4.MakeRelative (uri3));
 635
 636                         AssertEquals ("#7", "https://www.contoso.com/bar/foo/index.htm?y=1",
 637                                             uri4.MakeRelative (uri5));
 638
 639                         AssertEquals ("#8", "http://www.contoso2.com/bar/foo/index.htm?x=0",
 640                                             uri4.MakeRelative (uri6));
 641
 642                         AssertEquals ("#9", "", uri6.MakeRelative (uri6));
 643                         AssertEquals ("#10", "foobar.htm", uri6.MakeRelative (uri7));
 644
 645                         Uri uri10 = new Uri ("mailto:xxx@xxx.com");
 646                         Uri uri11 = new Uri ("mailto:xxx@xxx.com?subject=hola");
 647                         AssertEquals ("#11", "", uri10.MakeRelative (uri11));
 648
 649                         Uri uri12 = new Uri ("mailto:xxx@mail.xxx.com?subject=hola");
 650                         AssertEquals ("#12", "mailto:xxx@mail.xxx.com?subject=hola", uri10.MakeRelative (uri12));
 651
 652                         Uri uri13 = new Uri ("mailto:xxx@xxx.com/foo/bar");
 653                         AssertEquals ("#13", "/foo/bar", uri10.MakeRelative (uri13));
 654
 655                         AssertEquals ("#14", "http://www.xxx.com/bar/foo/foobar.htm?z=0&y=5" + (char) 0xa9, uri1.MakeRelative (uri8));
 656                 }
 657
 658                 [Test]
 659                 public void ToStringTest()
 660                 {
 661                         Uri uri = new Uri ("dummy://xxx");
 662                         AssertEquals ("#1", "dummy://xxx/", uri.ToString ());
 663                 }
 664
 665                 [Test]
 666                 public void CheckSchemeName ()
 667                 {
 668                         AssertEquals ("#01", false, Uri.CheckSchemeName (null));
 669                         AssertEquals ("#02", false, Uri.CheckSchemeName (""));
 670                         AssertEquals ("#03", true, Uri.CheckSchemeName ("http"));
 671                         AssertEquals ("#04", true, Uri.CheckSchemeName ("http-"));
 672                         AssertEquals ("#05", false, Uri.CheckSchemeName ("6http-"));
 673                         AssertEquals ("#06", true, Uri.CheckSchemeName ("http6-"));
 674                         AssertEquals ("#07", false, Uri.CheckSchemeName ("http6,"));
 675                         AssertEquals ("#08", true, Uri.CheckSchemeName ("http6."));
 676                         AssertEquals ("#09", false, Uri.CheckSchemeName ("+http"));
 677                         AssertEquals ("#10", true, Uri.CheckSchemeName ("htt+p6"));
 678                         // 0x00E1 -> &atilde;
 679                         AssertEquals ("#11", true, Uri.CheckSchemeName ("htt\u00E1+p6"));
 680                 }
 681
 682                 [Test]
 683                 [ExpectedException (typeof (UriFormatException))]
 684                 public void NoHostname ()
 685                 {
 686                         Uri uri = new Uri ("http://");
 687                 }
 688
 689                 [Test]
 690                 [ExpectedException (typeof (UriFormatException))]
 691                 [Ignore ("MS throws an IndexOutOfRangeException. Bug?")]
 692                 public void NoHostname2 ()
 693                 {
 694                         Uri uri = new Uri ("file://");
 695                 }
 696
 697                 [Test]
 698                 public void Segments1 ()
 699                 {
 700                         Uri uri = new Uri ("http://localhost/");
 701                         string [] segments = uri.Segments;
 702                         AssertEquals ("#01", 1, segments.Length);
 703                         AssertEquals ("#02", "/", segments [0]);
 704
 705                 }
 706
 707                 [Test]
 708                 public void Segments2 ()
 709                 {
 710                         Uri uri = new Uri ("http://localhost/dir/dummypage.html");
 711                         string [] segments = uri.Segments;
 712                         AssertEquals ("#01", 3, segments.Length);
 713                         AssertEquals ("#02", "/", segments [0]);
 714                         AssertEquals ("#03", "dir/", segments [1]);
 715                         AssertEquals ("#04", "dummypage.html", segments [2]);
 716
 717                 }
 718
 719                 [Test]
 720                 public void Segments3 ()
 721                 {
 722                         Uri uri = new Uri ("http://localhost/dir/dummypage/");
 723                         string [] segments = uri.Segments;
 724                         AssertEquals ("#01", 3, segments.Length);
 725                         AssertEquals ("#02", "/", segments [0]);
 726                         AssertEquals ("#03", "dir/", segments [1]);
 727                         AssertEquals ("#04", "dummypage/", segments [2]);
 728
 729                 }
 730
 731                 [Test]
 732                 public void Segments4 ()
 733                 {
 734                         Uri uri = new Uri ("file:///c:/hello");
 735                         string [] segments = uri.Segments;
 736                         AssertEquals ("#01", 3, segments.Length);
 737                         AssertEquals ("#02", "c:", segments [0]);
 738                         AssertEquals ("#03", "/", segments [1]);
 739                         AssertEquals ("#04", "hello", segments [2]);
 740
 741                 }
 742
 743                 [Test]
 744                 public void Segments5 ()
 745                 {
 746                         Uri uri = new Uri ("http://www.xxx.com/bar/foo/foobar.htm?z=0&y=5" + (char) 0xa9);
 747                         string [] segments = uri.Segments;
 748                         AssertEquals ("#01", 4, segments.Length);
 749                         AssertEquals ("#02", "/", segments [0]);
 750                         AssertEquals ("#03", "bar/", segments [1]);
 751                         AssertEquals ("#04", "foo/", segments [2]);
 752                         AssertEquals ("#05", "foobar.htm", segments [3]);
 753                 }
 754
 755                 [Test]
 756                 [ExpectedException (typeof (UriFormatException))]
 757                 public void EmptyScheme ()
 758                 {
 759                         new Uri ("hey");
 760                 }
 761
 762                 [Test]
 763                 public void InvalidPortsThatWorkWithMS ()
 764                 {
 765                         new Uri ("http://www.contoso.com:12345678/foo/bar/");
 766                         // UInt32.MaxValue gives port == -1 !!!
 767                         new Uri ("http://www.contoso.com:4294967295/foo/bar/");
 768                         // ((uint) Int32.MaxValue + (uint) 1) gives port == -2147483648 !!!
 769                         new Uri ("http://www.contoso.com:2147483648/foo/bar/");
 770                 }
 771
 772                 class UriEx2 : Uri
 773                 {
 774                         public UriEx2 (string s) : base (s)
 775                         {
 776                         }
 777
 778                         protected override void Parse ()
 779                         {
 780                         }
 781                 }
 782
 783                 [Test]
 784                 public void ParseOverride ()
 785                 {
 786                         // If this does not override base's Parse(), it will
 787                         // fail since this argument is not Absolute URI.
 788                         UriEx2 ex = new UriEx2 ("readme.txt");
 789                 }
 790
 791                 [Test]
 792                 public void UnixLocalPath ()
 793                 {
 794                         // This works--the location is not part of the absolute path
 795                         string path = "file://localhost/tmp/foo/bar";
 796                         Uri fileUri = new Uri( path );
 797                         AssertEquals (path, "/tmp/foo/bar", fileUri.AbsolutePath);
 798
 799                         // Empty path == localhost, in theory
 800                         path = "file:///tmp/foo/bar";
 801                         fileUri = new Uri( path );
 802                         AssertEquals (path, "/tmp/foo/bar", fileUri.AbsolutePath);
 803
 804                         // Empty path == localhost, in theory
 805                         path = "file:///c:/tmp/foo/bar";
 806                         fileUri = new Uri( path );
 807                         AssertEquals (path, "c:/tmp/foo/bar", fileUri.AbsolutePath);
 808                 }
 809
 810                 public static void Print (Uri uri)
 811                 {
 812                         Console.WriteLine ("ToString: " + uri.ToString ());
 813
 814                         Console.WriteLine ("AbsolutePath: " + uri.AbsolutePath);
 815                         Console.WriteLine ("AbsoluteUri: " + uri.AbsoluteUri);
 816                         Console.WriteLine ("Authority: " + uri.Authority);
 817                         Console.WriteLine ("Fragment: " + uri.Fragment);
 818                         Console.WriteLine ("Host: " + uri.Host);
 819                         Console.WriteLine ("HostNameType: " + uri.HostNameType);
 820                         Console.WriteLine ("IsDefaultPort: " + uri.IsDefaultPort);
 821                         Console.WriteLine ("IsFile: " + uri.IsFile);
 822                         Console.WriteLine ("IsLoopback: " + uri.IsLoopback);
 823                         Console.WriteLine ("IsUnc: " + uri.IsUnc);
 824                         Console.WriteLine ("LocalPath: " + uri.LocalPath);
 825                         Console.WriteLine ("PathAndQuery: " + uri.PathAndQuery);
 826                         Console.WriteLine ("Port: " + uri.Port);
 827                         Console.WriteLine ("Query: " + uri.Query);
 828                         Console.WriteLine ("Scheme: " + uri.Scheme);
 829                         Console.WriteLine ("UserEscaped: " + uri.UserEscaped);
 830                         Console.WriteLine ("UserInfo: " + uri.UserInfo);
 831
 832                         Console.WriteLine ("Segments:");
 833                         string [] segments = uri.Segments;
 834                         if (segments == null)
 835                                 Console.WriteLine ("\tNo Segments");
 836                         else
 837                                 for (int i = 0; i < segments.Length; i++)
 838                                         Console.WriteLine ("\t" + segments[i]);
 839                         Console.WriteLine ("");
 840                 }
 841
 842         }
 843 }
 844