#![expect(deprecated)]
use std::cmp::Ordering;
use std::thread;
use std::time::Instant as StdInstant;
use rstest::rstest;
use time::ext::{NumericalDuration, NumericalStdDuration};
use time::{Duration, Instant};
#[rstest]
fn elapsed() {
let instant = Instant::now();
thread::sleep(1.std_milliseconds());
assert!(instant.elapsed() >= 1.milliseconds());
}
#[rstest]
#[case(0.seconds())]
#[case(5.seconds())]
#[case((-5).seconds())]
fn checked_add(#[case] duration: Duration) {
let now = Instant::now();
assert_eq!(now.checked_add(duration), Some(now + duration));
}
#[rstest]
#[case(0.seconds())]
#[case(5.seconds())]
#[case((-5).seconds())]
fn checked_sub(#[case] duration: Duration) {
let now = Instant::now();
assert_eq!(now.checked_sub(duration), Some(now - duration));
}
#[rstest]
fn into_inner() {
let now = Instant::now();
assert_eq!(now.into_inner(), now.0);
}
#[rstest]
fn std_from() {
let now_time = Instant::now();
let now_std = StdInstant::from(now_time);
assert_eq!(now_time, now_std);
}
#[rstest]
fn from_std() {
let now_std = StdInstant::now();
let now_time = Instant::from(now_std);
assert_eq!(now_time, now_std);
}
#[rstest]
#[case(0)]
#[case(1)]
fn sub(#[case] ms: u64) {
let start = Instant::now();
thread::sleep(ms.std_milliseconds());
assert!(Instant::now() - start >= ms.cast_signed().milliseconds());
}
#[rstest]
#[case(0)]
#[case(1)]
fn sub_std(#[case] ms: u64) {
let start = StdInstant::now();
thread::sleep(ms.std_milliseconds());
assert!(Instant::now() - start >= ms.cast_signed().milliseconds());
}
#[rstest]
#[case(0)]
#[case(1)]
fn std_sub(#[case] ms: u64) {
let start = Instant::now();
thread::sleep(ms.std_milliseconds());
assert!(StdInstant::now() - start >= ms.cast_signed().milliseconds());
}
#[rstest]
#[case(0)]
#[case(1)]
fn add_duration(#[case] ms: u64) {
let start = Instant::now();
thread::sleep(ms.std_milliseconds());
assert!(start + ms.cast_signed().milliseconds() <= Instant::now());
}
#[rstest]
#[case(0)]
#[case(1)]
fn std_add_duration(#[case] ms: u64) {
let start = StdInstant::now();
thread::sleep(ms.std_milliseconds());
assert!(start + ms.cast_signed().milliseconds() <= StdInstant::now());
}
#[rstest]
#[case(0)]
#[case(1)]
fn add_std_duration(#[case] ms: u64) {
let start = Instant::now();
thread::sleep(ms.std_milliseconds());
assert!(start + ms.std_milliseconds() <= Instant::now());
}
#[rstest]
#[case(0)]
#[case(1)]
fn add_assign_duration(#[case] ms: u64) {
let mut start = Instant::now();
thread::sleep(ms.std_milliseconds());
start += ms.cast_signed().milliseconds();
assert!(start <= Instant::now());
}
#[rstest]
#[case(0)]
#[case(1)]
fn std_add_assign_duration(#[case] ms: u64) {
let mut start = StdInstant::now();
thread::sleep(ms.std_milliseconds());
start += ms.cast_signed().milliseconds();
assert!(start <= StdInstant::now());
}
#[rstest]
#[case(0)]
#[case(1)]
fn add_assign_std_duration(#[case] ms: u64) {
let mut start = Instant::now();
thread::sleep(ms.std_milliseconds());
start += ms.std_milliseconds();
assert!(start <= Instant::now());
}
#[rstest]
#[case(0)]
#[case(100)]
fn sub_duration(#[case] ms: i64) {
let instant = Instant::now();
assert!(instant - ms.milliseconds() <= Instant::now());
assert_eq!(instant - Duration::ZERO, instant);
}
#[rstest]
#[case(0)]
#[case(100)]
fn std_sub_duration(#[case] ms: i64) {
let instant = StdInstant::now();
assert!(instant - ms.milliseconds() <= StdInstant::now());
}
#[rstest]
#[case(0)]
#[case(100)]
fn sub_std_duration(#[case] ms: u64) {
let instant = Instant::now();
assert!(instant - ms.std_milliseconds() <= Instant::now());
}
#[rstest]
#[case(0)]
#[case(100)]
fn sub_assign_duration(#[case] ms: i64) {
let mut instant = Instant::now();
instant -= ms.milliseconds();
assert!(instant <= Instant::now());
}
#[rstest]
#[case(0)]
#[case(100)]
fn std_sub_assign_duration(#[case] ms: i64) {
let mut instant = StdInstant::now();
instant -= ms.milliseconds();
assert!(instant <= StdInstant::now());
}
#[rstest]
#[case(0)]
#[case(100)]
fn sub_assign_std_duration(#[case] ms: u64) {
let mut instant = Instant::now();
instant -= ms.std_milliseconds();
assert!(instant <= Instant::now());
}
#[rstest]
fn eq_std() {
let now_time = Instant::now();
let now_std = StdInstant::from(now_time);
assert_eq!(now_time, now_std);
}
#[rstest]
fn std_eq() {
let now_time = Instant::now();
let now_std = StdInstant::from(now_time);
assert_eq!(now_std, now_time);
}
#[rstest]
#[case(1.seconds(), Ordering::Less)]
#[case((-1).seconds(), Ordering::Greater)]
fn ord(#[case] duration: Duration, #[case] expected: Ordering) {
let now_time = Instant::now();
let now_std = now_time + duration;
assert_eq!(now_time.cmp(&now_std), expected);
}
#[rstest]
#[case(1.seconds(), Ordering::Less)]
#[case((-1).seconds(), Ordering::Greater)]
fn partial_ord_std(#[case] duration: Duration, #[case] expected: Ordering) {
let now_time = Instant::now();
let now_std = StdInstant::from(now_time) + duration;
assert_eq!(now_time.partial_cmp(&now_std), Some(expected));
}
#[rstest]
#[case(1.seconds(), Ordering::Greater)]
#[case((-1).seconds(), Ordering::Less)]
fn std_partial_ord(#[case] duration: Duration, #[case] expected: Ordering) {
let now_time = Instant::now();
let now_std = StdInstant::from(now_time) + duration;
assert_eq!(now_std.partial_cmp(&now_time), Some(expected));
}
#[rstest]
fn sub_regression() {
let now = Instant::now();
let future = now + Duration::seconds(5);
let past = now - Duration::seconds(5);
assert_eq!(future - now, Duration::seconds(5));
assert_eq!(now - past, Duration::seconds(5));
assert_eq!(future - past, Duration::seconds(10));
assert_eq!(now - future, Duration::seconds(-5));
assert_eq!(past - now, Duration::seconds(-5));
assert_eq!(past - future, Duration::seconds(-10));
}
#[rstest]
fn as_ref() {
let now = Instant::now();
assert_eq!(now.as_ref(), now.as_ref());
}
#[rstest]
fn borrow() {
use std::borrow::Borrow;
let now = Instant::now();
assert_eq!(
<Instant as Borrow<StdInstant>>::borrow(&now),
<Instant as Borrow<StdInstant>>::borrow(&now)
);
}