vanilla-test 2.1.0

#![forbid(unsafe_code)]

use std::env;
use std::time::{Duration, Instant};

use vanilla_test::VanillaTest;

const DEFAULT_CASES: usize = 100_000;
const DEFAULT_SAMPLES: usize = 5;

fn main() {
    let cases = argument(1, DEFAULT_CASES);
    let samples = argument(2, DEFAULT_SAMPLES);
    assert!(
        cases > 0 && samples > 0,
        "cases and samples must be positive"
    );

    run(cases);
    let mut durations: Vec<_> = (0..samples).map(|_| run(cases)).collect();
    for (index, duration) in durations.iter().enumerate() {
        println!(
            "sample_{}_ms={:.3}",
            index + 1,
            duration.as_secs_f64() * 1_000.0
        );
    }
    durations.sort_unstable();
    let median = durations[durations.len() / 2];
    let seconds = median.as_secs_f64();

    println!("cases={cases}");
    println!("samples={samples}");
    println!("median_ms={:.3}", seconds * 1_000.0);
    println!("median_cases_per_second={:.0}", cases as f64 / seconds);
}

fn run(cases: usize) -> Duration {
    let started = Instant::now();
    let mut test = VanillaTest::new();
    for index in 0..cases {
        test.expects(&format!("case {index}")).unwrap();
        test.pass().unwrap();
        test.done().unwrap();
    }
    let elapsed = started.elapsed();
    let result = test.report().unwrap();
    assert!(result.ok && result.total == cases);
    elapsed
}

fn argument(index: usize, default: usize) -> usize {
    env::args()
        .nth(index)
        .map(|value| value.parse().expect("benchmark arguments must be integers"))
        .unwrap_or(default)
}