fix missing suffix in output

Author: STRTSNM

src/uu/df/src/blocks.rs

@@ -131,19 +131,21 @@ pub(crate) enum BlockSize {
     ///
     /// The number must be positive.
     Bytes(u64),
+    /// for when we need to display suffix along with blocksize
+    PrefixedBytes(u64, String),
 }
 
 impl BlockSize {
     /// Returns the associated value
     pub(crate) fn as_u64(&self) -> u64 {
         match *self {
-            Self::Bytes(n) => n,
+            Self::Bytes(n) | Self::PrefixedBytes(n, _) => n,
         }
     }
 
     pub(crate) fn to_header(&self) -> String {
         match self {
-            Self::Bytes(n) => {
+            Self::Bytes(n) | Self::PrefixedBytes(n, _) => {
                 if n % 1024 == 0 && n % 1000 != 0 {
                     to_magnitude_and_suffix(*n as u128, SuffixType::Iec, false)
                 } else {
@@ -166,7 +168,11 @@ pub(crate) fn read_block_size(matches: &ArgMatches) -> Result<BlockSize, ParseSi
         let bytes = parse_size_u64(s)?;
 
         if bytes > 0 {
-            Ok(BlockSize::Bytes(bytes))
+            if s.chars().all(char::is_alphabetic) {
+                Ok(BlockSize::PrefixedBytes(bytes, s.clone()))
+            } else {
+                Ok(BlockSize::Bytes(bytes))
+            }
         } else {
             Err(ParseSizeError::ParseFailure(format!("{}", s.quote())))
         }
@@ -184,7 +190,7 @@ pub(crate) fn read_block_size(matches: &ArgMatches) -> Result<BlockSize, ParseSi
 impl fmt::Display for BlockSize {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Self::Bytes(n) => {
+            Self::Bytes(n) | Self::PrefixedBytes(n, _) => {
                 let s = if n % 1024 == 0 && n % 1000 != 0 {
                     to_magnitude_and_suffix(*n as u128, SuffixType::Iec, true)
                 } else {

src/uu/df/src/table.rs

@@ -215,10 +215,7 @@ impl BytesCell {
     fn new(bytes: u64, block_size: &BlockSize) -> Self {
         Self {
             bytes,
-            scaled: {
-                let BlockSize::Bytes(d) = block_size;
-                (bytes as f64 / *d as f64).ceil() as u64
-            },
+            scaled: (bytes as f64 / block_size.as_u64() as f64).ceil() as u64,
         }
     }
 }
@@ -308,14 +305,21 @@ impl<'a> RowFormatter<'a> {
         let size = bytes_column.scaled;
         let s = if let Some(h) = self.options.human_readable {
             let size = if self.is_total_row {
-                let BlockSize::Bytes(d) = self.options.block_size;
+                let d = self.options.block_size.as_u64();
                 d * size
             } else {
                 bytes_column.bytes
             };
             to_magnitude_and_suffix(size.into(), SuffixType::HumanReadable(h), true)
-        } else {
-            size.to_string()
+        }else {
+            match &self.options.block_size {
+                /// if it has a suffix, append it to the size (but not on the 'total' row)
+                BlockSize::PrefixedBytes(_, suffix) if !self.is_total_row => {
+                    format!("{}{}", size, suffix)
+                }
+                /// else, just print the raw number as before
+                _ => size.to_string(),
+            }
         };
         Cell::from_ascii_string(s)
     }
@@ -327,7 +331,14 @@ impl<'a> RowFormatter<'a> {
         let s = if let Some(h) = self.options.human_readable {
             to_magnitude_and_suffix(size, SuffixType::HumanReadable(h), true)
         } else {
-            size.to_string()
+            match &self.options.block_size {
+                /// if it has a suffix, append it to the size (but not on the 'total' row)
+                BlockSize::PrefixedBytes(_, suffix) if !self.is_total_row => {
+                    format!("{}{}", size, suffix)
+                }
+                /// else, just print the raw number as before
+                _ => size.to_string(),
+            }
         };
         Cell::from_ascii_string(s)
     }