Add unit tests

src/hyperfine/benchmark.rs

@@ -7,7 +7,7 @@ use statistical::{mean, standard_deviation};
 
 use hyperfine::internal::{get_progress_bar, max, min, HyperfineOptions, Second, Warnings,
                           MIN_EXECUTION_TIME, CmdFailureAction};
-use hyperfine::format::{format_duration, format_duration_unit, Unit};
+use hyperfine::format::{format_duration, format_duration_unit};
 
 /// Results from timing a single shell command
 pub struct TimingResult {
@@ -168,7 +168,7 @@ pub fn run_benchmark(
         run_preparation_command();
 
         let msg = {
-            let mean = format_duration(mean(&execution_times), Unit::Auto);
+            let mean = format_duration(mean(&execution_times), None);
             format!("Current estimate: {}", Green.paint(mean))
         };
         bar.set_message(&msg);
@@ -189,10 +189,10 @@ pub fn run_benchmark(
     let t_max = max(&execution_times);
 
     // Formatting and console output
-    let (mean_str, unit_mean) = format_duration_unit(t_mean, Unit::Auto);
-    let stddev_str = format_duration(t_stddev, unit_mean);
-    let min_str = format_duration(t_min, unit_mean);
-    let max_str = format_duration(t_max, unit_mean);
+    let (mean_str, unit_mean) = format_duration_unit(t_mean, None);
+    let stddev_str = format_duration(t_stddev, Some(unit_mean));
+    let min_str = format_duration(t_min, Some(unit_mean));
+    let max_str = format_duration(t_max, Some(unit_mean));
 
     println!(
         "  Time ({} ± {}):     {} ± {}",

src/hyperfine/format.rs

@@ -1,22 +1,65 @@
 use hyperfine::internal::Second;
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Unit {
-    Auto,
     Second,
     MilliSecond,
 }
 
-pub fn format_duration(duration: Second, unit: Unit) -> String {
+/// Format the given duration as a string. The output-unit can be enforced by setting `unit` to
+/// `Some(target_unit)`. If `unit` is `None`, it will be determined automatically.
+pub fn format_duration(duration: Second, unit: Option<Unit>) -> String {
     match format_duration_unit(duration, unit) {
         (duration_fmt, _) => duration_fmt,
     }
 }
 
-pub fn format_duration_unit(duration: Second, unit: Unit) -> (String, Unit) {
-    if (duration < 1.0 && unit == Unit::Auto) || unit == Unit::MilliSecond {
+/// Like `format_duration`, but returns the target unit as well.
+pub fn format_duration_unit(duration: Second, unit: Option<Unit>) -> (String, Unit) {
+    if (duration < 1.0 && unit.is_none()) || unit == Some(Unit::MilliSecond) {
         (format!("{:5.1} ms", duration * 1e3), Unit::MilliSecond)
     } else {
         (format!("{:5.3} s", duration), Unit::Second)
     }
 }
+
+#[test]
+fn test_format_duration_unit_basic() {
+    let (out_str, out_unit) = format_duration_unit(1.3, None);
+
+    assert_eq!("1.300 s", out_str);
+    assert_eq!(Unit::Second, out_unit);
+
+    let (out_str, out_unit) = format_duration_unit(1.0, None);
+
+    assert_eq!("1.000 s", out_str);
+    assert_eq!(Unit::Second, out_unit);
+
+    let (out_str, out_unit) = format_duration_unit(0.999, None);
+
+    assert_eq!("999.0 ms", out_str);
+    assert_eq!(Unit::MilliSecond, out_unit);
+
+    let (out_str, out_unit) = format_duration_unit(0.0, None);
+
+    assert_eq!("  0.0 ms", out_str);
+    assert_eq!(Unit::MilliSecond, out_unit);
+
+    let (out_str, out_unit) = format_duration_unit(1000.0, None);
+
+    assert_eq!("1000.000 s", out_str);
+    assert_eq!(Unit::Second, out_unit);
+}
+
+#[test]
+fn test_format_duration_unit_with_unit() {
+    let (out_str, out_unit) = format_duration_unit(1.3, Some(Unit::Second));
+
+    assert_eq!("1.300 s", out_str);
+    assert_eq!(Unit::Second, out_unit);
+
+    let (out_str, out_unit) = format_duration_unit(1.3, Some(Unit::MilliSecond));
+
+    assert_eq!("1300.0 ms", out_str);
+    assert_eq!(Unit::MilliSecond, out_unit);
+}