Timing now conditional. All faulty inputs detected.

hw7/task1/src/hash256.rs

@@ -14,8 +14,6 @@ pub fn verify_product(base: usize, number: usize, difficulty: &String) -> Option
 
     let hash = Sha256::hash(bytes).hex();
 
-    //println!("{} ends with {}", hash, difficulty);
-
     if hash.ends_with(difficulty) {
         return Some(Solution{ number: number, hash: hash,});
     }

hw7/task1/src/main.rs

@@ -13,33 +13,44 @@ pub fn main() {
     let diff = matches.value_of("difficulty").unwrap_or("1");
     let mut time_measurement = false;
 
-    println!("Using base: {}", base);
-    println!("Using difficulty: {}", diff);
-
     if diff.chars().any( |c| !c.is_digit(16)) {
         println!("Difficulty is not hexadecimal.");
         process::exit(1)
     }
 
-    if let Some(_) = matches.subcommand {
-        time_measurement = true;
+    if let Some(ref sub_command) = matches.subcommand {
+        if sub_command.name.eq("timings") {
+            time_measurement = true;
+        }
     }
 
     match base.parse::<usize>() {
         Ok(b) => {
+            println!("Using base: {}", base);
+            println!("Using difficulty: {}", diff);
             println!("Please wait...");
             let start = get_time();
-            for n in 0..<usize>::max_value() {
+
+            let max = <usize>::max_value();
+            for n in 0..max {
                 if let Some(x) = hash256::verify_product(b, n, &diff.to_string()) {
                     let end = get_time();
-                    let diff = end - start;
                     println!("Number: {} --> hash: {}", x.number, x.hash);
-                    println!("(Duration {}s / {}ms / {}us)", diff.num_seconds(), diff.num_milliseconds(), diff.num_microseconds().unwrap_or(0));
+                    if time_measurement{
+                        let diff = end - 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);
+                    }
                     process::exit(0)
                 }
             }
         }
-        Err(_) => {}
+        Err(_) => {
+            println!("Base is not integer.");
+            process::exit(1)
+        }
     };
 }