Merge pull request #428 from rustcoreutils/updates

Updates

Author: jgarzik

CONTRIBUTING.md

@@ -39,9 +39,18 @@ There are several ways to contribute to posixutils-rs:
    Code should be readable by unfamiliar developers.  Avoid dense,
    uncommented code.
 
-### Testing, POSIX compliance and programmaticgoals
+### Testing, POSIX compliance and programmatic goals
 
 * All utilities should have tests.
+* Use plib's TestPlan framework for integration tests.
+* Test pattern:
+	1. Pre-generate input data files.
+	2. Run system OS utility on input data files,
+	   generating known-good output.
+	3. Store input and output in-tree, as known-good data.
+	4. Write a TestPlan that executes our utility, using
+	   static input data, and compares output with
+	   static output data.
 * Only "quick" tests should be run automatically in `cargo test`
 * Longer tests, or tests requiring root access, should be triggered
   via special environment variables.
@@ -50,7 +59,9 @@ There are several ways to contribute to posixutils-rs:
 * If a system has an OS-specific feature that _must_ be
   exposed through a given utility, do so.
 * Race-free userland.  See `ftw` internal crate.
-* Push small crates out:  Create tiny, light-dep crates from common functionality (such as Lex or Yacc file parsing), and publish via cargo.  Remove from main posixutils tree and set of crates.
+* Push small crates out:  Create tiny, light-dep crates from common
+  functionality (such as Lex or Yacc file parsing), and publish via cargo.
+  Remove from main posixutils tree and set of crates.
 
 ### Testing and Bug Reporting: Info to provide in GH issue
 

Cargo.lock

