Moved everthing to functions in lib.rs. Tests working.

hw8/task1/src/lib.rs

@@ -1,6 +1,17 @@
 extern crate sha2;
+extern crate time;
+
+mod tests;
+
 #[cfg(feature = "SHA2")]
 use self::sha2::Sha256;
+use std::thread;
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering::Relaxed;
+use std::sync::mpsc::{Sender, channel};
+use time::{Duration, get_time};
+
 
 pub struct Sha256;
 
@@ -94,7 +105,7 @@ impl HashResult for [u8; 32] {
     }
 }
 
-
+#[derive(Debug,PartialEq)]
 pub struct Solution {
     pub number: usize,
     pub hash: String,
@@ -116,3 +127,137 @@ pub fn verify_product(base: usize, number: usize, difficulty: &String) -> Option
 
     None
 }
+
+
+pub fn search_with_threads(threads:usize, diff_string:String, with_base:usize, time_measurement:bool, verbosity:u64, sync:Option<usize>, wait:bool){
+    let total_start = get_time();
+    let diff = Arc::new(diff_string);
+    let mut children = vec![];
+
+    let (solution_tx, solution_rx) = channel();
+    let (timing_tx, timing_rx) = channel();
+
+    let found = Arc::new(AtomicBool::new(false));
+    let m = time_measurement && verbosity > 0;
+
+    if threads > 1 {
+
+        for i in 0..threads {
+            let diff = diff.clone();
+            let solution_tx = solution_tx.clone();
+            let timing_tx = timing_tx.clone();
+            let found = found.clone();
+
+            children.push(thread::spawn(move || {
+
+                search_hash(
+                    &diff,
+                    with_base,
+                    i,
+                    threads,
+                    sync.is_some(),
+                    found,
+                    sync.unwrap_or(1),
+                    solution_tx,
+                    timing_tx,
+                    m,
+                )
+            }));
+        }
+    } else {
+        search_hash(
+            &diff,
+            with_base,
+            0,
+            1,
+            sync.is_some(),
+            found,
+            sync.unwrap_or(1),
+            solution_tx,
+            timing_tx,
+            m,
+        )
+    }
+
+    match solution_rx.recv() {
+        Ok(sol) => {
+            let total_end = get_time();
+            println!("Number: {} --> hash: {}", sol.number, sol.hash);
+            if time_measurement && verbosity == 0 {
+                let diff = total_end - total_start;
+                let s = diff.num_seconds();
+                let ms = diff.num_milliseconds();
+                let us = diff.num_microseconds().unwrap_or(ms * 1000);
+                println!("(Duration {}s / {}ms / {}us)", s, ms, us);
+            }
+        }
+        Err(_) => {}
+    }
+
+    let mut sum_loops = 0usize;
+    let mut sum_time: Duration = Duration::zero();
+
+    for child in children {
+
+        if time_measurement && verbosity > 0 {
+            match timing_rx.recv() {
+                Ok(stats) => {
+                    sum_time = sum_time + stats.0;
+                    sum_loops += stats.1;
+                }
+                Err(_) => {}
+            }
+        }
+
+        if wait {
+            let _ = child.join();
+        }
+    }
+
+    if time_measurement && verbosity > 0 {
+        println!("Sum Loops in Producers:       {}", sum_loops);
+        let s = sum_time.num_seconds();
+        let ms = sum_time.num_milliseconds();
+        let us = sum_time.num_microseconds().unwrap_or(ms * 1000);
+        println!("Sum Duration in Producers:    {}s / {}ms / {}us", s, ms, us);
+    }
+}
+
+fn search_hash(
+    hash: &String,
+    base: usize,
+    current: usize,
+    total: usize,
+    sync: bool,
+    found: Arc<AtomicBool>,
+    special: usize,
+    solution_tx: Sender<Solution>,
+    timing_tx: Sender<(Duration, usize)>,
+    measure: bool,
+) {
+    let max = <usize>::max_value();
+    let mut n = current;
+
+    let thread_start = get_time();
+    while n < max {
+
+        if n % special == 0 && found.load(Relaxed) {
+            break;
+        }
+
+        if let Some(solution) = verify_product(base, n, hash) {
+            if sync {
+                found.store(true, Relaxed);
+            }
+
+            let _ = solution_tx.send(solution);
+            break;
+        }
+        n += total;
+    }
+
+    if measure {
+        let thread_end = get_time();
+        let _ = timing_tx.send((thread_end - thread_start, n));
+    }
+}

hw8/task1/src/main.rs

@@ -1,20 +1,11 @@
 #[macro_use]
 extern crate clap;
-extern crate time;
 extern crate task1;
 extern crate sys_info;
 
-mod tests;
-
-use std::sync::mpsc::{Sender, channel};
-use time::get_time;
 use clap::App;
