Repository: uutils/coreutils (Rust)

Issue:
df: should respect -t argument when specific file is provided, but doesn't
The uutils version of `df` should respect the `-t` argument when a specific file is provided, but it currently does not.

GNU df:
```
$ df -t _non_existent_type .
df: no file systems processed
```

uutils df:
```
$ ./target/release/df -t _non_existent_type .
Filesystem          1K-blocks         Used    Available  Use% Mounted on
/dev/mapper/vgubuntu-root    242791844    122128628    108260324   51% /
```



Discussion:

Patch:
diff --git a/src/uu/df/src/df.rs b/src/uu/df/src/df.rs
index b4f3457c432..2b9c929c7cc 100644
--- a/src/uu/df/src/df.rs
+++ b/src/uu/df/src/df.rs
@@ -292,7 +292,7 @@ fn get_all_filesystems(opt: &Options) -> Vec<Filesystem> {
 }
 
 /// For each path, get the filesystem that contains that path.
-fn get_named_filesystems<P>(paths: &[P]) -> Vec<Filesystem>
+fn get_named_filesystems<P>(paths: &[P], opt: &Options) -> Vec<Filesystem>
 where
     P: AsRef<Path>,
 {
@@ -302,21 +302,35 @@ where
     // considered. The "lofs" filesystem is a loopback
     // filesystem present on Solaris and FreeBSD systems. It
     // is similar to a symbolic link.
-    let mounts: Vec<MountInfo> = read_fs_list()
+    let mounts: Vec<MountInfo> = filter_mount_list(read_fs_list(), opt)
         .into_iter()
         .filter(|mi| mi.fs_type != "lofs" && !mi.dummy)
         .collect();
 
+    let mut result = vec![];
+
+    // this happens if the file system type doesn't exist
+    if mounts.is_empty() {
+        show!(USimpleError::new(1, "no file systems processed"));
+        return result;
+    }
+
     // Convert each path into a `Filesystem`, which contains
     // both the mount information and usage information.
-    let mut result = vec![];
     for path in paths {
         match Filesystem::from_path(&mounts, path) {
             Some(fs) => result.push(fs),
-            None => show!(USimpleError::new(
-                1,
-                format!("{}: No such file or directory", path.as_ref().display())
-            )),
+            None => {
+                // this happens if specified file system type != file system type of the file
+                if path.as_ref().exists() {
+                    show!(USimpleError::new(1, "no file systems processed"));
+                } else {
+                    show!(USimpleError::new(
+                        1,
+                        format!("{}: No such file or directory", path.as_ref().display())
+                    ));
+                }
+            }
         }
     }
     result
@@ -370,7 +384,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
         Some(paths) => {
             let paths: Vec<&str> = paths.collect();
-            let filesystems = get_named_filesystems(&paths);
+            let filesystems = get_named_filesystems(&paths, &opt);
 
             // This can happen if paths are given as command-line arguments
             // but none of the paths exist.
@@ -382,12 +396,6 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
     };
 
-    // This can happen if paths are given as command-line arguments
-    // but none of the paths exist.
-    if filesystems.is_empty() {
-        return Ok(());
-    }
-
     println!("{}", Table::new(&opt, filesystems));
 
     Ok(())


Test patch:
diff --git a/tests/by-util/test_df.rs b/tests/by-util/test_df.rs
index 3de3c677b02..54c41e229a5 100644
--- a/tests/by-util/test_df.rs
+++ b/tests/by-util/test_df.rs
@@ -199,7 +199,42 @@ fn test_type_option() {
     new_ucmd!()
         .args(&["-t", fs_type, "-t", "nonexisting"])
         .succeeds();
-    new_ucmd!().args(&["-t", "nonexisting"]).fails();
+    new_ucmd!()
+        .args(&["-t", "nonexisting"])
+        .fails()
+        .stderr_contains("no file systems processed");
+}
+
+#[test]
+fn test_type_option_with_file() {
+    let fs_type = new_ucmd!()
+        .args(&["--output=fstype", "."])
+        .succeeds()
+        .stdout_move_str();
+    let fs_type = fs_type.lines().nth(1).unwrap().trim();
+
+    new_ucmd!().args(&["-t", fs_type, "."]).succeeds();
+    new_ucmd!()
+        .args(&["-t", "nonexisting", "."])
+        .fails()
+        .stderr_contains("no file systems processed");
+
+    let fs_types = new_ucmd!()
+        .arg("--output=fstype")
+        .succeeds()
+        .stdout_move_str();
+    let fs_types: Vec<_> = fs_types
+        .lines()
+        .skip(1)
+        .filter(|t| t.trim() != fs_type && t.trim() != "")
+        .collect();
+
+    if !fs_types.is_empty() {
+        new_ucmd!()
+            .args(&["-t", fs_types[0], "."])
+            .fails()
+            .stderr_contains("no file systems processed");
+    }
 }
 
 #[test]