Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 1279 insertions, 0 deletions

diff --git a/third_party/rust/walkdir/src/tests/mod.rs b/third_party/rust/walkdir/src/tests/mod.rs
new file mode 100644
index 0000000000..ebf952dfc5
--- /dev/null
+++ b/third_party/rust/walkdir/src/tests/mod.rs
@@ -0,0 +1,4 @@
+#[macro_use]
+mod util;
+
+mod recursive;
diff --git a/third_party/rust/walkdir/src/tests/recursive.rs b/third_party/rust/walkdir/src/tests/recursive.rs
new file mode 100644
index 0000000000..4119f461d3
--- /dev/null
+++ b/third_party/rust/walkdir/src/tests/recursive.rs
@@ -0,0 +1,1023 @@
+use std::fs;
+use std::path::PathBuf;
+
+use crate::tests::util::Dir;
+use crate::WalkDir;
+
+#[test]
+fn send_sync_traits() {
+    use crate::{FilterEntry, IntoIter};
+
+    fn assert_send<T: Send>() {}
+    fn assert_sync<T: Sync>() {}
+
+    assert_send::<WalkDir>();
+    assert_sync::<WalkDir>();
+    assert_send::<IntoIter>();
+    assert_sync::<IntoIter>();
+    assert_send::<FilterEntry<IntoIter, u8>>();
+    assert_sync::<FilterEntry<IntoIter, u8>>();
+}
+
+#[test]
+fn empty() {
+    let dir = Dir::tmp();
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    assert_eq!(1, r.ents().len());
+    let ent = &r.ents()[0];
+    assert!(ent.file_type().is_dir());
+    assert!(!ent.path_is_symlink());
+    assert_eq!(0, ent.depth());
+    assert_eq!(dir.path(), ent.path());
+    assert_eq!(dir.path().file_name().unwrap(), ent.file_name());
+}
+
+#[test]
+fn empty_follow() {
+    let dir = Dir::tmp();
+    let wd = WalkDir::new(dir.path()).follow_links(true);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    assert_eq!(1, r.ents().len());
+    let ent = &r.ents()[0];
+    assert!(ent.file_type().is_dir());
+    assert!(!ent.path_is_symlink());
+    assert_eq!(0, ent.depth());
+    assert_eq!(dir.path(), ent.path());
+    assert_eq!(dir.path().file_name().unwrap(), ent.file_name());
+}
+
+#[test]
+fn empty_file() {
+    let dir = Dir::tmp();
+    dir.touch("a");
+
+    let wd = WalkDir::new(dir.path().join("a"));
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    assert_eq!(1, r.ents().len());
+    let ent = &r.ents()[0];
+    assert!(ent.file_type().is_file());
+    assert!(!ent.path_is_symlink());
+    assert_eq!(0, ent.depth());
+    assert_eq!(dir.join("a"), ent.path());
+    assert_eq!("a", ent.file_name());
+}
+
+#[test]
+fn empty_file_follow() {
+    let dir = Dir::tmp();
+    dir.touch("a");
+
+    let wd = WalkDir::new(dir.path().join("a")).follow_links(true);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    assert_eq!(1, r.ents().len());
+    let ent = &r.ents()[0];
+    assert!(ent.file_type().is_file());
+    assert!(!ent.path_is_symlink());
+    assert_eq!(0, ent.depth());
+    assert_eq!(dir.join("a"), ent.path());
+    assert_eq!("a", ent.file_name());
+}
+
+#[test]
+fn one_dir() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a");
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let ents = r.ents();
+    assert_eq!(2, ents.len());
+    let ent = &ents[1];
+    assert_eq!(dir.join("a"), ent.path());
+    assert_eq!(1, ent.depth());
+    assert_eq!("a", ent.file_name());
+    assert!(ent.file_type().is_dir());
+}
+
+#[test]
+fn one_file() {
+    let dir = Dir::tmp();
+    dir.touch("a");
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let ents = r.ents();
+    assert_eq!(2, ents.len());
+    let ent = &ents[1];
+    assert_eq!(dir.join("a"), ent.path());
+    assert_eq!(1, ent.depth());
+    assert_eq!("a", ent.file_name());
+    assert!(ent.file_type().is_file());
+}
+
+#[test]
+fn one_dir_one_file() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo");
+    dir.touch("foo/a");
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("foo"),
+        dir.join("foo").join("a"),
+    ];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn many_files() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo");
+    dir.touch_all(&["foo/a", "foo/b", "foo/c"]);
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("foo"),
+        dir.join("foo").join("a"),
+        dir.join("foo").join("b"),
+        dir.join("foo").join("c"),
+    ];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn many_dirs() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo/a");
+    dir.mkdirp("foo/b");
+    dir.mkdirp("foo/c");
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("foo"),
+        dir.join("foo").join("a"),
+        dir.join("foo").join("b"),
+        dir.join("foo").join("c"),
+    ];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn many_mixed() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo/a");
+    dir.mkdirp("foo/c");
+    dir.mkdirp("foo/e");
+    dir.touch_all(&["foo/b", "foo/d", "foo/f"]);
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("foo"),
+        dir.join("foo").join("a"),
+        dir.join("foo").join("b"),
+        dir.join("foo").join("c"),
+        dir.join("foo").join("d"),
+        dir.join("foo").join("e"),
+        dir.join("foo").join("f"),
+    ];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn nested() {
+    let nested =
+        PathBuf::from("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z");
+    let dir = Dir::tmp();
+    dir.mkdirp(&nested);
+    dir.touch(nested.join("A"));
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("a"),
+        dir.join("a/b"),
+        dir.join("a/b/c"),
+        dir.join("a/b/c/d"),
+        dir.join("a/b/c/d/e"),
+        dir.join("a/b/c/d/e/f"),
+        dir.join("a/b/c/d/e/f/g"),
+        dir.join("a/b/c/d/e/f/g/h"),
+        dir.join("a/b/c/d/e/f/g/h/i"),
+        dir.join("a/b/c/d/e/f/g/h/i/j"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z"),
+        dir.join(&nested).join("A"),
+    ];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn nested_small_max_open() {
+    let nested =
+        PathBuf::from("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z");
+    let dir = Dir::tmp();
+    dir.mkdirp(&nested);
+    dir.touch(nested.join("A"));
+
+    let wd = WalkDir::new(dir.path()).max_open(1);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("a"),
+        dir.join("a/b"),
+        dir.join("a/b/c"),
+        dir.join("a/b/c/d"),
+        dir.join("a/b/c/d/e"),
+        dir.join("a/b/c/d/e/f"),
+        dir.join("a/b/c/d/e/f/g"),
+        dir.join("a/b/c/d/e/f/g/h"),
+        dir.join("a/b/c/d/e/f/g/h/i"),
+        dir.join("a/b/c/d/e/f/g/h/i/j"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y"),
+        dir.join("a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z"),
+        dir.join(&nested).join("A"),
+    ];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn siblings() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo");
+    dir.mkdirp("bar");
+    dir.touch_all(&["foo/a", "foo/b"]);
+    dir.touch_all(&["bar/a", "bar/b"]);
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("bar"),
+        dir.join("bar").join("a"),
+        dir.join("bar").join("b"),
+        dir.join("foo"),
+        dir.join("foo").join("a"),
+        dir.join("foo").join("b"),
+    ];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn sym_root_file_nofollow() {
+    let dir = Dir::tmp();
+    dir.touch("a");
+    dir.symlink_file("a", "a-link");
+
+    let wd = WalkDir::new(dir.join("a-link"));
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let ents = r.sorted_ents();
+    assert_eq!(1, ents.len());
+    let link = &ents[0];
+
+    assert_eq!(dir.join("a-link"), link.path());
+
+    assert!(link.path_is_symlink());
+
+    assert_eq!(dir.join("a"), fs::read_link(link.path()).unwrap());
+
+    assert_eq!(0, link.depth());
+
+    assert!(link.file_type().is_symlink());
+    assert!(!link.file_type().is_file());
+    assert!(!link.file_type().is_dir());
+
+    assert!(link.metadata().unwrap().file_type().is_symlink());
+    assert!(!link.metadata().unwrap().is_file());
+    assert!(!link.metadata().unwrap().is_dir());
+}
+
+#[test]
+fn sym_root_file_follow() {
+    let dir = Dir::tmp();
+    dir.touch("a");
+    dir.symlink_file("a", "a-link");
+
+    let wd = WalkDir::new(dir.join("a-link")).follow_links(true);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let ents = r.sorted_ents();
+    let link = &ents[0];
+
+    assert_eq!(dir.join("a-link"), link.path());
+
+    assert!(link.path_is_symlink());
+
+    assert_eq!(dir.join("a"), fs::read_link(link.path()).unwrap());
+
+    assert_eq!(0, link.depth());
+
+    assert!(!link.file_type().is_symlink());
+    assert!(link.file_type().is_file());
+    assert!(!link.file_type().is_dir());
+
+    assert!(!link.metadata().unwrap().file_type().is_symlink());
+    assert!(link.metadata().unwrap().is_file());
+    assert!(!link.metadata().unwrap().is_dir());
+}
+
+#[test]
+fn sym_root_dir_nofollow() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a");
+    dir.symlink_dir("a", "a-link");
+    dir.touch("a/zzz");
+
+    let wd = WalkDir::new(dir.join("a-link"));
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let ents = r.sorted_ents();
+    assert_eq!(2, ents.len());
+    let link = &ents[0];
+
+    assert_eq!(dir.join("a-link"), link.path());
+
+    assert!(link.path_is_symlink());
+
+    assert_eq!(dir.join("a"), fs::read_link(link.path()).unwrap());
+
+    assert_eq!(0, link.depth());
+
+    assert!(link.file_type().is_symlink());
+    assert!(!link.file_type().is_file());
+    assert!(!link.file_type().is_dir());
+
+    assert!(link.metadata().unwrap().file_type().is_symlink());
+    assert!(!link.metadata().unwrap().is_file());
+    assert!(!link.metadata().unwrap().is_dir());
+
+    let link_zzz = &ents[1];
+    assert_eq!(dir.join("a-link").join("zzz"), link_zzz.path());
+    assert!(!link_zzz.path_is_symlink());
+}
+
+#[test]
+fn sym_root_dir_follow() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a");
+    dir.symlink_dir("a", "a-link");
+    dir.touch("a/zzz");
+
+    let wd = WalkDir::new(dir.join("a-link")).follow_links(true);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let ents = r.sorted_ents();
+    assert_eq!(2, ents.len());
+    let link = &ents[0];
+
+    assert_eq!(dir.join("a-link"), link.path());
+
+    assert!(link.path_is_symlink());
+
+    assert_eq!(dir.join("a"), fs::read_link(link.path()).unwrap());
+
+    assert_eq!(0, link.depth());
+
+    assert!(!link.file_type().is_symlink());
+    assert!(!link.file_type().is_file());
+    assert!(link.file_type().is_dir());
+
+    assert!(!link.metadata().unwrap().file_type().is_symlink());
+    assert!(!link.metadata().unwrap().is_file());
+    assert!(link.metadata().unwrap().is_dir());
+
+    let link_zzz = &ents[1];
+    assert_eq!(dir.join("a-link").join("zzz"), link_zzz.path());
+    assert!(!link_zzz.path_is_symlink());
+}
+
+#[test]
+fn sym_file_nofollow() {
+    let dir = Dir::tmp();
+    dir.touch("a");
+    dir.symlink_file("a", "a-link");
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let ents = r.sorted_ents();
+    assert_eq!(3, ents.len());
+    let (src, link) = (&ents[1], &ents[2]);
+
+    assert_eq!(dir.join("a"), src.path());
+    assert_eq!(dir.join("a-link"), link.path());
+
+    assert!(!src.path_is_symlink());
+    assert!(link.path_is_symlink());
+
+    assert_eq!(dir.join("a"), fs::read_link(link.path()).unwrap());
+
+    assert_eq!(1, src.depth());
+    assert_eq!(1, link.depth());
+
+    assert!(src.file_type().is_file());
+    assert!(link.file_type().is_symlink());
+    assert!(!link.file_type().is_file());
+    assert!(!link.file_type().is_dir());
+
+    assert!(src.metadata().unwrap().is_file());
+    assert!(link.metadata().unwrap().file_type().is_symlink());
+    assert!(!link.metadata().unwrap().is_file());
+    assert!(!link.metadata().unwrap().is_dir());
+}
+
+#[test]
+fn sym_file_follow() {
+    let dir = Dir::tmp();
+    dir.touch("a");
+    dir.symlink_file("a", "a-link");
+
+    let wd = WalkDir::new(dir.path()).follow_links(true);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let ents = r.sorted_ents();
+    assert_eq!(3, ents.len());
+    let (src, link) = (&ents[1], &ents[2]);
+
+    assert_eq!(dir.join("a"), src.path());
+    assert_eq!(dir.join("a-link"), link.path());
+
+    assert!(!src.path_is_symlink());
+    assert!(link.path_is_symlink());
+
+    assert_eq!(dir.join("a"), fs::read_link(link.path()).unwrap());
+
+    assert_eq!(1, src.depth());
+    assert_eq!(1, link.depth());
+
+    assert!(src.file_type().is_file());
+    assert!(!link.file_type().is_symlink());
+    assert!(link.file_type().is_file());
+    assert!(!link.file_type().is_dir());
+
+    assert!(src.metadata().unwrap().is_file());
+    assert!(!link.metadata().unwrap().file_type().is_symlink());
+    assert!(link.metadata().unwrap().is_file());
+    assert!(!link.metadata().unwrap().is_dir());
+}
+
+#[test]
+fn sym_dir_nofollow() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a");
+    dir.symlink_dir("a", "a-link");
+    dir.touch("a/zzz");
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let ents = r.sorted_ents();
+    assert_eq!(4, ents.len());
+    let (src, link) = (&ents[1], &ents[3]);
+
+    assert_eq!(dir.join("a"), src.path());
+    assert_eq!(dir.join("a-link"), link.path());
+
+    assert!(!src.path_is_symlink());
+    assert!(link.path_is_symlink());
+
+    assert_eq!(dir.join("a"), fs::read_link(link.path()).unwrap());
+
+    assert_eq!(1, src.depth());
+    assert_eq!(1, link.depth());
+
+    assert!(src.file_type().is_dir());
+    assert!(link.file_type().is_symlink());
+    assert!(!link.file_type().is_file());
+    assert!(!link.file_type().is_dir());
+
+    assert!(src.metadata().unwrap().is_dir());
+    assert!(link.metadata().unwrap().file_type().is_symlink());
+    assert!(!link.metadata().unwrap().is_file());
+    assert!(!link.metadata().unwrap().is_dir());
+}
+
+#[test]
+fn sym_dir_follow() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a");
+    dir.symlink_dir("a", "a-link");
+    dir.touch("a/zzz");
+
+    let wd = WalkDir::new(dir.path()).follow_links(true);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let ents = r.sorted_ents();
+    assert_eq!(5, ents.len());
+    let (src, link) = (&ents[1], &ents[3]);
+
+    assert_eq!(dir.join("a"), src.path());
+    assert_eq!(dir.join("a-link"), link.path());
+
+    assert!(!src.path_is_symlink());
+    assert!(link.path_is_symlink());
+
+    assert_eq!(dir.join("a"), fs::read_link(link.path()).unwrap());
+
+    assert_eq!(1, src.depth());
+    assert_eq!(1, link.depth());
+
+    assert!(src.file_type().is_dir());
+    assert!(!link.file_type().is_symlink());
+    assert!(!link.file_type().is_file());
+    assert!(link.file_type().is_dir());
+
+    assert!(src.metadata().unwrap().is_dir());
+    assert!(!link.metadata().unwrap().file_type().is_symlink());
+    assert!(!link.metadata().unwrap().is_file());
+    assert!(link.metadata().unwrap().is_dir());
+
+    let (src_zzz, link_zzz) = (&ents[2], &ents[4]);
+    assert_eq!(dir.join("a").join("zzz"), src_zzz.path());
+    assert_eq!(dir.join("a-link").join("zzz"), link_zzz.path());
+    assert!(!src_zzz.path_is_symlink());
+    assert!(!link_zzz.path_is_symlink());
+}
+
+#[test]
+fn sym_noloop() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a/b/c");
+    dir.symlink_dir("a", "a/b/c/a-link");
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    // There's no loop if we aren't following symlinks.
+    r.assert_no_errors();
+
+    assert_eq!(5, r.ents().len());
+}
+
+#[test]
+fn sym_loop_detect() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a/b/c");
+    dir.symlink_dir("a", "a/b/c/a-link");
+
+    let wd = WalkDir::new(dir.path()).follow_links(true);
+    let r = dir.run_recursive(wd);
+
+    let (ents, errs) = (r.sorted_ents(), r.errs());
+    assert_eq!(4, ents.len());
+    assert_eq!(1, errs.len());
+
+    let err = &errs[0];
+
+    let expected = dir.join("a/b/c/a-link");
+    assert_eq!(Some(&*expected), err.path());
+
+    let expected = dir.join("a");
+    assert_eq!(Some(&*expected), err.loop_ancestor());
+
+    assert_eq!(4, err.depth());
+    assert!(err.io_error().is_none());
+}
+
+#[test]
+fn sym_self_loop_no_error() {
+    let dir = Dir::tmp();
+    dir.symlink_file("a", "a");
+
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    // No errors occur because even though the symlink points to nowhere, it
+    // is never followed, and thus no error occurs.
+    r.assert_no_errors();
+    assert_eq!(2, r.ents().len());
+
+    let ent = &r.ents()[1];
+    assert_eq!(dir.join("a"), ent.path());
+    assert!(ent.path_is_symlink());
+
+    assert!(ent.file_type().is_symlink());
+    assert!(!ent.file_type().is_file());
+    assert!(!ent.file_type().is_dir());
+
+    assert!(ent.metadata().unwrap().file_type().is_symlink());
+    assert!(!ent.metadata().unwrap().file_type().is_file());
+    assert!(!ent.metadata().unwrap().file_type().is_dir());
+}
+
+#[test]
+fn sym_file_self_loop_io_error() {
+    let dir = Dir::tmp();
+    dir.symlink_file("a", "a");
+
+    let wd = WalkDir::new(dir.path()).follow_links(true);
+    let r = dir.run_recursive(wd);
+
+    let (ents, errs) = (r.sorted_ents(), r.errs());
+    assert_eq!(1, ents.len());
+    assert_eq!(1, errs.len());
+
+    let err = &errs[0];
+
+    let expected = dir.join("a");
+    assert_eq!(Some(&*expected), err.path());
+    assert_eq!(1, err.depth());
+    assert!(err.loop_ancestor().is_none());
+    assert!(err.io_error().is_some());
+}
+
+#[test]
+fn sym_dir_self_loop_io_error() {
+    let dir = Dir::tmp();
+    dir.symlink_dir("a", "a");
+
+    let wd = WalkDir::new(dir.path()).follow_links(true);
+    let r = dir.run_recursive(wd);
+
+    let (ents, errs) = (r.sorted_ents(), r.errs());
+    assert_eq!(1, ents.len());
+    assert_eq!(1, errs.len());
+
+    let err = &errs[0];
+
+    let expected = dir.join("a");
+    assert_eq!(Some(&*expected), err.path());
+    assert_eq!(1, err.depth());
+    assert!(err.loop_ancestor().is_none());
+    assert!(err.io_error().is_some());
+}
+
+#[test]
+fn min_depth_1() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a/b");
+
+    let wd = WalkDir::new(dir.path()).min_depth(1);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![dir.join("a"), dir.join("a").join("b")];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn min_depth_2() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a/b");
+
+    let wd = WalkDir::new(dir.path()).min_depth(2);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![dir.join("a").join("b")];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn max_depth_0() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a/b");
+
+    let wd = WalkDir::new(dir.path()).max_depth(0);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![dir.path().to_path_buf()];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn max_depth_1() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a/b");
+
+    let wd = WalkDir::new(dir.path()).max_depth(1);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![dir.path().to_path_buf(), dir.join("a")];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn max_depth_2() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a/b");
+
+    let wd = WalkDir::new(dir.path()).max_depth(2);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected =
+        vec![dir.path().to_path_buf(), dir.join("a"), dir.join("a").join("b")];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+// FIXME: This test seems wrong. It should return nothing!
+#[test]
+fn min_max_depth_diff_nada() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a/b/c");
+
+    let wd = WalkDir::new(dir.path()).min_depth(3).max_depth(2);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![dir.join("a").join("b").join("c")];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn min_max_depth_diff_0() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a/b/c");
+
+    let wd = WalkDir::new(dir.path()).min_depth(2).max_depth(2);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![dir.join("a").join("b")];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn min_max_depth_diff_1() {
+    let dir = Dir::tmp();
+    dir.mkdirp("a/b/c");
+
+    let wd = WalkDir::new(dir.path()).min_depth(1).max_depth(2);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![dir.join("a"), dir.join("a").join("b")];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn contents_first() {
+    let dir = Dir::tmp();
+    dir.touch("a");
+
+    let wd = WalkDir::new(dir.path()).contents_first(true);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![dir.join("a"), dir.path().to_path_buf()];
+    assert_eq!(expected, r.paths());
+}
+
+#[test]
+fn skip_current_dir() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo/bar/baz");
+    dir.mkdirp("quux");
+
+    let mut paths = vec![];
+    let mut it = WalkDir::new(dir.path()).into_iter();
+    while let Some(result) = it.next() {
+        let ent = result.unwrap();
+        paths.push(ent.path().to_path_buf());
+        if ent.file_name() == "bar" {
+            it.skip_current_dir();
+        }
+    }
+    paths.sort();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("foo"),
+        dir.join("foo").join("bar"),
+        dir.join("quux"),
+    ];
+    assert_eq!(expected, paths);
+}
+
+#[test]
+fn filter_entry() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo/bar/baz/abc");
+    dir.mkdirp("quux");
+
+    let wd = WalkDir::new(dir.path())
+        .into_iter()
+        .filter_entry(|ent| ent.file_name() != "baz");
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("foo"),
+        dir.join("foo").join("bar"),
+        dir.join("quux"),
+    ];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+#[test]
+fn sort_by() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo/bar/baz/abc");
+    dir.mkdirp("quux");
+
+    let wd = WalkDir::new(dir.path())
+        .sort_by(|a, b| a.file_name().cmp(b.file_name()).reverse());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("quux"),
+        dir.join("foo"),
+        dir.join("foo").join("bar"),
+        dir.join("foo").join("bar").join("baz"),
+        dir.join("foo").join("bar").join("baz").join("abc"),
+    ];
+    assert_eq!(expected, r.paths());
+}
+
+#[test]
+fn sort_by_key() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo/bar/baz/abc");
+    dir.mkdirp("quux");
+
+    let wd =
+        WalkDir::new(dir.path()).sort_by_key(|a| a.file_name().to_owned());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("foo"),
+        dir.join("foo").join("bar"),
+        dir.join("foo").join("bar").join("baz"),
+        dir.join("foo").join("bar").join("baz").join("abc"),
+        dir.join("quux"),
+    ];
+    assert_eq!(expected, r.paths());
+}
+
+#[test]
+fn sort_by_file_name() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo/bar/baz/abc");
+    dir.mkdirp("quux");
+
+    let wd = WalkDir::new(dir.path()).sort_by_file_name();
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("foo"),
+        dir.join("foo").join("bar"),
+        dir.join("foo").join("bar").join("baz"),
+        dir.join("foo").join("bar").join("baz").join("abc"),
+        dir.join("quux"),
+    ];
+    assert_eq!(expected, r.paths());
+}
+
+#[test]
+fn sort_max_open() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo/bar/baz/abc");
+    dir.mkdirp("quux");
+
+    let wd = WalkDir::new(dir.path())
+        .max_open(1)
+        .sort_by(|a, b| a.file_name().cmp(b.file_name()).reverse());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected = vec![
+        dir.path().to_path_buf(),
+        dir.join("quux"),
+        dir.join("foo"),
+        dir.join("foo").join("bar"),
+        dir.join("foo").join("bar").join("baz"),
+        dir.join("foo").join("bar").join("baz").join("abc"),
+    ];
+    assert_eq!(expected, r.paths());
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn same_file_system() {
+    use std::path::Path;
+
+    // This test is a little weird since it's not clear whether it's a good
+    // idea to setup a distinct mounted volume in these tests. Instead, we
+    // probe for an existing one.
+    if !Path::new("/sys").is_dir() {
+        return;
+    }
+
+    let dir = Dir::tmp();
+    dir.touch("a");
+    dir.symlink_dir("/sys", "sys-link");
+
+    // First, do a sanity check that things work without following symlinks.
+    let wd = WalkDir::new(dir.path());
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected =
+        vec![dir.path().to_path_buf(), dir.join("a"), dir.join("sys-link")];
+    assert_eq!(expected, r.sorted_paths());
+
+    // ... now follow symlinks and ensure we don't descend into /sys.
+    let wd =
+        WalkDir::new(dir.path()).same_file_system(true).follow_links(true);
+    let r = dir.run_recursive(wd);
+    r.assert_no_errors();
+
+    let expected =
+        vec![dir.path().to_path_buf(), dir.join("a"), dir.join("sys-link")];
+    assert_eq!(expected, r.sorted_paths());
+}
+
+// Tests that skip_current_dir doesn't destroy internal invariants.
+//
+// See: https://github.com/BurntSushi/walkdir/issues/118
+#[test]
+fn regression_skip_current_dir() {
+    let dir = Dir::tmp();
+    dir.mkdirp("foo/a/b");
+    dir.mkdirp("foo/1/2");
+
+    let mut wd = WalkDir::new(dir.path()).max_open(1).into_iter();
+    wd.next();
+    wd.next();
+    wd.next();
+    wd.next();
+
+    wd.skip_current_dir();
+    wd.skip_current_dir();
+    wd.next();
+}
diff --git a/third_party/rust/walkdir/src/tests/util.rs b/third_party/rust/walkdir/src/tests/util.rs
new file mode 100644
index 0000000000..fdf06f555e
--- /dev/null
+++ b/third_party/rust/walkdir/src/tests/util.rs
@@ -0,0 +1,252 @@
+use std::env;
+use std::error;
+use std::fs::{self, File};
+use std::io;
+use std::path::{Path, PathBuf};
+use std::result;
+
+use crate::{DirEntry, Error};
+
+/// Create an error from a format!-like syntax.
+#[macro_export]
+macro_rules! err {
+    ($($tt:tt)*) => {
+        Box::<dyn error::Error + Send + Sync>::from(format!($($tt)*))
+    }
+}
+
+/// A convenient result type alias.
+pub type Result<T> = result::Result<T, Box<dyn error::Error + Send + Sync>>;
+
+/// The result of running a recursive directory iterator on a single directory.
+#[derive(Debug)]
+pub struct RecursiveResults {
+    ents: Vec<DirEntry>,
+    errs: Vec<Error>,
+}
+
+impl RecursiveResults {
+    /// Return all of the errors encountered during traversal.
+    pub fn errs(&self) -> &[Error] {
+        &self.errs
+    }
+
+    /// Assert that no errors have occurred.
+    pub fn assert_no_errors(&self) {
+        assert!(
+            self.errs.is_empty(),
+            "expected to find no errors, but found: {:?}",
+            self.errs
+        );
+    }
+
+    /// Return all the successfully retrieved directory entries in the order
+    /// in which they were retrieved.
+    pub fn ents(&self) -> &[DirEntry] {
+        &self.ents
+    }
+
+    /// Return all paths from all successfully retrieved directory entries.
+    ///
+    /// This does not include paths that correspond to an error.
+    pub fn paths(&self) -> Vec<PathBuf> {
+        self.ents.iter().map(|d| d.path().to_path_buf()).collect()
+    }
+
+    /// Return all the successfully retrieved directory entries, sorted
+    /// lexicographically by their full file path.
+    pub fn sorted_ents(&self) -> Vec<DirEntry> {
+        let mut ents = self.ents.clone();
+        ents.sort_by(|e1, e2| e1.path().cmp(e2.path()));
+        ents
+    }
+
+    /// Return all paths from all successfully retrieved directory entries,
+    /// sorted lexicographically.
+    ///
+    /// This does not include paths that correspond to an error.
+    pub fn sorted_paths(&self) -> Vec<PathBuf> {
+        self.sorted_ents().into_iter().map(|d| d.into_path()).collect()
+    }
+}
+
+/// A helper for managing a directory in which to run tests.
+///
+/// When manipulating paths within this directory, paths are interpreted
+/// relative to this directory.
+#[derive(Debug)]
+pub struct Dir {
+    dir: TempDir,
+}
+
+impl Dir {
+    /// Create a new empty temporary directory.
+    pub fn tmp() -> Dir {
+        let dir = TempDir::new().unwrap();
+        Dir { dir }
+    }
+
+    /// Return the path to this directory.
+    pub fn path(&self) -> &Path {
+        self.dir.path()
+    }
+
+    /// Return a path joined to the path to this directory.
+    pub fn join<P: AsRef<Path>>(&self, path: P) -> PathBuf {
+        self.path().join(path)
+    }
+
+    /// Run the given iterator and return the result as a distinct collection
+    /// of directory entries and errors.
+    pub fn run_recursive<I>(&self, it: I) -> RecursiveResults
+    where
+        I: IntoIterator<Item = result::Result<DirEntry, Error>>,
+    {
+        let mut results = RecursiveResults { ents: vec![], errs: vec![] };
+        for result in it {
+            match result {
+                Ok(ent) => results.ents.push(ent),
+                Err(err) => results.errs.push(err),
+            }
+        }
+        results
+    }
+
+    /// Create a directory at the given path, while creating all intermediate
+    /// directories as needed.
+    pub fn mkdirp<P: AsRef<Path>>(&self, path: P) {
+        let full = self.join(path);
+        fs::create_dir_all(&full)
+            .map_err(|e| {
+                err!("failed to create directory {}: {}", full.display(), e)
+            })
+            .unwrap();
+    }
+
+    /// Create an empty file at the given path. All ancestor directories must
+    /// already exists.
+    pub fn touch<P: AsRef<Path>>(&self, path: P) {
+        let full = self.join(path);
+        File::create(&full)
+            .map_err(|e| {
+                err!("failed to create file {}: {}", full.display(), e)
+            })
+            .unwrap();
+    }
+
+    /// Create empty files at the given paths. All ancestor directories must
+    /// already exists.
+    pub fn touch_all<P: AsRef<Path>>(&self, paths: &[P]) {
+        for p in paths {
+            self.touch(p);
+        }
+    }
+
+    /// Create a file symlink to the given src with the given link name.
+    pub fn symlink_file<P1: AsRef<Path>, P2: AsRef<Path>>(
+        &self,
+        src: P1,
+        link_name: P2,
+    ) {
+        #[cfg(windows)]
+        fn imp(src: &Path, link_name: &Path) -> io::Result<()> {
+            use std::os::windows::fs::symlink_file;
+            symlink_file(src, link_name)
+        }
+
+        #[cfg(unix)]
+        fn imp(src: &Path, link_name: &Path) -> io::Result<()> {
+            use std::os::unix::fs::symlink;
+            symlink(src, link_name)
+        }
+
+        let (src, link_name) = (self.join(src), self.join(link_name));
+        imp(&src, &link_name)
+            .map_err(|e| {
+                err!(
+                    "failed to symlink file {} with target {}: {}",
+                    src.display(),
+                    link_name.display(),
+                    e
+                )
+            })
+            .unwrap()
+    }
+
+    /// Create a directory symlink to the given src with the given link name.
+    pub fn symlink_dir<P1: AsRef<Path>, P2: AsRef<Path>>(
+        &self,
+        src: P1,
+        link_name: P2,
+    ) {
+        #[cfg(windows)]
+        fn imp(src: &Path, link_name: &Path) -> io::Result<()> {
+            use std::os::windows::fs::symlink_dir;
+            symlink_dir(src, link_name)
+        }
+
+        #[cfg(unix)]
+        fn imp(src: &Path, link_name: &Path) -> io::Result<()> {
+            use std::os::unix::fs::symlink;
+            symlink(src, link_name)
+        }
+
+        let (src, link_name) = (self.join(src), self.join(link_name));
+        imp(&src, &link_name)
+            .map_err(|e| {
+                err!(
+                    "failed to symlink directory {} with target {}: {}",
+                    src.display(),
+                    link_name.display(),
+                    e
+                )
+            })
+            .unwrap()
+    }
+}
+
+/// A simple wrapper for creating a temporary directory that is automatically
+/// deleted when it's dropped.
+///
+/// We use this in lieu of tempfile because tempfile brings in too many
+/// dependencies.
+#[derive(Debug)]
+pub struct TempDir(PathBuf);
+
+impl Drop for TempDir {
+    fn drop(&mut self) {
+        fs::remove_dir_all(&self.0).unwrap();
+    }
+}
+
+impl TempDir {
+    /// Create a new empty temporary directory under the system's configured
+    /// temporary directory.
+    pub fn new() -> Result<TempDir> {
+        #[allow(deprecated)]
+        use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
+
+        static TRIES: usize = 100;
+        #[allow(deprecated)]
+        static COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
+
+        let tmpdir = env::temp_dir();
+        for _ in 0..TRIES {
+            let count = COUNTER.fetch_add(1, Ordering::SeqCst);
+            let path = tmpdir.join("rust-walkdir").join(count.to_string());
+            if path.is_dir() {
+                continue;
+            }
+            fs::create_dir_all(&path).map_err(|e| {
+                err!("failed to create {}: {}", path.display(), e)
+            })?;
+            return Ok(TempDir(path));
+        }
+        Err(err!("failed to create temp dir after {} tries", TRIES))
+    }
+
+    /// Return the underlying path to this temporary directory.
+    pub fn path(&self) -> &Path {
+        &self.0
+    }
+}