Finished child part of task1

hw5/task1/src/child/mod.rs

 use nix::unistd::{fork, getpid};
 use nix::sys::wait::wait;
+use nix::sys::wait::WaitStatus;
 use nix::unistd::ForkResult::{Child, Parent};
 
 mod pstree;
     let count = arg.parse::<u8>();
     match count {
         Ok(value) => {
-            for i in 0..value {
-                let pid = fork();
-                match pid {
-                    Ok(Child) => {
-                        println!("hello, I am child (pid:{})", getpid());
-                    }
-                    Ok(Parent { child }) => {
-                        println!("hello, I am parent of {} (pid:{})", child, getpid());
-                        match wait(){
-                            Ok(ws) => { println!("{:?}", ws); }
-                            Err(_) => {}
-                        }
-                    }
-                    // panic, fork should never fail unless there is a
-                    // serious problem with the OS
-                    Err(_) => panic!("fork failed"),
-                }
-            }
-            pstree::print(start_pid);
+
+            if value > 0 { }
+            fork_children(0, value - 1, start_pid);
             Ok(())
         },
         Err(_) => {
             Err("Parse Failed".to_string())
         },
     }
+}
+
+pub fn fork_children(count: u8, to:u8, start_pid: i32) {
+    let pid = fork();
+    match pid {
+        Ok(Child) => {
+            println!("hello, I am child (pid:{})", getpid());
+            if count < to {
+                fork_children(count + 1, to, start_pid);
+            } else {
+                println!();
+                pstree::print(start_pid);
+            }
+        }
+
+        Ok(Parent { child }) => {
+            if let Ok(ws) = wait() {
+                if let WaitStatus::Exited(child_pid, exit_code) = ws {
+                    println!("I am {} and my child is {}. After I waited for {}, it sent me status {:?}", getpid(), child, child_pid, exit_code);
+                }
+            }
+        }
+
+        Err(_) => {}
+    }
 }

hw5/task1/src/main.rs

 extern crate nix;
 
 use std::env::args;
+use std::process;
 
+mod unit_tests;
 mod zombie;
 mod child;
 
                 let result = child::run_childs(stat.pid, &arguments[1]);
                 match result {
                     Ok(_) => {},
-                    Err(_) => {},
+                    Err(e) => {
+                        println!("{}", e);
+                        process::exit(1)
+                    },
                 }
             },
-            Err(_) => {},
+            Err(_) => {
+                println!("Couldn't retrieve my own PID.");
+                process::exit(1)
+            },
         }
 
 
     } else {
-        //zombie::run_zombie();
+        zombie::run_zombie();
     }
 
 }

hw5/task1/src/unit_tests.rs

+#[cfg(test)]
+mod tests {
+    use child::*;
+
+    fn test_zero_forks(){
+        assert_eq!(run_childs(123,"2"))
+    }
+}