7 ($path:expr, iter: $iter:expr) => (
9 let path = Path::new($path);
12 let comps = path.iter()
13 .map(|p| p.to_string_lossy().into_owned())
14 .collect::<Vec<String>>();
15 let exp: &[&str] = &$iter;
16 let exps = exp.iter().map(|s| s.to_string()).collect::<Vec<String>>();
17 assert!(comps == exps, "iter: Expected {:?}, found {:?}",
21 let comps = Path::new($path).iter().rev()
22 .map(|p| p.to_string_lossy().into_owned())
23 .collect::<Vec<String>>();
24 let exps = exps.into_iter().rev().collect::<Vec<String>>();
25 assert!(comps == exps, "iter().rev(): Expected {:?}, found {:?}",
30 ($path:expr, has_root: $has_root:expr, is_absolute: $is_absolute:expr) => (
32 let path = Path::new($path);
34 let act_root = path.has_root();
35 assert!(act_root == $has_root, "has_root: Expected {:?}, found {:?}",
38 let act_abs = path.is_absolute();
39 assert!(act_abs == $is_absolute, "is_absolute: Expected {:?}, found {:?}",
40 $is_absolute, act_abs);
44 ($path:expr, parent: $parent:expr, file_name: $file:expr) => (
46 let path = Path::new($path);
48 let parent = path.parent().map(|p| p.to_str().unwrap());
49 let exp_parent: Option<&str> = $parent;
50 assert!(parent == exp_parent, "parent: Expected {:?}, found {:?}",
53 let file = path.file_name().map(|p| p.to_str().unwrap());
54 let exp_file: Option<&str> = $file;
55 assert!(file == exp_file, "file_name: Expected {:?}, found {:?}",
60 ($path:expr, file_stem: $file_stem:expr, extension: $extension:expr) => (
62 let path = Path::new($path);
64 let stem = path.file_stem().map(|p| p.to_str().unwrap());
65 let exp_stem: Option<&str> = $file_stem;
66 assert!(stem == exp_stem, "file_stem: Expected {:?}, found {:?}",
69 let ext = path.extension().map(|p| p.to_str().unwrap());
70 let exp_ext: Option<&str> = $extension;
71 assert!(ext == exp_ext, "extension: Expected {:?}, found {:?}",
76 ($path:expr, iter: $iter:expr,
77 has_root: $has_root:expr, is_absolute: $is_absolute:expr,
78 parent: $parent:expr, file_name: $file:expr,
79 file_stem: $file_stem:expr, extension: $extension:expr) => (
81 t!($path, iter: $iter);
82 t!($path, has_root: $has_root, is_absolute: $is_absolute);
83 t!($path, parent: $parent, file_name: $file);
84 t!($path, file_stem: $file_stem, extension: $extension);
91 use crate::borrow::Cow;
93 let static_path = Path::new("/home/foo");
94 let static_cow_path: Cow<'static, Path> = static_path.into();
95 let pathbuf = PathBuf::from("/home/foo");
98 let path: &Path = &pathbuf;
99 let borrowed_cow_path: Cow<'_, Path> = path.into();
101 assert_eq!(static_cow_path, borrowed_cow_path);
104 let owned_cow_path: Cow<'static, Path> = pathbuf.into();
106 assert_eq!(static_cow_path, owned_cow_path);
111 pub fn test_decompositions_unix() {
127 file_name: Some("foo"),
128 file_stem: Some("foo"),
147 file_name: Some("foo"),
148 file_stem: Some("foo"),
157 file_name: Some("foo"),
158 file_stem: Some("foo"),
167 file_name: Some("foo"),
168 file_stem: Some("foo"),
173 iter: ["foo", "bar"],
177 file_name: Some("bar"),
178 file_stem: Some("bar"),
183 iter: ["/", "foo", "bar"],
186 parent: Some("/foo"),
187 file_name: Some("bar"),
188 file_stem: Some("bar"),
197 file_name: Some("foo"),
198 file_stem: Some("foo"),
203 iter: ["/", "foo", "bar"],
206 parent: Some("///foo"),
207 file_name: Some("bar"),
208 file_stem: Some("bar"),
247 file_name: Some("foo"),
248 file_stem: Some("foo"),
267 file_name: Some("foo"),
268 file_stem: Some("foo"),
273 iter: ["foo", "bar"],
277 file_name: Some("bar"),
278 file_stem: Some("bar"),
293 iter: ["foo", "..", "bar"],
296 parent: Some("foo/.."),
297 file_name: Some("bar"),
298 file_stem: Some("bar"),
307 file_name: Some("a"),
308 file_stem: Some("a"),
337 file_name: Some("b"),
338 file_stem: Some("b"),
347 file_name: Some("b"),
348 file_stem: Some("b"),
357 file_name: Some("b"),
358 file_stem: Some("b"),
363 iter: ["a", "b", "c"],
367 file_name: Some("c"),
368 file_stem: Some("c"),
377 file_name: Some(".foo"),
378 file_stem: Some(".foo"),
385 pub fn test_decompositions_windows() {
401 file_name: Some("foo"),
402 file_stem: Some("foo"),
461 file_name: Some("foo"),
462 file_stem: Some("foo"),
471 file_name: Some("foo"),
472 file_stem: Some("foo"),
481 file_name: Some("foo"),
482 file_stem: Some("foo"),
487 iter: ["foo", "bar"],
491 file_name: Some("bar"),
492 file_stem: Some("bar"),
497 iter: ["\\", "foo", "bar"],
500 parent: Some("/foo"),
501 file_name: Some("bar"),
502 file_stem: Some("bar"),
511 file_name: Some("foo"),
512 file_stem: Some("foo"),
517 iter: ["\\", "foo", "bar"],
520 parent: Some("///foo"),
521 file_name: Some("bar"),
522 file_stem: Some("bar"),
561 file_name: Some("foo"),
562 file_stem: Some("foo"),
581 file_name: Some("foo"),
582 file_stem: Some("foo"),
587 iter: ["foo", "bar"],
591 file_name: Some("bar"),
592 file_stem: Some("bar"),
607 iter: ["foo", "..", "bar"],
610 parent: Some("foo/.."),
611 file_name: Some("bar"),
612 file_stem: Some("bar"),
621 file_name: Some("a"),
622 file_stem: Some("a"),
651 file_name: Some("b"),
652 file_stem: Some("b"),
661 file_name: Some("b"),
662 file_stem: Some("b"),
671 file_name: Some("b"),
672 file_stem: Some("b"),
677 iter: ["a", "b", "c"],
681 file_name: Some("c"),
682 file_stem: Some("c"),
686 iter: ["a", "b", "c"],
689 parent: Some("a\\b"),
690 file_name: Some("c"),
691 file_stem: Some("c"),
700 file_name: Some("a"),
701 file_stem: Some("a"),
706 iter: ["c:", "\\", "foo.txt"],
709 parent: Some("c:\\"),
710 file_name: Some("foo.txt"),
711 file_stem: Some("foo"),
712 extension: Some("txt")
715 t!("\\\\server\\share\\foo.txt",
716 iter: ["\\\\server\\share", "\\", "foo.txt"],
719 parent: Some("\\\\server\\share\\"),
720 file_name: Some("foo.txt"),
721 file_stem: Some("foo"),
722 extension: Some("txt")
725 t!("\\\\server\\share",
726 iter: ["\\\\server\\share", "\\"],
736 iter: ["\\", "server"],
740 file_name: Some("server"),
741 file_stem: Some("server"),
745 t!("\\\\?\\bar\\foo.txt",
746 iter: ["\\\\?\\bar", "\\", "foo.txt"],
749 parent: Some("\\\\?\\bar\\"),
750 file_name: Some("foo.txt"),
751 file_stem: Some("foo"),
752 extension: Some("txt")
756 iter: ["\\\\?\\bar"],
775 t!("\\\\?\\UNC\\server\\share\\foo.txt",
776 iter: ["\\\\?\\UNC\\server\\share", "\\", "foo.txt"],
779 parent: Some("\\\\?\\UNC\\server\\share\\"),
780 file_name: Some("foo.txt"),
781 file_stem: Some("foo"),
782 extension: Some("txt")
785 t!("\\\\?\\UNC\\server",
786 iter: ["\\\\?\\UNC\\server"],
796 iter: ["\\\\?\\UNC\\"],
805 t!("\\\\?\\C:\\foo.txt",
806 iter: ["\\\\?\\C:", "\\", "foo.txt"],
809 parent: Some("\\\\?\\C:\\"),
810 file_name: Some("foo.txt"),
811 file_stem: Some("foo"),
812 extension: Some("txt")
816 iter: ["\\\\?\\C:", "\\"],
836 iter: ["\\\\?\\foo/bar"],
846 iter: ["\\\\?\\C:/foo"],
855 t!("\\\\.\\foo\\bar",
856 iter: ["\\\\.\\foo", "\\", "bar"],
859 parent: Some("\\\\.\\foo\\"),
860 file_name: Some("bar"),
861 file_stem: Some("bar"),
866 iter: ["\\\\.\\foo", "\\"],
876 iter: ["\\\\.\\foo", "\\", "bar"],
879 parent: Some("\\\\.\\foo/"),
880 file_name: Some("bar"),
881 file_stem: Some("bar"),
885 t!("\\\\.\\foo\\bar/baz",
886 iter: ["\\\\.\\foo", "\\", "bar", "baz"],
889 parent: Some("\\\\.\\foo\\bar"),
890 file_name: Some("baz"),
891 file_stem: Some("baz"),
896 iter: ["\\\\.\\", "\\"],
906 iter: ["\\\\?\\a", "\\", "b"],
909 parent: Some("\\\\?\\a\\"),
910 file_name: Some("b"),
911 file_stem: Some("b"),
917 pub fn test_stem_ext() {
919 file_stem: Some("foo"),
924 file_stem: Some("foo"),
929 file_stem: Some(".foo"),
934 file_stem: Some("foo"),
935 extension: Some("txt")
939 file_stem: Some("foo.bar"),
940 extension: Some("txt")
944 file_stem: Some("foo.bar"),
948 t!(".", file_stem: None, extension: None);
950 t!("..", file_stem: None, extension: None);
952 t!("", file_stem: None, extension: None);
958 ($path:expr, $push:expr, $expected:expr) => ( {
959 let mut actual = PathBuf::from($path);
961 assert!(actual.to_str() == Some($expected),
962 "pushing {:?} onto {:?}: Expected {:?}, got {:?}",
963 $push, $path, $expected, actual.to_str().unwrap());
967 if cfg!(unix) || cfg!(all(target_env = "sgx", target_vendor = "fortanix")) {
968 tp!("", "foo", "foo");
969 tp!("foo", "bar", "foo/bar");
970 tp!("foo/", "bar", "foo/bar");
971 tp!("foo//", "bar", "foo//bar");
972 tp!("foo/.", "bar", "foo/./bar");
973 tp!("foo./.", "bar", "foo././bar");
974 tp!("foo", "", "foo/");
975 tp!("foo", ".", "foo/.");
976 tp!("foo", "..", "foo/..");
977 tp!("foo", "/", "/");
978 tp!("/foo/bar", "/", "/");
979 tp!("/foo/bar", "/baz", "/baz");
980 tp!("/foo/bar", "./baz", "/foo/bar/./baz");
982 tp!("", "foo", "foo");
983 tp!("foo", "bar", r"foo\bar");
984 tp!("foo/", "bar", r"foo/bar");
985 tp!(r"foo\", "bar", r"foo\bar");
986 tp!("foo//", "bar", r"foo//bar");
987 tp!(r"foo\\", "bar", r"foo\\bar");
988 tp!("foo/.", "bar", r"foo/.\bar");
989 tp!("foo./.", "bar", r"foo./.\bar");
990 tp!(r"foo\.", "bar", r"foo\.\bar");
991 tp!(r"foo.\.", "bar", r"foo.\.\bar");
992 tp!("foo", "", "foo\\");
993 tp!("foo", ".", r"foo\.");
994 tp!("foo", "..", r"foo\..");
995 tp!("foo", "/", "/");
996 tp!("foo", r"\", r"\");
997 tp!("/foo/bar", "/", "/");
998 tp!(r"\foo\bar", r"\", r"\");
999 tp!("/foo/bar", "/baz", "/baz");
1000 tp!("/foo/bar", r"\baz", r"\baz");
1001 tp!("/foo/bar", "./baz", r"/foo/bar\./baz");
1002 tp!("/foo/bar", r".\baz", r"/foo/bar\.\baz");
1004 tp!("c:\\", "windows", "c:\\windows");
1005 tp!("c:", "windows", "c:windows");
1007 tp!("a\\b\\c", "d", "a\\b\\c\\d");
1008 tp!("\\a\\b\\c", "d", "\\a\\b\\c\\d");
1009 tp!("a\\b", "c\\d", "a\\b\\c\\d");
1010 tp!("a\\b", "\\c\\d", "\\c\\d");
1011 tp!("a\\b", ".", "a\\b\\.");
1012 tp!("a\\b", "..\\c", "a\\b\\..\\c");
1013 tp!("a\\b", "C:a.txt", "C:a.txt");
1014 tp!("a\\b", "C:\\a.txt", "C:\\a.txt");
1015 tp!("C:\\a", "C:\\b.txt", "C:\\b.txt");
1016 tp!("C:\\a\\b\\c", "C:d", "C:d");
1017 tp!("C:a\\b\\c", "C:d", "C:d");
1018 tp!("C:", r"a\b\c", r"C:a\b\c");
1019 tp!("C:", r"..\a", r"C:..\a");
1020 tp!("\\\\server\\share\\foo", "bar", "\\\\server\\share\\foo\\bar");
1021 tp!("\\\\server\\share\\foo", "C:baz", "C:baz");
1022 tp!("\\\\?\\C:\\a\\b", "C:c\\d", "C:c\\d");
1023 tp!("\\\\?\\C:a\\b", "C:c\\d", "C:c\\d");
1024 tp!("\\\\?\\C:\\a\\b", "C:\\c\\d", "C:\\c\\d");
1025 tp!("\\\\?\\foo\\bar", "baz", "\\\\?\\foo\\bar\\baz");
1026 tp!("\\\\?\\UNC\\server\\share\\foo", "bar", "\\\\?\\UNC\\server\\share\\foo\\bar");
1027 tp!("\\\\?\\UNC\\server\\share", "C:\\a", "C:\\a");
1028 tp!("\\\\?\\UNC\\server\\share", "C:a", "C:a");
1030 // Note: modified from old path API
1031 tp!("\\\\?\\UNC\\server", "foo", "\\\\?\\UNC\\server\\foo");
1033 tp!("C:\\a", "\\\\?\\UNC\\server\\share", "\\\\?\\UNC\\server\\share");
1034 tp!("\\\\.\\foo\\bar", "baz", "\\\\.\\foo\\bar\\baz");
1035 tp!("\\\\.\\foo\\bar", "C:a", "C:a");
1036 // again, not sure about the following, but I'm assuming \\.\ should be verbatim
1037 tp!("\\\\.\\foo", "..\\bar", "\\\\.\\foo\\..\\bar");
1039 tp!("\\\\?\\C:", "foo", "\\\\?\\C:\\foo"); // this is a weird one
1046 ($path:expr, $expected:expr, $output:expr) => ( {
1047 let mut actual = PathBuf::from($path);
1048 let output = actual.pop();
1049 assert!(actual.to_str() == Some($expected) && output == $output,
1050 "popping from {:?}: Expected {:?}/{:?}, got {:?}/{:?}",
1051 $path, $expected, $output,
1052 actual.to_str().unwrap(), output);
1057 tp!("/", "/", false);
1058 tp!("foo", "", true);
1060 tp!("/foo", "/", true);
1061 tp!("/foo/bar", "/foo", true);
1062 tp!("foo/bar", "foo", true);
1063 tp!("foo/.", "", true);
1064 tp!("foo//bar", "foo", true);
1067 tp!("a\\b\\c", "a\\b", true);
1068 tp!("\\a", "\\", true);
1069 tp!("\\", "\\", false);
1071 tp!("C:\\a\\b", "C:\\a", true);
1072 tp!("C:\\a", "C:\\", true);
1073 tp!("C:\\", "C:\\", false);
1074 tp!("C:a\\b", "C:a", true);
1075 tp!("C:a", "C:", true);
1076 tp!("C:", "C:", false);
1077 tp!("\\\\server\\share\\a\\b", "\\\\server\\share\\a", true);
1078 tp!("\\\\server\\share\\a", "\\\\server\\share\\", true);
1079 tp!("\\\\server\\share", "\\\\server\\share", false);
1080 tp!("\\\\?\\a\\b\\c", "\\\\?\\a\\b", true);
1081 tp!("\\\\?\\a\\b", "\\\\?\\a\\", true);
1082 tp!("\\\\?\\a", "\\\\?\\a", false);
1083 tp!("\\\\?\\C:\\a\\b", "\\\\?\\C:\\a", true);
1084 tp!("\\\\?\\C:\\a", "\\\\?\\C:\\", true);
1085 tp!("\\\\?\\C:\\", "\\\\?\\C:\\", false);
1086 tp!("\\\\?\\UNC\\server\\share\\a\\b", "\\\\?\\UNC\\server\\share\\a", true);
1087 tp!("\\\\?\\UNC\\server\\share\\a", "\\\\?\\UNC\\server\\share\\", true);
1088 tp!("\\\\?\\UNC\\server\\share", "\\\\?\\UNC\\server\\share", false);
1089 tp!("\\\\.\\a\\b\\c", "\\\\.\\a\\b", true);
1090 tp!("\\\\.\\a\\b", "\\\\.\\a\\", true);
1091 tp!("\\\\.\\a", "\\\\.\\a", false);
1093 tp!("\\\\?\\a\\b\\", "\\\\?\\a\\", true);
1098 pub fn test_set_file_name() {
1100 ($path:expr, $file:expr, $expected:expr) => ( {
1101 let mut p = PathBuf::from($path);
1102 p.set_file_name($file);
1103 assert!(p.to_str() == Some($expected),
1104 "setting file name of {:?} to {:?}: Expected {:?}, got {:?}",
1105 $path, $file, $expected,
1106 p.to_str().unwrap());
1110 tfn!("foo", "foo", "foo");
1111 tfn!("foo", "bar", "bar");
1112 tfn!("foo", "", "");
1113 tfn!("", "foo", "foo");
1114 if cfg!(unix) || cfg!(all(target_env = "sgx", target_vendor = "fortanix")) {
1115 tfn!(".", "foo", "./foo");
1116 tfn!("foo/", "bar", "bar");
1117 tfn!("foo/.", "bar", "bar");
1118 tfn!("..", "foo", "../foo");
1119 tfn!("foo/..", "bar", "foo/../bar");
1120 tfn!("/", "foo", "/foo");
1122 tfn!(".", "foo", r".\foo");
1123 tfn!(r"foo\", "bar", r"bar");
1124 tfn!(r"foo\.", "bar", r"bar");
1125 tfn!("..", "foo", r"..\foo");
1126 tfn!(r"foo\..", "bar", r"foo\..\bar");
1127 tfn!(r"\", "foo", r"\foo");
1132 pub fn test_set_extension() {
1134 ($path:expr, $ext:expr, $expected:expr, $output:expr) => ( {
1135 let mut p = PathBuf::from($path);
1136 let output = p.set_extension($ext);
1137 assert!(p.to_str() == Some($expected) && output == $output,
1138 "setting extension of {:?} to {:?}: Expected {:?}/{:?}, got {:?}/{:?}",
1139 $path, $ext, $expected, $output,
1140 p.to_str().unwrap(), output);
1144 tfe!("foo", "txt", "foo.txt", true);
1145 tfe!("foo.bar", "txt", "foo.txt", true);
1146 tfe!("foo.bar.baz", "txt", "foo.bar.txt", true);
1147 tfe!(".test", "txt", ".test.txt", true);
1148 tfe!("foo.txt", "", "foo", true);
1149 tfe!("foo", "", "foo", true);
1150 tfe!("", "foo", "", false);
1151 tfe!(".", "foo", ".", false);
1152 tfe!("foo/", "bar", "foo.bar", true);
1153 tfe!("foo/.", "bar", "foo.bar", true);
1154 tfe!("..", "foo", "..", false);
1155 tfe!("foo/..", "bar", "foo/..", false);
1156 tfe!("/", "foo", "/", false);
1160 fn test_eq_receivers() {
1161 use crate::borrow::Cow;
1163 let borrowed: &Path = Path::new("foo/bar");
1164 let mut owned: PathBuf = PathBuf::new();
1167 let borrowed_cow: Cow<'_, Path> = borrowed.into();
1168 let owned_cow: Cow<'_, Path> = owned.clone().into();
1171 ($($current:expr),+) => {
1173 assert_eq!($current, borrowed);
1174 assert_eq!($current, owned);
1175 assert_eq!($current, borrowed_cow);
1176 assert_eq!($current, owned_cow);
1181 t!(borrowed, owned, borrowed_cow, owned_cow);
1185 pub fn test_compare() {
1186 use crate::collections::hash_map::DefaultHasher;
1187 use crate::hash::{Hash, Hasher};
1189 fn hash<T: Hash>(t: T) -> u64 {
1190 let mut s = DefaultHasher::new();
1196 ($path1:expr, $path2:expr, eq: $eq:expr,
1197 starts_with: $starts_with:expr, ends_with: $ends_with:expr,
1198 relative_from: $relative_from:expr) => ({
1199 let path1 = Path::new($path1);
1200 let path2 = Path::new($path2);
1202 let eq = path1 == path2;
1203 assert!(eq == $eq, "{:?} == {:?}, expected {:?}, got {:?}",
1204 $path1, $path2, $eq, eq);
1205 assert!($eq == (hash(path1) == hash(path2)),
1206 "{:?} == {:?}, expected {:?}, got {} and {}",
1207 $path1, $path2, $eq, hash(path1), hash(path2));
1209 let starts_with = path1.starts_with(path2);
1210 assert!(starts_with == $starts_with,
1211 "{:?}.starts_with({:?}), expected {:?}, got {:?}", $path1, $path2,
1212 $starts_with, starts_with);
1214 let ends_with = path1.ends_with(path2);
1215 assert!(ends_with == $ends_with,
1216 "{:?}.ends_with({:?}), expected {:?}, got {:?}", $path1, $path2,
1217 $ends_with, ends_with);
1219 let relative_from = path1.strip_prefix(path2)
1220 .map(|p| p.to_str().unwrap())
1222 let exp: Option<&str> = $relative_from;
1223 assert!(relative_from == exp,
1224 "{:?}.strip_prefix({:?}), expected {:?}, got {:?}",
1225 $path1, $path2, exp, relative_from);
1233 relative_from: Some("")
1240 relative_from: Some("foo")
1254 relative_from: Some("")
1261 relative_from: Some("")
1264 tc!("foo/bar", "foo",
1268 relative_from: Some("bar")
1271 tc!("foo/bar/baz", "foo/bar",
1275 relative_from: Some("baz")
1278 tc!("foo/bar", "foo/bar/baz",
1285 tc!("./foo/bar/", ".",
1289 relative_from: Some("foo/bar")
1293 tc!(r"C:\src\rust\cargo-test\test\Cargo.toml",
1294 r"c:\src\rust\cargo-test\test",
1298 relative_from: Some("Cargo.toml")
1301 tc!(r"c:\foo", r"C:\foo",
1305 relative_from: Some("")
1311 fn test_components_debug() {
1312 let path = Path::new("/tmp");
1314 let mut components = path.components();
1316 let expected = "Components([RootDir, Normal(\"tmp\")])";
1317 let actual = format!("{:?}", components);
1318 assert_eq!(expected, actual);
1320 let _ = components.next().unwrap();
1321 let expected = "Components([Normal(\"tmp\")])";
1322 let actual = format!("{:?}", components);
1323 assert_eq!(expected, actual);
1325 let _ = components.next().unwrap();
1326 let expected = "Components([])";
1327 let actual = format!("{:?}", components);
1328 assert_eq!(expected, actual);
1333 fn test_iter_debug() {
1334 let path = Path::new("/tmp");
1336 let mut iter = path.iter();
1338 let expected = "Iter([\"/\", \"tmp\"])";
1339 let actual = format!("{:?}", iter);
1340 assert_eq!(expected, actual);
1342 let _ = iter.next().unwrap();
1343 let expected = "Iter([\"tmp\"])";
1344 let actual = format!("{:?}", iter);
1345 assert_eq!(expected, actual);
1347 let _ = iter.next().unwrap();
1348 let expected = "Iter([])";
1349 let actual = format!("{:?}", iter);
1350 assert_eq!(expected, actual);
1355 let orig: &str = "some/sort/of/path";
1356 let path = Path::new(orig);
1357 let boxed: Box<Path> = Box::from(path);
1358 let path_buf = path.to_owned().into_boxed_path().into_path_buf();
1359 assert_eq!(path, &*boxed);
1360 assert_eq!(&*boxed, &*path_buf);
1361 assert_eq!(&*path_buf, path);
1365 fn test_clone_into() {
1366 let mut path_buf = PathBuf::from("supercalifragilisticexpialidocious");
1367 let path = Path::new("short");
1368 path.clone_into(&mut path_buf);
1369 assert_eq!(path, path_buf);
1370 assert!(path_buf.into_os_string().capacity() >= 15);
1374 fn display_format_flags() {
1375 assert_eq!(format!("a{:#<5}b", Path::new("").display()), "a#####b");
1376 assert_eq!(format!("a{:#<5}b", Path::new("a").display()), "aa####b");
1381 let orig = "hello/world";
1382 let path = Path::new(orig);
1383 let rc: Rc<Path> = Rc::from(path);
1384 let arc: Arc<Path> = Arc::from(path);
1386 assert_eq!(&*rc, path);
1387 assert_eq!(&*arc, path);
1389 let rc2: Rc<Path> = Rc::from(path.to_owned());
1390 let arc2: Arc<Path> = Arc::from(path.to_owned());
1392 assert_eq!(&*rc2, path);
1393 assert_eq!(&*arc2, path);