-use time::Duration;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering::Relaxed;
-use std::{process, thread};
-use task1::{Solution, verify_product};
+use std::process;
+use task1::search_with_threads;
 
 
 pub fn main() {
@@ -25,7 +16,7 @@ pub fn main() {
     // Speichere alle Argumente in Variablen
     // Falls ein Wert für ein Argument nicht existiert, lade einen default-Wert
     let base = matches.value_of("base").unwrap_or("1");
-    let diff = Arc::new(String::from(matches.value_of("difficulty").unwrap_or("1")));
+    let diff = String::from(matches.value_of("difficulty").unwrap_or("1"));
     let cpus = sys_info::cpu_num().unwrap_or(1).to_string();
     let threads = matches.value_of("threads").unwrap_or(&cpus);
     let sync = matches.is_present("sync");
@@ -33,7 +24,7 @@ pub fn main() {
     let wait = matches.is_present("wait");
     let verbosity = matches.occurrences_of("verbose");
 
-    let mut time_measurement = false;
+    let mut time = false;
 
     // Falls irgendein Zeichen nicht hexadezimal ist, breche ab.
     if diff.chars().any(|c| !c.is_digit(16)) {
@@ -44,7 +35,7 @@ pub fn main() {
     // Falls das Unterkommando timings angegeben wurde aktiviere die Zeitmessung.
     if let Some(ref sub_command) = matches.subcommand {
         if sub_command.name.eq("timings") {
-            time_measurement = true;
+            time = true;
         }
     }
 
@@ -64,7 +55,7 @@ pub fn main() {
     }
 
     // Versuche Strings der Basis und Threadanzahl zu usize zu parsen
-    // Anderenfalls
+    // Anderenfalls gebe den fehlerhaften Paramter aus.
     match (base.parse::<usize>(), threads.parse::<usize>()) {
         (Ok(b), Ok(t)) => {
             println!("Please wait...");
@@ -73,97 +64,12 @@ pub fn main() {
                 println!("Searching with {} threads", t);
             }
 
-            let total_start = get_time();
-
-            let mut children = vec![];
-
-            let (solution_tx, solution_rx) = channel();
-            let (timing_tx, timing_rx) = channel();
-
-            let found = Arc::new(AtomicBool::new(false));
-            let m = time_measurement && verbosity > 0;
-
-            if t > 1 {
-
-                for i in 0..t {
-                    let diff = diff.clone();
-                    let solution_tx = solution_tx.clone();
-                    let timing_tx = timing_tx.clone();
-                    let found = found.clone();
-
-                    children.push(thread::spawn(move || {
-
-                        search_hash(
-                            &diff,
-                            b,
-                            i,
-                            t,
-                            sync,
-                            found,
-                            special,
-                            solution_tx,
-                            timing_tx,
-                            m,
-                        )
-                    }));
-                }
-            } else {
-                search_hash(
-                    &diff,
-                    b,
-                    0,
-                    1,
-                    sync,
-                    found,
-                    special,
-                    solution_tx,
-                    timing_tx,
-                    m,
-                )
-            }
-
-            match solution_rx.recv() {
-                Ok(sol) => {
-                    let total_end = get_time();
-                    println!("Number: {} --> hash: {}", sol.number, sol.hash);
-                    if time_measurement && verbosity == 0 {
-                        let diff = total_end - total_start;
-                        let s = diff.num_seconds();
-                        let ms = diff.num_milliseconds();
-                        let us = diff.num_microseconds().unwrap_or(ms * 1000);
-                        println!("(Duration {}s / {}ms / {}us)", s, ms, us);
-                    }
-                }
-                Err(_) => {}
-            }
-
-            let mut sum_loops = 0usize;
-            let mut sum_time: Duration = Duration::zero();
-
-            for child in children {
-
-                if time_measurement && verbosity > 0 {
-                    match timing_rx.recv() {
-                        Ok(stats) => {
-                            sum_time = sum_time + stats.0;
-                            sum_loops += stats.1;
-                        }
-                        Err(_) => {}
-                    }
-                }
-
-                if wait {
-                    let _ = child.join();
-                }
+            let mut sync_opt = None;
+            if sync {
+                sync_opt = Some(special);
             }
 
-            if time_measurement && verbosity > 0 {
-                println!("Sum Loops in Producers:       {}", sum_loops);
-                let s = sum_time.num_seconds();
-                let ms = sum_time.num_milliseconds();
-                let us = sum_time.num_microseconds().unwrap_or(ms * 1000);
-                println!("Sum Duration in Producers:    {}s / {}ms / {}us", s, ms, us);
-            }
+            search_with_threads(t,diff,b,time, verbosity,sync_opt,wait);
 
         }
         (_, Err(_)) => {
@@ -177,41 +83,3 @@ pub fn main() {
     };
 }
 
-pub fn search_hash(
-    hash: &String,
-    base: usize,
-    current: usize,
-    total: usize,
-    sync: bool,
-    found: Arc<AtomicBool>,
-    special: usize,
-    solution_tx: Sender<Solution>,
-    timing_tx: Sender<(Duration, usize)>,
-    measure: bool,
-) {
-    let max = <usize>::max_value();
-    let mut n = current;
-
-    let thread_start = get_time();
-    while n < max {
-
-        if n % special == 0 && found.load(Relaxed) {
-            break;
-        }
-
-        if let Some(solution) = verify_product(base, n, hash) {
-            if sync {
-                found.store(true, Relaxed);
-            }
-
-            let _ = solution_tx.send(solution);
-            break;
-        }
-        n += total;
-    }
-
-    if measure {
-        let thread_end = get_time();
-        let _ = timing_tx.send((thread_end - thread_start, n));
-    }
-}

hw8/task1/src/tests/mod.rs

@@ -1,16 +1,28 @@
 #[cfg(test)]
 mod tests {
-    use search_hash;
+    use *;
 
     #[test]
-    fn test_faulty_diff() {
-        search_hash()
+    fn test_correct_diff() {
+        let hash = String::from("b6bea2a40ed1bd6d9999b2232072092f3df0e02c4b507aa3ad947367b9712345");
+        assert_eq!(
+            verify_product(42,567621, &String::from("12345")),
+            Some(Solution{number:567621, hash:hash})
+        )
     }
 
+    #[test]
+    fn test_wrong_diff() {
+        assert_eq!(
+            verify_product(42,13253224, &String::from("12345")),
+            None
+        )
+    }
 
-    fn test_hash() {
+    #[test]
+    fn test_hashing() {
         assert_eq!(
-            hash("test".as_bytes()).hex(),
+            Sha256::hash("test".as_bytes()).hex(),
             "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
         );
     }