mozilla-central/netwerk/test/unit/test_standardurl.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info:

"use strict";
const gPrefs = Services.prefs;
function symmetricEquality(expect, a, b) {
/* Use if/else instead of |do_check_eq(expect, a.spec == b.spec)| so
that we get the specs output on the console if the check fails.
*/
if (expect) {
/* Check all the sub-pieces too, since that can help with
debugging cases when equals() returns something unexpected */
/* We don't check port in the loop, because it can be defaulted in
some cases. */
[
"spec",
"prePath",
"scheme",
"userPass",
"username",
"password",
"hostPort",
"host",
"pathQueryRef",
"filePath",
"query",
"ref",
"directory",
"fileName",
"fileBaseName",
"fileExtension",
].map(function (prop) {
dump("Testing '" + prop + "'\n");
Assert.equal(a[prop], b[prop]);
});
} else {
Assert.notEqual(a.spec, b.spec);
}
Assert.equal(expect, a.equals(b));
Assert.equal(expect, b.equals(a));
}
function stringToURL(str) {
return Cc["@mozilla.org/network/standard-url-mutator;1"]
.createInstance(Ci.nsIStandardURLMutator)
.init(Ci.nsIStandardURL.URLTYPE_AUTHORITY, 80, str, "UTF-8", null)
.finalize()
.QueryInterface(Ci.nsIURL);
}
function pairToURLs(pair) {
Assert.equal(pair.length, 2);
return pair.map(stringToURL);
}
add_test(function test_setEmptyPath() {
var pairs = [
].map(pairToURLs);
for (var [provided, target] of pairs) {
symmetricEquality(false, target, provided);
provided = provided.mutate().setPathQueryRef("").finalize();
target = target.mutate().setPathQueryRef("").finalize();
Assert.equal(provided.spec, target.spec);
symmetricEquality(true, target, provided);
}
run_next_test();
});
add_test(function test_setQuery() {
var pairs = [
/* And one that's nonempty but shorter than "foo" */
].map(pairToURLs);
for (var [provided, target] of pairs) {
symmetricEquality(false, provided, target);
provided = provided
.mutate()
.setQuery("foo")
.finalize()
.QueryInterface(Ci.nsIURL);
Assert.equal(provided.spec, target.spec);
symmetricEquality(true, provided, target);
}
[provided, target] = [
].map(stringToURL);
symmetricEquality(false, provided, target);
provided = provided
.mutate()
.setQuery("foo")
.finalize()
.QueryInterface(Ci.nsIURL);
symmetricEquality(false, provided, target);
var newProvided = Services.io
.newURI("#bar", null, provided)
.QueryInterface(Ci.nsIURL);
Assert.equal(newProvided.spec, target.spec);
symmetricEquality(true, newProvided, target);
run_next_test();
});
add_test(function test_setRef() {
var tests = [
[
"xxxxxxxxxxxxxx",
],
[
"xxxxxxxxxxxxxx",
],
[
"xxxxxxxxxxxxxx",
],
[
"xxxxxxxxxxxxxx",
],
[
"xxxxxxxxxxxxxx",
],
[
"xxxxxxxxxxxxxx",
],
];
for (var [before, ref, result] of tests) {
/* Test1: starting with empty ref */
var a = stringToURL(before);
a = a.mutate().setRef(ref).finalize().QueryInterface(Ci.nsIURL);
var b = stringToURL(result);
Assert.equal(a.spec, b.spec);
Assert.equal(ref, b.ref);
symmetricEquality(true, a, b);
/* Test2: starting with non-empty */
a = a.mutate().setRef("yyyy").finalize().QueryInterface(Ci.nsIURL);
var c = stringToURL(before);
c = c.mutate().setRef("yyyy").finalize().QueryInterface(Ci.nsIURL);
symmetricEquality(true, a, c);
/* Test3: reset the ref */
a = a.mutate().setRef("").finalize().QueryInterface(Ci.nsIURL);
symmetricEquality(true, a, stringToURL(before));
/* Test4: verify again after reset */
a = a.mutate().setRef(ref).finalize().QueryInterface(Ci.nsIURL);
symmetricEquality(true, a, b);
}
run_next_test();
});
// Bug 960014 - Make nsStandardURL::SetHost less magical around IPv6
add_test(function test_ipv6() {
var url = stringToURL("http://example.com");
url = url.mutate().setHost("[2001::1]").finalize();
Assert.equal(url.host, "2001::1");
url = stringToURL("http://example.com");
url = url.mutate().setHostPort("[2001::1]:30").finalize();
Assert.equal(url.host, "2001::1");
Assert.equal(url.port, 30);
Assert.equal(url.hostPort, "[2001::1]:30");
url = stringToURL("http://example.com");
url = url.mutate().setHostPort("2001:1").finalize();
Assert.equal(url.host, "0.0.7.209");
Assert.equal(url.port, 1);
Assert.equal(url.hostPort, "0.0.7.209:1");
run_next_test();
});
add_test(function test_ipv6_fail() {
var url = stringToURL("http://example.com");
Assert.throws(
() => {
url = url.mutate().setHost("2001::1").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"missing brackets"
);
Assert.throws(
() => {
url = url.mutate().setHost("[2001::1]:20").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"url.host with port"
);
Assert.throws(
() => {
url = url.mutate().setHost("[2001::1").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"missing last bracket"
);
Assert.throws(
() => {
url = url.mutate().setHost("2001::1]").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"missing first bracket"
);
Assert.throws(
() => {
url = url.mutate().setHost("2001[::1]").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"bad bracket position"
);
Assert.throws(
() => {
url = url.mutate().setHost("[]").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"empty IPv6 address"
);
Assert.throws(
() => {
url = url.mutate().setHost("[hello]").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"bad IPv6 address"
);
Assert.throws(
() => {
url = url.mutate().setHost("[192.168.1.1]").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"bad IPv6 address"
);
Assert.throws(
() => {
url = url.mutate().setHostPort("2001::1").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"missing brackets"
);
Assert.throws(
() => {
url = url.mutate().setHostPort("[2001::1]30").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"missing : after IP"
);
Assert.throws(
() => {
url = url.mutate().setHostPort("[2001:1]").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"bad IPv6 address"
);
Assert.throws(
() => {
url = url.mutate().setHostPort("[2001:1]10").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"bad IPv6 address"
);
Assert.throws(
() => {
url = url.mutate().setHostPort("[2001:1]10:20").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"bad IPv6 address"
);
Assert.throws(
() => {
url = url.mutate().setHostPort("[2001:1]:10:20").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"bad IPv6 address"
);
Assert.throws(
() => {
url = url.mutate().setHostPort("[2001:1").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"bad IPv6 address"
);
Assert.throws(
() => {
url = url.mutate().setHostPort("2001]:1").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"bad IPv6 address"
);
Assert.throws(
() => {
url = url.mutate().setHostPort("2001:1]").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"bad IPv6 address"
);
Assert.throws(
() => {
url = url.mutate().setHostPort("").finalize();
},
/NS_ERROR_UNEXPECTED/,
"Empty hostPort should fail"
);
// These checks used to fail, but now don't (see bug 1433958 comment 57)
url = url.mutate().setHostPort("[2001::1]:").finalize();
Assert.equal(url.spec, "http://[2001::1]/");
url = url.mutate().setHostPort("[2002::1]:bad").finalize();
Assert.equal(url.spec, "http://[2002::1]/");
run_next_test();
});
add_test(function test_clearedSpec() {
var url = stringToURL("http://example.com/path");
Assert.throws(
() => {
url = url.mutate().setSpec("http: example").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"set bad spec"
);
Assert.throws(
() => {
url = url.mutate().setSpec("").finalize();
},
/NS_ERROR_MALFORMED_URI/,
"set empty spec"
);
Assert.equal(url.spec, "http://example.com/path");
url = url
.mutate()
.setHost("allizom.org")
.finalize()
.QueryInterface(Ci.nsIURL);
var ref = stringToURL("http://allizom.org/path");
symmetricEquality(true, url, ref);
run_next_test();
});
add_test(function test_escapeBrackets() {
// Query
var url = stringToURL("http://example.com/?a[x]=1");
Assert.equal(url.spec, "http://example.com/?a[x]=1");
url = stringToURL("http://example.com/?a%5Bx%5D=1");
Assert.equal(url.spec, "http://example.com/?a%5Bx%5D=1");
url = stringToURL("http://[2001::1]/?a[x]=1");
Assert.equal(url.spec, "http://[2001::1]/?a[x]=1");
url = stringToURL("http://[2001::1]/?a%5Bx%5D=1");
Assert.equal(url.spec, "http://[2001::1]/?a%5Bx%5D=1");
// Path
url = stringToURL("http://example.com/brackets[x]/test");
Assert.equal(url.spec, "http://example.com/brackets[x]/test");
url = stringToURL("http://example.com/a%5Bx%5D/test");
Assert.equal(url.spec, "http://example.com/a%5Bx%5D/test");
run_next_test();
});
add_test(function test_escapeQuote() {
var url = stringToURL("http://example.com/#'");
Assert.equal(url.spec, "http://example.com/#'");
Assert.equal(url.ref, "'");
url = url.mutate().setRef("test'test").finalize();
Assert.equal(url.spec, "http://example.com/#test'test");
Assert.equal(url.ref, "test'test");
run_next_test();
});
add_test(function test_apostropheEncoding() {
// For now, single quote is escaped everywhere _except_ the path.
// This policy is controlled by the bitmask in nsEscape.cpp::EscapeChars[]
var url = stringToURL("http://example.com/dir'/file'.ext'");
Assert.equal(url.spec, "http://example.com/dir'/file'.ext'");
run_next_test();
});
add_test(function test_accentEncoding() {
var url = stringToURL("http://example.com/?hello=`");
Assert.equal(url.spec, "http://example.com/?hello=`");
Assert.equal(url.query, "hello=`");
url = stringToURL("http://example.com/?hello=%2C");
Assert.equal(url.spec, "http://example.com/?hello=%2C");
Assert.equal(url.query, "hello=%2C");
run_next_test();
});
add_test(
{ skip_if: () => AppConstants.MOZ_APP_NAME == "thunderbird" },
function test_percentDecoding() {
var url = stringToURL("http://%70%61%73%74%65%62%69%6E.com");
Assert.equal(url.spec, "http://pastebin.com/");
// Disallowed hostname characters are rejected even when percent encoded
Assert.throws(
() => {
url = stringToURL("http://example.com%0a%23.google.com/");
},
/NS_ERROR_MALFORMED_URI/,
"invalid characters are not allowed"
);
run_next_test();
}
);
add_test(function test_hugeStringThrows() {
let prefs = Services.prefs;
let maxLen = prefs.getIntPref("network.standard-url.max-length");
let url = stringToURL("http://test:test@example.com");
let hugeString = new Array(maxLen + 1).fill("a").join("");
let setters = [
{ method: "setSpec", qi: Ci.nsIURIMutator },
{ method: "setUsername", qi: Ci.nsIURIMutator },
{ method: "setPassword", qi: Ci.nsIURIMutator },
{ method: "setFilePath", qi: Ci.nsIURIMutator },
{ method: "setHostPort", qi: Ci.nsIURIMutator },
{ method: "setHost", qi: Ci.nsIURIMutator },
{ method: "setUserPass", qi: Ci.nsIURIMutator },
{ method: "setPathQueryRef", qi: Ci.nsIURIMutator },
{ method: "setQuery", qi: Ci.nsIURIMutator },
{ method: "setRef", qi: Ci.nsIURIMutator },
{ method: "setScheme", qi: Ci.nsIURIMutator },
{ method: "setFileName", qi: Ci.nsIURLMutator },
{ method: "setFileExtension", qi: Ci.nsIURLMutator },
{ method: "setFileBaseName", qi: Ci.nsIURLMutator },
];
for (let prop of setters) {
Assert.throws(
() =>
(url = url
.mutate()
.QueryInterface(prop.qi)
[prop.method](hugeString)
.finalize()),
/NS_ERROR_MALFORMED_URI/,
`Passing a huge string to "${prop.method}" should throw`
);
}
run_next_test();
});
add_test(function test_filterWhitespace() {
let url = stringToURL(
" \r\n\th\nt\rt\tp://ex\r\n\tample.com/path\r\n\t/\r\n\tto the/fil\r\n\te.e\r\n\txt?que\r\n\try#ha\r\n\tsh \r\n\t "
);
Assert.equal(
url.spec,
);
// These setters should filter \r\n\t.
url = stringToURL("http://test.com/path?query#hash");
url = url.mutate().setFilePath("pa\r\n\tth").finalize();
Assert.equal(url.spec, "http://test.com/path?query#hash");
url = url.mutate().setQuery("que\r\n\try").finalize();
Assert.equal(url.spec, "http://test.com/path?query#hash");
url = url.mutate().setRef("ha\r\n\tsh").finalize();
Assert.equal(url.spec, "http://test.com/path?query#hash");
url = url
.mutate()
.QueryInterface(Ci.nsIURLMutator)
.setFileName("fi\r\n\tle.name")
.finalize();
run_next_test();
});
add_test(function test_backslashReplacement() {
var url = stringToURL(
"http:\\\\test.com\\path/to\\file?query\\backslash#hash\\"
);
Assert.equal(
url.spec,
);
url = stringToURL("http:\\\\test.com\\example.org/path\\to/file");
Assert.equal(url.spec, "http://test.com/example.org/path/to/file");
Assert.equal(url.host, "test.com");
Assert.equal(url.pathQueryRef, "/example.org/path/to/file");
run_next_test();
});
add_test(function test_authority_host() {
Assert.throws(
() => {
stringToURL("http:");
},
/NS_ERROR_MALFORMED_URI/,
"TYPE_AUTHORITY should have host"
);
Assert.throws(
() => {
stringToURL("http:///");
},
/NS_ERROR_MALFORMED_URI/,
"TYPE_AUTHORITY should have host"
);
run_next_test();
});
add_test(function test_trim_C0_and_space() {
var url = stringToURL(
"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f http://example.com/ \x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f "
);
Assert.equal(url.spec, "http://example.com/");
url = url
.mutate()
.setSpec(
"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f http://test.com/ \x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f "
)
.finalize();
Assert.equal(url.spec, "http://test.com/");
Assert.throws(
() => {
url = url
.mutate()
.setSpec(
"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19 "
)
.finalize();
},
/NS_ERROR_MALFORMED_URI/,
"set empty spec"
);
run_next_test();
});
// This tests that C0-and-space characters in the path, query and ref are
// percent encoded.
add_test(function test_encode_C0_and_space() {
function toHex(d) {
var hex = d.toString(16);
if (hex.length == 1) {
hex = "0" + hex;
}
return hex.toUpperCase();
}
for (var i = 0x0; i <= 0x20; i++) {
// These characters get filtered - they are not encoded.
if (
String.fromCharCode(i) == "\r" ||
String.fromCharCode(i) == "\n" ||
String.fromCharCode(i) == "\t"
) {
continue;
}
let url = stringToURL(
String.fromCharCode(i) +
"th?qu" +
String.fromCharCode(i) +
"ery#ha" +
String.fromCharCode(i) +
"sh"
);
Assert.equal(
url.spec,
toHex(i) +
"th?qu%" +
toHex(i) +
"ery#ha%" +
toHex(i) +
"sh"
);
}
// Additionally, we need to check the setters.
let url = stringToURL("http://example.com/path?query#hash");
url = url.mutate().setFilePath("pa\0th").finalize();
Assert.equal(url.spec, "http://example.com/pa%00th?query#hash");
url = url.mutate().setQuery("qu\0ery").finalize();
Assert.equal(url.spec, "http://example.com/pa%00th?qu%00ery#hash");
url = url.mutate().setRef("ha\0sh").finalize();
Assert.equal(url.spec, "http://example.com/pa%00th?qu%00ery#ha%00sh");
url = url
.mutate()
.QueryInterface(Ci.nsIURLMutator)
.setFileName("fi\0le.name")
.finalize();
run_next_test();
});
add_test(function test_ipv4Normalize() {
var localIPv4s = [
].map(stringToURL);
let url;
for (url of localIPv4s) {
Assert.equal(url.spec, "http://127.0.0.1/");
}
// These should treated as a domain instead of an IPv4.
var nonIPv4s = [
];
var spec;
for (spec of nonIPv4s) {
url = stringToURL(spec);
Assert.equal(url.spec, spec);
}
url = stringToURL("resource://path/to/resource/");
url = url.mutate().setHost("123").finalize();
Assert.equal(url.host, "123");
run_next_test();
});
add_test(function test_invalidHostChars() {
var url = stringToURL("http://example.org/");
for (let i = 0; i <= 0x20; i++) {
// These characters get filtered.
if (
String.fromCharCode(i) == "\r" ||
String.fromCharCode(i) == "\n" ||
String.fromCharCode(i) == "\t"
) {
continue;
}
Assert.throws(
() => {
url = url
.mutate()
.setHost("a" + String.fromCharCode(i) + "b")
.finalize();
},
/NS_ERROR_MALFORMED_URI/,
"Trying to set hostname containing char code: " + i
);
}
for (let c of '@[]*<>|:"') {
Assert.throws(
() => {
url = url
.mutate()
.setHost("a" + c)
.finalize();
},
/NS_ERROR_MALFORMED_URI/,
"Trying to set hostname containing char: " + c
);
}
// It also can't contain /, \, #, ?, but we treat these characters as
// hostname separators, so there is no way to set them and fail.
run_next_test();
});
add_test(function test_normalize_ipv6() {
var url = stringToURL("http://example.com");
url = url.mutate().setHost("[::192.9.5.5]").finalize();
Assert.equal(url.spec, "http://[::c009:505]/");
run_next_test();
});
add_test(function test_emptyPassword() {
var url = stringToURL("http://a:@example.com");
Assert.equal(url.spec, "http://a@example.com/");
url = url.mutate().setPassword("pp").finalize();
Assert.equal(url.spec, "http://a:pp@example.com/");
url = url.mutate().setPassword("").finalize();
Assert.equal(url.spec, "http://a@example.com/");
url = url.mutate().setUserPass("xxx:").finalize();
Assert.equal(url.spec, "http://xxx@example.com/");
url = url.mutate().setPassword("zzzz").finalize();
Assert.equal(url.spec, "http://xxx:zzzz@example.com/");
url = url.mutate().setUserPass("xxxxx:yyyyyy").finalize();
Assert.equal(url.spec, "http://xxxxx:yyyyyy@example.com/");
url = url.mutate().setUserPass("z:").finalize();
Assert.equal(url.spec, "http://z@example.com/");
url = url.mutate().setPassword("ppppppppppp").finalize();
Assert.equal(url.spec, "http://z:ppppppppppp@example.com/");
url = stringToURL("http://example.com");
url = url.mutate().setPassword("").finalize(); // Still empty. Should work.
Assert.equal(url.spec, "http://example.com/");
run_next_test();
});
add_test(function test_emptyUser() {
const kurl = stringToURL(
);
url = kurl.mutate().setUsername("").finalize();
Assert.equal(
url.spec,
);
Assert.equal(url.host, "example.com");
Assert.equal(url.hostPort, "example.com:8888");
Assert.equal(url.filePath, "/path/to/something");
Assert.equal(url.query, "query");
Assert.equal(url.ref, "hash");
url = kurl.mutate().setUserPass(":pass1").finalize();
Assert.equal(
url.spec,
);
Assert.equal(url.host, "example.com");
Assert.equal(url.hostPort, "example.com:8888");
Assert.equal(url.filePath, "/path/to/something");
Assert.equal(url.query, "query");
Assert.equal(url.ref, "hash");
url = url.mutate().setUsername("user2").finalize();
Assert.equal(
url.spec,
);
Assert.equal(url.host, "example.com");
url = url.mutate().setUserPass(":pass234").finalize();
Assert.equal(
url.spec,
);
Assert.equal(url.host, "example.com");
url = url.mutate().setUserPass("").finalize();
Assert.equal(
url.spec,
);
Assert.equal(url.host, "example.com");
url = url.mutate().setPassword("pa").finalize();
Assert.equal(
url.spec,
);
Assert.equal(url.host, "example.com");
url = url.mutate().setUserPass("user:pass").finalize();
symmetricEquality(true, url.QueryInterface(Ci.nsIURL), kurl);
url = url.mutate().setPassword("pass").finalize();
Assert.equal(
url.spec,
);
url = url.mutate().setUsername("").finalize();
Assert.equal(
url.spec,
);
url = stringToURL("http://example.com:8888");
url = url.mutate().setUsername("user").finalize();
url = url.mutate().setUsername("").finalize();
Assert.equal(url.spec, "http://example.com:8888/");
url = stringToURL("http://:pass@example.com");
Assert.equal(url.spec, "http://:pass@example.com/");
url = url.mutate().setPassword("").finalize();
Assert.equal(url.spec, "http://example.com/");
url = url.mutate().setUserPass("user:pass").finalize();
Assert.equal(url.spec, "http://user:pass@example.com/");
Assert.equal(url.host, "example.com");
url = url.mutate().setUserPass("u:p").finalize();
Assert.equal(url.spec, "http://u:p@example.com/");
Assert.equal(url.host, "example.com");
url = url.mutate().setUserPass("u1:p23").finalize();
Assert.equal(url.spec, "http://u1:p23@example.com/");
Assert.equal(url.host, "example.com");
url = url.mutate().setUsername("u").finalize();
Assert.equal(url.spec, "http://u:p23@example.com/");
Assert.equal(url.host, "example.com");
url = url.mutate().setPassword("p").finalize();
Assert.equal(url.spec, "http://u:p@example.com/");
Assert.equal(url.host, "example.com");
url = url.mutate().setUserPass("u2:p2").finalize();
Assert.equal(url.spec, "http://u2:p2@example.com/");
Assert.equal(url.host, "example.com");
url = url.mutate().setUserPass("u23:p23").finalize();
Assert.equal(url.spec, "http://u23:p23@example.com/");
Assert.equal(url.host, "example.com");
run_next_test();
});
registerCleanupFunction(function () {
gPrefs.clearUserPref("network.standard-url.punycode-host");
});
add_test(function test_idna_host() {
// See bug 945240 - this test makes sure that URLs return a punycode hostname
let url = stringToURL(
);
equal(url.host, "xn--lt-uia.example.org");
equal(url.hostPort, "xn--lt-uia.example.org:8080");
equal(
url.spec,
);
equal(
url.specIgnoringRef,
);
equal(
url
.QueryInterface(Ci.nsISensitiveInfoHiddenURI)
.getSensitiveInfoHiddenSpec(),
);
equal(url.displayHost, "ält.example.org");
equal(url.displayHostPort, "ält.example.org:8080");
equal(
url.displaySpec,
);
equal(url.asciiHost, "xn--lt-uia.example.org");
equal(url.asciiHostPort, "xn--lt-uia.example.org:8080");
equal(
url.asciiSpec,
);
url = url.mutate().setRef("").finalize(); // SetRef calls InvalidateCache()
equal(
url.spec,
);
equal(
url.displaySpec,
);
equal(
url.asciiSpec,
);
url = url.mutate().setRef("").finalize();
run_next_test();
});
add_test(
{ skip_if: () => AppConstants.MOZ_APP_NAME == "thunderbird" },
function test_bug1517025() {
Assert.throws(
() => {
stringToURL("https://b%9a/");
},
/NS_ERROR_MALFORMED_URI/,
"bad URI"
);
Assert.throws(
() => {
stringToURL("https://b%9ª/");
},
/NS_ERROR_MALFORMED_URI/,
"bad URI"
);
let base = stringToURL(
"https://bug1517025.bmoattachments.org/attachment.cgi?id=9033787"
);
Assert.throws(
() => {
Services.io.newURI("/\\b%9ª", "windows-1252", base);
},
/NS_ERROR_MALFORMED_URI/,
"bad URI"
);
run_next_test();
}
);
add_task(async function test_emptyHostWithURLType() {
let makeURL = (str, type) => {
return Cc["@mozilla.org/network/standard-url-mutator;1"]
.createInstance(Ci.nsIStandardURLMutator)
.init(type, 80, str, "UTF-8", null)
.finalize()
.QueryInterface(Ci.nsIURL);
};
let url = makeURL("http://foo.com/bar/", Ci.nsIStandardURL.URLTYPE_AUTHORITY);
Assert.throws(
() => url.mutate().setHost("").finalize().spec,
/NS_ERROR_UNEXPECTED/,
"Empty host is not allowed for URLTYPE_AUTHORITY"
);
url = makeURL("http://foo.com/bar/", Ci.nsIStandardURL.URLTYPE_STANDARD);
Assert.throws(
() => url.mutate().setHost("").finalize().spec,
/NS_ERROR_UNEXPECTED/,
"Empty host is not allowed for URLTYPE_STANDARD"
);
url = makeURL("http://foo.com/bar/", Ci.nsIStandardURL.URLTYPE_NO_AUTHORITY);
equal(
url.spec,
"Host is removed when parsing URLTYPE_NO_AUTHORITY"
);
equal(
url.mutate().setHost("").finalize().spec,
"Setting an empty host does nothing for URLTYPE_NO_AUTHORITY"
);
Assert.throws(
() => url.mutate().setHost("something").finalize().spec,
/NS_ERROR_UNEXPECTED/,
"Setting a non-empty host is not allowed for URLTYPE_NO_AUTHORITY"
);
equal(
url.mutate().setHost("#j").finalize().spec,
"Setting a pseudo-empty host does nothing for URLTYPE_NO_AUTHORITY"
);
url = makeURL(
Ci.nsIStandardURL.URLTYPE_AUTHORITY
);
Assert.throws(
() => url.mutate().setHost("#j").finalize().spec,
/NS_ERROR_UNEXPECTED/,
"A pseudo-empty host is not allowed for URLTYPE_AUTHORITY"
);
});
add_task(async function test_fuzz() {
let makeURL = str => {
return (
Cc["@mozilla.org/network/standard-url-mutator;1"]
.createInstance(Ci.nsIStandardURLMutator)
.QueryInterface(Ci.nsIURIMutator)
// .init(type, 80, str, "UTF-8", null)
.setSpec(str)
.finalize()
.QueryInterface(Ci.nsIURL)
);
};
Assert.throws(() => {
let url = makeURL("/");
url.mutate().setHost("(").finalize();
}, /NS_ERROR_MALFORMED_URI/);
});
add_task(async function test_bug1648493() {
let url = stringToURL("https://example.com/");
url = url.mutate().setScheme("file").finalize();
url = url.mutate().setScheme("resource").finalize();
url = url.mutate().setPassword("ê").finalize();
url = url.mutate().setUsername("ç").finalize();
url = url.mutate().setScheme("t").finalize();
equal(url.username, "%C3%83%C2%A7");
});
add_task(async function test_bug1873976() {
let url = Services.io.newURI("file:.");
equal(url.spec, "file:///");
});
add_task(async function test_bug1890346() {
let url = Services.io.newURI("file:..?/..");
equal(url.spec, "file:///?/..");
});