//! Helper functionality used by the rest of `tor-guardmgr`.

use rand::Rng;

use std::time::{Duration, SystemTime};

/// Return a random time within the range `when-max ..= when`.

///

/// Uses a uniform distribution; saturates at UNIX_EPOCH.  Rounds down to the

/// nearest 10 seconds.

///

/// This kind of date randomization is used in our persistent state in

/// an attempt to make some kinds of traffic analysis attacks a bit

/// harder for an attacker who can read our state after the fact.

/// Round `when` to a multiple of `d` seconds relative to epoch.

///

/// Rounds towards the epoch.

///

/// There's no reason to actually do this, since the times we use it

/// on are randomized, but rounding times in this way avoids giving a

/// false impression that we're storing hyper-accurate numbers.

///

/// # Panics

///

/// Panics if d == 0.

    } else {

    };

    } else {

    }

#[cfg(test)]

mod test {

    #![allow(clippy::unwrap_used)]

    use super::*;

    #[test]

    fn test_randomize_time() {

        let now = SystemTime::now();

        let one_hour = Duration::from_secs(3600);

        let ten_sec = Duration::from_secs(10);

        let mut rng = rand::thread_rng();

        for _ in 0..1000 {

            let t = randomize_time(&mut rng, now, one_hour);

            assert!(t >= now - one_hour - ten_sec);

            assert!(t <= now);

        }

        let close_to_epoch = SystemTime::UNIX_EPOCH + one_hour / 2;

        for _ in 0..1000 {

            let t = randomize_time(&mut rng, close_to_epoch, one_hour);

            assert!(t >= SystemTime::UNIX_EPOCH);

            assert!(t <= close_to_epoch);

            let d = t.duration_since(SystemTime::UNIX_EPOCH).unwrap();

            assert_eq!(d.subsec_nanos(), 0);

            assert_eq!(d.as_secs() % 10, 0);

        }

    }

}