Added some tests. Removed valuable code.

hw6/task1/src/main.rs

 extern crate nix;
 
 use nix::unistd::{fork, pipe, read, write};
-use nix::sys::wait::wait;
+use nix::sys::wait::{wait, WaitStatus};
 use std::str;
-use nix::sys::wait::WaitStatus;
 use nix::unistd::ForkResult::{Child, Parent};
 use std::os::unix::io::RawFd;
 
+mod unit_test_pipe;
+
 const BUFFER_SIZE: usize = 256;
 
 
                                 Ok(Child) => {
                                     match sum_strings(vec) {
                                         Ok(res) => println!("Sum = {}", res),
-                                        Err(e) => println!("{}", e),
+                                        Err(e) => {
+                                            println!("{}", e);
+                                            process::exit(1);
+                                        }
                                     }
                                 }
                                 Ok(Parent { .. }) => {
                                     if let Ok(ws) = wait() {
-                                        if let WaitStatus::Exited(_, _) = ws {
+                                        if let WaitStatus::Exited(_, exit_code) = ws {
                                             match mul_strings(vec) {
                                                 Ok(res) => println!("Mul = {}", res),
-                                                Err(e) => println!("{}", e),
+                                                Err(e) => {
+                                                    println!("{}", e);
+                                                    process::exit(1);
+                                                }
                                             }
+                                            process::exit(exit_code as i32);
                                         }
                                     }
                                 }
                     for s in numbers {
                         args = concatenate_strings(&args, &concatenate_strings(&s, " "));
                     }
-                    println!("sending to children: {}", args);
+                    println!("sending to childs: {}", args);
+
                     if let Err(_) = write(writer, args.as_bytes()) {
                         println!("Broken pipe")
                     }
 
-                    if let Err(_) = wait() {
-                        println!("Waiting on children failed")
+                    if let Ok(ws) = wait() {
+                        if let WaitStatus::Exited(_, exit_code) = ws {
+                            process::exit(exit_code as i32);
+                        }
                     }
                 }
 
 }
 
 /// Calculates the sum of the given Strings and returns them as a Result.
