From 78d2d670d371854e83e4d00c8fd8a7330a2de8df Mon Sep 17 00:00:00 2001 From: ldm0 Date: Tue, 8 Sep 2026 09:34:30 +0800 Subject: [PATCH] fix(url): keep hierarchical paths distinct from authorities Apply scheme-specific slash handling to relative URL resolution: consume all special authority slashes, but retain non-special backslashes as path data. Share serialization-only path prefix adjustment across parsing and path mutation, preserve logical paths when adding or removing authorities, and keep host metadata and query/fragment offsets consistent. Distinguish empty authorities from missing hosts in pathname setters and remove the redundant Web API workaround. Add seven parser/mutation regressions and two cross-realm URL/DOM regressions. Remove only the seven upstream expected failures proven fixed; retain the original WPT data. Validation: cargo fmt --all; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo nextest run --no-fail-fast (17,624 passed, 13 skipped); upstream all-features unit/WPT/doctests. Focused CLI/CDP WPT agree across 50 cases: 48 additional passing subtests, no new failures. CDP smoke passes 42/43 groups; Puppeteer cannot start because node is missing, unchanged from baseline. --- .../src/script_vm/tests/url_components.rs | 71 ++++++++ moli-url/src/components.rs | 8 +- moli-url/src/hierarchical_path.rs | 168 ++++++++++++++++++ moli-url/src/lib.rs | 2 + vendor/url-2.5.8/MOLI-PATCHES.md | 38 +++- vendor/url-2.5.8/src/lib.rs | 26 ++- vendor/url-2.5.8/src/parser.rs | 97 +++++----- vendor/url-2.5.8/src/quirks.rs | 2 +- vendor/url-2.5.8/tests/expected_failures.txt | 7 - 9 files changed, 338 insertions(+), 81 deletions(-) create mode 100644 moli-url/src/hierarchical_path.rs diff --git a/moli-renderer-v8/src/script_vm/tests/url_components.rs b/moli-renderer-v8/src/script_vm/tests/url_components.rs index 90b46e58389..e0e1aa0631d 100644 --- a/moli-renderer-v8/src/script_vm/tests/url_components.rs +++ b/moli-renderer-v8/src/script_vm/tests/url_components.rs @@ -352,6 +352,77 @@ for (const tag of ['a', 'area']) { ); } +#[test] +fn url_hierarchical_path_mutations_keep_hosts_and_logical_paths_separate() { + assert_url_components( + r#" +for (const input of ['custom:/old?q#f', 'custom:/.//old?q#f']) { + for (const value of ['//p', '/.//p', '/..//p']) { + checkSetter(input, 'pathname', value, 'custom:/.//p?q#f'); + } + checkSetter(input, 'pathname', 'p', 'custom:/p?q#f'); + checkSetter(input, 'pathname', '', 'custom:/?q#f'); +} +checkSetter('custom:///old?q#f', 'pathname', '', 'custom://?q#f'); +checkSetter('custom://host/old?q#f', 'pathname', '//p', 'custom://host//p?q#f'); +checkSetter('custom:/.//p?q#f', 'host', 'h:77', 'custom://h:77//p?q#f'); +for (const [name, create] of factories) { + for (const hostname of ['h', '', '[::1]']) { + const object = create('custom:/.//p?q#f'); + assert(object.pathname === '//p', name + ': prefix is not part of pathname'); + object.hostname = hostname; + assert(object.href === 'custom://' + hostname + '//p?q#f', name + ': add authority'); + assert(object.pathname === '//p', name + ': authority change preserves path'); + assert(object.search === '?q' && object.hash === '#f', name + ': suffix offsets'); + assert(new URL(object.href).pathname === '//p', name + ': serialized URL round-trips'); + object.pathname = ''; + assert(object.href === 'custom://' + hostname + '?q#f', name + ': empty authority path'); + } +} +"#, + ); +} + +#[test] +fn url_relative_resolution_distinguishes_special_slashes_and_non_special_backslashes() { + assert_url_components( + r#" +for (const [input, base, expected] of [ + ['///next.test/a/../p?q#f', 'https://user:pass@old.test:123/a/b', 'https://next.test/p?q#f'], + ['///\\//\\//next.test/p', 'http://old.test/a/b', 'http://next.test/p'], + ['\\p', 'custom://host/a/b', 'custom://host/a/\\p'], + ['\\/p', 'custom://host/a/b', 'custom://host/a/\\/p'], + ['\\\\p', 'custom://host/a/b', 'custom://host/a/\\\\p'], + ['\\p', 'custom:/.//a/b', 'custom:/.//a/\\p'], + ['///next', 'custom://host/a/b', 'custom:///next'], + ['////next', 'custom:/a/b', 'custom:////next'], +]) { + for (const constructor of [URL, frame.contentWindow.URL]) { + assert(new constructor(input, base).href === expected, 'relative constructor: ' + input); + assert(constructor.parse(input, base).href === expected, 'relative URL.parse: ' + input); + assert(constructor.canParse(input, base), 'relative URL.canParse: ' + input); + } + for (const owner of [document, frame.contentDocument, + document.implementation.createHTMLDocument('relative path')]) { + const baseElement = owner.head.appendChild(owner.createElement('base')); + baseElement.href = base; + for (const tag of ['a', 'area']) { + const link = owner.body.appendChild(owner.createElement(tag)); + link.href = input; + assert(link.href === expected, tag + ': relative document base: ' + input); + link.remove(); + } + baseElement.remove(); + } +} +for (const constructor of [URL, frame.contentWindow.URL]) { + assert(constructor.parse('///?q', 'https://host/') === null, 'empty special host fails'); + assert(!constructor.canParse('//\\host', 'custom://base/'), 'backslash in opaque host fails'); +} +"#, + ); +} + #[test] fn file_url_components_preserve_hosts_drive_letters_and_empty_path_segments() { assert_url_components( diff --git a/moli-url/src/components.rs b/moli-url/src/components.rs index b42180448f7..c5e7dec4f66 100644 --- a/moli-url/src/components.rs +++ b/moli-url/src/components.rs @@ -47,13 +47,7 @@ pub fn set_pathname(url: &mut Url, value: &str) { return; } let value = strip_tabs_and_newlines(value); - // rust-url represents an empty host like a missing host. An authority - // distinguishes them: non-special URLs with an empty host can have no path. - if value.is_empty() && url.has_authority() { - url.set_path(&value); - } else { - url::quirks::set_pathname(url, &value); - } + url::quirks::set_pathname(url, &value); } fn strip_tabs_and_newlines(value: &str) -> Cow<'_, str> { diff --git a/moli-url/src/hierarchical_path.rs b/moli-url/src/hierarchical_path.rs new file mode 100644 index 00000000000..61c3bfbf565 --- /dev/null +++ b/moli-url/src/hierarchical_path.rs @@ -0,0 +1,168 @@ +use url::Url; + +fn assert_url(url: &Url, expected: &str, path: &str) { + assert_eq!(url.as_str(), expected); + assert_eq!(url.path(), path); + url.check_invariants().unwrap(); + assert_eq!(Url::parse(url.as_str()).unwrap(), *url); +} + +#[test] +fn relative_special_urls_skip_all_authority_slashes() { + for scheme in ["http", "https", "ws", "wss", "ftp"] { + let base = Url::parse(&format!("{scheme}://user:pass@old.test:123/a/b?q#f")).unwrap(); + for prefix in ["//", "///", r"///\//\//", r"\\", r"/\", r"\/", "/\t/\n/"] { + let url = base + .join(&format!("{prefix}new.test/a/../p?next#frag")) + .unwrap(); + assert_url(&url, &format!("{scheme}://new.test/p?next#frag"), "/p"); + assert_eq!(url.host_str(), Some("new.test")); + assert_eq!(url.port(), None); + assert!(url.username().is_empty()); + assert_eq!(url.password(), None); + } + for input in ["///", r"/\\", "////?query", r"\\#fragment"] { + assert!(base.join(input).is_err(), "{scheme}: {input:?}"); + } + for input in ["/p", r"\p"] { + assert_url( + &base.join(input).unwrap(), + &format!("{scheme}://user:pass@old.test:123/p"), + "/p", + ); + } + } +} + +#[test] +fn relative_non_special_urls_keep_backslashes_in_the_path() { + for (base, prefix) in [ + ("custom://host/a/b?q#f", "custom://host/a/"), + ("custom:/a/b?q#f", "custom:/a/"), + ("custom:/.//a/b?q#f", "custom:/.//a/"), + ] { + let base = Url::parse(base).unwrap(); + for input in [r"\p", r"\/p", r"\\p"] { + let expected = format!("{prefix}{input}"); + let url = base.join(input).unwrap(); + assert_eq!(url.as_str(), expected); + url.check_invariants().unwrap(); + assert_eq!(url.has_authority(), base.has_authority()); + assert_eq!(url.host_str(), base.host_str()); + } + for (input, expected, path) in [ + ("//next", "custom://next", ""), + ("///next", "custom:///next", "/next"), + ("////next", "custom:////next", "//next"), + ] { + assert_url(&base.join(input).unwrap(), expected, path); + } + assert!(base.join(r"//\next").is_err()); + } +} + +#[test] +fn hierarchical_path_setters_add_and_remove_only_the_serialization_prefix() { + for input in ["custom:/old?q#f", "custom:/.//old?q#f"] { + for (value, expected, path) in [ + ("//p", "custom:/.//p?q#f", "//p"), + ("/.//p", "custom:/.//p?q#f", "//p"), + ("/..//p", "custom:/.//p?q#f", "//p"), + ("//", "custom:/.//?q#f", "//"), + ("p", "custom:/p?q#f", "/p"), + ("/", "custom:/?q#f", "/"), + ] { + let mut url = Url::parse(input).unwrap(); + url.set_path(value); + assert_url(&url, expected, path); + assert!(!url.has_authority()); + assert_eq!(url.query(), Some("q")); + assert_eq!(url.fragment(), Some("f")); + } + let mut url = Url::parse(input).unwrap(); + crate::components::set_pathname(&mut url, ""); + assert_url(&url, "custom:/?q#f", "/"); + } + for authority in ["", "host", "user:pass@host:123"] { + let mut url = Url::parse(&format!("custom://{authority}/old?q#f")).unwrap(); + url.set_path("//p"); + assert_url(&url, &format!("custom://{authority}//p?q#f"), "//p"); + assert!(url.has_authority()); + } +} + +#[test] +fn adding_a_host_drops_the_path_serialization_prefix_without_changing_the_path() { + for input in ["custom:/.//p?q#f", "custom:/.//?q#f"] { + for host in ["h", "", "[::1]"] { + let mut url = Url::parse(input).unwrap(); + let path = url.path().to_owned(); + crate::components::set_hostname(&mut url, host); + assert_url(&url, &format!("custom://{host}{path}?q#f"), &path); + assert!(url.has_authority()); + assert_eq!(url.query(), Some("q")); + assert_eq!(url.fragment(), Some("f")); + } + let mut url = Url::parse(input).unwrap(); + let path = url.path().to_owned(); + crate::components::set_host(&mut url, "h:77"); + assert_url(&url, &format!("custom://h:77{path}?q#f"), &path); + assert_eq!(url.port(), Some(77)); + } +} + +#[test] +fn removing_a_host_keeps_leading_empty_segments_out_of_the_authority() { + for authority in ["h", "", "[::1]", "user:pass@h:77"] { + for path in ["", "/p", "//p", "///"] { + let mut url = Url::parse(&format!("custom://{authority}{path}?q#f")).unwrap(); + url.set_host(None).unwrap(); + let path = if path.is_empty() { "/" } else { path }; + let prefix = if path.starts_with("//") { "/." } else { "" }; + assert_url(&url, &format!("custom:{prefix}{path}?q#f"), path); + assert!(!url.has_authority()); + assert_eq!(url.host_str(), None); + assert_eq!(url.port(), None); + assert_eq!(url.query(), Some("q")); + assert_eq!(url.fragment(), Some("f")); + url.set_host(Some("next")).unwrap(); + assert_url(&url, &format!("custom://next{path}?q#f"), path); + } + } +} + +#[test] +fn empty_pathname_distinguishes_empty_hosts_from_missing_hosts() { + for (input, expected, path) in [ + ("custom:///p?q#f", "custom://?q#f", ""), + ("custom://host/p?q#f", "custom://host?q#f", ""), + ("custom:/p?q#f", "custom:/?q#f", "/"), + ("custom:/.//p?q#f", "custom:/?q#f", "/"), + ("https://host/p?q#f", "https://host/?q#f", "/"), + ("file:///p?q#f", "file:///?q#f", "/"), + ("data:payload?q#f", "data:payload?q#f", "payload"), + ] { + let mut url = Url::parse(input).unwrap(); + url::quirks::set_pathname(&mut url, ""); + assert_url(&url, expected, path); + } +} + +#[test] +fn path_segment_mutations_keep_the_path_prefix_and_component_offsets_consistent() { + let mut url = Url::parse("custom:/.//p?q#f").unwrap(); + url.path_segments_mut().unwrap().pop(); + assert_url(&url, "custom:/?q#f", "/"); + url.set_path("//p"); + url.path_segments_mut() + .unwrap() + .clear() + .push("next") + .push(""); + assert_url(&url, "custom:/next/?q#f", "/next/"); + url.set_path("///"); + url.path_segments_mut().unwrap().pop_if_empty(); + assert_url(&url, "custom:/.//?q#f", "//"); + url.path_segments_mut().unwrap().pop_if_empty(); + assert_url(&url, "custom:/?q#f", "/"); +} diff --git a/moli-url/src/lib.rs b/moli-url/src/lib.rs index b07a02504b5..7103c048eea 100644 --- a/moli-url/src/lib.rs +++ b/moli-url/src/lib.rs @@ -9,6 +9,8 @@ pub use origin::is_about_srcdoc; #[cfg(test)] mod file_url; +#[cfg(test)] +mod hierarchical_path; pub use origin::{ WebOrigin, is_about_blank, is_opaque_origin, is_potentially_trustworthy_url, diff --git a/vendor/url-2.5.8/MOLI-PATCHES.md b/vendor/url-2.5.8/MOLI-PATCHES.md index 160ebc90df1..97825c552bd 100644 --- a/vendor/url-2.5.8/MOLI-PATCHES.md +++ b/vendor/url-2.5.8/MOLI-PATCHES.md @@ -26,11 +26,33 @@ References: , and . -The upstream WPT data is unchanged. The 39 file parsing/setter tests fixed by -this patch were removed from `tests/expected_failures.txt`; the eight remaining -upstream expected failures are retained. The obsolete unit-test expectation of -a host/drive-letter syntax violation is replaced with an explicit preservation -and no-violation assertion. +Hierarchical URL parsing and mutation also keep the authority distinct from +the logical path: + +- In relative special URLs, consume all authority slashes before the host. + In non-special URLs, backslashes remain path data and only two leading + forward slashes introduce an authority. +- Share the serialization-only "/." prefix adjustment between parsing, path + replacement, and path-segment mutation. Keep query and fragment offsets in + sync when the prefix is added or removed. +- Discard that prefix when adding a host, and restore it when removing a host + from a URL whose logical path starts with "//". Host removal also clears the + internal host kind and preserves an empty hierarchical path with a slash. +- Distinguish a missing host from an empty authority when clearing pathname, + so the Web API adapter no longer needs its own empty-authority workaround. + +References: +, +, +, +, and +. + +The upstream WPT data is unchanged. The 39 file parsing/setter tests and seven +hierarchical setter tests fixed by these patches were removed from +`tests/expected_failures.txt`; the one remaining upstream expected failure is +retained. The obsolete unit-test expectation of a host/drive-letter syntax +violation is replaced with an explicit preservation and no-violation assertion. Packaging adjustment: `debug_metadata/url.natvis` is copied from the same pinned upstream revision, and its include path is made package-local so the @@ -43,6 +65,8 @@ cargo test --manifest-path vendor/url-2.5.8/Cargo.toml --all-features ``` Workspace regressions live in `moli-url/src/file_url.rs`, +`moli-url/src/hierarchical_path.rs`, `moli-renderer-v8/src/script_vm/tests/url_components.rs`, and -`moli-url-policy/src/tests.rs`. Non-file parser and setter conformance issues -remain separate work; this patch does not change resource access permissions. +`moli-url-policy/src/tests.rs`. Remaining opaque-path and percent-encoding +conformance issues are separate work; these patches do not change resource +access permissions. diff --git a/vendor/url-2.5.8/src/lib.rs b/vendor/url-2.5.8/src/lib.rs index 60b3f703e34..142bf4732cd 100644 --- a/vendor/url-2.5.8/src/lib.rs +++ b/vendor/url-2.5.8/src/lib.rs @@ -1797,6 +1797,9 @@ impl Url { } fn restore_after_path(&mut self, old_after_path_position: u32, after_path: &str) { + let scheme_end = self.scheme_end; + let path_start = self.path_start; + self.path_start = self.mutate(|parser| parser.adjust_path_prefix(scheme_end, path_start)); let new_after_path_position = to_u32(self.serialization.len()).unwrap(); let adjust = |index: &mut u32| { *index -= old_after_path_position; @@ -2044,11 +2047,17 @@ impl Url { } else { self.set_host_internal(Host::parse_opaque_cow(host_substr.into())?, None); } - } else if self.has_host() { + } else if self.has_authority() { if scheme_type.is_special() && !scheme_type.is_file() { return Err(ParseError::EmptyHost); - } else if self.serialization.len() == self.path_start as usize { - self.serialization.push('/'); + } else if self.path().is_empty() { + self.serialization.insert(self.path_start as usize, '/'); + if let Some(ref mut index) = self.query_start { + *index += 1; + } + if let Some(ref mut index) = self.fragment_start { + *index += 1; + } } debug_assert!(self.byte_at(self.scheme_end) == b':'); debug_assert!(self.byte_at(self.path_start) == b'/'); @@ -2061,12 +2070,17 @@ impl Url { self.serialization .drain(new_path_start as usize..self.path_start as usize); - let offset = self.path_start - new_path_start; + let old_path_start = self.path_start; self.path_start = new_path_start; self.username_end = new_path_start; self.host_start = new_path_start; self.host_end = new_path_start; + self.host = HostInternal::None; self.port = None; + let scheme_end = self.scheme_end; + self.path_start = + self.mutate(|parser| parser.adjust_path_prefix(scheme_end, new_path_start)); + let offset = old_path_start - self.path_start; if let Some(ref mut index) = self.query_start { *index -= offset } @@ -2079,7 +2093,9 @@ impl Url { /// opt_new_port: None means leave unchanged, Some(None) means remove any port number. fn set_host_internal(&mut self, host: Host>, opt_new_port: Option>) { - let old_suffix_pos = if opt_new_port.is_some() { + // When creating an authority, discard any serialization-only "/." + // prefix and retain the logical path, query, and fragment. + let old_suffix_pos = if opt_new_port.is_some() || !self.has_authority() { self.path_start } else { self.host_end diff --git a/vendor/url-2.5.8/src/parser.rs b/vendor/url-2.5.8/src/parser.rs index 886ec064eaf..c2c606bd024 100644 --- a/vendor/url-2.5.8/src/parser.rs +++ b/vendor/url-2.5.8/src/parser.rs @@ -690,25 +690,33 @@ impl Parser<'_> { }) } Some('#') => self.fragment_only(base_url, input), - Some('/') | Some('\\') => { - let (slashes_count, remaining) = input.count_matching(|c| matches!(c, '/' | '\\')); + Some(c) if c == '/' || (c == '\\' && scheme_type.is_special()) => { + let (slashes_count, remaining) = + input.count_matching(|c| c == '/' || (c == '\\' && scheme_type.is_special())); if slashes_count >= 2 { - self.log_violation_if(SyntaxViolation::ExpectedDoubleSlash, || { - input - .clone() - .take_while(|&c| matches!(c, '/' | '\\')) - .collect::() - != "//" - }); + let remaining = if scheme_type.is_special() { + self.log_violation_if(SyntaxViolation::ExpectedDoubleSlash, || { + input + .clone() + .take_while(|&c| matches!(c, '/' | '\\')) + .collect::() + != "//" + }); + // Special authority ignore slashes state consumes every + // leading slash or backslash before parsing the host. + remaining + } else { + // A non-special authority consumes exactly two slashes; + // further slashes belong to its path, not its host. + input_after_first_char.split_prefix('/').unwrap() + }; let scheme_end = base_url.scheme_end; debug_assert!(base_url.byte_at(scheme_end) == b':'); self.serialization .push_str(base_url.slice(..scheme_end + 1)); - if let Some(after_prefix) = input.split_prefix("//") { - return self.after_double_slash(after_prefix, scheme_type, scheme_end); - } return self.after_double_slash(remaining, scheme_type, scheme_end); } + self.log_violation_if(SyntaxViolation::Backslash, || c == '\\'); let path_start = base_url.path_start; self.serialization.push_str(base_url.slice(..path_start)); self.serialization.push('/'); @@ -1341,6 +1349,27 @@ impl Parser<'_> { } } + /// Keep a hostless hierarchical path beginning with "//" distinct from an + /// authority. The "/." prefix belongs to serialization, never to path(). + /// Callers must keep query and fragment offsets in sync with the new offset. + pub fn adjust_path_prefix(&mut self, scheme_end: u32, path_start: u32) -> u32 { + let prefix_start = scheme_end as usize + 1; + let path_start_usize = path_start as usize; + let needs_prefix = self.serialization[path_start_usize..].starts_with("//"); + if path_start_usize == prefix_start && needs_prefix { + self.serialization.insert_str(prefix_start, "/."); + path_start + 2 + } else if path_start_usize == prefix_start + 2 + && &self.serialization[prefix_start..path_start_usize] == "/." + && !needs_prefix + { + self.serialization.drain(prefix_start..path_start_usize); + path_start - 2 + } else { + path_start + } + } + #[allow(clippy::too_many_arguments)] fn with_query_and_fragment( mut self, @@ -1351,50 +1380,10 @@ impl Parser<'_> { host_end: u32, host: HostInternal, port: Option, - mut path_start: u32, + path_start: u32, remaining: Input<'_>, ) -> ParseResult { - // Special case for anarchist URL's with a leading empty path segment - // This prevents web+demo:/.//not-a-host/ or web+demo:/path/..//not-a-host/, - // when parsed and then serialized, from ending up as web+demo://not-a-host/ - // (they end up as web+demo:/.//not-a-host/). - // - // If url’s host is null, url does not have an opaque path, - // url’s path’s size is greater than 1, and url’s path[0] is the empty string, - // then append U+002F (/) followed by U+002E (.) to output. - let scheme_end_as_usize = scheme_end as usize; - let path_start_as_usize = path_start as usize; - if path_start_as_usize == scheme_end_as_usize + 1 { - // Anarchist URL - if self.serialization[path_start_as_usize..].starts_with("//") { - // Case 1: The base URL did not have an empty path segment, but the resulting one does - // Insert the "/." prefix - self.serialization.insert_str(path_start_as_usize, "/."); - path_start += 2; - } - assert!(!self.serialization[scheme_end_as_usize..].starts_with("://")); - } else if path_start_as_usize == scheme_end_as_usize + 3 - && &self.serialization[scheme_end_as_usize..path_start_as_usize] == ":/." - { - // Anarchist URL with leading empty path segment - // The base URL has a "/." between the host and the path - assert_eq!(self.serialization.as_bytes()[path_start_as_usize], b'/'); - if self - .serialization - .as_bytes() - .get(path_start_as_usize + 1) - .copied() - != Some(b'/') - { - // Case 2: The base URL had an empty path segment, but the resulting one does not - // Remove the "/." prefix - self.serialization - .replace_range(scheme_end_as_usize..path_start_as_usize, ":"); - path_start -= 2; - } - assert!(!self.serialization[scheme_end_as_usize..].starts_with("://")); - } - + let path_start = self.adjust_path_prefix(scheme_end, path_start); let (query_start, fragment_start) = self.parse_query_and_fragment(scheme_type, scheme_end, remaining)?; Ok(Url { diff --git a/vendor/url-2.5.8/src/quirks.rs b/vendor/url-2.5.8/src/quirks.rs index 55853c7f1ac..9f7790b1976 100644 --- a/vendor/url-2.5.8/src/quirks.rs +++ b/vendor/url-2.5.8/src/quirks.rs @@ -286,7 +286,7 @@ pub fn set_pathname(url: &mut Url, new_pathname: &str) { url.set_path(new_pathname) } else if SchemeType::from(url.scheme()).is_special() || !new_pathname.is_empty() - || !url.has_host() + || !url.has_authority() { let mut path_to_set = String::from("/"); path_to_set.push_str(new_pathname); diff --git a/vendor/url-2.5.8/tests/expected_failures.txt b/vendor/url-2.5.8/tests/expected_failures.txt index aed4a0cccdc..0076e88afd8 100644 --- a/vendor/url-2.5.8/tests/expected_failures.txt +++ b/vendor/url-2.5.8/tests/expected_failures.txt @@ -1,8 +1 @@ - set hostname to - set hostname to <> - set pathname to <> set href to - set pathname to - set pathname to - set pathname to - set pathname to