mcs/class/System/Test/System/UriTest3.cs

   1 //
   2 // UriTest3.cs - Even more (2.0 specific) unit tests for System.Uri
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 #if NET_2_0
  30
  31 using NUnit.Framework;
  32
  33 using System;
  34
  35 namespace MonoTests.System
  36 {
  37         [TestFixture]
  38         public class UriTest3
  39         {
  40                 private const string absolute = "http://www.mono-project.com/CAS";
  41                 private const string relative = "server.com/directory/";
  42
  43                 [Test]
  44                 public void AbsoluteUri_RelativeUri ()
  45                 {
  46                         Uri uri1 = new Uri ("http://www.contoso.com/index.htm?x=2");
  47                         Uri uri2 = new Uri ("http://www.contoso.com/foo/bar/index.htm#fragment");
  48                         Uri relativeUri = uri1.MakeRelativeUri (uri2);
  49
  50                         try {
  51                                 string result = relativeUri.AbsoluteUri;
  52                                 Assert.Fail ("#1: " + result);
  53                         } catch (InvalidOperationException ex) {
  54                                 // This operation is not supported for a relative URI
  55                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
  56                                 Assert.IsNull (ex.InnerException, "#3");
  57                                 Assert.IsNotNull (ex.Message, "#4");
  58                         }
  59                 }
  60
  61                 [Test]
  62                 public void Absolute_UriKind_Absolute ()
  63                 {
  64                         Uri uri = new Uri (absolute, UriKind.Absolute);
  65                         Assert.AreEqual ("www.mono-project.com", uri.DnsSafeHost, "#1");
  66                         Assert.IsTrue (uri.IsAbsoluteUri, "#2");
  67                         Assert.AreEqual (absolute, uri.OriginalString, "#3");
  68                         Assert.AreEqual (absolute, uri.ToString (), "#4");
  69                         Assert.IsFalse (uri.UserEscaped, "#5");
  70                 }
  71
  72                 [Test]
  73                 public void Relative_UriKind_Relative ()
  74                 {
  75                         Uri uri = new Uri (relative, UriKind.Relative);
  76                         Assert.IsFalse (uri.IsAbsoluteUri, "#A1");
  77                         Assert.AreEqual (relative, uri.OriginalString, "#A2");
  78                         Assert.AreEqual (relative, uri.ToString (), "#A3");
  79                         Assert.IsFalse (uri.UserEscaped, "#A4");
  80
  81                         uri = new Uri (string.Empty, UriKind.Relative);
  82                         Assert.IsFalse (uri.IsAbsoluteUri, "#B1");
  83                         Assert.AreEqual (string.Empty, uri.OriginalString, "#B2");
  84                         Assert.AreEqual (string.Empty, uri.ToString (), "#B3");
  85                         Assert.IsFalse (uri.UserEscaped, "#B4");
  86
  87                         uri = new Uri ("foo/bar", UriKind.Relative);
  88                         Assert.IsFalse (uri.IsAbsoluteUri, "#C1");
  89                         Assert.AreEqual ("foo/bar", uri.OriginalString, "#C2");
  90                         Assert.AreEqual ("foo/bar", uri.ToString (), "#C3");
  91                         Assert.IsFalse (uri.UserEscaped, "#C4");
  92
  93                         uri = new Uri ("/test.aspx", UriKind.Relative);
  94                         Assert.IsFalse (uri.IsAbsoluteUri, "#D1");
  95                         Assert.AreEqual ("/test.aspx", uri.OriginalString, "#D2");
  96                         Assert.AreEqual ("/test.aspx", uri.ToString (), "#D3");
  97                         Assert.IsFalse (uri.UserEscaped, "#D4");
  98
  99                         uri = new Uri ("", UriKind.Relative);
 100                         Assert.IsFalse (uri.IsAbsoluteUri, "#E1");
 101                         Assert.AreEqual ("", uri.OriginalString, "#E2");
 102                         Assert.AreEqual ("", uri.ToString (), "#E3");
 103                         Assert.IsFalse (uri.UserEscaped, "#E4");
 104
 105                         uri = new Uri ("a", UriKind.Relative);
 106                         Assert.IsFalse (uri.IsAbsoluteUri, "#F1");
 107                         Assert.AreEqual ("a", uri.OriginalString, "#F2");
 108                         Assert.AreEqual ("a", uri.ToString (), "#F3");
 109                         Assert.IsFalse (uri.UserEscaped, "#F4");
 110                 }
 111
 112                 [Test]
 113                 [ExpectedException (typeof (UriFormatException))]
 114                 public void Relative_UriKind_Absolute ()
 115                 {
 116                         new Uri (relative, UriKind.Absolute);
 117                 }
 118
 119                 [Test]
 120                 [ExpectedException (typeof (UriFormatException))]
 121                 public void Absolute_UriKind_Relative ()
 122                 {
 123                         new Uri (absolute, UriKind.Relative);
 124                 }
 125
 126                 [Test]
 127                 public void TryCreate_String_UriKind_Uri ()
 128                 {
 129                         Uri uri = null;
 130                         Assert.IsTrue (Uri.TryCreate (absolute, UriKind.Absolute, out uri), "absolute-Absolute");
 131                         Assert.AreEqual (absolute, uri.AbsoluteUri, "absolute-Absolute-AbsoluteUri");
 132
 133                         Assert.IsTrue (Uri.TryCreate (absolute, UriKind.RelativeOrAbsolute, out uri), "absolute-RelativeOrAbsolute");
 134                         Assert.AreEqual (absolute, uri.AbsoluteUri, "absolute-RelativeOrAbsolute-AbsoluteUri");
 135
 136                         Assert.IsFalse (Uri.TryCreate (absolute, UriKind.Relative, out uri), "absolute-Relative");
 137                         Assert.IsNull (uri, "absolute-Relative-uri");
 138
 139                         Assert.IsFalse (Uri.TryCreate (relative, UriKind.Absolute, out uri), "relative-Absolute");
 140                         Assert.IsNull (uri, "relative-Relative-uri");
 141
 142                         Assert.IsTrue (Uri.TryCreate (relative, UriKind.RelativeOrAbsolute, out uri), "relative-RelativeOrAbsolute");
 143                         Assert.AreEqual (relative, uri.OriginalString, "relative-RelativeOrAbsolute-OriginalString");
 144
 145                         Assert.IsTrue (Uri.TryCreate (relative, UriKind.Relative, out uri), "relative-Relative");
 146                         Assert.AreEqual (relative, uri.OriginalString, "relative-RelativeOrAbsolute-OriginalString");
 147                 }
 148
 149                 [Test]
 150                 [Category ("NotWorking")]
 151                 public void TryCreate_Uri_String_Uri ()
 152                 {
 153                         Uri baseUri = new Uri (absolute);
 154                         Uri uri = null;
 155
 156                         Assert.IsTrue (Uri.TryCreate (baseUri, relative, out uri), "baseUri+relative");
 157                         Assert.AreEqual ("http://www.mono-project.com/server.com/directory/", uri.AbsoluteUri, "baseUri+relative+AbsoluteUri");
 158                         Assert.AreEqual ("http://www.mono-project.com/server.com/directory/", uri.OriginalString, "baseUri+relative+OriginalString");
 159
 160                         Assert.IsTrue (Uri.TryCreate (baseUri, absolute, out uri), "baseUri+absolute");
 161                         Assert.AreEqual (absolute, uri.AbsoluteUri, "baseUri+absolute+AbsoluteUri");
 162                         Assert.AreEqual (absolute, uri.OriginalString, "baseUri+absolute+OriginalString");
 163
 164                         Uri relativeUri = new Uri (relative, UriKind.Relative);
 165                         Assert.IsFalse (Uri.TryCreate (relativeUri, relative, out uri), "relativeUri+relative");
 166                         Assert.IsNull (uri, "relativeUri+relative+Uri");
 167
 168                         Assert.IsTrue (Uri.TryCreate (relativeUri, absolute, out uri), "relativeUri+absolute");
 169                         Assert.AreEqual (absolute, uri.OriginalString, "relativeUri+absolute+OriginalString");
 170
 171                         string n = null;
 172                         Assert.IsFalse (Uri.TryCreate (baseUri, n, out uri), "baseUri+null");
 173                         Assert.IsNull (uri, "baseUri+null+Uri");
 174                         Assert.IsFalse (Uri.TryCreate (relativeUri, n, out uri), "relativeUri+null");
 175                         Assert.IsNull (uri, "relativeUri+null+Uri");
 176                         Assert.IsFalse (Uri.TryCreate (null, relative, out uri), "null+relative");
 177                         Assert.IsNull (uri, "null+relative+Uri");
 178
 179                         Assert.IsTrue (Uri.TryCreate (null, absolute, out uri), "null+absolute");
 180                         Assert.AreEqual (absolute, uri.OriginalString, "null+absolute+OriginalString");
 181                 }
 182
 183                 [Test]
 184                 [Category ("NotWorking")]
 185                 public void TryCreate_Uri_Uri_Uri ()
 186                 {
 187                         Uri baseUri = new Uri (absolute);
 188                         Uri relativeUri = new Uri (relative, UriKind.Relative);
 189                         Uri uri = null;
 190
 191                         Assert.IsTrue (Uri.TryCreate (baseUri, relativeUri, out uri), "baseUri+relativeUri");
 192                         Assert.AreEqual ("http://www.mono-project.com/server.com/directory/", uri.AbsoluteUri, "baseUri+relativeUri+AbsoluteUri");
 193                         Assert.AreEqual ("http://www.mono-project.com/server.com/directory/", uri.OriginalString, "baseUri+relativeUri+OriginalString");
 194
 195                         Assert.IsTrue (Uri.TryCreate (baseUri, baseUri, out uri), "baseUri+baseUri");
 196                         Assert.AreEqual (absolute, uri.AbsoluteUri, "baseUri+baseUri+AbsoluteUri");
 197                         Assert.AreEqual (absolute, uri.OriginalString, "baseUri+baseUri+OriginalString");
 198
 199                         Assert.IsFalse (Uri.TryCreate (relativeUri, relativeUri, out uri), "relativeUri+relativeUri");
 200                         Assert.IsNull (uri, "relativeUri+relativeUri+Uri");
 201
 202                         Assert.IsFalse (Uri.TryCreate (relativeUri, baseUri, out uri), "relativeUri+baseUri");
 203                         Assert.IsNull (uri, "relativeUri+baseUri+Uri");
 204
 205                         // a null relativeUri throws a NullReferenceException (see next test)
 206                         Assert.IsFalse (Uri.TryCreate (null, relativeUri, out uri), "null+relativeUri");
 207                         Assert.IsNull (uri, "null+relativeUri+Uri");
 208                         Assert.IsFalse (Uri.TryCreate (null, baseUri, out uri), "null+baseUri");
 209                         Assert.IsNull (uri, "null+baseUri+Uri");
 210                 }
 211
 212                 [Test]
 213                 [ExpectedException (typeof (NullReferenceException))]
 214                 public void TryCreate_Uri_UriNull_Uri ()
 215                 {
 216                         Uri uri = null;
 217                         Uri.TryCreate (new Uri (absolute), (Uri) null, out uri);
 218                 }
 219
 220                 [Test]
 221                 public void IsWellFormedUriString_Null ()
 222                 {
 223                         Assert.IsFalse (Uri.IsWellFormedUriString (null, UriKind.Absolute), "null");
 224                 }
 225
 226                 [Test]
 227                 public void IsWellFormedUriString_Http ()
 228                 {
 229                         Assert.IsFalse (Uri.IsWellFormedUriString ("http://www.go-mono.com/Main Page", UriKind.Absolute), "http/space");
 230                         Assert.IsTrue (Uri.IsWellFormedUriString ("http://www.go-mono.com/Main%20Page", UriKind.Absolute), "http/%20");
 231                 }
 232
 233                 [Test]
 234                 [ExpectedException (typeof (ArgumentException))]
 235                 public void IsWellFormedUriString_BadUriKind ()
 236                 {
 237                         Uri.IsWellFormedUriString ("http://www.go-mono.com/Main Page", (UriKind)Int32.MinValue);
 238                 }
 239
 240                 [Test]
 241                 public void Compare ()
 242                 {
 243                         Uri u1 = null;
 244                         Uri u2 = null;
 245                         Assert.AreEqual (0, Uri.Compare (u1, u2, UriComponents.AbsoluteUri, UriFormat.UriEscaped, StringComparison.CurrentCulture), "null-null");
 246
 247                         u1 = new Uri ("http://www.go-mono.com/Main Page");
 248                         u2 = new Uri ("http://www.go-mono.com/Main%20Page");
 249                         Assert.AreEqual (0, Uri.Compare (u1, u2, UriComponents.AbsoluteUri, UriFormat.Unescaped, StringComparison.CurrentCulture), "http/space-http/%20-unescaped");
 250                         Assert.AreEqual (0, Uri.Compare (u1, u2, UriComponents.AbsoluteUri, UriFormat.UriEscaped, StringComparison.CurrentCulture), "http/space-http/%20-escaped");
 251                         Assert.AreEqual (0, Uri.Compare (u1, u2, UriComponents.AbsoluteUri, UriFormat.SafeUnescaped, StringComparison.CurrentCulture), "http/space-http/%20-safe");
 252                 }
 253
 254                 [Test]
 255                 public void IsBaseOf ()
 256                 {
 257                         Uri http = new Uri ("http://www.mono-project.com/Main_Page#FAQ?Edit");
 258                         Assert.IsTrue (http.IsBaseOf (http), "http-http");
 259
 260                         Uri u = new Uri ("http://www.mono-project.com/Main_Page#FAQ");
 261                         Assert.IsTrue (u.IsBaseOf (http), "http-1a");
 262                         Assert.IsTrue (http.IsBaseOf (u), "http-1b");
 263
 264                         u = new Uri ("http://www.mono-project.com/Main_Page");
 265                         Assert.IsTrue (u.IsBaseOf (http), "http-2a");
 266                         Assert.IsTrue (http.IsBaseOf (u), "http-2b");
 267
 268                         u = new Uri ("http://www.mono-project.com/");
 269                         Assert.IsTrue (u.IsBaseOf (http), "http-3a");
 270                         Assert.IsTrue (http.IsBaseOf (u), "http-3b");
 271
 272                         u = new Uri ("http://www.mono-project.com/Main_Page/");
 273                         Assert.IsFalse (u.IsBaseOf (http), "http-4a");
 274                         Assert.IsTrue (http.IsBaseOf (u), "http-4b");
 275
 276                         // docs says the UserInfo isn't evaluated, but...
 277                         u = new Uri ("http://username:password@www.mono-project.com/Main_Page");
 278                         Assert.IsFalse (u.IsBaseOf (http), "http-5a");
 279                         Assert.IsFalse (http.IsBaseOf (u), "http-5b");
 280
 281                         // scheme case sensitive ? no
 282                         u = new Uri ("HTTP://www.mono-project.com/Main_Page");
 283                         Assert.IsTrue (u.IsBaseOf (http), "http-6a");
 284                         Assert.IsTrue (http.IsBaseOf (u), "http-6b");
 285
 286                         // host case sensitive ? no
 287                         u = new Uri ("http://www.Mono-Project.com/Main_Page");
 288                         Assert.IsTrue (u.IsBaseOf (http), "http-7a");
 289                         Assert.IsTrue (http.IsBaseOf (u), "http-7b");
 290
 291                         // path case sensitive ? no
 292                         u = new Uri ("http://www.Mono-Project.com/MAIN_Page");
 293                         Assert.IsTrue (u.IsBaseOf (http), "http-8a");
 294                         Assert.IsTrue (http.IsBaseOf (u), "http-8b");
 295
 296                         // different scheme
 297                         u = new Uri ("ftp://www.mono-project.com/Main_Page");
 298                         Assert.IsFalse (u.IsBaseOf (http), "http-9a");
 299                         Assert.IsFalse (http.IsBaseOf (u), "http-9b");
 300
 301                         // different host
 302                         u = new Uri ("http://www.go-mono.com/Main_Page");
 303                         Assert.IsFalse (u.IsBaseOf (http), "http-10a");
 304                         Assert.IsFalse (http.IsBaseOf (u), "http-10b");
 305
 306                         // different port
 307                         u = new Uri ("http://www.mono-project.com:8080/");
 308                         Assert.IsFalse (u.IsBaseOf (http), "http-11a");
 309                         Assert.IsFalse (http.IsBaseOf (u), "http-11b");
 310
 311                         // specify default port
 312                         u = new Uri ("http://www.mono-project.com:80/");
 313                         Assert.IsTrue (u.IsBaseOf (http), "http-12a");
 314                         Assert.IsTrue (http.IsBaseOf (u), "http-12b");
 315                 }
 316
 317                 [Test]
 318                 [ExpectedException (typeof (NullReferenceException))]
 319                 public void IsBaseOf_Null ()
 320                 {
 321                         Uri http = new Uri ("http://www.mono-project.com/Main_Page#FAQ?Edit");
 322                         http.IsBaseOf (null);
 323                 }
 324
 325                 [Test]
 326                 public void MakeRelativeUri ()
 327                 {
 328                         Uri uri1 = new Uri ("http://www.contoso.com/index.htm?x=2");
 329                         Uri uri2 = new Uri ("http://www.contoso.com/foo/bar/index.htm#fragment");
 330                         Uri uri3 = new Uri ("http://www.contoso.com/bar/foo/index.htm?y=1");
 331                         Uri uri4 = new Uri ("http://www.contoso.com/bar/foo2/index.htm?x=0");
 332                         Uri uri5 = new Uri ("https://www.contoso.com/bar/foo/index.htm?y=1");
 333                         Uri uri6 = new Uri ("http://www.contoso2.com/bar/foo/index.htm?x=0");
 334                         Uri uri7 = new Uri ("http://www.contoso2.com/bar/foo/foobar.htm?z=0&y=5");
 335                         Uri uri8 = new Uri ("http://www.xxx.com/bar/foo/foobar.htm?z=0&y=5" + (char) 0xa9);
 336                         Uri uri10 = new Uri ("mailto:xxx@xxx.com");
 337                         Uri uri11 = new Uri ("mailto:xxx@xxx.com?subject=hola");
 338                         Uri uri12 = new Uri ("mailto:xxx@mail.xxx.com?subject=hola");
 339                         Uri uri13 = new Uri ("mailto:xxx@xxx.com/foo/bar");
 340
 341                         AssertRelativeUri ("foo/bar/index.htm#fragment", uri1, uri2, "#A");
 342                         AssertRelativeUri ("../../index.htm?x=2", uri2, uri1, "#B");
 343                         AssertRelativeUri ("../../bar/foo/index.htm?y=1", uri2, uri3, "#C");
 344                         AssertRelativeUri ("../../foo/bar/index.htm#fragment", uri3, uri2, "#D");
 345                         AssertRelativeUri ("../foo2/index.htm?x=0", uri3, uri4, "#E");
 346                         AssertRelativeUri ("../foo/index.htm?y=1", uri4, uri3, "#F");
 347                         AssertRelativeUri ("?x=0", uri6, uri6, "#G");
 348                         AssertRelativeUri ("foobar.htm?z=0&y=5", uri6, uri7, "#H");
 349                         AssertRelativeUri ("?subject=hola", uri10, uri11, "#I");
 350                         AssertRelativeUri ("/foo/bar", uri10, uri13, "#J");
 351
 352                         Uri relativeUri = uri1.MakeRelativeUri (uri8);
 353                         Assert.IsTrue (relativeUri.IsAbsoluteUri, "#K1");
 354                         Assert.AreEqual (uri8.ToString (), relativeUri.ToString (), "#K2");
 355                         Assert.AreEqual (uri8.OriginalString, relativeUri.OriginalString, "#K3");
 356
 357                         relativeUri = uri10.MakeRelativeUri (uri12);
 358                         Assert.IsTrue (relativeUri.IsAbsoluteUri, "#L1");
 359                         Assert.AreEqual (uri12.ToString (), relativeUri.ToString (), "#L2");
 360                         Assert.AreEqual (uri12.OriginalString, relativeUri.OriginalString, "#L3");
 361
 362                         relativeUri = uri4.MakeRelativeUri (uri6);
 363                         Assert.IsTrue (relativeUri.IsAbsoluteUri, "#M1");
 364                         Assert.AreEqual (uri6.ToString (), relativeUri.ToString (), "#M2");
 365                         Assert.AreEqual (uri6.OriginalString, relativeUri.OriginalString, "#M3");
 366
 367                         relativeUri = uri4.MakeRelativeUri (uri5);
 368                         Assert.IsTrue (relativeUri.IsAbsoluteUri, "#N1");
 369                         Assert.AreEqual (uri5.ToString (), relativeUri.ToString (), "#N2");
 370                         Assert.AreEqual (uri5.OriginalString, relativeUri.OriginalString, "#N3");
 371                 }
 372
 373                 [Test]
 374                 [Category ("NotDotNet")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=299942
 375                 public void MakeRelativeUri_Uri_Null_Mono ()
 376                 {
 377                         Uri uri = new Uri ("http://test.com");
 378                         try {
 379                                 uri.MakeRelativeUri ((Uri) null);
 380                                 Assert.Fail ("#1");
 381                         } catch (ArgumentNullException ex) {
 382                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 383                                 Assert.IsNull (ex.InnerException, "#3");
 384                                 Assert.IsNotNull (ex.Message, "#4");
 385                                 Assert.IsNotNull (ex.ParamName, "#5");
 386                                 Assert.AreEqual ("uri", ex.ParamName, "#6");
 387                         }
 388                 }
 389
 390                 [Test]
 391                 [Category ("NotWorking")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=299942
 392                 public void MakeRelativeUri_Uri_Null_MS ()
 393                 {
 394                         Uri uri = new Uri ("http://test.com");
 395                         try {
 396                                 uri.MakeRelativeUri ((Uri) null);
 397                                 Assert.Fail ("#1");
 398                         } catch (NullReferenceException) {
 399                         }
 400                 }
 401
 402                 [Test]
 403                 // LAMESPEC: see bug #78374.
 404                 public void OriginalStringRelative ()
 405                 {
 406                         Uri k1 = new Uri ("http://www.mono-project.com");
 407                         Uri k2 = new Uri (k1, "docs");
 408                         Assert.AreEqual ("http://www.mono-project.com/docs", k2.OriginalString, "#1");
 409
 410                         Uri a = new Uri ("http://www.mono-project.com:808/foo");
 411                         Uri b = new Uri (a, "../docs?queryyy#% %20%23%25bar");
 412
 413                         // it won't work.
 414                         // Assert.AreEqual ("http://www.mono-project.com:808/docs?queryyy#% %20%23%25bar", b.OriginalString, "#2");
 415
 416                         Uri c = new Uri ("http://www.mono-project.com:909");
 417                         Uri d = new Uri (c, "http://www.mono-project.com:606/docs");
 418                         Assert.AreEqual ("http://www.mono-project.com:606/docs", d.OriginalString, "#3");
 419
 420                         Uri e = new Uri ("http://www.mono-project.com:303/foo");
 421                         Uri f = new Uri (e, "?query");
 422                         // it doesn't work. MS.NET also returns incorrect URI: ..303/?query
 423                         // Assert.AreEqual ("http://www.mono-project.com:303/foo?query", f.OriginalString, "#4");
 424                 }
 425
 426                 [Test]
 427                 public void PathAndQuery_RelativeUri ()
 428                 {
 429                         Uri uri1 = new Uri ("http://www.contoso.com/index.htm?x=2");
 430                         Uri uri2 = new Uri ("http://www.contoso.com/foo/bar/index.htm#fragment");
 431                         Uri relativeUri = uri1.MakeRelativeUri (uri2);
 432
 433                         try {
 434                                 string result = relativeUri.PathAndQuery;
 435                                 Assert.Fail ("#1: " + result);
 436                         } catch (InvalidOperationException ex) {
 437                                 // This operation is not supported for a relative URI
 438                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 439                                 Assert.IsNull (ex.InnerException, "#3");
 440                                 Assert.IsNotNull (ex.Message, "#4");
 441                         }
 442                 }
 443
 444                 [Test]
 445                 public void Query_RelativeUri ()
 446                 {
 447                         Uri uri1 = new Uri ("http://www.contoso.com/index.htm?x=2");
 448                         Uri uri2 = new Uri ("http://www.contoso.com/foo/bar/index.htm#fragment");
 449                         Uri relativeUri = uri1.MakeRelativeUri (uri2);
 450
 451                         try {
 452                                 string result = relativeUri.Query;
 453                                 Assert.Fail ("#1: " + result);
 454                         } catch (InvalidOperationException ex) {
 455                                 // This operation is not supported for a relative URI
 456                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 457                                 Assert.IsNull (ex.InnerException, "#3");
 458                                 Assert.IsNotNull (ex.Message, "#4");
 459                         }
 460                 }
 461
 462                 [Test]
 463                 public void Scheme_RelativeUri ()
 464                 {
 465                         Uri uri1 = new Uri ("http://www.contoso.com/index.htm?x=2");
 466                         Uri uri2 = new Uri ("http://www.contoso.com/foo/bar/index.htm#fragment");
 467                         Uri relativeUri = uri1.MakeRelativeUri (uri2);
 468
 469                         try {
 470                                 string result = relativeUri.Scheme;
 471                                 Assert.Fail ("#1: " + result);
 472                         } catch (InvalidOperationException ex) {
 473                                 // This operation is not supported for a relative URI
 474                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 475                                 Assert.IsNull (ex.InnerException, "#3");
 476                                 Assert.IsNotNull (ex.Message, "#4");
 477                         }
 478                 }
 479
 480                 [Test]
 481                 public void UnescapeDataString ()
 482                 {
 483                         Assert.AreEqual ("/new folder/", Uri.UnescapeDataString ("/new%20folder/"));
 484                         Assert.AreEqual ("/new folder/", Uri.UnescapeDataString ("/new%20%66older/"));
 485                         Assert.AreEqual ("/new+folder/", Uri.UnescapeDataString ("/new+folder/"));
 486                 }
 487
 488                 void AssertRelativeUri (string expected, Uri uri1, Uri uri2, string msg)
 489                 {
 490                         Uri relativeUri;
 491                         relativeUri = uri1.MakeRelativeUri (uri2);
 492
 493                         Assert.IsFalse (relativeUri.IsAbsoluteUri, msg + "1");
 494                         Assert.AreEqual (expected, relativeUri.ToString (), msg + "2");
 495                         Assert.AreEqual (expected, relativeUri.OriginalString, msg + "3");
 496                         Assert.IsFalse (relativeUri.UserEscaped, msg + "4");
 497                 }
 498
 499                 [Test]
 500                 public void DontCheckHostWithCustomParsers ()
 501                 {
 502                         UriParser.Register (new TolerantUriParser (), "assembly", 0);
 503                         try {
 504                                 new Uri ("assembly://Spring.Core, Version=1.2.0.20001, Culture=neutral, "
 505                                         + "PublicKeyToken=null/Spring.Objects.Factory.Xml/spring-objects-1.1.xsd");
 506                         } catch (UriFormatException) {
 507                                 Assert.Fail ("Spring Uri is expected to work.");
 508                         }
 509                 }
 510
 511                 private class TolerantUriParser : GenericUriParser
 512                 {
 513                         private const GenericUriParserOptions DefaultOptions
 514                                 = GenericUriParserOptions.Default
 515                                 | GenericUriParserOptions.GenericAuthority
 516                                 | GenericUriParserOptions.AllowEmptyAuthority;
 517
 518                         public TolerantUriParser()
 519                                                         : base(DefaultOptions)
 520                         {
 521                         }
 522                 }
 523         }
 524 }
 525
 526 #endif