Enabled tests. Commented pstree.

hw4/task1/Cargo.toml

 [package]
 name = "task1"
 version = "0.1.0"
-authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
+authors = ["Lorenz Bung & Joshua Rutschmann"]
 
 [dependencies]
 procinfo = "^0.4.2"
-libc = "0.2"
+libc = "^0.2"

hw4/task1/src/main.rs

 mod readproc;
 mod pstree;
 
+mod unit_test_pstree;
+mod unit_test_readproc;
+
 fn main() {
 
     let args:Vec<String> = env::args().collect();

hw4/task1/src/pstree.rs

 use procinfo::pid;
 use self::libc::pid_t;
 
+/// Datenstruktur für einen Prozess.
 struct Process {
     name : String,
     pid : pid_t,
 
 impl Process {
 
+    /// Erstellt eine Prozess-Datenstruktur aus procinfo::Stat.
     fn new(with_pid:pid_t) -> Self {
         if let Ok(stat) = pid::stat(with_pid) {
             Process{name: stat.command, pid:stat.pid, ppid:stat.ppid}
         }
     }
 
+    /// Prüft ob das Prozess-Struct ein Elternprozess besitzt.
     fn has_parent(&self) -> bool {
         self.ppid != 0
     }
 
+    /// Gibt den Elternprozess zurück.
     fn parent(&self) -> Self {
         Process::new(self.ppid)
     }
 
+    /// Prüft ob das Prozess-Struct einen (entfernten) Elternprozess mit dem übergebenen pid hat.
     fn has_parent_with_pid(&self, pid: pid_t) -> bool {
         if self.pid == pid {
             return true
         false
     }
 
+    /// Gibt über Rekursion über die Eltern eine Prozesskette aus.
     fn print_recursive(&self, to_pid:pid_t, output: &mut String) {
 
         if output.len() == 0 {
     }
 }
 
+/// Erstellt einen 'Process' aus der übergebenen PID und
+/// Gibt über Rekursion über die Eltern eine Prozesskette aus.
+/// Fängt mögliche Fehler ab und
 pub fn print(pid:pid_t) -> bool {
 
     if let Err(_) = pid::stat(pid) {
     }
 
     if let Ok(my_pid) = pid::stat_self() {
-        let mut output = "".to_string();
         let my_proc = Process::new(my_pid.pid);
 
         if !my_proc.has_parent_with_pid(pid) {
             return false
         }
 
+        let mut output = String::new();
         my_proc.print_recursive(pid, &mut output);
         println!("{}", output);
     }

hw4/task1/src/unit_test_readproc.rs

 #[cfg(test)]
 mod tests {
     use procinfo::pid::{status, status_self};
-    use {self_pids, get_pid_command, get_thread_count, get_ownprocess_mem, get_task_total};
+    use readproc::{self_pids, get_pid_command, get_thread_count, get_ownprocess_mem, get_task_total};
 
 
     fn sol_self_pids() -> (i32, i32) {