Revision control
Copy as Markdown
Other Tools
#![expect(deprecated)]
use std::cmp::Ordering;
use std::thread;
use std::time::Instant as StdInstant;
use time::ext::{NumericalDuration, NumericalStdDuration};
use time::{Duration, Instant};
#[test]
fn elapsed() {
let instant = Instant::now();
thread::sleep(1.std_milliseconds());
assert!(instant.elapsed() >= 1.milliseconds());
}
#[test]
fn checked_add() {
let now = Instant::now();
assert_eq!(now.checked_add(0.seconds()), Some(now));
assert_eq!(now.checked_add(5.seconds()), Some(now + 5.seconds()));
assert_eq!(now.checked_add((-5).seconds()), Some(now + (-5).seconds()));
}
#[test]
fn checked_sub() {
let now = Instant::now();
assert_eq!(now.checked_sub(0.seconds()), Some(now));
assert_eq!(now.checked_sub(5.seconds()), Some(now - 5.seconds()));
assert_eq!(now.checked_sub((-5).seconds()), Some(now - (-5).seconds()));
}
#[test]
fn into_inner() {
let now = Instant::now();
assert_eq!(now.into_inner(), now.0);
}
#[test]
fn std_from() {
let now_time = Instant::now();
let now_std = StdInstant::from(now_time);
assert_eq!(now_time, now_std);
}
#[test]
fn from_std() {
let now_std = StdInstant::now();
let now_time = Instant::from(now_std);
assert_eq!(now_time, now_std);
}
#[test]
fn sub() {
let start = Instant::now();
thread::sleep(1.std_milliseconds());
assert!(Instant::now() - start >= 1.milliseconds());
assert_eq!(start - start, Duration::ZERO);
}
#[test]
fn sub_std() {
let start = StdInstant::now();
thread::sleep(1.std_milliseconds());
assert!(Instant::now() - start >= 1.milliseconds());
}
#[test]
fn std_sub() {
let start = Instant::now();
thread::sleep(1.std_milliseconds());
assert!(StdInstant::now() - start >= 1.milliseconds());
}
#[test]
fn add_duration() {
let start = Instant::now();
assert!(start + 0.seconds() <= Instant::now());
thread::sleep(1.std_milliseconds());
assert!(start + 1.milliseconds() <= Instant::now());
}
#[test]
fn std_add_duration() {
let start = StdInstant::now();
thread::sleep(1.std_milliseconds());
assert!(start + 1.milliseconds() <= StdInstant::now());
}
#[test]
fn add_std_duration() {
let start = Instant::now();
thread::sleep(1.std_milliseconds());
assert!(start + 1.std_milliseconds() <= Instant::now());
}
#[test]
fn add_assign_duration() {
let mut start = Instant::now();
thread::sleep(1.std_milliseconds());
start += 1.milliseconds();
assert!(start <= Instant::now());
}
#[test]
fn std_add_assign_duration() {
let mut start = StdInstant::now();
thread::sleep(1.std_milliseconds());
start += 1.milliseconds();
assert!(start <= StdInstant::now());
}
#[test]
fn add_assign_std_duration() {
let mut start = Instant::now();
thread::sleep(1.std_milliseconds());
start += 1.std_milliseconds();
assert!(start <= Instant::now());
}
#[test]
fn sub_duration() {
let instant = Instant::now();
assert!(instant - 100.milliseconds() <= Instant::now());
assert_eq!(instant - Duration::ZERO, instant);
}
#[test]
fn std_sub_duration() {
let instant = StdInstant::now();
assert!(instant - 100.milliseconds() <= StdInstant::now());
}
#[test]
fn sub_std_duration() {
let instant = Instant::now();
assert!(instant - 100.std_milliseconds() <= Instant::now());
}
#[test]
fn sub_assign_duration() {
let mut instant = Instant::now();
instant -= 100.milliseconds();
assert!(instant <= Instant::now());
}
#[test]
fn std_sub_assign_duration() {
let mut instant = StdInstant::now();
instant -= 100.milliseconds();
assert!(instant <= StdInstant::now());
}
#[test]
fn sub_assign_std_duration() {
let mut instant = Instant::now();
instant -= 100.std_milliseconds();
assert!(instant <= Instant::now());
}
#[test]
fn eq_std() {
let now_time = Instant::now();
let now_std = StdInstant::from(now_time);
assert_eq!(now_time, now_std);
}
#[test]
fn std_eq() {
let now_time = Instant::now();
let now_std = StdInstant::from(now_time);
assert_eq!(now_std, now_time);
}
#[test]
fn ord() {
let now_time = Instant::now();
let now_std = now_time + 1.seconds();
assert_eq!(now_time.cmp(&now_std), Ordering::Less);
let now_time = Instant::now();
let now_std = now_time - 1.seconds();
assert_eq!(now_time.cmp(&now_std), Ordering::Greater);
}
#[test]
fn partial_ord_std() {
let now_time = Instant::now();
let now_std = StdInstant::from(now_time) + 1.seconds();
assert!(now_time < now_std);
let now_time = Instant::now();
let now_std = StdInstant::from(now_time) - 1.seconds();
assert!(now_time > now_std);
}
#[test]
fn std_partial_ord() {
let now_time = Instant::now();
let now_std = StdInstant::from(now_time) + 1.seconds();
assert!(now_std > now_time);
let now_time = Instant::now();
let now_std = StdInstant::from(now_time) - 1.seconds();
assert!(now_std < now_time);
}
#[test]
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));
}
#[test]
fn as_ref() {
let now = Instant::now();
assert_eq!(now.as_ref(), now.as_ref());
}
#[test]
fn borrow() {
use std::borrow::Borrow;
let now = Instant::now();
assert_eq!(
<Instant as Borrow<StdInstant>>::borrow(&now),
<Instant as Borrow<StdInstant>>::borrow(&now)
);
}