summaryrefslogtreecommitdiffstats
path: root/netwerk/test/unit/test_URIs.js
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /netwerk/test/unit/test_URIs.js
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'netwerk/test/unit/test_URIs.js')
-rw-r--r--netwerk/test/unit/test_URIs.js608
1 files changed, 608 insertions, 0 deletions
diff --git a/netwerk/test/unit/test_URIs.js b/netwerk/test/unit/test_URIs.js
new file mode 100644
index 000000000..b68c4f787
--- /dev/null
+++ b/netwerk/test/unit/test_URIs.js
@@ -0,0 +1,608 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+Components.utils.import("resource://gre/modules/NetUtil.jsm");
+
+var gIoService = Components.classes["@mozilla.org/network/io-service;1"]
+ .getService(Components.interfaces.nsIIOService);
+
+
+// Run by: cd objdir; make -C netwerk/test/ xpcshell-tests
+// or: cd objdir; make SOLO_FILE="test_URIs.js" -C netwerk/test/ check-one
+
+// See also test_URIs2.js.
+
+// Relevant RFCs: 1738, 1808, 2396, 3986 (newer than the code)
+// http://greenbytes.de/tech/webdav/rfc3986.html#rfc.section.5.4
+// http://greenbytes.de/tech/tc/uris/
+
+// TEST DATA
+// ---------
+var gTests = [
+ { spec: "about:blank",
+ scheme: "about",
+ prePath: "about:",
+ path: "blank",
+ ref: "",
+ nsIURL: false, nsINestedURI: true, immutable: true },
+ { spec: "about:foobar",
+ scheme: "about",
+ prePath: "about:",
+ path: "foobar",
+ ref: "",
+ nsIURL: false, nsINestedURI: false, immutable: true },
+ { spec: "chrome://foobar/somedir/somefile.xml",
+ scheme: "chrome",
+ prePath: "chrome://foobar",
+ path: "/somedir/somefile.xml",
+ ref: "",
+ nsIURL: true, nsINestedURI: false, immutable: true },
+ { spec: "data:text/html;charset=utf-8,<html></html>",
+ scheme: "data",
+ prePath: "data:",
+ path: "text/html;charset=utf-8,<html></html>",
+ ref: "",
+ nsIURL: false, nsINestedURI: false },
+ { spec: "data:text/html;charset=utf-8,<html>\r\n\t</html>",
+ scheme: "data",
+ prePath: "data:",
+ path: "text/html;charset=utf-8,<html></html>",
+ ref: "",
+ nsIURL: false, nsINestedURI: false },
+ { spec: "data:text/plain,hello world",
+ scheme: "data",
+ prePath: "data:",
+ path: "text/plain,hello%20world",
+ ref: "",
+ nsIURL: false, nsINestedURI: false },
+ { spec: "file:///dir/afile",
+ scheme: "data",
+ prePath: "data:",
+ path: "text/plain,2",
+ ref: "",
+ relativeURI: "data:te\nxt/plain,2",
+ nsIURL: false, nsINestedURI: false },
+ { spec: "file://",
+ scheme: "file",
+ prePath: "file://",
+ path: "/",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "file:///",
+ scheme: "file",
+ prePath: "file://",
+ path: "/",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "file:///myFile.html",
+ scheme: "file",
+ prePath: "file://",
+ path: "/myFile.html",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "file:///dir/afile",
+ scheme: "file",
+ prePath: "file://",
+ path: "/dir/data/text/plain,2",
+ ref: "",
+ relativeURI: "data/text/plain,2",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "file:///dir/dir2/",
+ scheme: "file",
+ prePath: "file://",
+ path: "/dir/dir2/data/text/plain,2",
+ ref: "",
+ relativeURI: "data/text/plain,2",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "ftp://",
+ scheme: "ftp",
+ prePath: "ftp://",
+ path: "/",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "ftp:///",
+ scheme: "ftp",
+ prePath: "ftp://",
+ path: "/",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "ftp://ftp.mozilla.org/pub/mozilla.org/README",
+ scheme: "ftp",
+ prePath: "ftp://ftp.mozilla.org",
+ path: "/pub/mozilla.org/README",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "ftp://foo:bar@ftp.mozilla.org:100/pub/mozilla.org/README",
+ scheme: "ftp",
+ prePath: "ftp://foo:bar@ftp.mozilla.org:100",
+ port: 100,
+ username: "foo",
+ password: "bar",
+ path: "/pub/mozilla.org/README",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "ftp://foo:@ftp.mozilla.org:100/pub/mozilla.org/README",
+ scheme: "ftp",
+ prePath: "ftp://foo:@ftp.mozilla.org:100",
+ port: 100,
+ username: "foo",
+ password: "",
+ path: "/pub/mozilla.org/README",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ //Bug 706249
+ { spec: "gopher://mozilla.org/",
+ scheme: "gopher",
+ prePath: "gopher:",
+ path: "//mozilla.org/",
+ ref: "",
+ nsIURL: false, nsINestedURI: false },
+ { spec: "http://",
+ scheme: "http",
+ prePath: "http://",
+ path: "/",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "http:///",
+ scheme: "http",
+ prePath: "http://",
+ path: "/",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "http://www.example.com/",
+ scheme: "http",
+ prePath: "http://www.example.com",
+ path: "/",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "http://www.exa\nmple.com/",
+ scheme: "http",
+ prePath: "http://www.example.com",
+ path: "/",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "http://10.32.4.239/",
+ scheme: "http",
+ prePath: "http://10.32.4.239",
+ host: "10.32.4.239",
+ path: "/",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "http://[::192.9.5.5]/ipng",
+ scheme: "http",
+ prePath: "http://[::192.9.5.5]",
+ host: "::192.9.5.5",
+ path: "/ipng",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:8888/index.html",
+ scheme: "http",
+ prePath: "http://[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:8888",
+ host: "fedc:ba98:7654:3210:fedc:ba98:7654:3210",
+ port: 8888,
+ path: "/index.html",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "http://bar:foo@www.mozilla.org:8080/pub/mozilla.org/README.html",
+ scheme: "http",
+ prePath: "http://bar:foo@www.mozilla.org:8080",
+ port: 8080,
+ username: "bar",
+ password: "foo",
+ host: "www.mozilla.org",
+ path: "/pub/mozilla.org/README.html",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "jar:resource://!/",
+ scheme: "jar",
+ prePath: "jar:",
+ path: "resource:///!/",
+ ref: "",
+ nsIURL: true, nsINestedURI: true },
+ { spec: "jar:resource://gre/chrome.toolkit.jar!/",
+ scheme: "jar",
+ prePath: "jar:",
+ path: "resource://gre/chrome.toolkit.jar!/",
+ ref: "",
+ nsIURL: true, nsINestedURI: true },
+ { spec: "mailto:webmaster@mozilla.com",
+ scheme: "mailto",
+ prePath: "mailto:",
+ path: "webmaster@mozilla.com",
+ ref: "",
+ nsIURL: false, nsINestedURI: false },
+ { spec: "javascript:new Date()",
+ scheme: "javascript",
+ prePath: "javascript:",
+ path: "new%20Date()",
+ ref: "",
+ nsIURL: false, nsINestedURI: false },
+ { spec: "blob:123456",
+ scheme: "blob",
+ prePath: "blob:",
+ path: "123456",
+ ref: "",
+ nsIURL: false, nsINestedURI: false, immutable: true },
+ { spec: "place:sort=8&maxResults=10",
+ scheme: "place",
+ prePath: "place:",
+ path: "sort=8&maxResults=10",
+ ref: "",
+ nsIURL: false, nsINestedURI: false },
+ { spec: "resource://gre/",
+ scheme: "resource",
+ prePath: "resource://gre",
+ path: "/",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+ { spec: "resource://gre/components/",
+ scheme: "resource",
+ prePath: "resource://gre",
+ path: "/components/",
+ ref: "",
+ nsIURL: true, nsINestedURI: false },
+
+ // Adding more? Consider adding to test_URIs2.js instead, so that neither
+ // test runs for *too* long, risking timeouts on slow platforms.
+];
+
+var gHashSuffixes = [
+ "#",
+ "#myRef",
+ "#myRef?a=b",
+ "#myRef#",
+ "#myRef#x:yz"
+];
+
+// TEST HELPER FUNCTIONS
+// ---------------------
+function do_info(text, stack) {
+ if (!stack)
+ stack = Components.stack.caller;
+
+ dump( "\n" +
+ "TEST-INFO | " + stack.filename + " | [" + stack.name + " : " +
+ stack.lineNumber + "] " + text + "\n");
+}
+
+// Checks that the URIs satisfy equals(), in both possible orderings.
+// Also checks URI.equalsExceptRef(), because equal URIs should also be equal
+// when we ignore the ref.
+//
+// The third argument is optional. If the client passes a third argument
+// (e.g. todo_check_true), we'll use that in lieu of do_check_true.
+function do_check_uri_eq(aURI1, aURI2, aCheckTrueFunc) {
+ if (!aCheckTrueFunc) {
+ aCheckTrueFunc = do_check_true;
+ }
+
+ do_info("(uri equals check: '" + aURI1.spec + "' == '" + aURI2.spec + "')");
+ aCheckTrueFunc(aURI1.equals(aURI2));
+ do_info("(uri equals check: '" + aURI2.spec + "' == '" + aURI1.spec + "')");
+ aCheckTrueFunc(aURI2.equals(aURI1));
+
+ // (Only take the extra step of testing 'equalsExceptRef' when we expect the
+ // URIs to really be equal. In 'todo' cases, the URIs may or may not be
+ // equal when refs are ignored - there's no way of knowing in general.)
+ if (aCheckTrueFunc == do_check_true) {
+ do_check_uri_eqExceptRef(aURI1, aURI2, aCheckTrueFunc);
+ }
+}
+
+// Checks that the URIs satisfy equalsExceptRef(), in both possible orderings.
+//
+// The third argument is optional. If the client passes a third argument
+// (e.g. todo_check_true), we'll use that in lieu of do_check_true.
+function do_check_uri_eqExceptRef(aURI1, aURI2, aCheckTrueFunc) {
+ if (!aCheckTrueFunc) {
+ aCheckTrueFunc = do_check_true;
+ }
+
+ do_info("(uri equalsExceptRef check: '" +
+ aURI1.spec + "' == '" + aURI2.spec + "')");
+ aCheckTrueFunc(aURI1.equalsExceptRef(aURI2));
+ do_info("(uri equalsExceptRef check: '" +
+ aURI2.spec + "' == '" + aURI1.spec + "')");
+ aCheckTrueFunc(aURI2.equalsExceptRef(aURI1));
+}
+
+// Checks that the given property on aURI matches the corresponding property
+// in the test bundle (or matches some function of that corresponding property,
+// if aTestFunctor is passed in).
+function do_check_property(aTest, aURI, aPropertyName, aTestFunctor) {
+ if (aTest[aPropertyName]) {
+ var expectedVal = aTestFunctor ?
+ aTestFunctor(aTest[aPropertyName]) :
+ aTest[aPropertyName];
+
+ do_info("testing " + aPropertyName + " of " +
+ (aTestFunctor ? "modified '" : "'" ) + aTest.spec +
+ "' is '" + expectedVal + "'");
+ do_check_eq(aURI[aPropertyName], expectedVal);
+ }
+}
+
+// Test that a given URI parses correctly into its various components.
+function do_test_uri_basic(aTest) {
+ var URI;
+
+ do_info("Basic tests for " + aTest.spec + " relative URI: " + aTest.relativeURI);
+
+ try {
+ URI = NetUtil.newURI(aTest.spec);
+ } catch(e) {
+ do_info("Caught error on parse of" + aTest.spec + " Error: " + e.result);
+ if (aTest.fail) {
+ do_check_eq(e.result, aTest.result);
+ return;
+ }
+ do_throw(e.result);
+ }
+
+ if (aTest.relativeURI) {
+ var relURI;
+
+ try {
+ relURI = gIoService.newURI(aTest.relativeURI, null, URI);
+ } catch (e) {
+ do_info("Caught error on Relative parse of " + aTest.spec + " + " + aTest.relativeURI +" Error: " + e.result);
+ if (aTest.relativeFail) {
+ do_check_eq(e.result, aTest.relativeFail);
+ return;
+ }
+ do_throw(e.result);
+ }
+ do_info("relURI.path = " + relURI.path + ", was " + URI.path);
+ URI = relURI;
+ do_info("URI.path now = " + URI.path);
+ }
+
+ // Sanity-check
+ do_info("testing " + aTest.spec + " equals a clone of itself");
+ do_check_uri_eq(URI, URI.clone());
+ do_check_uri_eqExceptRef(URI, URI.cloneIgnoringRef());
+ do_info("testing " + aTest.spec + " instanceof nsIURL");
+ do_check_eq(URI instanceof Ci.nsIURL, aTest.nsIURL);
+ do_info("testing " + aTest.spec + " instanceof nsINestedURI");
+ do_check_eq(URI instanceof Ci.nsINestedURI,
+ aTest.nsINestedURI);
+
+ do_info("testing that " + aTest.spec + " throws or returns false " +
+ "from equals(null)");
+ // XXXdholbert At some point it'd probably be worth making this behavior
+ // (throwing vs. returning false) consistent across URI implementations.
+ var threw = false;
+ var isEqualToNull;
+ try {
+ isEqualToNull = URI.equals(null);
+ } catch(e) {
+ threw = true;
+ }
+ do_check_true(threw || !isEqualToNull);
+
+
+ // Check the various components
+ do_check_property(aTest, URI, "scheme");
+ do_check_property(aTest, URI, "prePath");
+ do_check_property(aTest, URI, "path");
+ do_check_property(aTest, URI, "ref");
+ do_check_property(aTest, URI, "port");
+ do_check_property(aTest, URI, "username");
+ do_check_property(aTest, URI, "password");
+ do_check_property(aTest, URI, "host");
+ do_check_property(aTest, URI, "specIgnoringRef");
+ if ("hasRef" in aTest) {
+ do_info("testing hasref: " + aTest.hasRef + " vs " + URI.hasRef);
+ do_check_eq(aTest.hasRef, URI.hasRef);
+ }
+}
+
+// Test that a given URI parses correctly when we add a given ref to the end
+function do_test_uri_with_hash_suffix(aTest, aSuffix) {
+ do_info("making sure caller is using suffix that starts with '#'");
+ do_check_eq(aSuffix[0], "#");
+
+ var origURI = NetUtil.newURI(aTest.spec);
+ var testURI;
+
+ if (aTest.relativeURI) {
+ try {
+ origURI = gIoService.newURI(aTest.relativeURI, null, origURI);
+ } catch (e) {
+ do_info("Caught error on Relative parse of " + aTest.spec + " + " + aTest.relativeURI +" Error: " + e.result);
+ return;
+ }
+ try {
+ testURI = gIoService.newURI(aSuffix, null, origURI);
+ } catch (e) {
+ do_info("Caught error adding suffix to " + aTest.spec + " + " + aTest.relativeURI + ", suffix " + aSuffix + " Error: " + e.result);
+ return;
+ }
+ } else {
+ testURI = NetUtil.newURI(aTest.spec + aSuffix);
+ }
+
+ do_info("testing " + aTest.spec + " with '" + aSuffix + "' appended " +
+ "equals a clone of itself");
+ do_check_uri_eq(testURI, testURI.clone());
+
+ do_info("testing " + aTest.spec +
+ " doesn't equal self with '" + aSuffix + "' appended");
+
+ do_check_false(origURI.equals(testURI));
+
+ do_info("testing " + aTest.spec +
+ " is equalExceptRef to self with '" + aSuffix + "' appended");
+ do_check_uri_eqExceptRef(origURI, testURI);
+
+ do_check_eq(testURI.hasRef, true);
+
+ if (!origURI.ref) {
+ // These tests fail if origURI has a ref
+ do_info("testing cloneIgnoringRef on " + testURI.spec +
+ " is equal to no-ref version but not equal to ref version");
+ var cloneNoRef = testURI.cloneIgnoringRef();
+ do_check_uri_eq(cloneNoRef, origURI);
+ do_check_false(cloneNoRef.equals(testURI));
+
+ do_info("testing cloneWithNewRef on " + testURI.spec +
+ " with an empty ref is equal to no-ref version but not equal to ref version");
+ var cloneNewRef = testURI.cloneWithNewRef("");
+ do_check_uri_eq(cloneNewRef, origURI);
+ do_check_uri_eq(cloneNewRef, cloneNoRef);
+ do_check_false(cloneNewRef.equals(testURI));
+
+ do_info("testing cloneWithNewRef on " + origURI.spec +
+ " with the same new ref is equal to ref version and not equal to no-ref version");
+ cloneNewRef = origURI.cloneWithNewRef(aSuffix);
+ do_check_uri_eq(cloneNewRef, testURI);
+ do_check_true(cloneNewRef.equals(testURI));
+ }
+
+ do_check_property(aTest, testURI, "scheme");
+ do_check_property(aTest, testURI, "prePath");
+ if (!origURI.ref) {
+ // These don't work if it's a ref already because '+' doesn't give the right result
+ do_check_property(aTest, testURI, "path",
+ function(aStr) { return aStr + aSuffix; });
+ do_check_property(aTest, testURI, "ref",
+ function(aStr) { return aSuffix.substr(1); });
+ }
+}
+
+// Tests various ways of setting & clearing a ref on a URI.
+function do_test_mutate_ref(aTest, aSuffix) {
+ do_info("making sure caller is using suffix that starts with '#'");
+ do_check_eq(aSuffix[0], "#");
+
+ var refURIWithSuffix = NetUtil.newURI(aTest.spec + aSuffix);
+ var refURIWithoutSuffix = NetUtil.newURI(aTest.spec);
+
+ var testURI = NetUtil.newURI(aTest.spec);
+
+ // First: Try setting .ref to our suffix
+ do_info("testing that setting .ref on " + aTest.spec +
+ " to '" + aSuffix + "' does what we expect");
+ testURI.ref = aSuffix;
+ do_check_uri_eq(testURI, refURIWithSuffix);
+ do_check_uri_eqExceptRef(testURI, refURIWithoutSuffix);
+
+ // Now try setting .ref but leave off the initial hash (expect same result)
+ var suffixLackingHash = aSuffix.substr(1);
+ if (suffixLackingHash) { // (skip this our suffix was *just* a #)
+ do_info("testing that setting .ref on " + aTest.spec +
+ " to '" + suffixLackingHash + "' does what we expect");
+ testURI.ref = suffixLackingHash;
+ do_check_uri_eq(testURI, refURIWithSuffix);
+ do_check_uri_eqExceptRef(testURI, refURIWithoutSuffix);
+ }
+
+ // Now, clear .ref (should get us back the original spec)
+ do_info("testing that clearing .ref on " + testURI.spec +
+ " does what we expect");
+ testURI.ref = "";
+ do_check_uri_eq(testURI, refURIWithoutSuffix);
+ do_check_uri_eqExceptRef(testURI, refURIWithSuffix);
+
+ if (!aTest.relativeURI) {
+ // TODO: These tests don't work as-is for relative URIs.
+
+ // Now try setting .spec directly (including suffix) and then clearing .ref
+ var specWithSuffix = aTest.spec + aSuffix;
+ do_info("testing that setting spec to " +
+ specWithSuffix + " and then clearing ref does what we expect");
+ testURI.spec = specWithSuffix;
+ testURI.ref = "";
+ do_check_uri_eq(testURI, refURIWithoutSuffix);
+ do_check_uri_eqExceptRef(testURI, refURIWithSuffix);
+
+ // XXX nsIJARURI throws an exception in SetPath(), so skip it for next part.
+ if (!(testURI instanceof Ci.nsIJARURI)) {
+ // Now try setting .path directly (including suffix) and then clearing .ref
+ // (same as above, but with now with .path instead of .spec)
+ testURI = NetUtil.newURI(aTest.spec);
+
+ var pathWithSuffix = aTest.path + aSuffix;
+ do_info("testing that setting path to " +
+ pathWithSuffix + " and then clearing ref does what we expect");
+ testURI.path = pathWithSuffix;
+ testURI.ref = "";
+ do_check_uri_eq(testURI, refURIWithoutSuffix);
+ do_check_uri_eqExceptRef(testURI, refURIWithSuffix);
+
+ // Also: make sure that clearing .path also clears .ref
+ testURI.path = pathWithSuffix;
+ do_info("testing that clearing path from " +
+ pathWithSuffix + " also clears .ref");
+ testURI.path = "";
+ do_check_eq(testURI.ref, "");
+ }
+ }
+}
+
+// Tests that normally-mutable properties can't be modified on
+// special URIs that are known to be immutable.
+function do_test_immutable(aTest) {
+ do_check_true(aTest.immutable);
+
+ var URI = NetUtil.newURI(aTest.spec);
+ // All the non-readonly attributes on nsIURI.idl:
+ var propertiesToCheck = ["spec", "scheme", "userPass", "username", "password",
+ "hostPort", "host", "port", "path", "ref"];
+
+ propertiesToCheck.forEach(function(aProperty) {
+ var threw = false;
+ try {
+ URI[aProperty] = "anothervalue";
+ } catch(e) {
+ threw = true;
+ }
+
+ do_info("testing that setting '" + aProperty +
+ "' on immutable URI '" + aTest.spec + "' will throw");
+ do_check_true(threw);
+ });
+}
+
+
+// TEST MAIN FUNCTION
+// ------------------
+function run_test()
+{
+ // UTF-8 check - From bug 622981
+ // ASCII
+ let base = gIoService.newURI("http://example.org/xenia?", null, null);
+ let resolved = gIoService.newURI("?x", null, base);
+ let expected = gIoService.newURI("http://example.org/xenia?x",
+ null, null);
+ do_info("Bug 662981: ACSII - comparing " + resolved.spec + " and " + expected.spec);
+ do_check_true(resolved.equals(expected));
+
+ // UTF-8 character "è"
+ // Bug 622981 was triggered by an empty query string
+ base = gIoService.newURI("http://example.org/xènia?", null, null);
+ resolved = gIoService.newURI("?x", null, base);
+ expected = gIoService.newURI("http://example.org/xènia?x",
+ null, null);
+ do_info("Bug 662981: UTF8 - comparing " + resolved.spec + " and " + expected.spec);
+ do_check_true(resolved.equals(expected));
+
+ gTests.forEach(function(aTest) {
+ // Check basic URI functionality
+ do_test_uri_basic(aTest);
+
+ if (!aTest.fail) {
+ // Try adding various #-prefixed strings to the ends of the URIs
+ gHashSuffixes.forEach(function(aSuffix) {
+ do_test_uri_with_hash_suffix(aTest, aSuffix);
+ if (!aTest.immutable) {
+ do_test_mutate_ref(aTest, aSuffix);
+ }
+ });
+
+ // For URIs that we couldn't mutate above due to them being immutable:
+ // Now we check that they're actually immutable.
+ if (aTest.immutable) {
+ do_test_immutable(aTest);
+ }
+ }
+ });
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 21:30:25 +0000