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         [TestFixture]
  14         public class UriTest2
  15         {
  16                 // Segments cannot be validated here...
  17                 public void AssertUri (string relsrc, Uri uri,
  18                         string toString,
  19                         string absoluteUri,
  20                         string scheme,
  21                         string host,
  22                         string localPath,
  23                         string query,
  24                         int port,
  25                         bool isFile,
  26                         bool isUnc,
  27                         bool isLoopback,
  28                         bool userEscaped,
  29                         UriHostNameType hostNameType,
  30                         string absolutePath,
  31                         string pathAndQuery,
  32                         string authority,
  33                         string fragment,
  34                         string userInfo)
  35                 {
  36                         Assert.AreEqual (absoluteUri, uri.AbsoluteUri, relsrc + " AbsoluteUri");
  37                         Assert.AreEqual (scheme, uri.Scheme, relsrc + " Scheme");
  38                         Assert.AreEqual (host, uri.Host, relsrc + " Host");
  39                         Assert.AreEqual (port, uri.Port, relsrc + " Port");
  40                         // Windows UNC path is not automatically testable on *nix environment,
  41                         if (relsrc.StartsWith ("\\\\") && Path.DirectorySeparatorChar == '\\')
  42                                 Assert.AreEqual (localPath, uri.LocalPath, relsrc + " LocalPath");
  43                         Assert.AreEqual (query, uri.Query, relsrc + " Query");
  44                         Assert.AreEqual (fragment, uri.Fragment, relsrc + " Fragment");
  45                         Assert.AreEqual (isFile, uri.IsFile, relsrc + " IsFile");
  46                         Assert.AreEqual (isUnc, uri.IsUnc, relsrc + " IsUnc");
  47                         Assert.AreEqual (isLoopback, uri.IsLoopback, relsrc + " IsLoopback");
  48                         Assert.AreEqual (authority, uri.Authority, relsrc + " Authority");
  49                         Assert.AreEqual (userEscaped, uri.UserEscaped, relsrc + " UserEscaped");
  50                         Assert.AreEqual (userInfo, uri.UserInfo, relsrc + " UserInfo");
  51                         Assert.AreEqual (hostNameType, uri.HostNameType, relsrc + " HostNameType");
  52                         Assert.AreEqual (absolutePath, uri.AbsolutePath, relsrc + " AbsolutePath");
  53                         Assert.AreEqual (pathAndQuery, uri.PathAndQuery, relsrc + " PathAndQuery");
  54                         Assert.AreEqual (toString, uri.ToString (), relsrc + " ToString()");
  55                 }
  56
  57                 [Test]
  58 #if NET_2_0
  59                 [Ignore ("Tests needs to be updated for 2.0")]
  60 #endif
  61                 public void AbsoluteUriFromFile ()
  62                 {
  63                         FromResource ("test-uri-props.txt", null);
  64                 }
  65
  66                 [Test]
  67                 [Category("NotDotNet")]
  68 #if NET_2_0
  69                 [Ignore ("Tests needs to be updated for 2.0")]
  70 #endif
  71                 public void AbsoluteUriFromFileManual ()
  72                 {
  73                         if (Path.DirectorySeparatorChar == '\\')
  74                                 return;
  75                         FromResource ("test-uri-props-manual.txt", null);
  76                 }
  77
  78                 [Test]
  79 #if NET_2_0
  80                 [Ignore ("Tests needs to be updated for 2.0")]
  81 #endif
  82                 public void RelativeUriFromFile ()
  83                 {
  84                         FromResource ("test-uri-relative-props.txt", new Uri ("http://www.go-mono.com"));
  85                 }
  86
  87                 private void FromResource (string res, Uri baseUri)
  88                 {
  89                         Assembly a = Assembly.GetExecutingAssembly ();
  90                         Stream s = a.GetManifestResourceStream (res);
  91                         StreamReader sr = new StreamReader (s, Encoding.UTF8);
  92                         while (sr.Peek () > 0) {
  93                                 sr.ReadLine (); // skip
  94                                 string uriString = sr.ReadLine ();
  95 /*
  96 TextWriter sw = Console.Out;
  97                                 sw.WriteLine ("-------------------------");
  98                                 sw.WriteLine (uriString);
  99 */
 100                                 if (uriString == null || uriString.Length == 0)
 101                                         break;
 102
 103                                 try {
 104                                         Uri uri = baseUri == null ? new Uri (uriString) : new Uri (baseUri, uriString);
 105 /*
 106                                 sw.WriteLine ("ToString(): " + uri.ToString ());
 107                                 sw.WriteLine (uri.AbsoluteUri);
 108                                 sw.WriteLine (uri.Scheme);
 109                                 sw.WriteLine (uri.Host);
 110                                 sw.WriteLine (uri.LocalPath);
 111                                 sw.WriteLine (uri.Query);
 112                                 sw.WriteLine ("Port: " + uri.Port);
 113                                 sw.WriteLine (uri.IsFile);
 114                                 sw.WriteLine (uri.IsUnc);
 115                                 sw.WriteLine (uri.IsLoopback);
 116                                 sw.WriteLine (uri.UserEscaped);
 117                                 sw.WriteLine ("HostNameType: " + uri.HostNameType);
 118                                 sw.WriteLine (uri.AbsolutePath);
 119                                 sw.WriteLine ("PathAndQuery: " + uri.PathAndQuery);
 120                                 sw.WriteLine (uri.Authority);
 121                                 sw.WriteLine (uri.Fragment);
 122                                 sw.WriteLine (uri.UserInfo);
 123 */
 124                                         AssertUri (uriString, uri,
 125                                                 sr.ReadLine (),
 126                                                 sr.ReadLine (),
 127                                                 sr.ReadLine (),
 128                                                 sr.ReadLine (),
 129                                                 sr.ReadLine (),
 130                                                 sr.ReadLine (),
 131                                                 int.Parse (sr.ReadLine ()),
 132                                                 bool.Parse (sr.ReadLine ()),
 133                                                 bool.Parse (sr.ReadLine ()),
 134                                                 bool.Parse (sr.ReadLine ()),
 135                                                 bool.Parse (sr.ReadLine ()),
 136                                                 (UriHostNameType) Enum.Parse (typeof (UriHostNameType), sr.ReadLine (), false),
 137                                                 sr.ReadLine (),
 138                                                 sr.ReadLine (),
 139                                                 sr.ReadLine (),
 140                                                 sr.ReadLine (),
 141                                                 sr.ReadLine ());
 142 //                              Console.WriteLine ("Passed: " + uriString);
 143                                 } catch (UriFormatException ex) {
 144                                         Assert.Fail (String.Format ("Construction failed: [{0}] {1}", uriString, ex.Message));
 145                                 }
 146                         }
 147                 }
 148
 149                 [Test]
 150                 public void MoreUnescape () // bug 733316
 151                 {
 152                         int index = 0;
 153                         char unesc = Uri.HexUnescape ("%F6", ref index);
 154                         Assert.AreEqual (3, index, "#01");
 155                         Assert.AreEqual (0xf6, unesc, "#02");
 156                 }
 157
 158                 [Test]
 159                 public void UriScheme ()
 160                 {
 161                         Assert.AreEqual ("://", Uri.SchemeDelimiter, "://");
 162                         Assert.AreEqual ("file", Uri.UriSchemeFile, "file");
 163                         Assert.AreEqual ("ftp", Uri.UriSchemeFtp, "ftp");
 164                         Assert.AreEqual ("gopher", Uri.UriSchemeGopher, "gopher");
 165                         Assert.AreEqual ("http", Uri.UriSchemeHttp, "http");
 166                         Assert.AreEqual ("https", Uri.UriSchemeHttps, "https");
 167                         Assert.AreEqual ("mailto", Uri.UriSchemeMailto, "mailto");
 168                         Assert.AreEqual ("news", Uri.UriSchemeNews, "news");
 169                         Assert.AreEqual ("nntp", Uri.UriSchemeNntp, "file");
 170 #if NET_2_0
 171                         Assert.AreEqual ("net.pipe", Uri.UriSchemeNetPipe, "net.pipe");
 172                         Assert.AreEqual ("net.tcp", Uri.UriSchemeNetTcp, "net.tcp");
 173 #endif
 174                 }
 175
 176                 [Test] // bug #71049
 177                 [ExpectedException (typeof (UriFormatException))]
 178                 public void StarsInHost ()
 179                 {
 180                         new Uri ("http://w*w*w.go-mono.com");
 181                 }
 182
 183                 [Test]
 184 #if ONLY_1_1
 185                 [Category ("NotDotNet")] // 1.x throws an UriFormatException
 186 #endif
 187                 public void NoHostName1_Bug76146 ()
 188                 {
 189                         Uri u = new Uri ("foo:///?bar");
 190                         Assert.AreEqual ("/", u.AbsolutePath, "AbsolutePath");
 191                         Assert.AreEqual ("foo:///?bar", u.AbsoluteUri, "AbsoluteUri");
 192                         Assert.AreEqual (String.Empty, u.Authority, "Authority");
 193                         Assert.AreEqual (String.Empty, u.Fragment, "Fragment");
 194                         Assert.AreEqual (String.Empty, u.Host, "Host");
 195                         // FIXME (2.0) - Normally this is never Basic without an Host name :(
 196                         // Assert.AreEqual (UriHostNameType.Basic, u.HostNameType, "HostNameType");
 197                         Assert.IsTrue (u.IsDefaultPort, "IsDefaultPort");
 198                         Assert.IsFalse (u.IsFile, "IsFile");
 199                         // FIXME Assert.IsTrue (u.IsLoopback, "IsLoopback");
 200                         Assert.IsFalse (u.IsUnc, "IsUnc");
 201                         Assert.AreEqual ("/", u.LocalPath, "LocalPath");
 202                         Assert.AreEqual ("/?bar", u.PathAndQuery, "PathAndQuery");
 203                         Assert.AreEqual ("foo", u.Scheme, "Scheme");
 204                         Assert.IsFalse (u.UserEscaped, "UserEscaped");
 205                         Assert.AreEqual (String.Empty, u.UserInfo, "UserInfo");
 206                 }
 207
 208                 [Test]
 209 #if ONLY_1_1
 210                 [Category ("NotDotNet")] // 1.x throws an UriFormatException
 211 #endif
 212                 public void NoHostName2_Bug76146 ()
 213                 {
 214                         Uri u = new Uri ("foo:///bar");
 215                         Assert.AreEqual ("/bar", u.AbsolutePath, "AbsolutePath");
 216                         Assert.AreEqual ("foo:///bar", u.AbsoluteUri, "AbsoluteUri");
 217                         Assert.AreEqual (String.Empty, u.Authority, "Authority");
 218                         Assert.AreEqual (String.Empty, u.Fragment, "Fragment");
 219                         Assert.AreEqual (String.Empty, u.Host, "Host");
 220                         // FIXME (2.0) - Normally this is never Basic without an Host name :(
 221                         // Assert.AreEqual (UriHostNameType.Basic, u.HostNameType, "HostNameType");
 222                         Assert.IsTrue (u.IsDefaultPort, "IsDefaultPort");
 223                         Assert.IsFalse (u.IsFile, "IsFile");
 224                         // FIXME Assert.IsTrue (u.IsLoopback, "IsLoopback");
 225                         Assert.IsFalse (u.IsUnc, "IsUnc");
 226                         Assert.AreEqual ("/bar", u.LocalPath, "LocalPath");
 227                         Assert.AreEqual ("/bar", u.PathAndQuery, "PathAndQuery");
 228                         Assert.AreEqual ("foo", u.Scheme, "Scheme");
 229                         Assert.IsFalse (u.UserEscaped, "UserEscaped");
 230                         Assert.AreEqual (String.Empty, u.UserInfo, "UserInfo");
 231                 }
 232
 233                 [Test]
 234                 [ExpectedException (typeof (UriFormatException))]
 235                 public void InvalidIPAddress_Bug76659 ()
 236                 {
 237                         new Uri ("http://127.0.0.1::::/");
 238                 }
 239 #if NET_2_0
 240                 [Test]
 241                 public void File ()
 242                 {
 243                         string s = "file:///dir1%2f..%2fdir%2fapp.xap#header";
 244                         Uri uri = new Uri (s);
 245                         Assert.AreEqual ("/dir/app.xap", uri.AbsolutePath, "AbsolutePath");
 246                         // default port is removed
 247                         Assert.AreEqual ("file:///dir/app.xap#header", uri.AbsoluteUri, "AbsoluteUri");
 248                         Assert.AreEqual (String.Empty, uri.DnsSafeHost, "DnsSafeHost");
 249                         Assert.AreEqual ("#header", uri.Fragment, "Fragment");
 250                         Assert.AreEqual (String.Empty, uri.Host, "Host");
 251                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 252                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 253                         Assert.AreEqual ("/dir/app.xap", uri.LocalPath, "LocalPath");
 254                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 255                         Assert.AreEqual (-1, uri.Port, "Port");
 256                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 257                         Assert.AreEqual ("file", uri.Scheme, "Scheme");
 258                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 259                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 260                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 261                 }
 262
 263                 [Test]
 264                 public void HttpWithDefaultPort ()
 265                 {
 266                         string s = "HTTP://host.domain.com:80/app.xap";
 267                         Uri uri = new Uri (s);
 268                         Assert.AreEqual ("/app.xap", uri.AbsolutePath, "AbsolutePath");
 269                         // default port is removed
 270                         Assert.AreEqual ("http://host.domain.com/app.xap", uri.AbsoluteUri, "AbsoluteUri");
 271                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 272                         Assert.AreEqual (String.Empty, uri.Fragment, "Fragment");
 273                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 274                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 275                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 276                         Assert.AreEqual ("/app.xap", uri.LocalPath, "LocalPath");
 277                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 278                         Assert.AreEqual (80, uri.Port, "Port");
 279                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 280                         Assert.AreEqual ("http", uri.Scheme, "Scheme");
 281                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 282                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 283                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 284                 }
 285
 286                 [Test]
 287                 public void HttpWithoutPort ()
 288                 {
 289                         string s = "Http://host.DOMAIN.com/dir/app.xap#options";
 290                         Uri uri = new Uri (s);
 291                         Assert.AreEqual ("/dir/app.xap", uri.AbsolutePath, "AbsolutePath");
 292                         Assert.AreEqual ("http://host.domain.com/dir/app.xap#options", uri.AbsoluteUri, "AbsoluteUri");
 293                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 294                         Assert.AreEqual ("#options", uri.Fragment, "Fragment");
 295                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 296                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 297                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 298                         Assert.AreEqual ("/dir/app.xap", uri.LocalPath, "LocalPath");
 299                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 300                         Assert.AreEqual (80, uri.Port, "Port");
 301                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 302                         Assert.AreEqual ("http", uri.Scheme, "Scheme");
 303                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 304                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 305                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 306                 }
 307
 308                 [Test]
 309                 public void HttpWithNonStandardPort ()
 310                 {
 311                         string s = "http://monkey:s3kr3t@HOST.domain.Com:8080/dir/../app.xap?option=1";
 312                         Uri uri = new Uri (s);
 313                         Assert.AreEqual ("/app.xap", uri.AbsolutePath, "AbsolutePath");
 314                         // non-standard port is present
 315                         Assert.AreEqual ("http://monkey:s3kr3t@host.domain.com:8080/app.xap?option=1", uri.AbsoluteUri, "AbsoluteUri");
 316                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 317                         Assert.AreEqual (String.Empty, uri.Fragment, "Fragment");
 318                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 319                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 320                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 321                         Assert.AreEqual ("/app.xap", uri.LocalPath, "LocalPath");
 322                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 323                         Assert.AreEqual (8080, uri.Port, "Port");
 324                         Assert.AreEqual ("?option=1", uri.Query, "Query");
 325                         Assert.AreEqual ("http", uri.Scheme, "Scheme");
 326                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 327                         Assert.AreEqual ("monkey:s3kr3t", uri.UserInfo, "UserInfo");
 328                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 329                 }
 330
 331                 [Test]
 332                 public void HttpsWithDefaultPort ()
 333                 {
 334                         string s = "httpS://host.domain.com:443/";
 335                         Uri uri = new Uri (s);
 336                         Assert.AreEqual ("/", uri.AbsolutePath, "AbsolutePath");
 337                         // default port is removed
 338                         Assert.AreEqual ("https://host.domain.com/", uri.AbsoluteUri, "AbsoluteUri");
 339                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 340                         Assert.AreEqual (String.Empty, uri.Fragment, "Fragment");
 341                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 342                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 343                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 344                         Assert.AreEqual ("/", uri.LocalPath, "LocalPath");
 345                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 346                         Assert.AreEqual (443, uri.Port, "Port");
 347                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 348                         Assert.AreEqual ("https", uri.Scheme, "Scheme");
 349                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 350                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 351                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 352                 }
 353
 354                 [Test]
 355                 public void HttpsWithoutPort ()
 356                 {
 357                         string s = "Https://host.DOMAIN.com/dir%2fapp.xap#";
 358                         Uri uri = new Uri (s);
 359                         Assert.AreEqual ("/dir/app.xap", uri.AbsolutePath, "AbsolutePath");
 360                         Assert.AreEqual ("https://host.domain.com/dir/app.xap#", uri.AbsoluteUri, "AbsoluteUri");
 361                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 362                         Assert.AreEqual ("#", uri.Fragment, "Fragment");
 363                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 364                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 365                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 366                         Assert.AreEqual ("/dir/app.xap", uri.LocalPath, "LocalPath");
 367                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 368                         Assert.AreEqual (443, uri.Port, "Port");
 369                         Assert.AreEqual (String.Empty, uri.Query, "Query");
 370                         Assert.AreEqual ("https", uri.Scheme, "Scheme");
 371                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 372                         Assert.AreEqual (String.Empty, uri.UserInfo, "UserInfo");
 373                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 374                 }
 375
 376                 [Test]
 377                 public void HttpsWithNonStandardPort ()
 378                 {
 379                         string s = "https://monkey:s3kr3t@HOST.domain.Com:4430/dir/..%5Capp.xap?";
 380                         Uri uri = new Uri (s);
 381                         Assert.AreEqual ("/app.xap", uri.AbsolutePath, "AbsolutePath");
 382                         // non-standard port is present
 383                         Assert.AreEqual ("https://monkey:s3kr3t@host.domain.com:4430/app.xap?", uri.AbsoluteUri, "AbsoluteUri");
 384                         Assert.AreEqual ("host.domain.com", uri.DnsSafeHost, "DnsSafeHost");
 385                         Assert.AreEqual (String.Empty, uri.Fragment, "Fragment");
 386                         Assert.AreEqual ("host.domain.com", uri.Host, "Host");
 387                         Assert.IsTrue (uri.IsAbsoluteUri, "IsAbsoluteUri");
 388                         Assert.IsFalse (uri.IsUnc, "IsUnc");
 389                         Assert.AreEqual ("/app.xap", uri.LocalPath, "LocalPath");
 390                         Assert.AreEqual (s, uri.OriginalString, "OriginalString");
 391                         Assert.AreEqual (4430, uri.Port, "Port");
 392                         Assert.AreEqual ("?", uri.Query, "Query");
 393                         Assert.AreEqual ("https", uri.Scheme, "Scheme");
 394                         Assert.IsFalse (uri.UserEscaped, "UserEscaped");
 395                         Assert.AreEqual ("monkey:s3kr3t", uri.UserInfo, "UserInfo");
 396                         Assert.AreEqual (uri.AbsoluteUri, uri.ToString (), "ToString");
 397                 }
 398 #endif
 399         }
 400 }