mcs/class/System/Test/System/UriTest2.cs

   1 //
   2 // UriTest2.cs - More NUnit Test Cases for System.Uri
   3 //
   4
   5 using System;
   6 using System.IO;
   7 using System.Reflection;
   8 using System.Text;
   9 using NUnit.Framework;
  10
  11 namespace MonoTests.System
  12 {
  13         // help bring Moonlight tests back to mono/mcs nunit
  14
  15         public delegate void TestCode ();
  16
  17         static class Assert2 {
  18
  19                 public static void Throws<TException> (TestCode code, string message) where TException : Exception
  20                 {
  21                         Throws (code, typeof (TException), null, message);
  22                 }
  23
  24                 public static void Throws (TestCode code, Type expected_exception, Type expected_inner_exception, string message)
  25                 {
  26                         bool failed = false;
  27                         try {
  28                                 code ();
  29                                 failed = true;
  30                         }
  31                         catch (Exception ex) {
  32                                 if (!(ex.GetType () == expected_exception))
  33                                         throw new AssertionException (string.Format ("Expected '{0}', got '{1}'. {2}", expected_exception.FullName, ex.GetType ().FullName, message));
  34                                 //System.Diagnostics.Debug.WriteLine (ex.ToString ());
  35                                 if (expected_inner_exception != null) {
  36                                         // we only check if the inner exception was supplied
  37                                         if (ex.InnerException.GetType () != expected_inner_exception)
  38                                                 throw new AssertionException (string.Format ("Expected InnerException '{0}', got '{1}'. {2}", expected_inner_exception.FullName, ex.InnerException.GetType ().FullName, message));
  39                                 }
  40                         }
  41                         if (failed)
  42                                 throw new AssertionException (string.Format ("Expected '{0}', but got no exception. {1}", expected_exception.FullName, message));
  43                 }
  44         }
  45
  46         [TestFixture]
  47         public class UriTest2
  48         {
  49                 protected bool isWin32 = false;
  50                 public bool IriParsing;
  51
  52                 [SetUp]
  53                 public void SetUp ()
  54                 {
  55                         isWin32 = (Path.DirectorySeparatorChar == '\\');
  56
  57                         //Make sure Uri static constructor is called
  58                         Uri.EscapeDataString ("");
  59
  60                         FieldInfo iriParsingField = typeof (Uri).GetField ("s_IriParsing",
  61                                 BindingFlags.Static | BindingFlags.GetField | BindingFlags.NonPublic);
  62                         if (iriParsingField != null)
  63                                 IriParsing = (bool)iriParsingField.GetValue (null);
  64                 }
  65
  66                 // Segments cannot be validated here...
  67                 public void AssertUri (string relsrc, Uri uri,
  68                         string toString,
  69                         string absoluteUri,
  70                         string scheme,
  71                         string host,
  72                         string localPath,
  73                         string query,
  74                         int port,
  75                         bool isFile,
  76                         bool isUnc,
  77                         bool isLoopback,
  78                         bool userEscaped,
  79                         UriHostNameType hostNameType,
  80                         string absolutePath,
  81                         string pathAndQuery,
  82                         string authority,
  83                         string fragment,
  84                         string userInfo)
  85                 {
  86                         Assert.AreEqual (absoluteUri, uri.AbsoluteUri, relsrc + " AbsoluteUri");
  87                         Assert.AreEqual (scheme, uri.Scheme, relsrc + " Scheme");
  88                         Assert.AreEqual (host, uri.Host, relsrc + " Host");
  89                         Assert.AreEqual (port, uri.Port, relsrc + " Port");
  90                         // Windows UNC path is not automatically testable on *nix environment,
  91                         if (relsrc.StartsWith ("\\\\") && Path.DirectorySeparatorChar == '\\')
  92                                 Assert.AreEqual (localPath, uri.LocalPath, relsrc + " LocalPath");
  93                         Assert.AreEqual (query, uri.Query, relsrc + " Query");
  94                         Assert.AreEqual (fragment, uri.Fragment, relsrc + " Fragment");
  95                         Assert.AreEqual (isFile, uri.IsFile, relsrc + " IsFile");
  96                         Assert.AreEqual (isUnc, uri.IsUnc, relsrc + " IsUnc");
  97                         Assert.AreEqual (isLoopback, uri.IsLoopback, relsrc + " IsLoopback");
  98                         Assert.AreEqual (authority, uri.Authority, relsrc + " Authority");
  99                         Assert.AreEqual (userEscaped, uri.UserEscaped, relsrc + " UserEscaped");
 100                         Assert.AreEqual (userInfo, uri.UserInfo, relsrc + " UserInfo");
 101                         Assert.AreEqual (hostNameType, uri.HostNameType, relsrc + " HostNameType");
 102                         Assert.AreEqual (absolutePath, uri.AbsolutePath, relsrc + " AbsolutePath");
 103                         Assert.AreEqual (pathAndQuery, uri.PathAndQuery, relsrc + " PathAndQuery");
 104                         Assert.AreEqual (toString, uri.ToString (), relsrc + " ToString()");
 105                 }
 106
 107                 [Test]
 108                 [Ignore ("Tests needs to be updated for 2.0")]
 109                 public void AbsoluteUriFromFile ()
 110                 {
 111                         FromResource ("test-uri-props.txt", null);
 112                 }
 113
 114                 [Test]
 115                 [Category("NotDotNet")]
 116                 [Ignore ("Tests needs to be updated for 2.0")]
 117                 public void AbsoluteUriFromFileManual ()
 118                 {
 119                         if (Path.DirectorySeparatorChar == '\\')
 120                                 return;
 121                         FromResource ("test-uri-props-manual.txt", null);
 122                 }
 123
 124                 [Test]
 125                 [Ignore ("Tests needs to be updated for 2.0")]
 126                 public void RelativeUriFromFile ()
 127                 {
 128                         FromResource ("test-uri-relative-props.txt", new Uri ("http://www.go-mono.com"));
 129                 }
 130
 131                 private void FromResource (string res, Uri baseUri)
 132                 {
 133                         Assembly a = Assembly.GetExecutingAssembly ();
 134                         Stream s = a.GetManifestResourceStream (res);
 135                         StreamReader sr = new StreamReader (s, Encoding.UTF8);
 136                         while (sr.Peek () > 0) {
 137                                 sr.ReadLine (); // skip
 138                                 string uriString = sr.ReadLine ();
 139 /*
 140 TextWriter sw = Console.Out;
 141                                 sw.WriteLine ("-------------------------");
 142                                 sw.WriteLine (uriString);
 143 */
 144                                 if (uriString == null || uriString.Length == 0)
 145                                         break;
 146
 147                                 try {
 148                                         Uri uri = baseUri == null ? new Uri (uriString) : new Uri (baseUri, uriString);
 149 /*
 150                                 sw.WriteLine ("ToString(): " + uri.ToString ());
 151                                 sw.WriteLine (uri.AbsoluteUri);
 152                                 sw.WriteLine (uri.Scheme);
 153                                 sw.WriteLine (uri.Host);
 154                                 sw.WriteLine (uri.LocalPath);
 155                                 sw.WriteLine (uri.Query);
 156                                 sw.WriteLine ("Port: " + uri.Port);
 157                                 sw.WriteLine (uri.IsFile);
 158                                 sw.WriteLine (uri.IsUnc);
 159                                 sw.WriteLine (uri.IsLoopback);
 160                                 sw.WriteLine (uri.UserEscaped);
 161                                 sw.WriteLine ("HostNameType: " + uri.HostNameType);
 162                                 sw.WriteLine (uri.AbsolutePath);
 163                                 sw.WriteLine ("PathAndQuery: " + uri.PathAndQuery);
 164                                 sw.WriteLine (uri.Authority);
 165                                 sw.WriteLine (uri.Fragment);
 166                                 sw.WriteLine (uri.UserInfo);
 167 */
 168                                         AssertUri (uriString, uri,
 169                                                 sr.ReadLine (),
 170                                                 sr.ReadLine (),
 171                                                 sr.ReadLine (),
 172                                                 sr.ReadLine (),
 173                                                 sr.ReadLine (),
 174                                                 sr.ReadLine (),
 175                                                 int.Parse (sr.ReadLine ()),
 176                                                 bool.Parse (sr.ReadLine ()),
 177                                                 bool.Parse (sr.ReadLine ()),
 178                                                 bool.Parse (sr.ReadLine ()),
 179                                                 bool.Parse (sr.ReadLine ()),
 180                                                 (UriHostNameType) Enum.Parse (typeof (UriHostNameType), sr.ReadLine (), false),
 181                                                 sr.ReadLine (),
 182                                                 sr.ReadLine (),
 183                                                 sr.ReadLine (),
 184                                                 sr.ReadLine (),
 185                                                 sr.ReadLine ());
 186 //                              Console.WriteLine ("Passed: " + uriString);
 187                                 } catch (UriFormatException ex) {
 188                                         Assert.Fail (String.Format ("Construction failed: [{0}] {1}", uriString, ex.Message));
 189                                 }
 190                         }
 191                 }
 192
 193                 [Test]
 194                 public void MoreUnescape () // bug 733316
 195                 {
 196                         int index = 0;
 197                         char unesc = Uri.HexUnescape ("%F6", ref index);
 198                         Assert.AreEqual (3, index, "#01");
 199                         Assert.AreEqual (0xf6, unesc, "#02");
 200                 }
 201
 202                 [Test]
 203                 public void UriScheme ()
 204                 {
 205                         Assert.AreEqual ("://", Uri.SchemeDelimiter, "://");
 206                         Assert.AreEqual ("file", Uri.UriSchemeFile, "file");
 207                         Assert.AreEqual ("ftp", Uri.UriSchemeFtp, "ftp");
 208                         Assert.AreEqual ("gopher", Uri.UriSchemeGopher, "gopher");
 209                         Assert.AreEqual ("http", Uri.UriSchemeHttp, "http");
 210                         Assert.AreEqual ("https", Uri.UriSchemeHttps, "https");
 211                         Assert.AreEqual ("mailto", Uri.UriSchemeMailto, "mailto");
 212                         Assert.AreEqual ("news", Uri.UriSchemeNews, "news");
 213                         Assert.AreEqual ("nntp", Uri.UriSchemeNntp, "file");
 214                         Assert.AreEqual ("net.pipe", Uri.UriSchemeNetPipe, "net.pipe");
 215                         Assert.AreEqual ("net.tcp", Uri.UriSchemeNetTcp, "net.tcp");
 216                 }
 217
 218                 [Test] // bug #71049
 219                 [ExpectedException (typeof (UriFormatException))]
 220                 public void StarsInHost ()
 221                 {
 222                         new Uri ("http://w*w*w.go-mono.com");
 223                 }
 224
 225                 [Test]
 226                 public void NoHostName1_Bug76146 ()
 227                 {
 228                         Uri u = new Uri ("foo:///?bar");
 229                         Assert.AreEqual ("/", u.AbsolutePath, "AbsolutePath");
 230                         Assert.AreEqual ("foo:///?bar", u.AbsoluteUri, "AbsoluteUri");
 231                         Assert.AreEqual (String.Empty, u.Authority, "Authority");
 232                         Assert.AreEqual (String.Empty, u.Fragment, "Fragment");
 233                         Assert.AreEqual (String.Empty, u.Host, "Host");
 234                         // FIXME (2.0) - Normally this is never Basic without an Host name :(
 235                         // Assert.AreEqual (UriHostNameType.Basic, u.HostNameType, "HostNameType");
 236                         Assert.IsTrue (u.IsDefaultPort, "IsDefaultPort");
 237                         Assert.IsFalse (u.IsFile, "IsFile");
 238                         // FIXME Assert.IsTrue (u.IsLoopback, "IsLoopback");
 239                         Assert.IsFalse (u.IsUnc, "IsUnc");
 240                         Assert.AreEqual ("/", u.LocalPath, "LocalPath");
 241                         Assert.AreEqual ("/?bar", u.PathAndQuery, "PathAndQuery");
 242                         Assert.AreEqual ("foo", u.Scheme, "Scheme");
 243                         Assert.IsFalse (u.UserEscaped, "UserEscaped");
 244                         Assert.AreEqual (String.Empty, u.UserInfo, "UserInfo");
 245                 }
 246
 247                 [Test]
 248                 public void NoHostName2_Bug76146 ()
 249                 {
 250                         Uri u = new Uri ("foo:///bar");
 251                         Assert.AreEqual ("/bar", u.AbsolutePath, "AbsolutePath");
 252                         Assert.AreEqual ("foo:///bar", u.AbsoluteUri, "AbsoluteUri");
 253                         Assert.AreEqual (String.Empty, u.Authority, "Authority");
 254                         Assert.AreEqual (String.Empty, u.Fragment, "Fragment");
 255                         Assert.AreEqual (String.Empty, u.Host, "Host");
 256                         // FIXME (2.0) - Normally this is never Basic without an Host name :(
 257                         // Assert.AreEqual (UriHostNameType.Basic, u.HostNameType, "HostNameType");
 258                         Assert.IsTrue (u.IsDefaultPort, "IsDefaultPort");
 259                         Assert.IsFalse (u.IsFile, "IsFile");
 260                         // FIXME Assert.IsTrue (u.IsLoopback, "IsLoopback");
 261                         Assert.IsFalse (u.IsUnc, "IsUnc");
 262                         Assert.AreEqual ("/bar", u.LocalPath, "LocalPath");
 263                         Assert.AreEqual ("/bar", u.PathAndQuery, "PathAndQuery");
 264                         Assert.AreEqual ("foo", u.Scheme, "Scheme");
 265                         Assert.IsFalse (u.UserEscaped, "UserEscaped");
 266                         Assert.AreEqual (String.Empty, u.UserInfo, "UserInfo");
 267                 }
 268
 269                 [Test]
 270                 [ExpectedException (typeof (UriFormatException))]
 271                 public void InvalidIPAddress_Bug76659 ()
 272                 {
 273                         new Uri ("http://127.0.0.1::::/");
 274                 }
 275
 276                 [Test]
 277                 public void File ()
 278                 {
 279                         string s = "file:///dir1%2f..%2fdir%2fapp.xap#header";
 280                         Uri uri = new Uri (s);
 281                         Assert.AreEqual ("/dir/app.xap", uri.AbsolutePath, "AbsolutePath");
 282                         // default port is removed
 283                         Assert.AreEqual ("file:///dir/app.xap#header", uri.AbsoluteUri, "AbsoluteUri");
 284                         Assert.AreEqual (String.Empty, uri.DnsSafeHost, "DnsSafeHost");
 285                         Assert.AreEqual ("#header", uri.Fragment, "Fragment");
 286                         Assert.AreEqual (String.Empty, uri.Host, "Host");
 287                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 288                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 289                         Assert.AreEqual ("/dir/app.xap", uri.LocalPath, "LocalPath");
 290                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 291                         Assert.AreEqual (-1, uri.Port, "Port");
 292                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 293                         Assert.AreEqual ("file", uri.Scheme, "Scheme");
 294                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 295                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 296                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 297                 }
 298
 299                 [Test]
 300                 public void HttpWithDefaultPort ()
 301                 {
 302                         string s = "HTTP://host.domain.com:80/app.xap";
 303                         Uri uri = new Uri (s);
 304                         Assert.AreEqual ("/app.xap", uri.AbsolutePath, "AbsolutePath");
 305                         // default port is removed
 306                         Assert.AreEqual ("http://host.domain.com/app.xap", uri.AbsoluteUri, "AbsoluteUri");
 307                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 308                         Assert.AreEqual (String.Empty, uri.Fragment, "Fragment");
 309                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 310                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 311                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 312                         Assert.AreEqual ("/app.xap", uri.LocalPath, "LocalPath");
 313                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 314                         Assert.AreEqual (80, uri.Port, "Port");
 315                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 316                         Assert.AreEqual ("http", uri.Scheme, "Scheme");
 317                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 318                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 319                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 320                 }
 321
 322                 [Test]
 323                 public void HttpWithoutPort ()
 324                 {
 325                         string s = "Http://host.DOMAIN.com/dir/app.xap#options";
 326                         Uri uri = new Uri (s);
 327                         Assert.AreEqual ("/dir/app.xap", uri.AbsolutePath, "AbsolutePath");
 328                         Assert.AreEqual ("http://host.domain.com/dir/app.xap#options", uri.AbsoluteUri, "AbsoluteUri");
 329                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 330                         Assert.AreEqual ("#options", uri.Fragment, "Fragment");
 331                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 332                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 333                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 334                         Assert.AreEqual ("/dir/app.xap", uri.LocalPath, "LocalPath");
 335                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 336                         Assert.AreEqual (80, uri.Port, "Port");
 337                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 338                         Assert.AreEqual ("http", uri.Scheme, "Scheme");
 339                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 340                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 341                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 342                 }
 343
 344                 [Test]
 345                 public void HttpWithNonStandardPort ()
 346                 {
 347                         string s = "http://monkey:s3kr3t@HOST.domain.Com:8080/dir/../app.xap?option=1";
 348                         Uri uri = new Uri (s);
 349                         Assert.AreEqual ("/app.xap", uri.AbsolutePath, "AbsolutePath");
 350                         // non-standard port is present
 351                         Assert.AreEqual ("http://monkey:s3kr3t@host.domain.com:8080/app.xap?option=1", uri.AbsoluteUri, "AbsoluteUri");
 352                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 353                         Assert.AreEqual (String.Empty, uri.Fragment, "Fragment");
 354                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 355                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 356                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 357                         Assert.AreEqual ("/app.xap", uri.LocalPath, "LocalPath");
 358                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 359                         Assert.AreEqual (8080, uri.Port, "Port");
 360                         Assert.AreEqual ("?option=1", uri.Query, "Query");
 361                         Assert.AreEqual ("http", uri.Scheme, "Scheme");
 362                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 363                         Assert.AreEqual ("monkey:s3kr3t", uri.UserInfo, "UserInfo");
 364                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 365                 }
 366
 367                 [Test]
 368                 public void HttpsWithDefaultPort ()
 369                 {
 370                         string s = "httpS://host.domain.com:443/";
 371                         Uri uri = new Uri (s);
 372                         Assert.AreEqual ("/", uri.AbsolutePath, "AbsolutePath");
 373                         // default port is removed
 374                         Assert.AreEqual ("https://host.domain.com/", uri.AbsoluteUri, "AbsoluteUri");
 375                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 376                         Assert.AreEqual (String.Empty, uri.Fragment, "Fragment");
 377                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 378                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 379                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 380                         Assert.AreEqual ("/", uri.LocalPath, "LocalPath");
 381                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 382                         Assert.AreEqual (443, uri.Port, "Port");
 383                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 384                         Assert.AreEqual ("https", uri.Scheme, "Scheme");
 385                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 386                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 387                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 388                 }
 389
 390                 [Test]
 391                 public void HttpsWithoutPort ()
 392                 {
 393                         string s = "Https://host.DOMAIN.com/dir%2fapp.xap#";
 394                         Uri uri = new Uri (s);
 395
 396                         if (IriParsing) {
 397                                 Assert.AreEqual ("/dir%2fapp.xap", uri.AbsolutePath, "AbsolutePath");
 398                                 Assert.AreEqual ("https://host.domain.com/dir%2fapp.xap#", uri.AbsoluteUri, "AbsoluteUri");
 399                         } else {
 400                                 Assert.AreEqual ("/dir/app.xap", uri.AbsolutePath, "AbsolutePath");
 401                                 Assert.AreEqual ("https://host.domain.com/dir/app.xap#", uri.AbsoluteUri, "AbsoluteUri");
 402                         }
 403
 404                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 405                         Assert.AreEqual ("#", uri.Fragment, "Fragment");
 406                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 407                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 408                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 409                         Assert.AreEqual ("/dir/app.xap", uri.LocalPath, "LocalPath");
 410                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 411                         Assert.AreEqual (443, uri.Port, "Port");
 412                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 413                         Assert.AreEqual ("https", uri.Scheme, "Scheme");
 414                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 415                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 416                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 417                 }
 418
 419                 [Test]
 420                 public void HttpsWithNonStandardPort ()
 421                 {
 422                         string s = "https://monkey:s3kr3t@HOST.domain.Com:4430/dir/..%5Capp.xap?";
 423                         Uri uri = new Uri (s);
 424
 425                         if (IriParsing) {
 426                                 Assert.AreEqual ("/dir/..%5Capp.xap", uri.AbsolutePath, "AbsolutePath");
 427                                 Assert.AreEqual ("https://monkey:s3kr3t@host.domain.com:4430/dir/..%5Capp.xap?", uri.AbsoluteUri, "AbsoluteUri");
 428                                 Assert.AreEqual ("/dir/..\\app.xap", uri.LocalPath, "LocalPath");
 429                         } else {
 430                                 Assert.AreEqual ("/app.xap", uri.AbsolutePath, "AbsolutePath");
 431                                 Assert.AreEqual ("https://monkey:s3kr3t@host.domain.com:4430/app.xap?", uri.AbsoluteUri, "AbsoluteUri");
 432                                 Assert.AreEqual ("/app.xap", uri.LocalPath, "LocalPath");
 433                         }
 434
 435                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 436                         Assert.AreEqual (String.Empty, uri.Fragment, "Fragment");
 437                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 438                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 439                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 440                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 441                         Assert.AreEqual (4430, uri.Port, "Port");
 442                         Assert.AreEqual ("?", uri.Query, "Query");
 443                         Assert.AreEqual ("https", uri.Scheme, "Scheme");
 444                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 445                         Assert.AreEqual ("monkey:s3kr3t", uri.UserInfo, "UserInfo");
 446                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 447                 }
 448
 449                 [Test]
 450                 public void Relative ()
 451                 {
 452                         Uri relative = new Uri ("/Moonlight", UriKind.Relative);
 453
 454                         Assert2.Throws<ArgumentNullException> (delegate {
 455                                 new Uri (null, "/Moonlight");
 456                         }, "null,string");
 457                         Assert2.Throws<ArgumentNullException> (delegate {
 458                                 new Uri (null, relative);
 459                         }, "null,Uri");
 460
 461                         Assert2.Throws<ArgumentOutOfRangeException> (delegate {
 462                                 new Uri (relative, "/Moonlight");
 463                         }, "Uri,string");
 464                         Assert2.Throws<ArgumentOutOfRangeException> (delegate {
 465                                 new Uri (relative, relative);
 466                         }, "Uri,Uri");
 467
 468                         Assert2.Throws<ArgumentOutOfRangeException> (delegate {
 469                                 new Uri (relative, (string) null);
 470                         }, "Uri,string-null");
 471                         Assert2.Throws<ArgumentOutOfRangeException> (delegate {
 472                                 new Uri (relative, (Uri) null);
 473                         }, "Uri,Uri-null");
 474                 }
 475
 476                 private void CheckRelativeUri (Uri uri)
 477                 {
 478                         Assert2.Throws<InvalidOperationException> (delegate {
 479                                 Assert.IsNotNull (uri.AbsolutePath);
 480                         }, "AbsolutePath");
 481                         Assert2.Throws<InvalidOperationException> (delegate {
 482                                 Assert.IsNotNull (uri.AbsoluteUri);
 483                         }, "AbsoluteUri");
 484                         Assert2.Throws<InvalidOperationException> (delegate {
 485                                 Assert.IsNotNull (uri.DnsSafeHost);
 486                         }, "DnsSafeHost");
 487                         Assert2.Throws<InvalidOperationException> (delegate {
 488                                 Assert.IsNotNull (uri.Fragment);
 489                         }, "Fragment");
 490                         Assert2.Throws<InvalidOperationException> (delegate {
 491                                 Assert.IsNotNull (uri.Host);
 492                         }, "Host");
 493
 494                         Assert.IsFalse (uri.IsAbsoluteUri, "IsAbsoluteUri");
 495
 496                         Assert2.Throws<InvalidOperationException> (delegate {
 497                                 Assert.IsNotNull (uri.IsUnc);
 498                         }, "IsUnc");
 499                         Assert2.Throws<InvalidOperationException> (delegate {
 500                                 Assert.IsNotNull (uri.LocalPath);
 501                         }, "LocalPath");
 502
 503                         Assert.AreEqual ("/Moonlight", uri.OriginalString, "OriginalString");
 504
 505                         Assert2.Throws<InvalidOperationException> (delegate {
 506                                 Assert.IsNotNull (uri.Port);
 507                         }, "Port");
 508                         Assert2.Throws<InvalidOperationException> (delegate {
 509                                 Assert.IsNotNull (uri.Query);
 510                         }, "Query");
 511                         Assert2.Throws<InvalidOperationException> (delegate {
 512                                 Assert.IsNotNull (uri.Scheme);
 513                         }, "Scheme");
 514
 515                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 516
 517                         Assert2.Throws<InvalidOperationException> (delegate {
 518                                 Assert.IsNotNull (uri.UserInfo);
 519                         }, "UserInfo");
 520
 521                         Assert.AreEqual ("/Moonlight", uri.ToString (), "ToString");
 522                 }
 523
 524                 [Test]
 525                 public void Relative_AsRelative ()
 526                 {
 527                         Uri uri = new Uri ("/Moonlight", UriKind.Relative);
 528                         CheckRelativeUri (uri);
 529                 }
 530
 531                 [Test]
 532                 public void Bug496783 ()
 533                 {
 534                         string s = "tcp://csve2.csse.unimelb.edu.au:9090/Aneka";
 535                         Uri uri = new Uri (s);
 536                         // this is not parsed by a known UriParser
 537                         Assert.IsFalse (UriParser.IsKnownScheme (uri.Scheme), "UriParser");
 538
 539                         Uri uri2 = new Uri ("tcp://csve2.csse.unimelb.edu.au:9090/");
 540                         Assert.IsTrue (uri2.IsBaseOf (uri), "IsBaseOf");
 541
 542                         Assert.AreEqual (uri.AbsoluteUri, uri.GetComponents (UriComponents.AbsoluteUri, UriFormat.Unescaped), "AbsoluteUri");
 543                         Assert.AreEqual (uri.Fragment, uri.GetComponents (UriComponents.Fragment, UriFormat.Unescaped), "Fragment");
 544                         Assert.AreEqual (uri.Host, uri.GetComponents (UriComponents.Host, UriFormat.Unescaped), "Host");
 545                         Assert.AreEqual (uri.Authority, uri.GetComponents (UriComponents.HostAndPort, UriFormat.Unescaped), "HostAndPort");
 546                         Assert.AreEqual (uri.AbsoluteUri, uri.GetComponents (UriComponents.HttpRequestUrl, UriFormat.Unescaped), "HttpRequestUrl");
 547                         Assert.AreEqual (String.Empty, uri.GetComponents (UriComponents.KeepDelimiter, UriFormat.Unescaped), "KeepDelimiter");
 548                         Assert.AreEqual ("Aneka", uri.GetComponents (UriComponents.Path, UriFormat.Unescaped), "Path");
 549                         Assert.AreEqual (uri.LocalPath, uri.GetComponents (UriComponents.PathAndQuery, UriFormat.Unescaped), "PathAndQuery");
 550                         Assert.AreEqual (uri.Port.ToString (), uri.GetComponents (UriComponents.Port, UriFormat.Unescaped), "Port");
 551                         Assert.AreEqual (uri.Query, uri.GetComponents (UriComponents.Query, UriFormat.Unescaped), "Query");
 552                         Assert.AreEqual (uri.Scheme, uri.GetComponents (UriComponents.Scheme, UriFormat.Unescaped), "Scheme");
 553                         Assert.AreEqual ("tcp://csve2.csse.unimelb.edu.au:9090", uri.GetComponents (UriComponents.SchemeAndServer, UriFormat.Unescaped), "SchemeAndServer");
 554                         Assert.AreEqual (uri.OriginalString, uri.GetComponents (UriComponents.SerializationInfoString, UriFormat.Unescaped), "SerializationInfoString");
 555                         Assert.AreEqual (uri.Authority, uri.GetComponents (UriComponents.StrongAuthority, UriFormat.Unescaped), "StrongAuthority");
 556                         Assert.AreEqual (uri.Port.ToString (), uri.GetComponents (UriComponents.StrongPort, UriFormat.Unescaped), "StrongPort");
 557                         Assert.AreEqual (uri.UserInfo, uri.GetComponents (UriComponents.UserInfo, UriFormat.Unescaped), "UserInfo");
 558                 }
 559
 560                 [Test]
 561                 public void Merge_Query_Fragment ()
 562                 {
 563                         Uri absolute = new Uri ("http://host/dir/subdir/weird;name?moonlight");
 564                         Assert.AreEqual ("?moonlight", absolute.Query, "absolute.Query");
 565
 566                         Uri merged = new Uri (absolute, "#mono");
 567                         Assert.AreEqual ("#mono", merged.Fragment, "merged.Fragment");
 568                         Assert.AreEqual ("?moonlight", merged.Query, "merged.Query");
 569                         Assert.AreEqual ("http://host/dir/subdir/weird;name?moonlight#mono", merged.ToString (), "merged.ToString");
 570                 }
 571
 572                 [Test]
 573                 public void Merge_Query_Query ()
 574                 {
 575                         Uri absolute = new Uri ("http://host/dir/subdir/weird;name?moonlight");
 576                         Assert.AreEqual ("?moonlight", absolute.Query, "absolute.Query");
 577
 578                         Uri merged = new Uri (absolute, "?moon");
 579                         Assert.AreEqual ("?moon", merged.Query, "merged.Query");
 580 #if NET_4_0
 581                         Assert.AreEqual ("http://host/dir/subdir/weird;name?moon", merged.ToString (), "merged.ToString");
 582 #else
 583                         Assert.AreEqual ("http://host/dir/subdir/?moon", merged.ToString (), "merged.ToString");
 584 #endif
 585                 }
 586
 587                 [Test]
 588                 public void Merge_Query_RelativePath ()
 589                 {
 590                         Uri absolute = new Uri ("http://host/dir/subdir/weird;name?moonlight");
 591                         Assert.AreEqual ("?moonlight", absolute.Query, "absolute.Query");
 592
 593                         Uri merged = new Uri (absolute, "../");
 594                         Assert.AreEqual (String.Empty, merged.Query, "../Query");
 595                         Assert.AreEqual ("http://host/dir/", merged.ToString (), "../ToString");
 596
 597                         merged = new Uri (absolute, "..");
 598                         Assert.AreEqual (String.Empty, merged.Query, "..Query");
 599                         Assert.AreEqual ("http://host/dir/", merged.ToString (), "..ToString");
 600
 601                         merged = new Uri (absolute, "./");
 602                         Assert.AreEqual (String.Empty, merged.Query, "./Query");
 603                         Assert.AreEqual ("http://host/dir/subdir/", merged.ToString (), "./ToString");
 604
 605                         merged = new Uri (absolute, ".");
 606                         Assert.AreEqual (String.Empty, merged.Query, ".Query");
 607                         Assert.AreEqual ("http://host/dir/subdir/", merged.ToString (), ".ToString");
 608
 609                         merged = new Uri (absolute, "/");
 610                         Assert.AreEqual (String.Empty, merged.Query, "/Query");
 611                         Assert.AreEqual ("http://host/", merged.ToString (), "/ToString");
 612
 613                         merged = new Uri (absolute, "index.html");
 614                         Assert.AreEqual (String.Empty, merged.Query, "index.html Query");
 615                         Assert.AreEqual ("http://host/dir/subdir/index.html", merged.ToString (), "index.html ToString");
 616
 617                         merged = new Uri (absolute, "i");
 618                         Assert.AreEqual (String.Empty, merged.Query, "i Query");
 619                         Assert.AreEqual ("http://host/dir/subdir/i", merged.ToString (), "i ToString");
 620
 621                         merged = new Uri (absolute, String.Empty);
 622                         Assert.AreEqual ("?moonlight", merged.Query, "Query");
 623                         Assert.AreEqual ("http://host/dir/subdir/weird;name?moonlight", merged.ToString (), "ToString");
 624                 }
 625
 626                 [Test]
 627                 public void Merge_Fragment_RelativePath ()
 628                 {
 629                         Uri absolute = new Uri ("http://host/dir/subdir/weird;name#mono");
 630                         Assert.AreEqual ("#mono", absolute.Fragment, "absolute.Fragment");
 631
 632                         Uri merged = new Uri (absolute, "../");
 633                         Assert.AreEqual (String.Empty, merged.Fragment, "../Fragment");
 634                         Assert.AreEqual ("http://host/dir/", merged.ToString (), "../ToString");
 635
 636                         merged = new Uri (absolute, "..");
 637                         Assert.AreEqual (String.Empty, merged.Fragment, "..Fragment");
 638                         Assert.AreEqual ("http://host/dir/", merged.ToString (), "..ToString");
 639
 640                         merged = new Uri (absolute, "./");
 641                         Assert.AreEqual (String.Empty, merged.Fragment, "./Fragment");
 642                         Assert.AreEqual ("http://host/dir/subdir/", merged.ToString (), "./ToString");
 643
 644                         merged = new Uri (absolute, ".");
 645                         Assert.AreEqual (String.Empty, merged.Fragment, ".Fragment");
 646                         Assert.AreEqual ("http://host/dir/subdir/", merged.ToString (), ".ToString");
 647
 648                         merged = new Uri (absolute, "/");
 649                         Assert.AreEqual (String.Empty, merged.Fragment, "/Fragment");
 650                         Assert.AreEqual ("http://host/", merged.ToString (), "/ToString");
 651
 652                         merged = new Uri (absolute, "index.html");
 653                         Assert.AreEqual (String.Empty, merged.Fragment, "index.html Fragment");
 654                         Assert.AreEqual ("http://host/dir/subdir/index.html", merged.ToString (), "index.html ToString");
 655
 656                         merged = new Uri (absolute, "i");
 657                         Assert.AreEqual (String.Empty, merged.Fragment, "i Fragment");
 658                         Assert.AreEqual ("http://host/dir/subdir/i", merged.ToString (), "i ToString");
 659
 660                         merged = new Uri (absolute, String.Empty);
 661                         Assert.AreEqual ("#mono", merged.Fragment, "Fragment");
 662                         Assert.AreEqual ("http://host/dir/subdir/weird;name#mono", merged.ToString (), "ToString");
 663                 }
 664
 665                 [Test]
 666                 public void Host_Drive ()
 667                 {
 668                         Assert.AreEqual (UriHostNameType.Unknown, Uri.CheckHostName ("c:"), "c:");
 669                         Assert.AreEqual (UriHostNameType.Dns, Uri.CheckHostName ("c"), "c");
 670
 671                         Uri uri = new Uri ("http://c:/dir/subdir/file");
 672                         Assert.AreEqual ("c", uri.Authority, "http.Authority");
 673                         Assert.AreEqual ("c", uri.DnsSafeHost, "http.DnsSafeHost");
 674                         Assert.AreEqual ("c", uri.Host, "http.Host");
 675                         Assert.AreEqual (UriHostNameType.Dns, uri.HostNameType, "http.HostNameType");
 676                         Assert.AreEqual ("http://c/dir/subdir/file", uri.ToString (), "http.ToString");
 677
 678                         uri = new Uri ("https://c:/dir/subdir/file");
 679                         Assert.AreEqual ("c", uri.Authority, "https.Authority");
 680                         Assert.AreEqual ("c", uri.DnsSafeHost, "https.DnsSafeHost");
 681                         Assert.AreEqual ("c", uri.Host, "https.Host");
 682                         Assert.AreEqual (UriHostNameType.Dns, uri.HostNameType, "https.HostNameType");
 683                         Assert.AreEqual ("https://c/dir/subdir/file", uri.ToString (), "https.ToString");
 684
 685                         uri = new Uri ("ftp://c:/dir/subdir/file");
 686                         Assert.AreEqual ("c", uri.Authority, "ftp.Authority");
 687                         Assert.AreEqual ("c", uri.DnsSafeHost, "ftp.DnsSafeHost");
 688                         Assert.AreEqual ("c", uri.Host, "ftp.Host");
 689                         Assert.AreEqual (UriHostNameType.Dns, uri.HostNameType, "ftp.HostNameType");
 690                         Assert.AreEqual ("ftp://c/dir/subdir/file", uri.ToString (), "ftp.ToString");
 691
 692                         uri = new Uri ("nntp://c:/123456@c");
 693                         Assert.AreEqual ("c", uri.Authority, "nntp.Authority");
 694                         Assert.AreEqual ("c", uri.DnsSafeHost, "nntp.DnsSafeHost");
 695                         Assert.AreEqual ("c", uri.Host, "nntp.Host");
 696                         Assert.AreEqual (UriHostNameType.Dns, uri.HostNameType, "nntp.HostNameType");
 697                         Assert.AreEqual ("nntp://c/123456@c", uri.ToString (), "nntp.ToString");
 698
 699                         uri = new Uri ("file://c:/dir/subdir/file");
 700                         Assert.AreEqual (String.Empty, uri.Authority, "file.Authority");
 701                         Assert.AreEqual (String.Empty, uri.DnsSafeHost, "file.DnsSafeHost");
 702                         Assert.AreEqual (String.Empty, uri.Host, "file.Host");
 703                         Assert.AreEqual (UriHostNameType.Basic, uri.HostNameType, "file.HostNameType");
 704                         Assert.AreEqual ("file:///c:/dir/subdir/file", uri.ToString (), "file.ToString");
 705                 }
 706
 707                 [Test]
 708                 public void UnknownScheme ()
 709                 {
 710                         Uri uri = new Uri ("mono:c:\\dir\\subdir\\file");
 711                         Assert.IsFalse (uri.IsWellFormedOriginalString (), "IsWellFormedOriginalString");
 712                         Assert.AreEqual (String.Empty, uri.Host, "Host");
 713                         Assert.AreEqual ("c:\\dir\\subdir\\file", uri.LocalPath, "LocalPath");
 714                         // make the next assert work on both Windows and Mac (wrt Silverlight)
 715                         Assert.AreEqual ("mono:c:/dir/subdir/file", uri.ToString ().Replace ("%5C", "/"), "ToString");
 716
 717                         uri = new Uri ("mono://host/dir/subdir/file");
 718                         Assert.IsTrue (uri.IsWellFormedOriginalString (), "2/IsWellFormedOriginalString");
 719                         Assert.AreEqual ("host", uri.Host, "2/Host");
 720                         Assert.AreEqual ("/dir/subdir/file", uri.AbsolutePath, "2/AbsolutePath");
 721                         Assert.AreEqual ("/dir/subdir/file", uri.LocalPath, "2/LocalPath");
 722
 723                         uri = new Uri ("mono:///host/dir/subdir/file");
 724                         Assert.IsTrue (uri.IsWellFormedOriginalString (), "3/IsWellFormedOriginalString");
 725                         Assert.AreEqual (String.Empty, uri.Host, "3/Host");
 726                         Assert.AreEqual ("/host/dir/subdir/file", uri.AbsolutePath, "3/AbsolutePath");
 727                         Assert.AreEqual ("/host/dir/subdir/file", uri.LocalPath, "3/LocalPath");
 728
 729                         uri = new Uri ("mono:////host/dir/subdir/file");
 730                         Assert.IsTrue (uri.IsWellFormedOriginalString (), "4/IsWellFormedOriginalString");
 731                         Assert.AreEqual (String.Empty, uri.Host, "4/Host");
 732                         Assert.AreEqual ("//host/dir/subdir/file", uri.AbsolutePath, "4/AbsolutePath");
 733                         Assert.AreEqual ("//host/dir/subdir/file", uri.LocalPath, "4/LocalPath");
 734
 735                         // query and fragment
 736                         uri = new Uri ("mono://host/dir/subdir/file?query#fragment");
 737                         Assert.AreEqual ("/dir/subdir/file", uri.AbsolutePath, "qf.AbsolutePath");
 738                         Assert.AreEqual ("?query", uri.Query, "qf.Query");
 739                         Assert.AreEqual ("#fragment", uri.Fragment, "qf.Fragment");
 740
 741                         // special characters
 742                         uri = new Uri ("mono://host/<>%\"{}|\\^`;/:@&=+$,[]#abc");
 743                         if (IriParsing)
 744                                 Assert.AreEqual ("/%3C%3E%25%22%7B%7D%7C/%5E%60;/:@&=+$,[]", uri.AbsolutePath, "Special");
 745                         else
 746                                 Assert.AreEqual ("/%3C%3E%25%22%7B%7D%7C/%5E%60;/:@&=+$,%5B%5D", uri.AbsolutePath, "Special");
 747                 }
 748
 749                 [Test]
 750                 public void DriveAndForwardSlashes_Segments ()
 751                 {
 752                         Uri uri = new Uri ("mono:c:\\dir\\subdir\\file");
 753                         string [] segments = uri.Segments;
 754                         Assert.AreEqual (4, segments.Length, "segments");
 755                         // make the tests work on both Windows and Mac (wrt Silverlight)
 756                         Assert.AreEqual ("c:/", segments [0].Replace ("%5C", "/"), "s[0]");
 757                         Assert.AreEqual ("dir/", segments [1].Replace ("%5C", "/"), "s[1]");
 758                         Assert.AreEqual ("subdir/", segments [2].Replace ("%5C", "/"), "s[2]");
 759                         Assert.AreEqual ("file", segments [3], "s[3]");
 760                 }
 761
 762                 [Test]
 763                 public void NewsScheme ()
 764                 {
 765                         Uri uri = new Uri ("news:novell.mono.moonlight/uri?query");
 766
 767                         Assert.AreEqual ("novell.mono.moonlight/uri%3Fquery", uri.AbsolutePath, "AbsolutePath");
 768                         Assert.AreEqual ("news:novell.mono.moonlight/uri%3Fquery", uri.AbsoluteUri, "AbsoluteUri");
 769                         Assert.AreEqual (String.Empty, uri.Authority, "Authority");
 770                         Assert.AreEqual (String.Empty, uri.DnsSafeHost, "DnsSafeHost");
 771                         Assert.AreEqual (String.Empty, uri.Fragment, "Fragment");
 772                         Assert.AreEqual (String.Empty, uri.Host, "Host");
 773                         Assert.AreEqual (UriHostNameType.Unknown, uri.HostNameType, "HostNameType");
 774                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 775                         Assert.IsTrue (uri.IsDefaultPort, "IsDefaultPort");
 776                         Assert.IsFalse (uri.IsFile, "IsFile");
 777                         Assert.IsFalse (uri.IsLoopback, "IsLoopback");
 778                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 779                         Assert.AreEqual ("novell.mono.moonlight/uri?query", uri.LocalPath, "LocalPath");
 780                         Assert.AreEqual ("news:novell.mono.moonlight/uri?query", uri.OriginalString, "OriginalString");
 781                         Assert.AreEqual ("novell.mono.moonlight/uri%3Fquery", uri.PathAndQuery, "PathAndQuery");
 782                         Assert.AreEqual (-1, uri.Port, "Port");
 783                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 784                         Assert.AreEqual ("news", uri.Scheme, "Scheme");
 785                         Assert.AreEqual ("novell.mono.moonlight/", uri.Segments [0], "Segments [0]");
 786                         Assert.AreEqual ("uri%3Fquery", uri.Segments [1], "Segments [1]");
 787                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 788                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 789
 790                         // special escaped characters - they differs a bit from other URI
 791                         uri = new Uri ("news:novell.mono.moonlight/<>%\"{}|\\^`;/?:@&=+$,[]#abc");
 792                         Assert.AreEqual ("#abc", uri.Fragment, "Special/Fragment");
 793                         if (IriParsing)
 794                                 Assert.AreEqual ("novell.mono.moonlight/%3C%3E%25%22%7B%7D%7C%5C%5E%60;/%3F:@&=+$,[]", uri.AbsolutePath, "Special");
 795                         else
 796                                 Assert.AreEqual ("novell.mono.moonlight/%3C%3E%25%22%7B%7D%7C%5C%5E%60;/%3F:@&=+$,%5B%5D", uri.AbsolutePath, "Special");
 797                 }
 798
 799                 [Test]
 800                 public void NntpScheme ()
 801                 {
 802                         Uri uri = new Uri ("nntp://news.mono-project.com/novell.mono.moonlight/uri?query");
 803
 804                         Assert.AreEqual ("/novell.mono.moonlight/uri%3Fquery", uri.AbsolutePath, "AbsolutePath");
 805                         Assert.AreEqual ("nntp://news.mono-project.com/novell.mono.moonlight/uri%3Fquery", uri.AbsoluteUri, "AbsoluteUri");
 806                         Assert.AreEqual ("news.mono-project.com", uri.Authority, "Authority");
 807                         Assert.AreEqual ("news.mono-project.com", uri.DnsSafeHost, "DnsSafeHost");
 808                         Assert.AreEqual (String.Empty, uri.Fragment, "Fragment");
 809                         Assert.AreEqual ("news.mono-project.com", uri.Host, "Host");
 810                         Assert.AreEqual (UriHostNameType.Dns, uri.HostNameType, "HostNameType");
 811                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 812                         Assert.IsTrue (uri.IsDefaultPort, "IsDefaultPort");
 813                         Assert.IsFalse (uri.IsFile, "IsFile");
 814                         Assert.IsFalse (uri.IsLoopback, "IsLoopback");
 815                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 816                         Assert.AreEqual ("/novell.mono.moonlight/uri?query", uri.LocalPath, "LocalPath");
 817                         Assert.AreEqual ("nntp://news.mono-project.com/novell.mono.moonlight/uri?query", uri.OriginalString, "OriginalString");
 818                         Assert.AreEqual ("/novell.mono.moonlight/uri%3Fquery", uri.PathAndQuery, "PathAndQuery");
 819                         Assert.AreEqual (119, uri.Port, "Port");
 820                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 821                         Assert.AreEqual ("nntp", uri.Scheme, "Scheme");
 822                         Assert.AreEqual ("/", uri.Segments [0], "Segments [0]");
 823                         Assert.AreEqual ("novell.mono.moonlight/", uri.Segments [1], "Segments [1]");
 824                         Assert.AreEqual ("uri%3Fquery", uri.Segments [2], "Segments [2]");
 825                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 826                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 827
 828                         // special escaped characters - they differs a bit from other URI
 829                         uri = new Uri ("nntp://news.mono-project.com/novell.mono.moonlight/<>%\"{}|\\^`;/?:@&=+$,[]#abc");
 830                         Assert.AreEqual ("#abc", uri.Fragment, "Special/Fragment");
 831                         if (IriParsing)
 832                                 Assert.AreEqual ("/novell.mono.moonlight/%3C%3E%25%22%7B%7D%7C%5C%5E%60;/%3F:@&=+$,[]", uri.AbsolutePath, "Special");
 833                         else
 834                                 Assert.AreEqual ("/novell.mono.moonlight/%3C%3E%25%22%7B%7D%7C%5C%5E%60;/%3F:@&=+$,%5B%5D", uri.AbsolutePath, "Special");
 835                 }
 836
 837                 [Test]
 838                 public void FtpScheme ()
 839                 {
 840                         // user, password, custom port and a "query"
 841                         Uri uri = new Uri ("ftp://user:password@ftp.mono-project.com:2121/mono.zip?latest-n-greatest");
 842                         Assert.AreEqual ("/mono.zip%3Flatest-n-greatest", uri.AbsolutePath, "AbsolutePath");
 843                         Assert.AreEqual ("ftp://user:password@ftp.mono-project.com:2121/mono.zip%3Flatest-n-greatest", uri.AbsoluteUri, "AbsoluteUri");
 844                         Assert.AreEqual ("ftp.mono-project.com:2121", uri.Authority, "Authority");
 845                         Assert.AreEqual ("ftp.mono-project.com", uri.DnsSafeHost, "DnsSafeHost");
 846                         Assert.AreEqual (String.Empty, uri.Fragment, "Fragment");
 847                         Assert.AreEqual ("ftp.mono-project.com", uri.Host, "Host");
 848                         Assert.AreEqual (UriHostNameType.Dns, uri.HostNameType, "HostNameType");
 849                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 850                         Assert.IsFalse (uri.IsDefaultPort, "IsDefaultPort");
 851                         Assert.IsFalse (uri.IsFile, "IsFile");
 852                         Assert.IsFalse (uri.IsLoopback, "IsLoopback");
 853                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 854                         Assert.AreEqual ("/mono.zip?latest-n-greatest", uri.LocalPath, "LocalPath");
 855                         Assert.AreEqual ("ftp://user:password@ftp.mono-project.com:2121/mono.zip?latest-n-greatest", uri.OriginalString, "OriginalString");
 856                         Assert.AreEqual ("/mono.zip%3Flatest-n-greatest", uri.PathAndQuery, "PathAndQuery");
 857                         Assert.AreEqual (2121, uri.Port, "Port");
 858                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 859                         Assert.AreEqual ("ftp", uri.Scheme, "Scheme");
 860                         Assert.AreEqual ("/", uri.Segments [0], "Segments [0]");
 861                         Assert.AreEqual ("mono.zip%3Flatest-n-greatest", uri.Segments [1], "Segments [1]");
 862                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 863                         Assert.AreEqual ("user:password", uri.UserInfo, "UserInfo");
 864
 865                         // special characters and fragment
 866                         uri = new Uri ("ftp://ftp.mono-project.com/<>%\"{}|\\^`;/?:@&=+$,[]#abc");
 867                         Assert.AreEqual ("#abc", uri.Fragment, "Special/Fragment");
 868                         if (IriParsing)
 869                                 Assert.AreEqual ("/%3C%3E%25%22%7B%7D%7C/%5E%60;/%3F:@&=+$,[]", uri.AbsolutePath, "Special");
 870                         else
 871                                 Assert.AreEqual ("/%3C%3E%25%22%7B%7D%7C/%5E%60;/%3F:@&=+$,%5B%5D", uri.AbsolutePath, "Special");
 872                 }
 873
 874                 [Test]
 875                 public void FileScheme ()
 876                 {
 877                         Uri uri = new Uri ("file://host/dir/subdir/file?this-is-not-a-query#but-this-is-a-fragment");
 878
 879                         if (IriParsing) {
 880                                 Assert.AreEqual ("/dir/subdir/file", uri.AbsolutePath, "AbsolutePath");
 881                                 Assert.AreEqual ("file://host/dir/subdir/file?this-is-not-a-query#but-this-is-a-fragment", uri.AbsoluteUri, "AbsoluteUri");
 882                                 Assert.AreEqual (isWin32 ? "\\\\host\\dir\\subdir\\file" : "/dir/subdir/file", uri.LocalPath, "LocalPath");
 883                                 Assert.AreEqual ("/dir/subdir/file?this-is-not-a-query", uri.PathAndQuery, "PathAndQuery");
 884                                 Assert.AreEqual ("?this-is-not-a-query", uri.Query, "Query");
 885                                 Assert.AreEqual ("file", uri.Segments [3], "Segments [3]");
 886                         } else {
 887                                 Assert.AreEqual ("/dir/subdir/file%3Fthis-is-not-a-query", uri.AbsolutePath, "AbsolutePath");
 888                                 Assert.AreEqual ("file://host/dir/subdir/file%3Fthis-is-not-a-query#but-this-is-a-fragment", uri.AbsoluteUri, "AbsoluteUri");
 889                                 Assert.AreEqual (isWin32 ? "\\\\host\\dir\\subdir\\file?this-is-not-a-query" : "/dir/subdir/file?this-is-not-a-query", uri.LocalPath, "LocalPath");
 890                                 Assert.AreEqual ("/dir/subdir/file%3Fthis-is-not-a-query", uri.PathAndQuery, "PathAndQuery");
 891                                 Assert.AreEqual (String.Empty, uri.Query, "Query");
 892                                 Assert.AreEqual ("file%3Fthis-is-not-a-query", uri.Segments [3], "Segments [3]");
 893                         }
 894
 895                         Assert.AreEqual ("host", uri.Authority, "Authority");
 896                         Assert.AreEqual ("host", uri.DnsSafeHost, "DnsSafeHost");
 897                         Assert.AreEqual ("#but-this-is-a-fragment", uri.Fragment, "Fragment");
 898                         Assert.AreEqual ("host", uri.Host, "Host");
 899                         Assert.AreEqual (UriHostNameType.Dns, uri.HostNameType, "HostNameType");
 900                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 901                         Assert.IsTrue (uri.IsDefaultPort, "IsDefaultPort");
 902                         Assert.IsTrue (uri.IsFile, "IsFile");
 903                         Assert.IsFalse (uri.IsLoopback, "IsLoopback");
 904                         Assert.AreEqual (isWin32, uri.IsUnc, "IsUnc");
 905                         Assert.AreEqual ("file://host/dir/subdir/file?this-is-not-a-query#but-this-is-a-fragment", uri.OriginalString, "OriginalString");
 906                         Assert.AreEqual (-1, uri.Port, "Port");
 907                         Assert.AreEqual ("file", uri.Scheme, "Scheme");
 908                         Assert.AreEqual ("/", uri.Segments [0], "Segments [0]");
 909                         Assert.AreEqual ("dir/", uri.Segments [1], "Segments [1]");
 910                         Assert.AreEqual ("subdir/", uri.Segments [2], "Segments [2]");
 911                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 912                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 913
 914                         // special characters
 915                         uri = new Uri ("file://host/<>%\"{}|\\^`;/:@&=+$,[]?#abc");
 916                         if (IriParsing)
 917                                 Assert.AreEqual ("/%3C%3E%25%22%7B%7D%7C/%5E%60;/:@&=+$,[]", uri.AbsolutePath, "Special");
 918                         else
 919                                 Assert.AreEqual ("/%3C%3E%25%22%7B%7D%7C/%5E%60;/:@&=+$,%5B%5D%3F", uri.AbsolutePath, "Special");
 920                 }
 921
 922                 [Test]
 923                 public void PathReduction_2e ()
 924                 {
 925                         Uri uri = new Uri ("http://host/dir/%2e%2E/file");
 926                         Assert.AreEqual ("/file", uri.AbsolutePath, "AbsolutePath");
 927                         Assert.AreEqual ("http://host/file", uri.AbsoluteUri, "AbsoluteUri");
 928                         Assert.AreEqual ("/", uri.Segments [0], "Segments [0]");
 929                         Assert.AreEqual ("file", uri.Segments [1], "Segments [1]");
 930                 }
 931
 932                 [Test]
 933                 public void ColonButNoPort ()
 934                 {
 935                         Uri uri = new Uri ("http://host:");
 936                         Assert.AreEqual ("http", uri.Scheme, "1.Scheme");
 937                         Assert.AreEqual ("host", uri.Host, "1.Host");
 938                         Assert.AreEqual (80, uri.Port, "1.Port");
 939                         Assert.IsTrue (uri.IsDefaultPort, "1.IsDefaultPort");
 940
 941                         uri = new Uri ("ftp://host:/dir/file");
 942                         Assert.AreEqual ("ftp", uri.Scheme, "2.Scheme");
 943                         Assert.AreEqual ("host", uri.Host, "2.Host");
 944                         Assert.AreEqual (21, uri.Port, "2.Port");
 945                         Assert.IsTrue (uri.IsDefaultPort, "2.IsDefaultPort");
 946                 }
 947
 948                 [Test]
 949                 public void IPv6SafeDnsName ()
 950                 {
 951                         Uri uri = new Uri ("http://[1:2:3:4:5:6:7:8]");
 952                         Assert.AreEqual (UriHostNameType.IPv6, uri.HostNameType, "1.HostNameType");
 953                         if (IriParsing) {
 954                                 Assert.AreEqual ("[1:2:3:4:5:6:7:8]", uri.Authority, "1.Authority");
 955                                 Assert.AreEqual ("1:2:3:4:5:6:7:8", uri.DnsSafeHost, "1.DnsSafeHost");
 956                                 Assert.AreEqual ("[1:2:3:4:5:6:7:8]", uri.Host, "1.Host");
 957                         } else {
 958                                 Assert.AreEqual ("[0001:0002:0003:0004:0005:0006:0007:0008]", uri.Authority, "1.Authority");
 959                                 Assert.AreEqual ("0001:0002:0003:0004:0005:0006:0007:0008", uri.DnsSafeHost, "1.DnsSafeHost");
 960                                 Assert.AreEqual ("[0001:0002:0003:0004:0005:0006:0007:0008]", uri.Host, "1.Host");
 961                         }
 962
 963                         uri = new Uri ("http://[fe80::200:39ff:fe36:1a2d%4]/temp/example.htm");
 964                         Assert.AreEqual (UriHostNameType.IPv6, uri.HostNameType, "1.HostNameType");
 965                         if (IriParsing) {
 966                                 Assert.AreEqual ("[fe80::200:39ff:fe36:1a2d]", uri.Authority, "2.Authority");
 967                                 Assert.AreEqual ("fe80::200:39ff:fe36:1a2d%4", uri.DnsSafeHost, "2.DnsSafeHost");
 968                                 Assert.AreEqual ("[fe80::200:39ff:fe36:1a2d]", uri.Host, "2.Host");
 969                         } else {
 970                                 Assert.AreEqual ("[FE80:0000:0000:0000:0200:39FF:FE36:1A2D]", uri.Authority, "2.Authority");
 971                                 Assert.AreEqual ("FE80:0000:0000:0000:0200:39FF:FE36:1A2D%4", uri.DnsSafeHost, "2.DnsSafeHost");
 972                                 Assert.AreEqual ("[FE80:0000:0000:0000:0200:39FF:FE36:1A2D]", uri.Host, "2.Host");
 973                         }
 974                 }
 975
 976                 [Test]
 977                 public void RelativeEscapes ()
 978                 {
 979                         Uri uri = new Uri ("%2e%2e/dir/%2e%2e/subdir/file?query#fragment", UriKind.Relative);
 980                         if (IriParsing)
 981                                 Assert.AreEqual ("../dir/../subdir/file?query#fragment", uri.ToString (), "1.ToString");
 982                         else
 983                                 Assert.AreEqual ("%2e%2e/dir/%2e%2e/subdir/file?query#fragment", uri.ToString (), "1.ToString");
 984                 }
 985
 986                 [Test]
 987                 public void BadUri ()
 988                 {
 989                         Assert2.Throws<UriFormatException> (delegate {
 990                                 new Uri ("a:b", UriKind.Absolute);
 991                         }, "a:b - Absolute");
 992
 993                         Uri abs = new Uri ("http://novell.com", UriKind.Absolute);
 994                         Assert2.Throws<UriFormatException> (delegate {
 995                                 new Uri (abs, "a:b");
 996                         }, "a:b - Relative");
 997                 }
 998
 999                 [Test]
1000                 public void MergeWithConfusingRelativeUri ()
1001                 {
1002                         Uri abs = new Uri ("http://novell.com", UriKind.Absolute);
1003
1004                         // note: invalid scheme
1005                         string srel = "http@ftp://mono-project.com/dir/file";
1006                         Uri uri = new Uri (abs, srel);
1007                         Assert.AreEqual ("http://novell.com/http@ftp://mono-project.com/dir/file", uri.ToString (), "1.ToString");
1008
1009                         Uri rel = new Uri (srel, UriKind.Relative);
1010                         Assert.AreEqual ("http@ftp://mono-project.com/dir/file", rel.ToString (), "2.ToString");
1011
1012                         uri = new Uri (abs, rel);
1013                         Assert.AreEqual ("http://novell.com/http@ftp://mono-project.com/dir/file", uri.ToString (), "3.ToString");
1014                 }
1015
1016                 [Test]
1017                 public void EmptyUserInfo ()
1018                 {
1019                         Uri uri = new Uri ("http://@www.mono-project.com");
1020                         Assert.AreEqual ("http://@www.mono-project.com/", uri.AbsoluteUri, "AbsoluteUri");
1021                         Assert.AreEqual ("http://@www.mono-project.com", uri.GetLeftPart (UriPartial.Authority), "UriPartial.Authority");
1022                         Assert.AreEqual ("http://@www.mono-project.com/", uri.GetLeftPart (UriPartial.Path), "UriPartial.Path");
1023                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
1024                 }
1025
1026                 [Test]
1027                 public void Fragment_SpecialCharacters ()
1028                 {
1029                         Uri uri = new Uri ("http://host/dir/file#fragment <>%\"{}|\\^`;/?:@&=+$,[]#second");
1030                         Assert.AreEqual ("http://host/dir/file#fragment <>%25\"{}|\\^`;/?:@&=+$,[]%23second", uri.ToString (), "ToString");
1031                         if (IriParsing)
1032                                 Assert.AreEqual ("#fragment%20%3C%3E%25%22%7B%7D%7C%5C%5E%60;/?:@&=+$,[]#second", uri.Fragment, "Fragment");
1033                         else
1034                                 Assert.AreEqual ("#fragment%20%3C%3E%25%22%7B%7D%7C%5C%5E%60;/?:@&=+$,%5B%5D%23second", uri.Fragment, "Fragment");
1035                 }
1036
1037                 [Test]
1038                 public void Query_SpecialCharacters ()
1039                 {
1040                         Uri uri = new Uri ("http://host/dir/file?query <>%\"{}|\\^`;/?:@&=+$,[]");
1041                         Assert.AreEqual ("http://host/dir/file?query <>%25\"{}|\\^`;/?:@&=+$,[]", uri.ToString (), "ToString");
1042                         if (IriParsing)
1043                                 Assert.AreEqual ("?query%20%3C%3E%25%22%7B%7D%7C%5C%5E%60;/?:@&=+$,[]", uri.Query, "Query");
1044                         else
1045                                 Assert.AreEqual ("?query%20%3C%3E%25%22%7B%7D%7C%5C%5E%60;/?:@&=+$,%5B%5D", uri.Query, "Query");
1046                 }
1047
1048                 [Test]
1049                 public void OriginalPathEscaped ()
1050                 {
1051                         Uri uri = new Uri ("http://www.mono-project.com/%41/%42/%43", UriKind.Absolute);
1052                         Assert.AreEqual ("/A/B/C", uri.LocalPath, "LocalPath");
1053                         if (IriParsing) {
1054                                 Assert.AreEqual ("http://www.mono-project.com/A/B/C", uri.AbsoluteUri, "AbsoluteUri");
1055                                 Assert.AreEqual ("/A/B/C", uri.AbsolutePath, "AbsolutePath");
1056                                 Assert.AreEqual ("http://www.mono-project.com/A/B/C", uri.GetLeftPart (UriPartial.Path), "GetLeftPart(Path)");
1057                         } else {
1058                                 Assert.AreEqual ("http://www.mono-project.com/%41/%42/%43", uri.AbsoluteUri, "AbsoluteUri");
1059                                 Assert.AreEqual ("/%41/%42/%43", uri.AbsolutePath, "AbsolutePath");
1060                                 Assert.AreEqual ("http://www.mono-project.com/%41/%42/%43", uri.GetLeftPart (UriPartial.Path), "GetLeftPart(Path)");
1061                         }
1062                 }
1063
1064                 [Test]
1065                 public void CheckHostName ()
1066                 {
1067                         Assert.AreEqual (UriHostNameType.Unknown, Uri.CheckHostName ("host;machine"), "CheckHostName ;");
1068                         Assert.AreEqual (UriHostNameType.Unknown, Uri.CheckHostName ("www..mono-project.com"), "CheckHostName ..");
1069                         Assert.AreEqual (UriHostNameType.Unknown, Uri.CheckHostName ("www.mono-project.com\\"), "CheckHostName \\");
1070                 }
1071
1072                 [Test]
1073                 public void Ports ()
1074                 {
1075                         Assert2.Throws<UriFormatException> (delegate {
1076                                 new Uri ("http://host:-1/");
1077                         }, "negative");
1078
1079                         Uri uri = new Uri ("http://host:0/");
1080                         Assert.AreEqual (0, uri.Port, "Port = 0");
1081
1082                         Assert2.Throws<UriFormatException> (delegate {
1083                                 new Uri ("http://host:+1/");
1084                         }, "positive");
1085
1086                         uri = new Uri ("http://host:" + UInt16.MaxValue.ToString ());
1087                         Assert.AreEqual (65535, uri.Port, "Port = 65535");
1088
1089                         Assert2.Throws<UriFormatException> (delegate {
1090                                 new Uri ("http://host:" + (UInt16.MaxValue + 1).ToString ());
1091                         }, "too big");
1092
1093                         Assert2.Throws<UriFormatException> (delegate {
1094                                 new Uri ("http://host:3.14");
1095                         }, "float");
1096                 }
1097
1098                 [Test]
1099                 public void NonAsciiHost ()
1100                 {
1101                         Uri uri = new Uri ("ftp://β:2121/", UriKind.Absolute);
1102                         Assert.AreEqual ("/", uri.AbsolutePath, "AbsolutePath");
1103                         Assert.AreEqual ("ftp://β:2121/", uri.AbsoluteUri, "AbsoluteUri");
1104                         Assert.AreEqual ("β:2121", uri.Authority, "Authority");
1105                         Assert.AreEqual ("β", uri.DnsSafeHost, "DnsSafeHost");
1106                         Assert.AreEqual ("β", uri.Host, "Host");
1107                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
1108                         Assert.IsFalse (uri.IsDefaultPort, "IsDefaultPort");
1109                         Assert.AreEqual ("/", uri.LocalPath, "LocalPath");
1110                         Assert.AreEqual ("ftp://β:2121/", uri.OriginalString, "OriginalString");
1111                         Assert.AreEqual ("/", uri.PathAndQuery, "PathAndQuery");
1112                         Assert.AreEqual (2121, uri.Port, "Port");
1113                         Assert.AreEqual ("ftp", uri.Scheme, "Scheme");
1114                         Assert.AreEqual ("/", uri.Segments [0], "Segments [0]");
1115                 }
1116         }
1117 }