##// END OF EJS Templates
revlog: update data file record before index rename...
revlog: update data file record before index rename When migrating from inline to non-inline data storage, the data file is recorded initially as zero sized so that it is removed on failure. But the record has to be updated before the index is renamed, otherwise data is lost on rollback. Differential Revision: https://phab.mercurial-scm.org/D10725

File last commit:

r47963:1249eb9c default
r48060:d92310d4 default
Show More
hg_path.rs
814 lines | 25.3 KiB | application/rls-services+xml | RustLexer
// hg_path.rs
//
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.
use crate::utils::SliceExt;
use std::borrow::Borrow;
use std::borrow::Cow;
use std::convert::TryFrom;
use std::ffi::{OsStr, OsString};
use std::fmt;
use std::ops::Deref;
use std::path::{Path, PathBuf};
#[derive(Debug, Eq, PartialEq)]
pub enum HgPathError {
/// Bytes from the invalid `HgPath`
LeadingSlash(Vec<u8>),
ConsecutiveSlashes {
bytes: Vec<u8>,
second_slash_index: usize,
},
ContainsNullByte {
bytes: Vec<u8>,
null_byte_index: usize,
},
/// Bytes
DecodeError(Vec<u8>),
/// The rest come from audit errors
EndsWithSlash(HgPathBuf),
ContainsIllegalComponent(HgPathBuf),
/// Path is inside the `.hg` folder
InsideDotHg(HgPathBuf),
IsInsideNestedRepo {
path: HgPathBuf,
nested_repo: HgPathBuf,
},
TraversesSymbolicLink {
path: HgPathBuf,
symlink: HgPathBuf,
},
NotFsCompliant(HgPathBuf),
/// `path` is the smallest invalid path
NotUnderRoot {
path: PathBuf,
root: PathBuf,
},
}
impl fmt::Display for HgPathError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
HgPathError::LeadingSlash(bytes) => {
write!(f, "Invalid HgPath '{:?}': has a leading slash.", bytes)
}
HgPathError::ConsecutiveSlashes {
bytes,
second_slash_index: pos,
} => write!(
f,
"Invalid HgPath '{:?}': consecutive slashes at pos {}.",
bytes, pos
),
HgPathError::ContainsNullByte {
bytes,
null_byte_index: pos,
} => write!(
f,
"Invalid HgPath '{:?}': contains null byte at pos {}.",
bytes, pos
),
HgPathError::DecodeError(bytes) => write!(
f,
"Invalid HgPath '{:?}': could not be decoded.",
bytes
),
HgPathError::EndsWithSlash(path) => {
write!(f, "Audit failed for '{}': ends with a slash.", path)
}
HgPathError::ContainsIllegalComponent(path) => write!(
f,
"Audit failed for '{}': contains an illegal component.",
path
),
HgPathError::InsideDotHg(path) => write!(
f,
"Audit failed for '{}': is inside the '.hg' folder.",
path
),
HgPathError::IsInsideNestedRepo {
path,
nested_repo: nested,
} => {
write!(f,
"Audit failed for '{}': is inside a nested repository '{}'.",
path, nested
)
}
HgPathError::TraversesSymbolicLink { path, symlink } => write!(
f,
"Audit failed for '{}': traverses symbolic link '{}'.",
path, symlink
),
HgPathError::NotFsCompliant(path) => write!(
f,
"Audit failed for '{}': cannot be turned into a \
filesystem path.",
path
),
HgPathError::NotUnderRoot { path, root } => write!(
f,
"Audit failed for '{}': not under root {}.",
path.display(),
root.display()
),
}
}
}
impl From<HgPathError> for std::io::Error {
fn from(e: HgPathError) -> Self {
std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string())
}
}
/// This is a repository-relative path (or canonical path):
/// - no null characters
/// - `/` separates directories
/// - no consecutive slashes
/// - no leading slash,
/// - no `.` nor `..` of special meaning
/// - stored in repository and shared across platforms
///
/// Note: there is no guarantee of any `HgPath` being well-formed at any point
/// in its lifetime for performance reasons and to ease ergonomics. It is
/// however checked using the `check_state` method before any file-system
/// operation.
///
/// This allows us to be encoding-transparent as much as possible, until really
/// needed; `HgPath` can be transformed into a platform-specific path (`OsStr`
/// or `Path`) whenever more complex operations are needed:
/// On Unix, it's just byte-to-byte conversion. On Windows, it has to be
/// decoded from MBCS to WTF-8. If WindowsUTF8Plan is implemented, the source
/// character encoding will be determined on a per-repository basis.
//
// FIXME: (adapted from a comment in the stdlib)
// `HgPath::new()` current implementation relies on `Slice` being
// layout-compatible with `[u8]`.
// When attribute privacy is implemented, `Slice` should be annotated as
// `#[repr(transparent)]`.
// Anyway, `Slice` representation and layout are considered implementation
// detail, are not documented and must not be relied upon.
#[derive(Eq, Ord, PartialEq, PartialOrd, Hash)]
pub struct HgPath {
inner: [u8],
}
impl HgPath {
pub fn new<S: AsRef<[u8]> + ?Sized>(s: &S) -> &Self {
unsafe { &*(s.as_ref() as *const [u8] as *const Self) }
}
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
pub fn len(&self) -> usize {
self.inner.len()
}
fn to_hg_path_buf(&self) -> HgPathBuf {
HgPathBuf {
inner: self.inner.to_owned(),
}
}
pub fn bytes(&self) -> std::slice::Iter<u8> {
self.inner.iter()
}
pub fn to_ascii_uppercase(&self) -> HgPathBuf {
HgPathBuf::from(self.inner.to_ascii_uppercase())
}
pub fn to_ascii_lowercase(&self) -> HgPathBuf {
HgPathBuf::from(self.inner.to_ascii_lowercase())
}
pub fn as_bytes(&self) -> &[u8] {
&self.inner
}
pub fn contains(&self, other: u8) -> bool {
self.inner.contains(&other)
}
pub fn starts_with(&self, needle: impl AsRef<Self>) -> bool {
self.inner.starts_with(needle.as_ref().as_bytes())
}
pub fn trim_trailing_slash(&self) -> &Self {
Self::new(if self.inner.last() == Some(&b'/') {
&self.inner[..self.inner.len() - 1]
} else {
&self.inner[..]
})
}
/// Returns a tuple of slices `(base, filename)` resulting from the split
/// at the rightmost `/`, if any.
///
/// # Examples:
///
/// ```
/// use hg::utils::hg_path::HgPath;
///
/// let path = HgPath::new(b"cool/hg/path").split_filename();
/// assert_eq!(path, (HgPath::new(b"cool/hg"), HgPath::new(b"path")));
///
/// let path = HgPath::new(b"pathwithoutsep").split_filename();
/// assert_eq!(path, (HgPath::new(b""), HgPath::new(b"pathwithoutsep")));
/// ```
pub fn split_filename(&self) -> (&Self, &Self) {
match &self.inner.iter().rposition(|c| *c == b'/') {
None => (HgPath::new(""), &self),
Some(size) => (
HgPath::new(&self.inner[..*size]),
HgPath::new(&self.inner[*size + 1..]),
),
}
}
pub fn join<T: ?Sized + AsRef<Self>>(&self, other: &T) -> HgPathBuf {
let mut inner = self.inner.to_owned();
if !inner.is_empty() && inner.last() != Some(&b'/') {
inner.push(b'/');
}
inner.extend(other.as_ref().bytes());
HgPathBuf::from_bytes(&inner)
}
pub fn components(&self) -> impl Iterator<Item = &HgPath> {
self.inner.split(|&byte| byte == b'/').map(HgPath::new)
}
/// Returns the first (that is "root-most") slash-separated component of
/// the path, and the rest after the first slash if there is one.
pub fn split_first_component(&self) -> (&HgPath, Option<&HgPath>) {
match self.inner.split_2(b'/') {
Some((a, b)) => (HgPath::new(a), Some(HgPath::new(b))),
None => (self, None),
}
}
pub fn parent(&self) -> &Self {
let inner = self.as_bytes();
HgPath::new(match inner.iter().rposition(|b| *b == b'/') {
Some(pos) => &inner[..pos],
None => &[],
})
}
/// Given a base directory, returns the slice of `self` relative to the
/// base directory. If `base` is not a directory (does not end with a
/// `b'/'`), returns `None`.
pub fn relative_to(&self, base: impl AsRef<Self>) -> Option<&Self> {
let base = base.as_ref();
if base.is_empty() {
return Some(self);
}
let is_dir = base.as_bytes().ends_with(b"/");
if is_dir && self.starts_with(base) {
Some(Self::new(&self.inner[base.len()..]))
} else {
None
}
}
#[cfg(windows)]
/// Copied from the Python stdlib's `os.path.splitdrive` implementation.
///
/// Split a pathname into drive/UNC sharepoint and relative path
/// specifiers. Returns a 2-tuple (drive_or_unc, path); either part may
/// be empty.
///
/// If you assign
/// result = split_drive(p)
/// It is always true that:
/// result[0] + result[1] == p
///
/// If the path contained a drive letter, drive_or_unc will contain
/// everything up to and including the colon.
/// e.g. split_drive("c:/dir") returns ("c:", "/dir")
///
/// If the path contained a UNC path, the drive_or_unc will contain the
/// host name and share up to but not including the fourth directory
/// separator character.
/// e.g. split_drive("//host/computer/dir") returns ("//host/computer",
/// "/dir")
///
/// Paths cannot contain both a drive letter and a UNC path.
pub fn split_drive<'a>(&self) -> (&HgPath, &HgPath) {
let bytes = self.as_bytes();
let is_sep = |b| std::path::is_separator(b as char);
if self.len() < 2 {
(HgPath::new(b""), &self)
} else if is_sep(bytes[0])
&& is_sep(bytes[1])
&& (self.len() == 2 || !is_sep(bytes[2]))
{
// Is a UNC path:
// vvvvvvvvvvvvvvvvvvvv drive letter or UNC path
// \\machine\mountpoint\directory\etc\...
// directory ^^^^^^^^^^^^^^^
let machine_end_index = bytes[2..].iter().position(|b| is_sep(*b));
let mountpoint_start_index = if let Some(i) = machine_end_index {
i + 2
} else {
return (HgPath::new(b""), &self);
};
match bytes[mountpoint_start_index + 1..]
.iter()
.position(|b| is_sep(*b))
{
// A UNC path can't have two slashes in a row
// (after the initial two)
Some(0) => (HgPath::new(b""), &self),
Some(i) => {
let (a, b) =
bytes.split_at(mountpoint_start_index + 1 + i);
(HgPath::new(a), HgPath::new(b))
}
None => (&self, HgPath::new(b"")),
}
} else if bytes[1] == b':' {
// Drive path c:\directory
let (a, b) = bytes.split_at(2);
(HgPath::new(a), HgPath::new(b))
} else {
(HgPath::new(b""), &self)
}
}
#[cfg(unix)]
/// Split a pathname into drive and path. On Posix, drive is always empty.
pub fn split_drive(&self) -> (&HgPath, &HgPath) {
(HgPath::new(b""), &self)
}
/// Checks for errors in the path, short-circuiting at the first one.
/// This generates fine-grained errors useful for debugging.
/// To simply check if the path is valid during tests, use `is_valid`.
pub fn check_state(&self) -> Result<(), HgPathError> {
if self.is_empty() {
return Ok(());
}
let bytes = self.as_bytes();
let mut previous_byte = None;
if bytes[0] == b'/' {
return Err(HgPathError::LeadingSlash(bytes.to_vec()));
}
for (index, byte) in bytes.iter().enumerate() {
match byte {
0 => {
return Err(HgPathError::ContainsNullByte {
bytes: bytes.to_vec(),
null_byte_index: index,
})
}
b'/' => {
if previous_byte.is_some() && previous_byte == Some(b'/') {
return Err(HgPathError::ConsecutiveSlashes {
bytes: bytes.to_vec(),
second_slash_index: index,
});
}
}
_ => (),
};
previous_byte = Some(*byte);
}
Ok(())
}
#[cfg(test)]
/// Only usable during tests to force developers to handle invalid states
fn is_valid(&self) -> bool {
self.check_state().is_ok()
}
}
impl fmt::Debug for HgPath {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "HgPath({:?})", String::from_utf8_lossy(&self.inner))
}
}
impl fmt::Display for HgPath {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", String::from_utf8_lossy(&self.inner))
}
}
#[derive(
Default, Eq, Ord, Clone, PartialEq, PartialOrd, Hash, derive_more::From,
)]
pub struct HgPathBuf {
inner: Vec<u8>,
}
impl HgPathBuf {
pub fn new() -> Self {
Default::default()
}
pub fn push(&mut self, byte: u8) {
self.inner.push(byte);
}
pub fn from_bytes(s: &[u8]) -> HgPathBuf {
HgPath::new(s).to_owned()
}
pub fn into_vec(self) -> Vec<u8> {
self.inner
}
}
impl fmt::Debug for HgPathBuf {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "HgPathBuf({:?})", String::from_utf8_lossy(&self.inner))
}
}
impl fmt::Display for HgPathBuf {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", String::from_utf8_lossy(&self.inner))
}
}
impl Deref for HgPathBuf {
type Target = HgPath;
#[inline]
fn deref(&self) -> &HgPath {
&HgPath::new(&self.inner)
}
}
impl<T: ?Sized + AsRef<HgPath>> From<&T> for HgPathBuf {
fn from(s: &T) -> HgPathBuf {
s.as_ref().to_owned()
}
}
impl Into<Vec<u8>> for HgPathBuf {
fn into(self) -> Vec<u8> {
self.inner
}
}
impl Borrow<HgPath> for HgPathBuf {
fn borrow(&self) -> &HgPath {
&HgPath::new(self.as_bytes())
}
}
impl ToOwned for HgPath {
type Owned = HgPathBuf;
fn to_owned(&self) -> HgPathBuf {
self.to_hg_path_buf()
}
}
impl AsRef<HgPath> for HgPath {
fn as_ref(&self) -> &HgPath {
self
}
}
impl AsRef<HgPath> for HgPathBuf {
fn as_ref(&self) -> &HgPath {
self
}
}
impl Extend<u8> for HgPathBuf {
fn extend<T: IntoIterator<Item = u8>>(&mut self, iter: T) {
self.inner.extend(iter);
}
}
/// TODO: Once https://www.mercurial-scm.org/wiki/WindowsUTF8Plan is
/// implemented, these conversion utils will have to work differently depending
/// on the repository encoding: either `UTF-8` or `MBCS`.
pub fn hg_path_to_os_string<P: AsRef<HgPath>>(
hg_path: P,
) -> Result<OsString, HgPathError> {
hg_path.as_ref().check_state()?;
let os_str;
#[cfg(unix)]
{
use std::os::unix::ffi::OsStrExt;
os_str = std::ffi::OsStr::from_bytes(&hg_path.as_ref().as_bytes());
}
// TODO Handle other platforms
// TODO: convert from WTF8 to Windows MBCS (ANSI encoding).
Ok(os_str.to_os_string())
}
pub fn hg_path_to_path_buf<P: AsRef<HgPath>>(
hg_path: P,
) -> Result<PathBuf, HgPathError> {
Ok(Path::new(&hg_path_to_os_string(hg_path)?).to_path_buf())
}
pub fn os_string_to_hg_path_buf<S: AsRef<OsStr>>(
os_string: S,
) -> Result<HgPathBuf, HgPathError> {
let buf;
#[cfg(unix)]
{
use std::os::unix::ffi::OsStrExt;
buf = HgPathBuf::from_bytes(&os_string.as_ref().as_bytes());
}
// TODO Handle other platforms
// TODO: convert from WTF8 to Windows MBCS (ANSI encoding).
buf.check_state()?;
Ok(buf)
}
pub fn path_to_hg_path_buf<P: AsRef<Path>>(
path: P,
) -> Result<HgPathBuf, HgPathError> {
let buf;
let os_str = path.as_ref().as_os_str();
#[cfg(unix)]
{
use std::os::unix::ffi::OsStrExt;
buf = HgPathBuf::from_bytes(&os_str.as_bytes());
}
// TODO Handle other platforms
// TODO: convert from WTF8 to Windows MBCS (ANSI encoding).
buf.check_state()?;
Ok(buf)
}
impl TryFrom<PathBuf> for HgPathBuf {
type Error = HgPathError;
fn try_from(path: PathBuf) -> Result<Self, Self::Error> {
path_to_hg_path_buf(path)
}
}
impl From<HgPathBuf> for Cow<'_, HgPath> {
fn from(path: HgPathBuf) -> Self {
Cow::Owned(path)
}
}
impl<'a> From<&'a HgPath> for Cow<'a, HgPath> {
fn from(path: &'a HgPath) -> Self {
Cow::Borrowed(path)
}
}
impl<'a> From<&'a HgPathBuf> for Cow<'a, HgPath> {
fn from(path: &'a HgPathBuf) -> Self {
Cow::Borrowed(&**path)
}
}
#[cfg(test)]
mod tests {
use super::*;
use pretty_assertions::assert_eq;
#[test]
fn test_path_states() {
assert_eq!(
Err(HgPathError::LeadingSlash(b"/".to_vec())),
HgPath::new(b"/").check_state()
);
assert_eq!(
Err(HgPathError::ConsecutiveSlashes {
bytes: b"a/b//c".to_vec(),
second_slash_index: 4
}),
HgPath::new(b"a/b//c").check_state()
);
assert_eq!(
Err(HgPathError::ContainsNullByte {
bytes: b"a/b/\0c".to_vec(),
null_byte_index: 4
}),
HgPath::new(b"a/b/\0c").check_state()
);
// TODO test HgPathError::DecodeError for the Windows implementation.
assert_eq!(true, HgPath::new(b"").is_valid());
assert_eq!(true, HgPath::new(b"a/b/c").is_valid());
// Backslashes in paths are not significant, but allowed
assert_eq!(true, HgPath::new(br"a\b/c").is_valid());
// Dots in paths are not significant, but allowed
assert_eq!(true, HgPath::new(b"a/b/../c/").is_valid());
assert_eq!(true, HgPath::new(b"./a/b/../c/").is_valid());
}
#[test]
fn test_iter() {
let path = HgPath::new(b"a");
let mut iter = path.bytes();
assert_eq!(Some(&b'a'), iter.next());
assert_eq!(None, iter.next_back());
assert_eq!(None, iter.next());
let path = HgPath::new(b"a");
let mut iter = path.bytes();
assert_eq!(Some(&b'a'), iter.next_back());
assert_eq!(None, iter.next_back());
assert_eq!(None, iter.next());
let path = HgPath::new(b"abc");
let mut iter = path.bytes();
assert_eq!(Some(&b'a'), iter.next());
assert_eq!(Some(&b'c'), iter.next_back());
assert_eq!(Some(&b'b'), iter.next_back());
assert_eq!(None, iter.next_back());
assert_eq!(None, iter.next());
let path = HgPath::new(b"abc");
let mut iter = path.bytes();
assert_eq!(Some(&b'a'), iter.next());
assert_eq!(Some(&b'b'), iter.next());
assert_eq!(Some(&b'c'), iter.next());
assert_eq!(None, iter.next_back());
assert_eq!(None, iter.next());
let path = HgPath::new(b"abc");
let iter = path.bytes();
let mut vec = Vec::new();
vec.extend(iter);
assert_eq!(vec![b'a', b'b', b'c'], vec);
let path = HgPath::new(b"abc");
let mut iter = path.bytes();
assert_eq!(Some(2), iter.rposition(|c| *c == b'c'));
let path = HgPath::new(b"abc");
let mut iter = path.bytes();
assert_eq!(None, iter.rposition(|c| *c == b'd'));
}
#[test]
fn test_join() {
let path = HgPathBuf::from_bytes(b"a").join(HgPath::new(b"b"));
assert_eq!(b"a/b", path.as_bytes());
let path = HgPathBuf::from_bytes(b"a/").join(HgPath::new(b"b/c"));
assert_eq!(b"a/b/c", path.as_bytes());
// No leading slash if empty before join
let path = HgPathBuf::new().join(HgPath::new(b"b/c"));
assert_eq!(b"b/c", path.as_bytes());
// The leading slash is an invalid representation of an `HgPath`, but
// it can happen. This creates another invalid representation of
// consecutive bytes.
// TODO What should be done in this case? Should we silently remove
// the extra slash? Should we change the signature to a problematic
// `Result<HgPathBuf, HgPathError>`, or should we just keep it so and
// let the error happen upon filesystem interaction?
let path = HgPathBuf::from_bytes(b"a/").join(HgPath::new(b"/b"));
assert_eq!(b"a//b", path.as_bytes());
let path = HgPathBuf::from_bytes(b"a").join(HgPath::new(b"/b"));
assert_eq!(b"a//b", path.as_bytes());
}
#[test]
fn test_relative_to() {
let path = HgPath::new(b"");
let base = HgPath::new(b"");
assert_eq!(Some(path), path.relative_to(base));
let path = HgPath::new(b"path");
let base = HgPath::new(b"");
assert_eq!(Some(path), path.relative_to(base));
let path = HgPath::new(b"a");
let base = HgPath::new(b"b");
assert_eq!(None, path.relative_to(base));
let path = HgPath::new(b"a/b");
let base = HgPath::new(b"a");
assert_eq!(None, path.relative_to(base));
let path = HgPath::new(b"a/b");
let base = HgPath::new(b"a/");
assert_eq!(Some(HgPath::new(b"b")), path.relative_to(base));
let path = HgPath::new(b"nested/path/to/b");
let base = HgPath::new(b"nested/path/");
assert_eq!(Some(HgPath::new(b"to/b")), path.relative_to(base));
let path = HgPath::new(b"ends/with/dir/");
let base = HgPath::new(b"ends/");
assert_eq!(Some(HgPath::new(b"with/dir/")), path.relative_to(base));
}
#[test]
#[cfg(unix)]
fn test_split_drive() {
// Taken from the Python stdlib's tests
assert_eq!(
HgPath::new(br"/foo/bar").split_drive(),
(HgPath::new(b""), HgPath::new(br"/foo/bar"))
);
assert_eq!(
HgPath::new(br"foo:bar").split_drive(),
(HgPath::new(b""), HgPath::new(br"foo:bar"))
);
assert_eq!(
HgPath::new(br":foo:bar").split_drive(),
(HgPath::new(b""), HgPath::new(br":foo:bar"))
);
// Also try NT paths; should not split them
assert_eq!(
HgPath::new(br"c:\foo\bar").split_drive(),
(HgPath::new(b""), HgPath::new(br"c:\foo\bar"))
);
assert_eq!(
HgPath::new(b"c:/foo/bar").split_drive(),
(HgPath::new(b""), HgPath::new(br"c:/foo/bar"))
);
assert_eq!(
HgPath::new(br"\\conky\mountpoint\foo\bar").split_drive(),
(
HgPath::new(b""),
HgPath::new(br"\\conky\mountpoint\foo\bar")
)
);
}
#[test]
#[cfg(windows)]
fn test_split_drive() {
assert_eq!(
HgPath::new(br"c:\foo\bar").split_drive(),
(HgPath::new(br"c:"), HgPath::new(br"\foo\bar"))
);
assert_eq!(
HgPath::new(b"c:/foo/bar").split_drive(),
(HgPath::new(br"c:"), HgPath::new(br"/foo/bar"))
);
assert_eq!(
HgPath::new(br"\\conky\mountpoint\foo\bar").split_drive(),
(
HgPath::new(br"\\conky\mountpoint"),
HgPath::new(br"\foo\bar")
)
);
assert_eq!(
HgPath::new(br"//conky/mountpoint/foo/bar").split_drive(),
(
HgPath::new(br"//conky/mountpoint"),
HgPath::new(br"/foo/bar")
)
);
assert_eq!(
HgPath::new(br"\\\conky\mountpoint\foo\bar").split_drive(),
(
HgPath::new(br""),
HgPath::new(br"\\\conky\mountpoint\foo\bar")
)
);
assert_eq!(
HgPath::new(br"///conky/mountpoint/foo/bar").split_drive(),
(
HgPath::new(br""),
HgPath::new(br"///conky/mountpoint/foo/bar")
)
);
assert_eq!(
HgPath::new(br"\\conky\\mountpoint\foo\bar").split_drive(),
(
HgPath::new(br""),
HgPath::new(br"\\conky\\mountpoint\foo\bar")
)
);
assert_eq!(
HgPath::new(br"//conky//mountpoint/foo/bar").split_drive(),
(
HgPath::new(br""),
HgPath::new(br"//conky//mountpoint/foo/bar")
)
);
// UNC part containing U+0130
assert_eq!(
HgPath::new(b"//conky/MOUNTPO\xc4\xb0NT/foo/bar").split_drive(),
(
HgPath::new(b"//conky/MOUNTPO\xc4\xb0NT"),
HgPath::new(br"/foo/bar")
)
);
}
#[test]
fn test_parent() {
let path = HgPath::new(b"");
assert_eq!(path.parent(), path);
let path = HgPath::new(b"a");
assert_eq!(path.parent(), HgPath::new(b""));
let path = HgPath::new(b"a/b");
assert_eq!(path.parent(), HgPath::new(b"a"));
let path = HgPath::new(b"a/other/b");
assert_eq!(path.parent(), HgPath::new(b"a/other"));
}
}