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

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