@@ -201,7 +201,7 @@ impl Interpreter {
                     .ok_or("array index is too large")? as usize;
                 if let Some(call_frame) = self.call_frames.last_mut() {
                     if let Some(array) = &mut call_frame.array_variables[name_index(*name)] {
-                        return Ok(get_or_extend(array, index as usize));
+                        return Ok(get_or_extend(array, index));
                     }
                 }
                 Ok(get_or_extend(

calc/bc_util/interpreter.rs

@@ -66,11 +66,7 @@ fn token_display(t: &Token) -> String {
 
 // is token an lval?
 fn token_is_lval(t: &Token) -> bool {
-    match t {
-        Token::Integer(_) => true,
-        Token::Str(_) => true,
-        _ => false,
-    }
+    matches!(t, Token::Integer(_) | Token::Str(_))
 }
 
 // is token zero?

calc/expr.rs

@@ -591,7 +591,7 @@ impl SeekPositions {
             let reader = BufReader::new(&mut self.buffer).lines();
             for line in reader {
                 if let Ok(line) = line {
-                    seek_pos += line.as_bytes().len();
+                    seek_pos += line.len();
                 }
                 i += 1;
                 if i >= n {

display/more.rs

@@ -110,7 +110,7 @@ fn get_magic_files(args: &Args) -> Vec<PathBuf> {
     magic_files
 }
 
-fn analyze_file(mut path: String, args: &Args, magic_files: &Vec<PathBuf>) {
+fn analyze_file(mut path: String, args: &Args, magic_files: &[PathBuf]) {
     if path == "-" {
         path = String::new();
         io::stdin().read_line(&mut path).unwrap();

file/file.rs

@@ -426,7 +426,7 @@ impl RawMagicFileLine {
     fn string_test(&self, tf_reader: &mut BufReader<File>) -> bool {
         if let Value::String(val) = &self.value {
             let mut buf = vec![0u8; val.len()];
-            if let Err(_) = tf_reader.read_exact(&mut buf) {
+            if tf_reader.read_exact(&mut buf).is_err() {
                 return false;
             }
 
@@ -439,7 +439,7 @@ impl RawMagicFileLine {
 
     fn number_test(&self, size: u64, mask: Option<u64>, tf_reader: &mut BufReader<File>) -> bool {
         let mut buf = vec![0; size as usize];
-        if let Err(_) = tf_reader.read_exact(&mut buf) {
+        if tf_reader.read_exact(&mut buf).is_err() {
             return false;
         }
 

file/magic.rs

@@ -170,15 +170,13 @@ pub fn from_ucs4<I: Iterator<Item = u32> + 'static>(
             let high_surrogate = ((code_point >> 10) as u16) + 0xD800;
             let low_surrogate = ((code_point & 0x3FF) as u16) + 0xDC00;
             utf16.extend_from_slice(&[high_surrogate, low_surrogate]);
+        } else if !omit_invalid {
+            return Vec::new();
         } else {
-            if !omit_invalid {
-                return Vec::new();
-            } else {
-                if !suppress_error {
-                    eprintln!("Error: Invalid Unicode code point U+{:X}", code_point);
-                }
-                exit(1)
+            if !suppress_error {
+                eprintln!("Error: Invalid Unicode code point U+{:X}", code_point);
             }
+            exit(1)
         }
 
         to_bytes(&utf16, variant)

i18n/iconv_lib/utf_16.rs

@@ -42,23 +42,20 @@ pub fn to_ucs4<I: Iterator<Item = u8> + 'static>(
 
             if !bom_checked {
                 let first_word = BigEndian::read_u32(&buffer);
-                match variant {
-                    UTF32Variant::UTF32 => {
-                        if first_word == BOM {
-                            variant = UTF32Variant::UTF32BE;
-                            buffer.clear();
-                        } else if first_word == BOM_OE {
-                            variant = UTF32Variant::UTF32LE;
-                            buffer.clear();
+                if variant == UTF32Variant::UTF32 {
+                    if first_word == BOM {
+                        variant = UTF32Variant::UTF32BE;
+                        buffer.clear();
+                    } else if first_word == BOM_OE {
+                        variant = UTF32Variant::UTF32LE;
+                        buffer.clear();
+                    } else {
+                        variant = if cfg!(target_endian = "little") {
+                            UTF32Variant::UTF32LE
                         } else {
-                            variant = if cfg!(target_endian = "little") {
-                                UTF32Variant::UTF32LE
-                            } else {
-                                UTF32Variant::UTF32BE
-                            };
-                        }
+                            UTF32Variant::UTF32BE
+                        };
                     }
-                    _ => {}
                 }
                 bom_checked = true;
                 if buffer.is_empty() {

i18n/iconv_lib/utf_32.rs

@@ -168,16 +168,14 @@ pub fn to_ucs4<I: Iterator<Item = u8> + 'static>(
                 }
                 buffer.drain(0..4);
                 return Some(code_point);
+            } else if omit_invalid {
+                buffer.drain(0..1);
+                continue;
             } else {
-                if omit_invalid {
-                    buffer.drain(0..1);
-                    continue;
-                } else {
-                    if !suppress_error {
-                        eprintln!("Error: Invalid byte");
-                    }
-                    exit(1);
+                if !suppress_error {
+                    eprintln!("Error: Invalid byte");
                 }
+                exit(1);
             }
         }
     });
@@ -225,19 +223,17 @@ pub fn from_ucs4<I: Iterator<Item = u32> + 'static>(
                 0x80 | (((code_point >> 6) & 0x3F) as u8),
                 0x80 | ((code_point & 0x3F) as u8),
             ])
+        } else if omit_invalid {
+            None
         } else {
-            if omit_invalid {
-                None
-            } else {
-                if !suppress_error {
-                    eprintln!(
-                        "Error: Code point U+{:X} is out of valid Unicode range",
-                        code_point
-                    );
-                    exit(1)
-                }
-                Some(vec![])
+            if !suppress_error {
+                eprintln!(
+                    "Error: Code point U+{:X} is out of valid Unicode range",
+                    code_point
+                );
+                exit(1)
             }
+            Some(vec![])
         }
     });
     Box::new(iter.flatten())