use earths::temporal::calendar::*;
use earths::temporal::epoch::*;
use earths::temporal::time_scale::*;
#[test]
fn j2000jdvalue() {
assert!((J2000JD - 2451545.0).abs() < 1e-10);
}
#[test]
fn unixepochjdvalue() {
assert!((UNIXEPOCHJD - 2440587.5).abs() < 1e-10);
}
#[test]
fn secondsperdayvalue() {
assert!((SECONDSPERDAY - 86400.0).abs() < 1e-10);
}
#[test]
fn datetimenew() {
let dt = DateTime::new(2000, 1, 1, 12, 0, 0.0);
assert_eq!(dt.year, 2000);
assert_eq!(dt.month, 1);
assert_eq!(dt.day, 1);
assert_eq!(dt.hour, 12);
}
#[test]
fn datetimetojulianj2000() {
let dt = DateTime::new(2000, 1, 1, 12, 0, 0.0);
let jd = dt.tojuliandate();
assert!((jd - 2451545.0).abs() < 0.01, "J2000 JD off: {jd}");
}
#[test]
fn datetimeroundtrip() {
let original = DateTime::new(2024, 6, 15, 10, 30, 45.0);
let jd = original.tojuliandate();
let recovered = DateTime::fromjuliandate(jd);
assert_eq!(recovered.year, 2024);
assert_eq!(recovered.month, 6);
assert_eq!(recovered.day, 15);
assert_eq!(recovered.hour, 10);
assert_eq!(recovered.minute, 30);
assert!((recovered.second - 45.0).abs() < 1.0);
}
#[test]
fn datetimeunixepoch() {
let dt = DateTime::new(1970, 1, 1, 0, 0, 0.0);
let ts = dt.tounixtimestamp();
assert!(ts.abs() < 100.0, "Unix epoch timestamp should be ~0: {ts}");
}
#[test]
fn datetimefromunixtimestamp() {
let dt = DateTime::fromunixtimestamp(0.0);
assert_eq!(dt.year, 1970);
assert_eq!(dt.month, 1);
assert_eq!(dt.day, 1);
}
#[test]
fn datetimeunixroundtrip() {
let ts = 1700000000.0;
let dt = DateTime::fromunixtimestamp(ts);
let ts2 = dt.tounixtimestamp();
assert!(
(ts - ts2).abs() < 1.0,
"Unix timestamp roundtrip off: {ts} vs {ts2}"
);
}
#[test]
fn deltatj2000() {
let dt = DateTime::new(2000, 1, 1, 12, 0, 0.0);
let delta = dt.deltatseconds();
assert!(
delta > 60.0 && delta < 70.0,
"Delta-T at J2000 off: {delta}"
);
}
#[test]
fn deltat1900() {
let dt = DateTime::new(1900, 1, 1, 0, 0, 0.0);
let delta = dt.deltatseconds();
assert!(delta.abs() < 5.0, "Delta-T at 1900 off: {delta}");
}
#[test]
fn deltat2020() {
let dt = DateTime::new(2020, 1, 1, 0, 0, 0.0);
let delta = dt.deltatseconds();
assert!(delta > 60.0 && delta < 80.0, "Delta-T at 2020 off: {delta}");
}
#[test]
fn deltatmonotonicrecent() {
let dt2000 = DateTime::new(2000, 1, 1, 0, 0, 0.0);
let dt2020 = DateTime::new(2020, 1, 1, 0, 0, 0.0);
assert!(
dt2020.deltatseconds() > dt2000.deltatseconds(),
"Delta-T should increase in recent decades"
);
}
#[test]
fn juliandatett() {
let dt = DateTime::new(2000, 1, 1, 12, 0, 0.0);
let jdut = dt.tojuliandate();
let jdtt = dt.tojuliandatett();
assert!(jdtt > jdut, "TT should be ahead of UT1");
let diffs = (jdtt - jdut) * SECONDSPERDAY;
assert!((diffs - dt.deltatseconds()).abs() < 0.01);
}
#[test]
fn epochj2000() {
let e = Epoch::j2000();
assert!((e.juliandate - J2000EPOCH).abs() < 1e-10);
}
#[test]
fn epochfromjd() {
let e = Epoch::fromjd(2460000.0);
assert!((e.juliandate - 2460000.0).abs() < 1e-10);
}
#[test]
fn epochfrommjd() {
let e = Epoch::frommjd(51544.5);
assert!((e.juliandate - (51544.5 + MJDOFFSET)).abs() < 1e-10);
}
#[test]
fn epochtomjdroundtrip() {
let e = Epoch::fromjd(2451545.0);
let mjd = e.tomjd();
let e2 = Epoch::frommjd(mjd);
assert!((e.juliandate - e2.juliandate).abs() < 1e-10);
}
#[test]
fn epochcenturiessincej2000() {
let e = Epoch::fromjd(J2000EPOCH + 36525.0);
let c = e.centuriessincej2000();
assert!((c - 1.0).abs() < 1e-10, "Should be 1 century: {c}");
}
#[test]
fn epochdayssincej2000() {
let e = Epoch::j2000();
assert!(e.dayssincej2000().abs() < 1e-10);
}
#[test]
fn epochgmstrange() {
let e = Epoch::j2000();
let gmst = e.gmstdegrees();
assert!(
(0.0..360.0).contains(&gmst),
"GMST should be [0,360): {gmst}"
);
}
#[test]
fn epochgmstvaries() {
let e1 = Epoch::fromjd(2451545.0);
let e2 = Epoch::fromjd(2451545.5);
assert!(
(e1.gmstdegrees() - e2.gmstdegrees()).abs() > 1.0,
"GMST should change over half a day"
);
}
#[test]
fn epochadvancedays() {
let mut e = Epoch::j2000();
e.advancedays(10.0);
assert!((e.dayssincej2000() - 10.0).abs() < 1e-10);
}
#[test]
fn epochadvanceseconds() {
let mut e = Epoch::j2000();
e.advanceseconds(86400.0);
assert!((e.dayssincej2000() - 1.0).abs() < 1e-10);
}
#[test]
fn mjdoffsetvalue() {
assert!((MJDOFFSET - 2400000.5).abs() < 1e-10);
}
#[test]
fn j1950epochvalue() {
assert!((J1950EPOCH - 2433282.5).abs() < 1e-10);
}
#[test]
fn timescalenew() {
let ts = TimeScale::new(2.0);
assert!((ts.speedmultiplier - 2.0).abs() < 1e-10);
assert!(!ts.paused);
}
#[test]
fn timescalerealtime() {
let ts = TimeScale::realtime();
assert!((ts.speedmultiplier - 1.0).abs() < 1e-10);
}
#[test]
fn timescalefastforward() {
let ts = TimeScale::fastforward(10.0);
assert!((ts.speedmultiplier - 10.0).abs() < 1e-10);
}
#[test]
fn timescaleslowmotion() {
let ts = TimeScale::slowmotion(4.0);
assert!((ts.speedmultiplier - 0.25).abs() < 1e-10);
}
#[test]
fn timescalestep() {
let mut ts = TimeScale::realtime();
ts.step(1.0);
assert!((ts.realtimes - 1.0).abs() < 1e-10);
assert!((ts.simulationtimes - 1.0).abs() < 1e-10);
}
#[test]
fn timescalestepfastforward() {
let mut ts = TimeScale::fastforward(10.0);
ts.step(1.0);
assert!((ts.simulationtimes - 10.0).abs() < 1e-10);
}
#[test]
fn timescalepauseresume() {
let mut ts = TimeScale::realtime();
ts.pause();
assert!(ts.paused);
ts.step(1.0);
assert!(
(ts.simulationtimes - 0.0).abs() < 1e-10,
"Should not advance when paused"
);
ts.resume();
ts.step(1.0);
assert!((ts.simulationtimes - 1.0).abs() < 1e-10);
}
#[test]
fn timescaletogglepause() {
let mut ts = TimeScale::realtime();
ts.togglepause();
assert!(ts.paused);
ts.togglepause();
assert!(!ts.paused);
}
#[test]
fn timescalesetspeed() {
let mut ts = TimeScale::realtime();
ts.setspeed(5.0);
assert!((ts.speedmultiplier - 5.0).abs() < 1e-10);
}
#[test]
fn timescalesimulationdt() {
let ts = TimeScale::fastforward(10.0);
let dt = ts.simulationdt(0.016);
assert!((dt - 0.16).abs() < 1e-10);
}
#[test]
fn timescalesimulationdtpaused() {
let mut ts = TimeScale::realtime();
ts.pause();
let dt = ts.simulationdt(0.016);
assert!(dt.abs() < 1e-10, "Paused should have 0 sim dt");
}
#[test]
fn timescalesimhours() {
let mut ts = TimeScale::realtime();
ts.step(3600.0);
assert!((ts.simhours() - 1.0).abs() < 1e-10);
}
#[test]
fn timescalesimdays() {
let mut ts = TimeScale::realtime();
ts.step(86400.0);
assert!((ts.simdays() - 1.0).abs() < 1e-10);
}
#[test]
fn timescalesimyears() {
let mut ts = TimeScale::realtime();
ts.step(86400.0 * 365.2422);
assert!((ts.simyears() - 1.0).abs() < 0.01);
}