netwerk/test/unit/test_URIs2.js

   1 /* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
   2 "use strict";
   3
   4 // Run by: cd objdir;  make -C netwerk/test/ xpcshell-tests
   5 // or: cd objdir; make SOLO_FILE="test_URIs2.js" -C netwerk/test/ check-one
   6
   7 // This is a clone of test_URIs.js, with a different set of test data in gTests.
   8 // The original test data in test_URIs.js was split between test_URIs and test_URIs2.js
   9 // because test_URIs.js was running for too long on slow platforms, causing
  10 // intermittent timeouts.
  11
  12 // Relevant RFCs: 1738, 1808, 2396, 3986 (newer than the code)
  13 // http://greenbytes.de/tech/webdav/rfc3986.html#rfc.section.5.4
  14 // http://greenbytes.de/tech/tc/uris/
  15
  16 // TEST DATA
  17 // ---------
  18 var gTests = [
  19   {
  20     spec: "view-source:about:blank",
  21     scheme: "view-source",
  22     prePath: "view-source:",
  23     pathQueryRef: "about:blank",
  24     ref: "",
  25     nsIURL: false,
  26     nsINestedURI: true,
  27     immutable: true,
  28   },
  29   {
  30     spec: "view-source:http://www.mozilla.org/",
  31     scheme: "view-source",
  32     prePath: "view-source:",
  33     pathQueryRef: "http://www.mozilla.org/",
  34     ref: "",
  35     nsIURL: false,
  36     nsINestedURI: true,
  37     immutable: true,
  38   },
  39   {
  40     spec: "x-external:",
  41     scheme: "x-external",
  42     prePath: "x-external:",
  43     pathQueryRef: "",
  44     ref: "",
  45     nsIURL: false,
  46     nsINestedURI: false,
  47   },
  48   {
  49     spec: "x-external:abc",
  50     scheme: "x-external",
  51     prePath: "x-external:",
  52     pathQueryRef: "abc",
  53     ref: "",
  54     nsIURL: false,
  55     nsINestedURI: false,
  56   },
  57   {
  58     spec: "http://www2.example.com/",
  59     relativeURI: "a/b/c/d",
  60     scheme: "http",
  61     prePath: "http://www2.example.com",
  62     pathQueryRef: "/a/b/c/d",
  63     ref: "",
  64     nsIURL: true,
  65     nsINestedURI: false,
  66   },
  67   // relative URL testcases from http://greenbytes.de/tech/webdav/rfc3986.html#rfc.section.5.4
  68   {
  69     spec: "http://a/b/c/d;p?q",
  70     relativeURI: "g:h",
  71     scheme: "g",
  72     prePath: "g:",
  73     pathQueryRef: "h",
  74     ref: "",
  75     nsIURL: false,
  76     nsINestedURI: false,
  77   },
  78   {
  79     spec: "http://a/b/c/d;p?q",
  80     relativeURI: "g",
  81     scheme: "http",
  82     prePath: "http://a",
  83     pathQueryRef: "/b/c/g",
  84     ref: "",
  85     nsIURL: true,
  86     nsINestedURI: false,
  87   },
  88   {
  89     spec: "http://a/b/c/d;p?q",
  90     relativeURI: "./g",
  91     scheme: "http",
  92     prePath: "http://a",
  93     pathQueryRef: "/b/c/g",
  94     ref: "",
  95     nsIURL: true,
  96     nsINestedURI: false,
  97   },
  98   {
  99     spec: "http://a/b/c/d;p?q",
 100     relativeURI: "g/",
 101     scheme: "http",
 102     prePath: "http://a",
 103     pathQueryRef: "/b/c/g/",
 104     ref: "",
 105     nsIURL: true,
 106     nsINestedURI: false,
 107   },
 108   {
 109     spec: "http://a/b/c/d;p?q",
 110     relativeURI: "/g",
 111     scheme: "http",
 112     prePath: "http://a",
 113     pathQueryRef: "/g",
 114     ref: "",
 115     nsIURL: true,
 116     nsINestedURI: false,
 117   },
 118   {
 119     spec: "http://a/b/c/d;p?q",
 120     relativeURI: "?y",
 121     scheme: "http",
 122     prePath: "http://a",
 123     pathQueryRef: "/b/c/d;p?y",
 124     ref: "", // fix
 125     nsIURL: true,
 126     nsINestedURI: false,
 127   },
 128   {
 129     spec: "http://a/b/c/d;p?q",
 130     relativeURI: "g?y",
 131     scheme: "http",
 132     prePath: "http://a",
 133     pathQueryRef: "/b/c/g?y",
 134     ref: "", // fix
 135     specIgnoringRef: "http://a/b/c/g?y",
 136     hasRef: false,
 137     hasQuery: true,
 138     nsIURL: true,
 139     nsINestedURI: false,
 140   },
 141   {
 142     spec: "http://a/b/c/d;p?q",
 143     relativeURI: "#s",
 144     scheme: "http",
 145     prePath: "http://a",
 146     pathQueryRef: "/b/c/d;p?q#s",
 147     ref: "s", // fix
 148     specIgnoringRef: "http://a/b/c/d;p?q",
 149     hasRef: true,
 150     nsIURL: true,
 151     nsINestedURI: false,
 152   },
 153   {
 154     spec: "http://a/b/c/d;p?q",
 155     relativeURI: "g#s",
 156     scheme: "http",
 157     prePath: "http://a",
 158     pathQueryRef: "/b/c/g#s",
 159     ref: "s",
 160     nsIURL: true,
 161     nsINestedURI: false,
 162   },
 163   {
 164     spec: "http://a/b/c/d;p?q",
 165     relativeURI: "g?y#s",
 166     scheme: "http",
 167     prePath: "http://a",
 168     pathQueryRef: "/b/c/g?y#s",
 169     ref: "s",
 170     nsIURL: true,
 171     nsINestedURI: false,
 172   },
 173   /*
 174     Bug xxxxxx - we return a path of b/c/;x
 175   { spec:    "http://a/b/c/d;p?q",
 176     relativeURI: ";x",
 177     scheme:  "http",
 178     prePath: "http://a",
 179     pathQueryRef: "/b/c/d;x",
 180     ref:     "",
 181     nsIURL:  true, nsINestedURI: false },
 182   */
 183   {
 184     spec: "http://a/b/c/d;p?q",
 185     relativeURI: "g;x",
 186     scheme: "http",
 187     prePath: "http://a",
 188     pathQueryRef: "/b/c/g;x",
 189     ref: "",
 190     nsIURL: true,
 191     nsINestedURI: false,
 192   },
 193   {
 194     spec: "http://a/b/c/d;p?q",
 195     relativeURI: "g;x?y#s",
 196     scheme: "http",
 197     prePath: "http://a",
 198     pathQueryRef: "/b/c/g;x?y#s",
 199     ref: "s",
 200     nsIURL: true,
 201     nsINestedURI: false,
 202   },
 203   /*
 204     Can't easily specify a relative URI of "" to the test code
 205   { spec:    "http://a/b/c/d;p?q",
 206     relativeURI: "",
 207     scheme:  "http",
 208     prePath: "http://a",
 209     pathQueryRef: "/b/c/d",
 210     ref:     "",
 211     nsIURL:  true, nsINestedURI: false },
 212   */
 213   {
 214     spec: "http://a/b/c/d;p?q",
 215     relativeURI: ".",
 216     scheme: "http",
 217     prePath: "http://a",
 218     pathQueryRef: "/b/c/",
 219     ref: "",
 220     nsIURL: true,
 221     nsINestedURI: false,
 222   },
 223   {
 224     spec: "http://a/b/c/d;p?q",
 225     relativeURI: "./",
 226     scheme: "http",
 227     prePath: "http://a",
 228     pathQueryRef: "/b/c/",
 229     ref: "",
 230     nsIURL: true,
 231     nsINestedURI: false,
 232   },
 233   {
 234     spec: "http://a/b/c/d;p?q",
 235     relativeURI: "..",
 236     scheme: "http",
 237     prePath: "http://a",
 238     pathQueryRef: "/b/",
 239     ref: "",
 240     nsIURL: true,
 241     nsINestedURI: false,
 242   },
 243   {
 244     spec: "http://a/b/c/d;p?q",
 245     relativeURI: "../",
 246     scheme: "http",
 247     prePath: "http://a",
 248     pathQueryRef: "/b/",
 249     ref: "",
 250     nsIURL: true,
 251     nsINestedURI: false,
 252   },
 253   {
 254     spec: "http://a/b/c/d;p?q",
 255     relativeURI: "../g",
 256     scheme: "http",
 257     prePath: "http://a",
 258     pathQueryRef: "/b/g",
 259     ref: "",
 260     nsIURL: true,
 261     nsINestedURI: false,
 262   },
 263   {
 264     spec: "http://a/b/c/d;p?q",
 265     relativeURI: "../..",
 266     scheme: "http",
 267     prePath: "http://a",
 268     pathQueryRef: "/",
 269     ref: "",
 270     nsIURL: true,
 271     nsINestedURI: false,
 272   },
 273   {
 274     spec: "http://a/b/c/d;p?q",
 275     relativeURI: "../../",
 276     scheme: "http",
 277     prePath: "http://a",
 278     pathQueryRef: "/",
 279     ref: "",
 280     nsIURL: true,
 281     nsINestedURI: false,
 282   },
 283   {
 284     spec: "http://a/b/c/d;p?q",
 285     relativeURI: "../../g",
 286     scheme: "http",
 287     prePath: "http://a",
 288     pathQueryRef: "/g",
 289     ref: "",
 290     nsIURL: true,
 291     nsINestedURI: false,
 292   },
 293
 294   // abnormal examples
 295   {
 296     spec: "http://a/b/c/d;p?q",
 297     relativeURI: "../../../g",
 298     scheme: "http",
 299     prePath: "http://a",
 300     pathQueryRef: "/g",
 301     ref: "",
 302     nsIURL: true,
 303     nsINestedURI: false,
 304   },
 305   {
 306     spec: "http://a/b/c/d;p?q",
 307     relativeURI: "../../../../g",
 308     scheme: "http",
 309     prePath: "http://a",
 310     pathQueryRef: "/g",
 311     ref: "",
 312     nsIURL: true,
 313     nsINestedURI: false,
 314   },
 315
 316   // coalesce
 317   {
 318     spec: "http://a/b/c/d;p?q",
 319     relativeURI: "/./g",
 320     scheme: "http",
 321     prePath: "http://a",
 322     pathQueryRef: "/g",
 323     ref: "",
 324     nsIURL: true,
 325     nsINestedURI: false,
 326   },
 327   {
 328     spec: "http://a/b/c/d;p?q",
 329     relativeURI: "/../g",
 330     scheme: "http",
 331     prePath: "http://a",
 332     pathQueryRef: "/g",
 333     ref: "",
 334     nsIURL: true,
 335     nsINestedURI: false,
 336   },
 337   {
 338     spec: "http://a/b/c/d;p?q",
 339     relativeURI: "g.",
 340     scheme: "http",
 341     prePath: "http://a",
 342     pathQueryRef: "/b/c/g.",
 343     ref: "",
 344     nsIURL: true,
 345     nsINestedURI: false,
 346   },
 347   {
 348     spec: "http://a/b/c/d;p?q",
 349     relativeURI: ".g",
 350     scheme: "http",
 351     prePath: "http://a",
 352     pathQueryRef: "/b/c/.g",
 353     ref: "",
 354     nsIURL: true,
 355     nsINestedURI: false,
 356   },
 357   {
 358     spec: "http://a/b/c/d;p?q",
 359     relativeURI: "g..",
 360     scheme: "http",
 361     prePath: "http://a",
 362     pathQueryRef: "/b/c/g..",
 363     ref: "",
 364     nsIURL: true,
 365     nsINestedURI: false,
 366   },
 367   {
 368     spec: "http://a/b/c/d;p?q",
 369     relativeURI: "..g",
 370     scheme: "http",
 371     prePath: "http://a",
 372     pathQueryRef: "/b/c/..g",
 373     ref: "",
 374     nsIURL: true,
 375     nsINestedURI: false,
 376   },
 377   {
 378     spec: "http://a/b/c/d;p?q",
 379     relativeURI: ".",
 380     scheme: "http",
 381     prePath: "http://a",
 382     pathQueryRef: "/b/c/",
 383     ref: "",
 384     nsIURL: true,
 385     nsINestedURI: false,
 386   },
 387   {
 388     spec: "http://a/b/c/d;p?q",
 389     relativeURI: "./../g",
 390     scheme: "http",
 391     prePath: "http://a",
 392     pathQueryRef: "/b/g",
 393     ref: "",
 394     nsIURL: true,
 395     nsINestedURI: false,
 396   },
 397   {
 398     spec: "http://a/b/c/d;p?q",
 399     relativeURI: "./g/.",
 400     scheme: "http",
 401     prePath: "http://a",
 402     pathQueryRef: "/b/c/g/",
 403     ref: "",
 404     nsIURL: true,
 405     nsINestedURI: false,
 406   },
 407   {
 408     spec: "http://a/b/c/d;p?q",
 409     relativeURI: "g/./h",
 410     scheme: "http",
 411     prePath: "http://a",
 412     pathQueryRef: "/b/c/g/h",
 413     ref: "",
 414     nsIURL: true,
 415     nsINestedURI: false,
 416   },
 417   {
 418     spec: "http://a/b/c/d;p?q",
 419     relativeURI: "g/../h",
 420     scheme: "http",
 421     prePath: "http://a",
 422     pathQueryRef: "/b/c/h",
 423     ref: "", // fix
 424     nsIURL: true,
 425     nsINestedURI: false,
 426   },
 427   {
 428     spec: "http://a/b/c/d;p?q",
 429     relativeURI: "g;x=1/./y",
 430     scheme: "http",
 431     prePath: "http://a",
 432     pathQueryRef: "/b/c/g;x=1/y",
 433     ref: "",
 434     nsIURL: true,
 435     nsINestedURI: false,
 436   },
 437   {
 438     spec: "http://a/b/c/d;p?q",
 439     relativeURI: "g;x=1/../y",
 440     scheme: "http",
 441     prePath: "http://a",
 442     pathQueryRef: "/b/c/y",
 443     ref: "",
 444     nsIURL: true,
 445     nsINestedURI: false,
 446   },
 447   // protocol-relative http://tools.ietf.org/html/rfc3986#section-4.2
 448   {
 449     spec: "http://www2.example.com/",
 450     relativeURI: "//www3.example2.com/bar",
 451     scheme: "http",
 452     prePath: "http://www3.example2.com",
 453     pathQueryRef: "/bar",
 454     ref: "",
 455     nsIURL: true,
 456     nsINestedURI: false,
 457   },
 458   {
 459     spec: "https://www2.example.com/",
 460     relativeURI: "//www3.example2.com/bar",
 461     scheme: "https",
 462     prePath: "https://www3.example2.com",
 463     pathQueryRef: "/bar",
 464     hasQuery: false,
 465     ref: "",
 466     nsIURL: true,
 467     nsINestedURI: false,
 468   },
 469 ];
 470
 471 var gHashSuffixes = ["#", "#myRef", "#myRef?a=b", "#myRef#", "#myRef#x:yz"];
 472
 473 // TEST HELPER FUNCTIONS
 474 // ---------------------
 475 function do_info(text, stack) {
 476   if (!stack) {
 477     stack = Components.stack.caller;
 478   }
 479
 480   dump(
 481     "\n" +
 482       "TEST-INFO | " +
 483       stack.filename +
 484       " | [" +
 485       stack.name +
 486       " : " +
 487       stack.lineNumber +
 488       "] " +
 489       text +
 490       "\n"
 491   );
 492 }
 493
 494 // Checks that the URIs satisfy equals(), in both possible orderings.
 495 // Also checks URI.equalsExceptRef(), because equal URIs should also be equal
 496 // when we ignore the ref.
 497 //
 498 // The third argument is optional. If the client passes a third argument
 499 // (e.g. todo_check_true), we'll use that in lieu of ok.
 500 function do_check_uri_eq(aURI1, aURI2, aCheckTrueFunc = ok) {
 501   do_info("(uri equals check: '" + aURI1.spec + "' == '" + aURI2.spec + "')");
 502   aCheckTrueFunc(aURI1.equals(aURI2));
 503   do_info("(uri equals check: '" + aURI2.spec + "' == '" + aURI1.spec + "')");
 504   aCheckTrueFunc(aURI2.equals(aURI1));
 505
 506   // (Only take the extra step of testing 'equalsExceptRef' when we expect the
 507   // URIs to really be equal.  In 'todo' cases, the URIs may or may not be
 508   // equal when refs are ignored - there's no way of knowing in general.)
 509   if (aCheckTrueFunc == ok) {
 510     do_check_uri_eqExceptRef(aURI1, aURI2, aCheckTrueFunc);
 511   }
 512 }
 513
 514 // Checks that the URIs satisfy equalsExceptRef(), in both possible orderings.
 515 //
 516 // The third argument is optional. If the client passes a third argument
 517 // (e.g. todo_check_true), we'll use that in lieu of ok.
 518 function do_check_uri_eqExceptRef(aURI1, aURI2, aCheckTrueFunc = ok) {
 519   do_info(
 520     "(uri equalsExceptRef check: '" + aURI1.spec + "' == '" + aURI2.spec + "')"
 521   );
 522   aCheckTrueFunc(aURI1.equalsExceptRef(aURI2));
 523   do_info(
 524     "(uri equalsExceptRef check: '" + aURI2.spec + "' == '" + aURI1.spec + "')"
 525   );
 526   aCheckTrueFunc(aURI2.equalsExceptRef(aURI1));
 527 }
 528
 529 // Checks that the given property on aURI matches the corresponding property
 530 // in the test bundle (or matches some function of that corresponding property,
 531 // if aTestFunctor is passed in).
 532 function do_check_property(aTest, aURI, aPropertyName, aTestFunctor) {
 533   if (aTest[aPropertyName]) {
 534     var expectedVal = aTestFunctor
 535       ? aTestFunctor(aTest[aPropertyName])
 536       : aTest[aPropertyName];
 537
 538     do_info(
 539       "testing " +
 540         aPropertyName +
 541         " of " +
 542         (aTestFunctor ? "modified '" : "'") +
 543         aTest.spec +
 544         "' is '" +
 545         expectedVal +
 546         "'"
 547     );
 548     Assert.equal(aURI[aPropertyName], expectedVal);
 549   }
 550 }
 551
 552 // Test that a given URI parses correctly into its various components.
 553 function do_test_uri_basic(aTest) {
 554   var URI;
 555
 556   do_info(
 557     "Basic tests for " + aTest.spec + " relative URI: " + aTest.relativeURI
 558   );
 559
 560   try {
 561     URI = NetUtil.newURI(aTest.spec);
 562   } catch (e) {
 563     do_info("Caught error on parse of" + aTest.spec + " Error: " + e.result);
 564     if (aTest.fail) {
 565       Assert.equal(e.result, aTest.result);
 566       return;
 567     }
 568     do_throw(e.result);
 569   }
 570
 571   if (aTest.relativeURI) {
 572     var relURI;
 573
 574     try {
 575       relURI = Services.io.newURI(aTest.relativeURI, null, URI);
 576     } catch (e) {
 577       do_info(
 578         "Caught error on Relative parse of " +
 579           aTest.spec +
 580           " + " +
 581           aTest.relativeURI +
 582           " Error: " +
 583           e.result
 584       );
 585       if (aTest.relativeFail) {
 586         Assert.equal(e.result, aTest.relativeFail);
 587         return;
 588       }
 589       do_throw(e.result);
 590     }
 591     do_info(
 592       "relURI.pathQueryRef = " +
 593         relURI.pathQueryRef +
 594         ", was " +
 595         URI.pathQueryRef
 596     );
 597     URI = relURI;
 598     do_info("URI.pathQueryRef now = " + URI.pathQueryRef);
 599   }
 600
 601   // Sanity-check
 602   do_info("testing " + aTest.spec + " equals a clone of itself");
 603   do_check_uri_eq(URI, URI.mutate().finalize());
 604   do_check_uri_eqExceptRef(URI, URI.mutate().setRef("").finalize());
 605   do_info("testing " + aTest.spec + " instanceof nsIURL");
 606   Assert.equal(URI instanceof Ci.nsIURL, aTest.nsIURL);
 607   do_info("testing " + aTest.spec + " instanceof nsINestedURI");
 608   Assert.equal(URI instanceof Ci.nsINestedURI, aTest.nsINestedURI);
 609
 610   do_info(
 611     "testing that " +
 612       aTest.spec +
 613       " throws or returns false " +
 614       "from equals(null)"
 615   );
 616   // XXXdholbert At some point it'd probably be worth making this behavior
 617   // (throwing vs. returning false) consistent across URI implementations.
 618   var threw = false;
 619   var isEqualToNull;
 620   try {
 621     isEqualToNull = URI.equals(null);
 622   } catch (e) {
 623     threw = true;
 624   }
 625   Assert.ok(threw || !isEqualToNull);
 626
 627   // Check the various components
 628   do_check_property(aTest, URI, "scheme");
 629   do_check_property(aTest, URI, "prePath");
 630   do_check_property(aTest, URI, "pathQueryRef");
 631   do_check_property(aTest, URI, "query");
 632   do_check_property(aTest, URI, "ref");
 633   do_check_property(aTest, URI, "port");
 634   do_check_property(aTest, URI, "username");
 635   do_check_property(aTest, URI, "password");
 636   do_check_property(aTest, URI, "host");
 637   do_check_property(aTest, URI, "specIgnoringRef");
 638   if ("hasRef" in aTest) {
 639     do_info("testing hasref: " + aTest.hasRef + " vs " + URI.hasRef);
 640     Assert.equal(aTest.hasRef, URI.hasRef);
 641   }
 642   if ("hasQuery" in aTest) {
 643     do_info("testing hasQuery: " + aTest.hasQuery + " vs " + URI.hasQuery);
 644     Assert.equal(aTest.hasQuery, URI.hasQuery);
 645   }
 646 }
 647
 648 // Test that a given URI parses correctly when we add a given ref to the end
 649 function do_test_uri_with_hash_suffix(aTest, aSuffix) {
 650   do_info("making sure caller is using suffix that starts with '#'");
 651   Assert.equal(aSuffix[0], "#");
 652
 653   var origURI = NetUtil.newURI(aTest.spec);
 654   var testURI;
 655
 656   if (aTest.relativeURI) {
 657     try {
 658       origURI = Services.io.newURI(aTest.relativeURI, null, origURI);
 659     } catch (e) {
 660       do_info(
 661         "Caught error on Relative parse of " +
 662           aTest.spec +
 663           " + " +
 664           aTest.relativeURI +
 665           " Error: " +
 666           e.result
 667       );
 668       return;
 669     }
 670     try {
 671       testURI = Services.io.newURI(aSuffix, null, origURI);
 672     } catch (e) {
 673       do_info(
 674         "Caught error adding suffix to " +
 675           aTest.spec +
 676           " + " +
 677           aTest.relativeURI +
 678           ", suffix " +
 679           aSuffix +
 680           " Error: " +
 681           e.result
 682       );
 683       return;
 684     }
 685   } else {
 686     testURI = NetUtil.newURI(aTest.spec + aSuffix);
 687   }
 688
 689   do_info(
 690     "testing " +
 691       aTest.spec +
 692       " with '" +
 693       aSuffix +
 694       "' appended " +
 695       "equals a clone of itself"
 696   );
 697   do_check_uri_eq(testURI, testURI.mutate().finalize());
 698
 699   do_info(
 700     "testing " +
 701       aTest.spec +
 702       " doesn't equal self with '" +
 703       aSuffix +
 704       "' appended"
 705   );
 706
 707   Assert.ok(!origURI.equals(testURI));
 708
 709   do_info(
 710     "testing " +
 711       aTest.spec +
 712       " is equalExceptRef to self with '" +
 713       aSuffix +
 714       "' appended"
 715   );
 716   do_check_uri_eqExceptRef(origURI, testURI);
 717
 718   Assert.equal(testURI.hasRef, true);
 719
 720   if (!origURI.ref) {
 721     // These tests fail if origURI has a ref
 722     do_info(
 723       "testing cloneIgnoringRef on " +
 724         testURI.spec +
 725         " is equal to no-ref version but not equal to ref version"
 726     );
 727     var cloneNoRef = testURI.mutate().setRef("").finalize();
 728     do_check_uri_eq(cloneNoRef, origURI);
 729     Assert.ok(!cloneNoRef.equals(testURI));
 730   }
 731
 732   do_check_property(aTest, testURI, "scheme");
 733   do_check_property(aTest, testURI, "prePath");
 734   if (!origURI.ref) {
 735     // These don't work if it's a ref already because '+' doesn't give the right result
 736     do_check_property(aTest, testURI, "pathQueryRef", function (aStr) {
 737       return aStr + aSuffix;
 738     });
 739     do_check_property(aTest, testURI, "ref", function () {
 740       return aSuffix.substr(1);
 741     });
 742   }
 743 }
 744
 745 // Tests various ways of setting & clearing a ref on a URI.
 746 function do_test_mutate_ref(aTest, aSuffix) {
 747   do_info("making sure caller is using suffix that starts with '#'");
 748   Assert.equal(aSuffix[0], "#");
 749
 750   var refURIWithSuffix = NetUtil.newURI(aTest.spec + aSuffix);
 751   var refURIWithoutSuffix = NetUtil.newURI(aTest.spec);
 752
 753   var testURI = NetUtil.newURI(aTest.spec);
 754
 755   // First: Try setting .ref to our suffix
 756   do_info(
 757     "testing that setting .ref on " +
 758       aTest.spec +
 759       " to '" +
 760       aSuffix +
 761       "' does what we expect"
 762   );
 763   testURI = testURI.mutate().setRef(aSuffix).finalize();
 764   do_check_uri_eq(testURI, refURIWithSuffix);
 765   do_check_uri_eqExceptRef(testURI, refURIWithoutSuffix);
 766
 767   // Now try setting .ref but leave off the initial hash (expect same result)
 768   var suffixLackingHash = aSuffix.substr(1);
 769   if (suffixLackingHash) {
 770     // (skip this our suffix was *just* a #)
 771     do_info(
 772       "testing that setting .ref on " +
 773         aTest.spec +
 774         " to '" +
 775         suffixLackingHash +
 776         "' does what we expect"
 777     );
 778     testURI = testURI.mutate().setRef(suffixLackingHash).finalize();
 779     do_check_uri_eq(testURI, refURIWithSuffix);
 780     do_check_uri_eqExceptRef(testURI, refURIWithoutSuffix);
 781   }
 782
 783   // Now, clear .ref (should get us back the original spec)
 784   do_info(
 785     "testing that clearing .ref on " + testURI.spec + " does what we expect"
 786   );
 787   testURI = testURI.mutate().setRef("").finalize();
 788   do_check_uri_eq(testURI, refURIWithoutSuffix);
 789   do_check_uri_eqExceptRef(testURI, refURIWithSuffix);
 790
 791   if (!aTest.relativeURI) {
 792     // TODO: These tests don't work as-is for relative URIs.
 793
 794     // Now try setting .spec directly (including suffix) and then clearing .ref
 795     var specWithSuffix = aTest.spec + aSuffix;
 796     do_info(
 797       "testing that setting spec to " +
 798         specWithSuffix +
 799         " and then clearing ref does what we expect"
 800     );
 801     testURI = testURI.mutate().setSpec(specWithSuffix).setRef("").finalize();
 802     do_check_uri_eq(testURI, refURIWithoutSuffix);
 803     do_check_uri_eqExceptRef(testURI, refURIWithSuffix);
 804
 805     // XXX nsIJARURI throws an exception in SetPath(), so skip it for next part.
 806     if (!(testURI instanceof Ci.nsIJARURI)) {
 807       // Now try setting .pathQueryRef directly (including suffix) and then clearing .ref
 808       // (same as above, but with now with .pathQueryRef instead of .spec)
 809       testURI = NetUtil.newURI(aTest.spec);
 810
 811       var pathWithSuffix = aTest.pathQueryRef + aSuffix;
 812       do_info(
 813         "testing that setting path to " +
 814           pathWithSuffix +
 815           " and then clearing ref does what we expect"
 816       );
 817       testURI = testURI
 818         .mutate()
 819         .setPathQueryRef(pathWithSuffix)
 820         .setRef("")
 821         .finalize();
 822       do_check_uri_eq(testURI, refURIWithoutSuffix);
 823       do_check_uri_eqExceptRef(testURI, refURIWithSuffix);
 824
 825       // Also: make sure that clearing .pathQueryRef also clears .ref
 826       testURI = testURI.mutate().setPathQueryRef(pathWithSuffix).finalize();
 827       do_info(
 828         "testing that clearing path from " +
 829           pathWithSuffix +
 830           " also clears .ref"
 831       );
 832       testURI = testURI.mutate().setPathQueryRef("").finalize();
 833       Assert.equal(testURI.ref, "");
 834     }
 835   }
 836 }
 837
 838 // TEST MAIN FUNCTION
 839 // ------------------
 840 function run_test() {
 841   // UTF-8 check - From bug 622981
 842   // ASCII
 843   let base = Services.io.newURI("http://example.org/xenia?");
 844   let resolved = Services.io.newURI("?x", null, base);
 845   let expected = Services.io.newURI("http://example.org/xenia?x");
 846   do_info(
 847     "Bug 662981: ACSII - comparing " + resolved.spec + " and " + expected.spec
 848   );
 849   Assert.ok(resolved.equals(expected));
 850
 851   // UTF-8 character "è"
 852   // Bug 622981 was triggered by an empty query string
 853   base = Services.io.newURI("http://example.org/xènia?");
 854   resolved = Services.io.newURI("?x", null, base);
 855   expected = Services.io.newURI("http://example.org/xènia?x");
 856   do_info(
 857     "Bug 662981: UTF8 - comparing " + resolved.spec + " and " + expected.spec
 858   );
 859   Assert.ok(resolved.equals(expected));
 860
 861   gTests.forEach(function (aTest) {
 862     // Check basic URI functionality
 863     do_test_uri_basic(aTest);
 864
 865     if (!aTest.fail) {
 866       // Try adding various #-prefixed strings to the ends of the URIs
 867       gHashSuffixes.forEach(function (aSuffix) {
 868         do_test_uri_with_hash_suffix(aTest, aSuffix);
 869         if (!aTest.immutable) {
 870           do_test_mutate_ref(aTest, aSuffix);
 871         }
 872       });
 873
 874       // For URIs that we couldn't mutate above due to them being immutable:
 875       // Now we check that they're actually immutable.
 876       if (aTest.immutable) {
 877         Assert.ok(aTest.immutable);
 878       }
 879     }
 880   });
 881 }