test(wip): write test for parsing nonprintable characters

1 files changed, 90 insertions, 34 deletions

diff --git a/src/lib.rs b/src/lib.rs
index c3665da..0ef1b4c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3 +1,5 @@
+use std::io::{BufReader, BufWriter, Read, Write};
+
 pub use crate::cli::{Cli, Opts};
 pub use crate::error::{Error, Result};
 pub use crate::input::Input;
@@ -31,53 +33,56 @@ Examples:
 const UNKNOWN_CHAR: &[u8; 2] = b"^?";
 
 pub fn run(cli: Cli) -> Result<()> {
-    use std::io::{BufReader, Read, Write};
-
     let stdout = std::io::stdout();
     let mut writer = stdout.lock();
 
     for file in cli.files.into_iter() {
-        let mut reader = BufReader::new(file.reader()?);
+        process_input(&mut file.reader()?, &mut writer, &cli.opts)?;
+    }
 
-        let mut nonblank_line_nr = 0;
-        let mut buf = Vec::new();
-        reader.read_to_end(&mut buf)?;
+    Ok(())
+}
 
-        for (index, arr) in buf.split(|c| *c == b'\n').enumerate() {
-            if arr.is_empty() && cli.opts.squeeze_blank {
-                continue;
-            }
+fn process_input(reader: impl Read, writer: &mut impl Write, opts: &Opts) -> Result<()> {
+    let mut reader = BufReader::new(reader);
+    let mut writer = BufWriter::new(writer);
+    let mut nonblank_line_nr = 0;
+    let mut buf = Vec::new();
+    reader.read_to_end(&mut buf)?;
 
-            let mut line = Vec::new();
-            for c in arr {
-                let parsed = match *c {
-                    b'\t' if cli.opts.show_tabs => b"^I".to_vec(),
-                    b'\t' => b"\t".to_vec(),
-                    c if cli.opts.show_nonprinting => parse_nonprinting_char(c),
-                    c => [c].to_vec(),
-                };
-                line.extend(parsed)
-            }
+    for (index, arr) in buf.split(|c| *c == b'\n').enumerate() {
+        if arr.is_empty() && opts.squeeze_blank {
+            continue;
+        }
 
-            if cli.opts.show_ends {
-                line.push(b'$');
-            }
+        let mut line = Vec::new();
+        for c in arr {
+            let parsed = match *c {
+                b'\t' if opts.show_tabs => b"^I".to_vec(),
+                b'\t' => b"\t".to_vec(),
+                c if opts.show_nonprinting => parse_nonprinting_char(c),
+                c => [c].to_vec(),
+            };
+            line.extend(parsed)
+        }
 
-            line.push(b'\n');
+        if opts.show_ends {
+            line.push(b'$');
+        }
 
-            if cli.opts.number_nonblank {
-                if !line.is_empty() {
-                    nonblank_line_nr += 1;
-                    write!(writer, "{:>6}  ", nonblank_line_nr)?;
-                }
-            } else if cli.opts.number {
-                write!(writer, "{:>6}  ", index + 1)?;
-            }
+        line.push(b'\n');
 
-            writer.write_all(&line)?
+        if opts.number_nonblank {
+            if !line.is_empty() {
+                nonblank_line_nr += 1;
+                write!(writer, "{:>6}  ", nonblank_line_nr)?;
+            }
+        } else if opts.number {
+            write!(writer, "{:>6}  ", index + 1)?;
         }
-    }
 
+        writer.write_all(&line)?
+    }
     Ok(())
 }
 
@@ -97,3 +102,54 @@ fn parse_nonprinting_char(mut c: u8) -> Vec<u8> {
 
     buf
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use std::{
+        io::{BufWriter, Write},
+        process::{Command, Stdio},
+    };
+
+    #[test]
+    fn test_nonprinting_char() {
+        let perl_exp = r#"\
+        for( my $i=0 ; $i < 256; $i++ ) {
+            print ( sprintf( "%c is %d %x", $i, $i ,$i ) );
+        }"#;
+
+        let perl_stdout = Command::new("perl")
+            .arg("-e")
+            .arg(perl_exp)
+            .output()
+            .unwrap()
+            .stdout;
+
+        println!("{:?}", perl_stdout);
+
+        let cat_child = Command::new("cat")
+            .arg("-")
+            .arg("-v")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .spawn()
+            .unwrap();
+
+        BufWriter::new(cat_child.stdin.as_ref().unwrap())
+            .write_all(&perl_stdout)
+            .unwrap();
+
+        let cat_output = cat_child.wait_with_output().unwrap().stdout;
+
+        let mut catr_output = Vec::new();
+        let opts = Opts {
+            show_nonprinting: true,
+            ..Default::default()
+        };
+
+        process_input(&*perl_stdout, &mut catr_output, &opts).unwrap();
+
+        assert_eq!(cat_output, catr_output)
+    }
+}