use gix_url::Scheme; use crate::parse::{assert_url, assert_url_roundtrip, url, url_alternate, url_with_pass}; #[test]fn without_user_and_without_port() -> crate::Result {    assert_url_roundtrip(        "ssh://host.xz/path/to/repo.git/",        url(Scheme::Ssh, None, "host.xz", None, b"/path/to/repo.git/"),    )} #[test]fn without_user_and_with_port() -> crate::Result {    assert_url_roundtrip("ssh://host.xz:21/", url(Scheme::Ssh, None, "host.xz", 21, b"/"))} #[test]fn host_is_ipv4() -> crate::Result {    assert_url_roundtrip(        "ssh://127.69.0.1/hello",        url(Scheme::Ssh, None, "127.69.0.1", None, b"/hello"),    )} #[test]fn username_expansion_with_username() -> crate::Result {    assert_url_roundtrip(        "ssh://example.com/~byron/hello/git",        url(Scheme::Ssh, None, "example.com", None, b"~byron/hello/git"),    )} #[test]fn username_expansion_without_username() -> crate::Result {    assert_url_roundtrip(        "ssh://example.com/~/hello/git",        url(Scheme::Ssh, None, "example.com", None, b"~/hello/git"),    )} #[test]fn scp_like_with_ssh_host_alias() -> crate::Result {    assert_url_roundtrip(        "user@alias:username/repo.git",        url_alternate(Scheme::Ssh, "user", "alias", None, b"username/repo.git"),    )} #[test]fn with_user_and_without_port() -> crate::Result {    assert_url_roundtrip(        "ssh://user@host.xz/.git",        url(Scheme::Ssh, "user", "host.xz", None, b"/.git"),    )} #[test]fn username_with_dot_is_not_percent_encoded() -> crate::Result {    assert_url_roundtrip(        "ssh://user.name@host.xz/.git",        url(Scheme::Ssh, "user.name", "host.xz", None, b"/.git"),    )} #[test]fn with_user_and_port_and_absolute_path() -> crate::Result {    assert_url_roundtrip(        "ssh://user@host.xz:42/.git",        url(Scheme::Ssh, "user", "host.xz", 42, b"/.git"),    )} #[test]fn ssh_alias_without_username() -> crate::Result {    let url = assert_url(        "host:/path/to/git",        url_alternate(Scheme::Ssh, None, "host", None, b"/path/to/git"),    )?    .to_bstring();    assert_eq!(url, "host:/path/to/git");    Ok(())} #[test]fn default_port_is_22() -> crate::Result {    let url = url_alternate(Scheme::Ssh, None, "host.xz", None, b"path/to/git");    assert_eq!(url.port_or_default(), Some(22));    Ok(())} #[test]fn scp_like_without_user() -> crate::Result {    let url = assert_url(        "host.xz:path/to/git",        url_alternate(Scheme::Ssh, None, "host.xz", None, b"path/to/git"),    )?    .to_bstring();    assert_eq!(url, "host.xz:path/to/git");    Ok(())} #[test]fn scp_like_with_absolute_path() -> crate::Result {    let url = assert_url(        "host.xz:/path/to/git",        url_alternate(Scheme::Ssh, None, "host.xz", None, b"/path/to/git"),    )?    .to_bstring();    assert_eq!(url, "host.xz:/path/to/git");    Ok(())} #[test]fn scp_like_with_absolute_path_with_whitespace() -> crate::Result {    let url = assert_url(        "host.xz:/path/to/git with space",        url_alternate(Scheme::Ssh, None, "host.xz", None, b"/path/to/git with space"),    )?    .to_bstring();    assert_eq!(url, "host.xz:/path/to/git with space");    Ok(())} #[test]fn scp_like_without_user_and_username_expansion_without_username() -> crate::Result {    let url = assert_url(        "host.xz:~/to/git",        url_alternate(Scheme::Ssh, None, "host.xz", None, b"~/to/git"),    )?    .to_bstring();    assert_eq!(url, "host.xz:~/to/git");    Ok(())} #[test]fn scp_like_without_user_and_username_expansion_with_username() -> crate::Result {    let url = assert_url(        "host.xz:~byron/to/git",        url_alternate(Scheme::Ssh, None, "host.xz", None, b"~byron/to/git"),    )?    .to_bstring();    assert_eq!(url, "host.xz:~byron/to/git");    Ok(())} #[test]fn scp_like_with_user_and_relative_path_keep_relative_path() -> crate::Result {    let url = assert_url(        "user@host.xz:relative",        url_alternate(Scheme::Ssh, "user", "host.xz", None, b"relative"),    )?    .to_bstring();    assert_eq!(url, "user@host.xz:relative");     let url = assert_url(        "user@host.xz:./relative",        url_alternate(Scheme::Ssh, "user", "host.xz", None, b"./relative"),    )?    .to_bstring();    assert_eq!(url, "user@host.xz:./relative", "./ is maintained");     let url = assert_url(        "user@host.xz:././relative",        url_alternate(Scheme::Ssh, "user", "host.xz", None, b"././relative"),    )?    .to_bstring();    assert_eq!(url, "user@host.xz:././relative", "./ is maintained, even if repeated");     let url = assert_url(        "user@host.xz:../relative",        url_alternate(Scheme::Ssh, "user", "host.xz", None, b"../relative"),    )?    .to_bstring();    assert_eq!(url, "user@host.xz:../relative");     let url = assert_url(        "user@host.xz:../relative with space",        url_alternate(Scheme::Ssh, "user", "host.xz", None, b"../relative with space"),    )?    .to_bstring();    assert_eq!(url, "user@host.xz:../relative with space");    Ok(())} #[test]fn scp_like_with_windows_path() -> crate::Result {    let url = assert_url(        "user@host.xz:C:/strange/absolute/path",        url_alternate(Scheme::Ssh, "user", "host.xz", None, b"C:/strange/absolute/path"),    )?    .to_bstring();    assert_eq!(url, "user@host.xz:C:/strange/absolute/path");    Ok(())} #[test]fn scp_like_with_windows_path_and_port_thinks_port_is_part_of_path() -> crate::Result {    let url = gix_url::parse("user@host.xz:42:C:/strange/absolute/path".into())?;    assert_eq!(        url.to_bstring(),        "user@host.xz:42:C:/strange/absolute/path",        "it reproduces correctly"    );    assert_eq!(        url.path, "42:C:/strange/absolute/path",        "but in fact it gets it quite wrong - git does the same on windows and linux"    );    assert_eq!(url.port, None, "the port wasn't actually parsed");    Ok(())} #[test]fn scp_like_with_non_alphanumeric_username() -> crate::Result {    let url = assert_url(        "_user.name@host.xz:C:/path",        url_alternate(Scheme::Ssh, "_user.name", "host.xz", None, b"C:/path"),    )?    .to_bstring();    assert_eq!(url, "_user.name@host.xz:C:/path");    Ok(())} // Git passes the non-path part "user@name@host.xz" to OpenSSH, and the ssh// command interprets it as user = "user@name", host = "host.xz".#[test]fn scp_like_with_username_including_at() -> crate::Result {    let url = assert_url(        "user@name@host.xz:path",        url_alternate(Scheme::Ssh, "user@name", "host.xz", None, b"path"),    )?    .to_bstring();    assert_eq!(url, "user@name@host.xz:path");    Ok(())} // Git does not care that the host is named `file`, it still treats it as an SCP url.// I btw tested this, yes you can really clone a repository from there, just `git init`// in the directory above your home directory on the remote machine.#[test]fn strange_scp_like_with_host_named_file() -> crate::Result {    let url = assert_url("file:..", url_alternate(Scheme::Ssh, None, "file", None, b".."))?;    assert_eq!(url.to_bstring(), "file:..");    Ok(())} #[test]fn bad_alternative_form_with_password() -> crate::Result {    let url = url_with_pass(Scheme::Ssh, "user", "password", "host.xz", None, b"/")        .serialize_alternate_form(true)        .to_bstring();    assert_eq!(url, "ssh://user:password@host.xz/");    Ok(())} #[test]fn bad_alternative_form_with_port() -> crate::Result {    let url = url_alternate(Scheme::Ssh, None, "host.xz", 21, b"/").to_bstring();    assert_eq!(url, "ssh://host.xz:21/");    Ok(())} #[test]fn ipv6_address_without_port() -> crate::Result {    let url = assert_url("ssh://[::1]/repo", url(Scheme::Ssh, None, "::1", None, b"/repo"))?;    assert_eq!(url.host(), Some("::1"), "brackets are stripped for SSH");    Ok(())} #[test]fn ipv6_address_with_port() -> crate::Result {    let url = assert_url("ssh://[::1]:22/repo", url(Scheme::Ssh, None, "::1", 22, b"/repo"))?;    assert_eq!(url.host(), Some("::1"));    assert_eq!(url.port, Some(22));    Ok(())} #[test]fn ipv6_address_with_user() -> crate::Result {    let url = assert_url("ssh://user@[::1]/repo", url(Scheme::Ssh, "user", "::1", None, b"/repo"))?;    assert_eq!(url.host(), Some("::1"));    assert_eq!(url.user(), Some("user"));    Ok(())} #[test]fn ipv6_address_with_user_and_port() -> crate::Result {    let url = assert_url(        "ssh://user@[::1]:22/repo",        url(Scheme::Ssh, "user", "::1", 22, b"/repo"),    )?;    assert_eq!(url.host(), Some("::1"));    assert_eq!(url.user(), Some("user"));    assert_eq!(url.port, Some(22));    Ok(())} #[test]fn ipv6_full_address() -> crate::Result {    let url = assert_url(        "ssh://[2001:db8::1]/repo",        url(Scheme::Ssh, None, "2001:db8::1", None, b"/repo"),    )?;    assert_eq!(url.host(), Some("2001:db8::1"));    Ok(())} #[test]fn ipv6_address_scp_like() -> crate::Result {    let url = assert_url("[::1]:repo", url_alternate(Scheme::Ssh, None, "::1", None, b"repo"))?;    assert_eq!(url.host(), Some("::1"), "SCP-like format with IPv6");    Ok(())} #[test]fn ipv6_address_scp_like_with_user() -> crate::Result {    let result = gix_url::parse("user@[::1]:repo".into());    assert!(        result.is_err(),        "SCP-like format with brackets is not supported - Git doesn't support this either"    );    Ok(())}