-fn sum_strings(v: Vec<String>) -> Result<i32, String> {
-    let mut sum = 0;
+fn sum_strings(v: Vec<String>) -> Result<i64, String> {
+    let mut sum: i64 = 0;
     for x in v {
-        match x.parse::<i32>() {
+        match x.parse::<i64>() {
             Ok(val) => {
-                match i32::checked_add(sum, val) {
+                match i64::checked_add(sum, val) {
                     Some(y) => {
                         sum = y;
                     }
 }
 
 /// Calculates the product of the given Strings and returns them as a Result.
-fn mul_strings(v: Vec<String>) -> Result<i32, String> {
-    let mut prod = 1;
+fn mul_strings(v: Vec<String>) -> Result<i64, String> {
+    let mut prod: i64 = 1;
     for x in v {
-        match x.parse::<i32>() {
+        match x.parse::<i64>() {
             Ok(val) => {
-                match i32::checked_mul(prod, val) {
+                match i64::checked_mul(prod, val) {
                     Some(y) => {
                         prod = y;
                     }

hw6/task1/src/unit_test_pipe.rs

+#[cfg(test)]
+mod test {
+    use read_from_pipe;
+    use nix::unistd::{pipe, write};
+
+    #[test]
+    fn test_pipe() {
+        match pipe() {
+            Ok((reader, writer)) => {
+                let input = b"teststring";
+
+                if let Err(_) = write(writer, input) {
+                    // Broken pipe
+                }
+                assert_eq!(read_from_pipe(reader).unwrap(), "teststring".to_string());
+            }
+            Err(_) => {}
+        }
+
+    }
+
+    #[test]
+    fn test_kill_last_child() {}
+}

hw6/task2/src/command.rs

 use std::str::FromStr;
 use std::env;
 
+#[derive(PartialEq, Debug)]
 pub enum Command {
     Empty,
     Exit,
     Cd(Option<OsString>),
 }
 
+#[derive(PartialEq, Debug)]
 pub struct CommandNotFoundError;
 
 impl FromStr for Command {
 
 
 impl Command {
-    /// If the passed String exists, set the path of the Cd in the enum
+    /// If the passed String exists, set the path of the Cd in the enum (as OsString)
+    /// Returns **Command**
     pub fn parse_cd(cmd: Option<&str>) -> Self {
         match cmd {
             None => Command::Cd(None),
         }
     }
 
+    /// If this instance is of Kind **Command::Cd** either go to HOME or navigate to the given path
     pub fn exec_cd(&self) {
         if let Command::Cd(None) = *self {
             let possible_home = env::home_dir();

hw6/task2/src/main.rs

 use std::process;
-use shell::{Shell, R, W};
+use shell::Shell;
 use std::io;
 
+mod unit_tests_shell;
 mod command;
 mod shell;
 
 
+
 fn main() {
     let stdin = io::stdin();
-    let input = R(stdin.lock());
-
     let stdout = io::stdout();
-    let output = W(stdout.lock());
 
-    let mut s = Shell::new(input, output, "schell".to_string());
+    let mut s = Shell::new(stdin.lock(), stdout.lock(), "schell".to_string());
     match s.start() {
         Ok(_) => process::exit(0),
         Err(_) => process::exit(1),

hw6/task2/src/shell.rs

-use std::io::{BufRead, Write, Read, StdinLock, StdoutLock};
-use std::io;
-
+use std::io::{BufRead, Write};
 use command::*;
 use std::str::FromStr;
 use std::env;
 
-///Tuple-Structs which hold Std-in and -out locks.
-pub struct R<'a>(pub StdinLock<'a>);
-pub struct W<'a>(pub StdoutLock<'a>);
-
-pub struct Shell<R, W> {
+pub struct Shell<R: BufRead, W: Write> {
     pub reader: R,
     pub writer: W,
     pub should_exit: bool,
     pub name: String,
 }
 
-impl<'a> Shell<R<'a>, W<'a>> {
+impl<R: BufRead, W: Write> Shell<R, W> {
     /// Creates a new Shell with a name, input and output.
-    pub fn new(input: R<'a>, output: W<'a>, name: String) -> Self {
+    pub fn new(input: R, output: W, name: String) -> Self {
         Shell {
             reader: input,
             writer: output,
     /// If the Command-creation succeeds, run the command.
     fn shell_loop(&mut self) -> Result<(), &str> {
         while !self.should_exit {
-            if let Ok(line) = self.prompt() {
+            if let Ok(Some(line)) = self.prompt() {
                 let _ = Command::from_str(&line).and_then(|cmd| self.run(cmd));
             }
         }
 
     /// Prints the shell prompt.
     /// Waits for user input and returns the read line.
-    fn prompt(&mut self) -> Result<String, &str> {
+    pub fn prompt(&mut self) -> Result<Option<String>, &str> {
         match env::current_dir() {
             Ok(pwd) => {
                 let _ = self.writer.write(
                 let mut line: String = String::new();
                 let read_result = self.reader.read_line(&mut line);
                 match read_result {
-                    Ok(_) => Ok(line),
-                    Err(_) => Err("Error reading."),
+                    Ok(_) => Ok(Some(line)),
+                    Err(_) => Ok(None),
                 }
             }
             Err(_) => return Err("Path Error"),
         Ok(())
     }
 }
-
-/// Implement Read-Trait for Tuple-Struct R
-/// Simply calls `read` of StdinLock
-impl<'a> Read for R<'a> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
-        self.0.read(buf)
-    }
-}
-
-/// Implement BufRead-Trait for Tuple-Struct R
-/// Simply calls `fill_buff` and `consume` from StdinLock
-impl<'a> BufRead for R<'a> {
-    fn fill_buf(&mut self) -> Result<&[u8], io::Error> {
-        self.0.fill_buf()
-    }
-
-    fn consume(&mut self, amt: usize) {
-        self.0.consume(amt)
-    }
-}
-
-/// Implement Write-Trait for Tuple-Struct W
-/// Simply calls `write` and `flush` from StdoutLock
-impl<'a> Write for W<'a> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
-        self.0.write(buf)
-    }
-
-    fn flush(&mut self) -> Result<(), io::Error> {
-        self.0.flush()
-    }
-}

hw6/task2/src/unit_tests_shell.rs

 #[cfg(test)]
 mod test {
-    use shell::Shell;
+    pub use shell::Shell;
+    use command::Command;
+    use command::CommandNotFoundError;
+    use std::str::FromStr;
+    use std::ffi::OsString;
+
+    #[test]
+    fn test_command_empty_whitespace() {
+        assert_eq!(Command::from_str("       ").unwrap(), Command::Empty);
+    }
+
+    #[test]
+    fn test_command_empty_tab() {
+        assert_eq!(Command::from_str("\t").unwrap(), Command::Empty);
+    }
+
+    #[test]
+    fn test_command_cd() {
+        assert_eq!(
+            Command::from_str("cd /home/peter/").unwrap(),
+            Command::Cd(Some(OsString::from("/home/peter/")))
+        );
+    }
+
+    #[test]
+    fn test_command_home() {
+        assert_eq!(Command::from_str("cd").unwrap(), Command::Cd(None));
+    }
+
+    #[test]
+    fn test_command_exit() {
+        assert_eq!(Command::from_str("exit").unwrap(), Command::Exit);
+    }
+
+    #[test]
+    fn test_command_not_found() {
+        assert_eq!(
+            Command::from_str("awdeiu33we").unwrap_err(),
+            CommandNotFoundError
+        );
+    }
 
     #[test]
     fn test_prompt_in_memory_with_string() {