rollup merge of #20481: seanmonstar/fmt-show-string
Conflicts: src/compiletest/runtest.rs src/libcore/fmt/mod.rs src/libfmt_macros/lib.rs src/libregex/parse.rs src/librustc/middle/cfg/construct.rs src/librustc/middle/dataflow.rs src/librustc/middle/infer/higher_ranked/mod.rs src/librustc/middle/ty.rs src/librustc_back/archive.rs src/librustc_borrowck/borrowck/fragments.rs src/librustc_borrowck/borrowck/gather_loans/mod.rs src/librustc_resolve/lib.rs src/librustc_trans/back/link.rs src/librustc_trans/save/mod.rs src/librustc_trans/trans/base.rs src/librustc_trans/trans/callee.rs src/librustc_trans/trans/common.rs src/librustc_trans/trans/consts.rs src/librustc_trans/trans/controlflow.rs src/librustc_trans/trans/debuginfo.rs src/librustc_trans/trans/expr.rs src/librustc_trans/trans/monomorphize.rs src/librustc_typeck/astconv.rs src/librustc_typeck/check/method/mod.rs src/librustc_typeck/check/mod.rs src/librustc_typeck/check/regionck.rs src/librustc_typeck/collect.rs src/libsyntax/ext/format.rs src/libsyntax/ext/source_util.rs src/libsyntax/ext/tt/transcribe.rs src/libsyntax/parse/mod.rs src/libsyntax/parse/token.rs src/test/run-pass/issue-8898.rs
This commit is contained in:
Alex Crichton
commit
5c3ddcb15d
252 changed files with 2703 additions and 2072 deletions
|
|
@ -460,7 +460,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
/// # #[cfg(unix)] fn foo() {
|
||||
/// let mut p = Path::new("abc/def.txt");
|
||||
/// p.set_extension("csv");
|
||||
/// assert!(p == Path::new("abc/def.csv"));
|
||||
/// assert_eq!(p, Path::new("abc/def.csv"));
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
|
|
@ -509,7 +509,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
/// # #[cfg(windows)] fn foo() {}
|
||||
/// # #[cfg(unix)] fn foo() {
|
||||
/// let mut p = Path::new("abc/def.txt");
|
||||
/// assert!(p.with_filename("foo.dat") == Path::new("abc/foo.dat"));
|
||||
/// assert_eq!(p.with_filename("foo.dat"), Path::new("abc/foo.dat"));
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
|
|
@ -534,7 +534,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
/// # #[cfg(windows)] fn foo() {}
|
||||
/// # #[cfg(unix)] fn foo() {
|
||||
/// let mut p = Path::new("abc/def.txt");
|
||||
/// assert!(p.with_extension("csv") == Path::new("abc/def.csv"));
|
||||
/// assert_eq!(p.with_extension("csv"), Path::new("abc/def.csv"));
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
|
|
@ -558,7 +558,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
/// # #[cfg(windows)] fn foo() {}
|
||||
/// # #[cfg(unix)] fn foo() {
|
||||
/// let p = Path::new("abc/def/ghi");
|
||||
/// assert!(p.dir_path() == Path::new("abc/def"));
|
||||
/// assert_eq!(p.dir_path(), Path::new("abc/def"));
|
||||
/// # }
|
||||
/// ```
|
||||
fn dir_path(&self) -> Self {
|
||||
|
|
@ -576,8 +576,8 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
/// # foo();
|
||||
/// # #[cfg(windows)] fn foo() {}
|
||||
/// # #[cfg(unix)] fn foo() {
|
||||
/// assert!(Path::new("abc/def").root_path() == None);
|
||||
/// assert!(Path::new("/abc/def").root_path() == Some(Path::new("/")));
|
||||
/// assert_eq!(Path::new("abc/def").root_path(), None);
|
||||
/// assert_eq!(Path::new("/abc/def").root_path(), Some(Path::new("/")));
|
||||
/// # }
|
||||
/// ```
|
||||
fn root_path(&self) -> Option<Self>;
|
||||
|
|
@ -593,7 +593,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
/// # #[cfg(unix)] fn foo() {
|
||||
/// let mut p = Path::new("foo/bar");
|
||||
/// p.push("baz.txt");
|
||||
/// assert!(p == Path::new("foo/bar/baz.txt"));
|
||||
/// assert_eq!(p, Path::new("foo/bar/baz.txt"));
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
|
|
@ -617,7 +617,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
/// # #[cfg(unix)] fn foo() {
|
||||
/// let mut p = Path::new("foo");
|
||||
/// p.push_many(&["bar", "baz.txt"]);
|
||||
/// assert!(p == Path::new("foo/bar/baz.txt"));
|
||||
/// assert_eq!(p, Path::new("foo/bar/baz.txt"));
|
||||
/// # }
|
||||
/// ```
|
||||
#[inline]
|
||||
|
|
@ -646,7 +646,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
/// # #[cfg(unix)] fn foo() {
|
||||
/// let mut p = Path::new("foo/bar/baz.txt");
|
||||
/// p.pop();
|
||||
/// assert!(p == Path::new("foo/bar"));
|
||||
/// assert_eq!(p, Path::new("foo/bar"));
|
||||
/// # }
|
||||
/// ```
|
||||
fn pop(&mut self) -> bool;
|
||||
|
|
@ -662,7 +662,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
/// # #[cfg(windows)] fn foo() {}
|
||||
/// # #[cfg(unix)] fn foo() {
|
||||
/// let p = Path::new("/foo");
|
||||
/// assert!(p.join("bar.txt") == Path::new("/foo/bar.txt"));
|
||||
/// assert_eq!(p.join("bar.txt"), Path::new("/foo/bar.txt"));
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
|
|
@ -688,7 +688,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
/// # #[cfg(unix)] fn foo() {
|
||||
/// let p = Path::new("foo");
|
||||
/// let fbbq = Path::new("foo/bar/baz/quux.txt");
|
||||
/// assert!(p.join_many(&["bar", "baz", "quux.txt"]) == fbbq);
|
||||
/// assert_eq!(p.join_many(&["bar", "baz", "quux.txt"]), fbbq);
|
||||
/// # }
|
||||
/// ```
|
||||
#[inline]
|
||||
|
|
@ -765,7 +765,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
/// let p = Path::new("foo/bar/baz/quux.txt");
|
||||
/// let fb = Path::new("foo/bar");
|
||||
/// let bq = Path::new("baz/quux.txt");
|
||||
/// assert!(p.path_relative_from(&fb) == Some(bq));
|
||||
/// assert_eq!(p.path_relative_from(&fb), Some(bq));
|
||||
/// # }
|
||||
/// ```
|
||||
fn path_relative_from(&self, base: &Self) -> Option<Self>;
|
||||
|
|
@ -823,7 +823,14 @@ pub struct Display<'a, P:'a> {
|
|||
filename: bool
|
||||
}
|
||||
|
||||
//NOTE(stage0): replace with deriving(Show) after snapshot
|
||||
impl<'a, P: GenericPath> fmt::Show for Display<'a, P> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
fmt::String::fmt(self, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, P: GenericPath> fmt::String for Display<'a, P> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
self.as_cow().fmt(f)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@
|
|||
|
||||
use clone::Clone;
|
||||
use cmp::{Ordering, Eq, Ord, PartialEq, PartialOrd};
|
||||
use fmt;
|
||||
use hash;
|
||||
use io::Writer;
|
||||
use iter::{AdditiveIterator, Extend};
|
||||
|
|
@ -57,6 +58,12 @@ pub fn is_sep(c: char) -> bool {
|
|||
c == SEP
|
||||
}
|
||||
|
||||
impl fmt::Show for Path {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(f, "Path {{ {} }}", self.display())
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq for Path {
|
||||
#[inline]
|
||||
fn eq(&self, other: &Path) -> bool {
|
||||
|
|
@ -439,13 +446,13 @@ mod tests {
|
|||
(s: $path:expr, $exp:expr) => (
|
||||
{
|
||||
let path = $path;
|
||||
assert!(path.as_str() == Some($exp));
|
||||
assert_eq!(path.as_str(), Some($exp));
|
||||
}
|
||||
);
|
||||
(v: $path:expr, $exp:expr) => (
|
||||
{
|
||||
let path = $path;
|
||||
assert!(path.as_vec() == $exp);
|
||||
assert_eq!(path.as_vec(), $exp);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -459,7 +466,7 @@ mod tests {
|
|||
t!(v: Path::new(b"a/b/c\xFF"), b"a/b/c\xFF");
|
||||
t!(v: Path::new(b"\xFF/../foo\x80"), b"foo\x80");
|
||||
let p = Path::new(b"a/b/c\xFF");
|
||||
assert!(p.as_str() == None);
|
||||
assert!(p.as_str().is_none());
|
||||
|
||||
t!(s: Path::new(""), ".");
|
||||
t!(s: Path::new("/"), "/");
|
||||
|
|
@ -489,14 +496,14 @@ mod tests {
|
|||
b"/bar");
|
||||
|
||||
let p = Path::new(b"foo/bar\x80");
|
||||
assert!(p.as_str() == None);
|
||||
assert!(p.as_str().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_opt_paths() {
|
||||
assert!(Path::new_opt(b"foo/bar\0") == None);
|
||||
assert!(Path::new_opt(b"foo/bar\0").is_none());
|
||||
t!(v: Path::new_opt(b"foo/bar").unwrap(), b"foo/bar");
|
||||
assert!(Path::new_opt("foo/bar\0") == None);
|
||||
assert!(Path::new_opt("foo/bar\0").is_none());
|
||||
t!(s: Path::new_opt("foo/bar").unwrap(), "foo/bar");
|
||||
}
|
||||
|
||||
|
|
@ -525,7 +532,7 @@ mod tests {
|
|||
($path:expr, $disp:ident, $exp:expr) => (
|
||||
{
|
||||
let path = Path::new($path);
|
||||
assert!(path.$disp().to_string() == $exp);
|
||||
assert_eq!(path.$disp().to_string(), $exp);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -541,14 +548,14 @@ mod tests {
|
|||
{
|
||||
let path = Path::new($path);
|
||||
let mo = path.display().as_cow();
|
||||
assert!(mo.as_slice() == $exp);
|
||||
assert_eq!(mo.as_slice(), $exp);
|
||||
}
|
||||
);
|
||||
($path:expr, $exp:expr, filename) => (
|
||||
{
|
||||
let path = Path::new($path);
|
||||
let mo = path.filename_display().as_cow();
|
||||
assert!(mo.as_slice() == $exp);
|
||||
assert_eq!(mo.as_slice(), $exp);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -568,9 +575,9 @@ mod tests {
|
|||
{
|
||||
let path = Path::new($path);
|
||||
let f = format!("{}", path.display());
|
||||
assert!(f == $exp);
|
||||
assert_eq!(f, $exp);
|
||||
let f = format!("{}", path.filename_display());
|
||||
assert!(f == $expf);
|
||||
assert_eq!(f, $expf);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -590,21 +597,21 @@ mod tests {
|
|||
(s: $path:expr, $op:ident, $exp:expr) => (
|
||||
{
|
||||
let path = Path::new($path);
|
||||
assert!(path.$op() == ($exp).as_bytes());
|
||||
assert_eq!(path.$op(), ($exp).as_bytes());
|
||||
}
|
||||
);
|
||||
(s: $path:expr, $op:ident, $exp:expr, opt) => (
|
||||
{
|
||||
let path = Path::new($path);
|
||||
let left = path.$op().map(|x| str::from_utf8(x).unwrap());
|
||||
assert!(left == $exp);
|
||||
assert_eq!(left, $exp);
|
||||
}
|
||||
);
|
||||
(v: $path:expr, $op:ident, $exp:expr) => (
|
||||
{
|
||||
let arg = $path;
|
||||
let path = Path::new(arg);
|
||||
assert!(path.$op() == $exp);
|
||||
assert_eq!(path.$op(), $exp);
|
||||
}
|
||||
);
|
||||
}
|
||||
|
|
@ -678,7 +685,7 @@ mod tests {
|
|||
let mut p1 = Path::new(path);
|
||||
let p2 = p1.clone();
|
||||
p1.push(join);
|
||||
assert!(p1 == p2.join(join));
|
||||
assert_eq!(p1, p2.join(join));
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -697,7 +704,7 @@ mod tests {
|
|||
let mut p = Path::new($path);
|
||||
let push = Path::new($push);
|
||||
p.push(&push);
|
||||
assert!(p.as_str() == Some($exp));
|
||||
assert_eq!(p.as_str(), Some($exp));
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -717,14 +724,14 @@ mod tests {
|
|||
{
|
||||
let mut p = Path::new($path);
|
||||
p.push_many(&$push);
|
||||
assert!(p.as_str() == Some($exp));
|
||||
assert_eq!(p.as_str(), Some($exp));
|
||||
}
|
||||
);
|
||||
(v: $path:expr, $push:expr, $exp:expr) => (
|
||||
{
|
||||
let mut p = Path::new($path);
|
||||
p.push_many(&$push);
|
||||
assert!(p.as_vec() == $exp);
|
||||
assert_eq!(p.as_vec(), $exp);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -745,16 +752,16 @@ mod tests {
|
|||
{
|
||||
let mut p = Path::new($path);
|
||||
let result = p.pop();
|
||||
assert!(p.as_str() == Some($left));
|
||||
assert!(result == $right);
|
||||
assert_eq!(p.as_str(), Some($left));
|
||||
assert_eq!(result, $right);
|
||||
}
|
||||
);
|
||||
(b: $path:expr, $left:expr, $right:expr) => (
|
||||
{
|
||||
let mut p = Path::new($path);
|
||||
let result = p.pop();
|
||||
assert!(p.as_vec() == $left);
|
||||
assert!(result == $right);
|
||||
assert_eq!(p.as_vec(), $left);
|
||||
assert_eq!(result, $right);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -777,8 +784,8 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_root_path() {
|
||||
assert!(Path::new(b"a/b/c").root_path() == None);
|
||||
assert!(Path::new(b"/a/b/c").root_path() == Some(Path::new("/")));
|
||||
assert_eq!(Path::new(b"a/b/c").root_path(), None);
|
||||
assert_eq!(Path::new(b"/a/b/c").root_path(), Some(Path::new("/")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -802,7 +809,7 @@ mod tests {
|
|||
let path = Path::new($path);
|
||||
let join = Path::new($join);
|
||||
let res = path.join(&join);
|
||||
assert!(res.as_str() == Some($exp));
|
||||
assert_eq!(res.as_str(), Some($exp));
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -822,14 +829,14 @@ mod tests {
|
|||
{
|
||||
let path = Path::new($path);
|
||||
let res = path.join_many(&$join);
|
||||
assert!(res.as_str() == Some($exp));
|
||||
assert_eq!(res.as_str(), Some($exp));
|
||||
}
|
||||
);
|
||||
(v: $path:expr, $join:expr, $exp:expr) => (
|
||||
{
|
||||
let path = Path::new($path);
|
||||
let res = path.join_many(&$join);
|
||||
assert!(res.as_vec() == $exp);
|
||||
assert_eq!(res.as_vec(), $exp);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -903,7 +910,7 @@ mod tests {
|
|||
let mut p1 = Path::new(path);
|
||||
p1.$set(arg);
|
||||
let p2 = Path::new(path);
|
||||
assert!(p1 == p2.$with(arg));
|
||||
assert_eq!(p1, p2.$with(arg));
|
||||
}
|
||||
);
|
||||
(v: $path:expr, $set:ident, $with:ident, $arg:expr) => (
|
||||
|
|
@ -913,7 +920,7 @@ mod tests {
|
|||
let mut p1 = Path::new(path);
|
||||
p1.$set(arg);
|
||||
let p2 = Path::new(path);
|
||||
assert!(p1 == p2.$with(arg));
|
||||
assert_eq!(p1, p2.$with(arg));
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -943,31 +950,19 @@ mod tests {
|
|||
(s: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
|
||||
{
|
||||
let path = $path;
|
||||
let filename = $filename;
|
||||
assert!(path.filename_str() == filename,
|
||||
"{}.filename_str(): Expected `{}`, found {}",
|
||||
path.as_str().unwrap(), filename, path.filename_str());
|
||||
let dirname = $dirname;
|
||||
assert!(path.dirname_str() == dirname,
|
||||
"`{}`.dirname_str(): Expected `{}`, found `{}`",
|
||||
path.as_str().unwrap(), dirname, path.dirname_str());
|
||||
let filestem = $filestem;
|
||||
assert!(path.filestem_str() == filestem,
|
||||
"`{}`.filestem_str(): Expected `{}`, found `{}`",
|
||||
path.as_str().unwrap(), filestem, path.filestem_str());
|
||||
let ext = $ext;
|
||||
assert!(path.extension_str() == ext,
|
||||
"`{}`.extension_str(): Expected `{}`, found `{}`",
|
||||
path.as_str().unwrap(), ext, path.extension_str());
|
||||
}
|
||||
assert_eq!(path.filename_str(), $filename);
|
||||
assert_eq!(path.dirname_str(), $dirname);
|
||||
assert_eq!(path.filestem_str(), $filestem);
|
||||
assert_eq!(path.extension_str(), $ext);
|
||||
}
|
||||
);
|
||||
(v: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
|
||||
{
|
||||
let path = $path;
|
||||
assert!(path.filename() == $filename);
|
||||
assert!(path.dirname() == $dirname);
|
||||
assert!(path.filestem() == $filestem);
|
||||
assert!(path.extension() == $ext);
|
||||
assert_eq!(path.filename(), $filename);
|
||||
assert_eq!(path.dirname(), $dirname);
|
||||
assert_eq!(path.filestem(), $filestem);
|
||||
assert_eq!(path.extension(), $ext);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -1155,12 +1150,10 @@ mod tests {
|
|||
let comps = path.components().collect::<Vec<&[u8]>>();
|
||||
let exp: &[&str] = &$exp;
|
||||
let exps = exp.iter().map(|x| x.as_bytes()).collect::<Vec<&[u8]>>();
|
||||
assert!(comps == exps, "components: Expected {}, found {}",
|
||||
comps, exps);
|
||||
assert_eq!(comps, exprs);
|
||||
let comps = path.components().rev().collect::<Vec<&[u8]>>();
|
||||
let exps = exps.into_iter().rev().collect::<Vec<&[u8]>>();
|
||||
assert!(comps == exps, "rev_components: Expected {}, found {}",
|
||||
comps, exps);
|
||||
assert_eq!(comps, exps);
|
||||
}
|
||||
);
|
||||
(b: $arg:expr, [$($exp:expr),*]) => (
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ use ascii::AsciiExt;
|
|||
use char::CharExt;
|
||||
use clone::Clone;
|
||||
use cmp::{Ordering, Eq, Ord, PartialEq, PartialOrd};
|
||||
use fmt;
|
||||
use hash;
|
||||
use io::Writer;
|
||||
use iter::{AdditiveIterator, Extend};
|
||||
|
|
@ -84,6 +85,12 @@ pub struct Path {
|
|||
sepidx: Option<uint> // index of the final separator in the non-prefix portion of repr
|
||||
}
|
||||
|
||||
impl fmt::Show for Path {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(f, "Path {{ {} }}", self.display())
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq for Path {
|
||||
#[inline]
|
||||
fn eq(&self, other: &Path) -> bool {
|
||||
|
|
@ -1119,13 +1126,13 @@ mod tests {
|
|||
(s: $path:expr, $exp:expr) => (
|
||||
{
|
||||
let path = $path;
|
||||
assert!(path.as_str() == Some($exp));
|
||||
assert_eq!(path.as_str(), Some($exp));
|
||||
}
|
||||
);
|
||||
(v: $path:expr, $exp:expr) => (
|
||||
{
|
||||
let path = $path;
|
||||
assert!(path.as_vec() == $exp);
|
||||
assert_eq!(path.as_vec(), $exp);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -1138,8 +1145,7 @@ mod tests {
|
|||
let path = $path;
|
||||
let exp = $exp;
|
||||
let res = parse_prefix(path);
|
||||
assert!(res == exp,
|
||||
"parse_prefix(\"{}\"): expected {}, found {}", path, exp, res);
|
||||
assert_eq!(res, exp);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -1355,7 +1361,7 @@ mod tests {
|
|||
{
|
||||
let path = $path;
|
||||
let path = Path::new(path);
|
||||
assert!(path.$op() == Some($exp));
|
||||
assert_eq!(path.$op(), Some($exp));
|
||||
}
|
||||
);
|
||||
(s: $path:expr, $op:ident, $exp:expr, opt) => (
|
||||
|
|
@ -1363,14 +1369,14 @@ mod tests {
|
|||
let path = $path;
|
||||
let path = Path::new(path);
|
||||
let left = path.$op();
|
||||
assert!(left == $exp);
|
||||
assert_eq!(left, $exp);
|
||||
}
|
||||
);
|
||||
(v: $path:expr, $op:ident, $exp:expr) => (
|
||||
{
|
||||
let path = $path;
|
||||
let path = Path::new(path);
|
||||
assert!(path.$op() == $exp);
|
||||
assert_eq!(path.$op(), $exp);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -1481,7 +1487,7 @@ mod tests {
|
|||
let mut p1 = Path::new(path);
|
||||
let p2 = p1.clone();
|
||||
p1.push(join);
|
||||
assert!(p1 == p2.join(join));
|
||||
assert_eq!(p1, p2.join(join));
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -1495,9 +1501,9 @@ mod tests {
|
|||
|
||||
// we do want to check one odd case though to ensure the prefix is re-parsed
|
||||
let mut p = Path::new("\\\\?\\C:");
|
||||
assert!(prefix(&p) == Some(VerbatimPrefix(2)));
|
||||
assert_eq!(prefix(&p), Some(VerbatimPrefix(2)));
|
||||
p.push("foo");
|
||||
assert!(prefix(&p) == Some(VerbatimDiskPrefix));
|
||||
assert_eq!(prefix(&p), Some(VerbatimDiskPrefix));
|
||||
assert_eq!(p.as_str(), Some("\\\\?\\C:\\foo"));
|
||||
|
||||
// and another with verbatim non-normalized paths
|
||||
|
|
@ -1596,10 +1602,8 @@ mod tests {
|
|||
let mut p = Path::new(pstr);
|
||||
let result = p.pop();
|
||||
let left = $left;
|
||||
assert!(p.as_str() == Some(left),
|
||||
"`{}`.pop() failed; expected remainder `{}`, found `{}`",
|
||||
pstr, left, p.as_str().unwrap());
|
||||
assert!(result == $right);
|
||||
assert_eq!(p.as_str(), Some(left));
|
||||
assert_eq!(result, $right);
|
||||
}
|
||||
);
|
||||
(b: $path:expr, $left:expr, $right:expr) => (
|
||||
|
|
@ -1607,7 +1611,7 @@ mod tests {
|
|||
let mut p = Path::new($path);
|
||||
let result = p.pop();
|
||||
assert_eq!(p.as_vec(), $left);
|
||||
assert!(result == $right);
|
||||
assert_eq!(result, $right);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -1650,16 +1654,16 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_root_path() {
|
||||
assert!(Path::new("a\\b\\c").root_path() == None);
|
||||
assert!(Path::new("\\a\\b\\c").root_path() == Some(Path::new("\\")));
|
||||
assert!(Path::new("C:a").root_path() == Some(Path::new("C:")));
|
||||
assert!(Path::new("C:\\a").root_path() == Some(Path::new("C:\\")));
|
||||
assert!(Path::new("\\\\a\\b\\c").root_path() == Some(Path::new("\\\\a\\b")));
|
||||
assert!(Path::new("\\\\?\\a\\b").root_path() == Some(Path::new("\\\\?\\a")));
|
||||
assert!(Path::new("\\\\?\\C:\\a").root_path() == Some(Path::new("\\\\?\\C:\\")));
|
||||
assert!(Path::new("\\\\?\\UNC\\a\\b\\c").root_path() ==
|
||||
assert_eq!(Path::new("a\\b\\c").root_path(), None);
|
||||
assert_eq!(Path::new("\\a\\b\\c").root_path(), Some(Path::new("\\")));
|
||||
assert_eq!(Path::new("C:a").root_path(), Some(Path::new("C:")));
|
||||
assert_eq!(Path::new("C:\\a").root_path(), Some(Path::new("C:\\")));
|
||||
assert_eq!(Path::new("\\\\a\\b\\c").root_path(), Some(Path::new("\\\\a\\b")));
|
||||
assert_eq!(Path::new("\\\\?\\a\\b").root_path(), Some(Path::new("\\\\?\\a")));
|
||||
assert_eq!(Path::new("\\\\?\\C:\\a").root_path(), Some(Path::new("\\\\?\\C:\\")));
|
||||
assert_eq!(Path::new("\\\\?\\UNC\\a\\b\\c").root_path(),
|
||||
Some(Path::new("\\\\?\\UNC\\a\\b")));
|
||||
assert!(Path::new("\\\\.\\a\\b").root_path() == Some(Path::new("\\\\.\\a")));
|
||||
assert_eq!(Path::new("\\\\.\\a\\b").root_path(), Some(Path::new("\\\\.\\a")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1737,9 +1741,7 @@ mod tests {
|
|||
let arg = $arg;
|
||||
let res = path.$op(arg);
|
||||
let exp = $res;
|
||||
assert!(res.as_str() == Some(exp),
|
||||
"`{}`.{}(\"{}\"): Expected `{}`, found `{}`",
|
||||
pstr, stringify!($op), arg, exp, res.as_str().unwrap());
|
||||
assert_eq!(Path::new($path).$op($arg), $res);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -1822,7 +1824,7 @@ mod tests {
|
|||
let mut p1 = Path::new(path);
|
||||
p1.$set(arg);
|
||||
let p2 = Path::new(path);
|
||||
assert!(p1 == p2.$with(arg));
|
||||
assert_eq!(p1, p2.$with(arg));
|
||||
}
|
||||
);
|
||||
(v: $path:expr, $set:ident, $with:ident, $arg:expr) => (
|
||||
|
|
@ -1832,7 +1834,7 @@ mod tests {
|
|||
let mut p1 = Path::new(path);
|
||||
p1.$set(arg);
|
||||
let p2 = Path::new(path);
|
||||
assert!(p1 == p2.$with(arg));
|
||||
assert_eq!(p1, p2.$with(arg));
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -1863,31 +1865,19 @@ mod tests {
|
|||
(s: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
|
||||
{
|
||||
let path = $path;
|
||||
let filename = $filename;
|
||||
assert!(path.filename_str() == filename,
|
||||
"`{}`.filename_str(): Expected `{}`, found `{}`",
|
||||
path.as_str().unwrap(), filename, path.filename_str());
|
||||
let dirname = $dirname;
|
||||
assert!(path.dirname_str() == dirname,
|
||||
"`{}`.dirname_str(): Expected `{}`, found `{}`",
|
||||
path.as_str().unwrap(), dirname, path.dirname_str());
|
||||
let filestem = $filestem;
|
||||
assert!(path.filestem_str() == filestem,
|
||||
"`{}`.filestem_str(): Expected `{}`, found `{}`",
|
||||
path.as_str().unwrap(), filestem, path.filestem_str());
|
||||
let ext = $ext;
|
||||
assert!(path.extension_str() == ext,
|
||||
"`{}`.extension_str(): Expected `{}`, found `{}`",
|
||||
path.as_str().unwrap(), ext, path.extension_str());
|
||||
assert_eq!(path.filename_str(), $filename);
|
||||
assert_eq!(path.dirname_str(), $dirname);
|
||||
assert_eq!(path.filestem_str(), $filestem);
|
||||
assert_eq!(path.extension_str(), $ext);
|
||||
}
|
||||
);
|
||||
(v: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
|
||||
{
|
||||
let path = $path;
|
||||
assert!(path.filename() == $filename);
|
||||
assert!(path.dirname() == $dirname);
|
||||
assert!(path.filestem() == $filestem);
|
||||
assert!(path.extension() == $ext);
|
||||
assert_eq!(path.filename(), $filename);
|
||||
assert_eq!(path.dirname(), $dirname);
|
||||
assert_eq!(path.filestem(), $filestem);
|
||||
assert_eq!(path.extension(), $ext);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -1931,17 +1921,10 @@ mod tests {
|
|||
let path = Path::new($path);
|
||||
let (abs, vol, cwd, rel) = ($abs, $vol, $cwd, $rel);
|
||||
let b = path.is_absolute();
|
||||
assert!(b == abs, "Path '{}'.is_absolute(): expected {}, found {}",
|
||||
path.as_str().unwrap(), abs, b);
|
||||
let b = is_vol_relative(&path);
|
||||
assert!(b == vol, "is_vol_relative('{}'): expected {}, found {}",
|
||||
path.as_str().unwrap(), vol, b);
|
||||
let b = is_cwd_relative(&path);
|
||||
assert!(b == cwd, "is_cwd_relative('{}'): expected {}, found {}",
|
||||
path.as_str().unwrap(), cwd, b);
|
||||
let b = path.is_relative();
|
||||
assert!(b == rel, "Path '{}'.is_relativf(): expected {}, found {}",
|
||||
path.as_str().unwrap(), rel, b);
|
||||
assert_eq!(path.is_absolute(), asb);
|
||||
assert_eq!(is_vol_relative(&path), vol);
|
||||
assert_eq!(is_cwd_relative(&path), cwd);
|
||||
assert_eq!(path.is_relative(), rel);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -1972,9 +1955,7 @@ mod tests {
|
|||
let dest = Path::new($dest);
|
||||
let exp = $exp;
|
||||
let res = path.is_ancestor_of(&dest);
|
||||
assert!(res == exp,
|
||||
"`{}`.is_ancestor_of(`{}`): Expected {}, found {}",
|
||||
path.as_str().unwrap(), dest.as_str().unwrap(), exp, res);
|
||||
assert_eq!(Path::new($path).is_ancestor_of(Path::new($dest)), $exp);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -2103,14 +2084,8 @@ mod tests {
|
|||
macro_rules! t {
|
||||
(s: $path:expr, $other:expr, $exp:expr) => (
|
||||
{
|
||||
let path = Path::new($path);
|
||||
let other = Path::new($other);
|
||||
let res = path.path_relative_from(&other);
|
||||
let exp = $exp;
|
||||
assert!(res.as_ref().and_then(|x| x.as_str()) == exp,
|
||||
"`{}`.path_relative_from(`{}`): Expected {}, got {}",
|
||||
path.as_str().unwrap(), other.as_str().unwrap(), exp,
|
||||
res.as_ref().and_then(|x| x.as_str()));
|
||||
assert_eq!(Path::new($path).path_relative_from(Path::new($other))
|
||||
.as_ref().and_then(|x| x.as_str()), $exp);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
@ -2319,7 +2294,7 @@ mod tests {
|
|||
let path = Path::new($path);
|
||||
let exp: Option<&str> = $exp;
|
||||
let exp = exp.map(|s| Path::new(s));
|
||||
assert!(make_non_verbatim(&path) == exp);
|
||||
assert_eq!(make_non_verbatim(&path), exp);
|
||||
}
|
||||
)
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue