use super::*;
#[test]
fn a_clock_names_the_position_its_parts_add_up_to() {
for (spelling, expected) in [
("0:00:00.000", 0),
("0:00:00", 0),
("0:00:00.137", 137_000_000),
("00:01:30.5", 90_500_000_000),
("0:00:01.000000001", 1_000_000_001),
("1:00:00", 3_600_000_000_000),
(
"123:45:06.789",
(123 * 3600 + 45 * 60 + 6) * 1_000_000_000 + 789_000_000,
),
("-0:00:01.500", -1_500_000_000),
("-1:00:00", -3_600_000_000_000),
] {
assert_eq!(nanos(spelling), Ok(expected), "{spelling}");
}
}
#[test]
fn the_fraction_is_padded_rather_than_divided() {
assert_eq!(nanos("0:00:00.5"), Ok(500_000_000));
assert_eq!(nanos("0:00:00.05"), Ok(50_000_000));
assert_eq!(nanos("0:00:00.000000005"), Ok(5));
assert_eq!(nanos("0:00:00.500000000"), nanos("0:00:00.5"));
}
#[test]
fn each_refusal_names_the_rule_it_is_about() {
for (spelling, expected) in [
("", ParseClockError::Shape),
("90", ParseClockError::Shape),
("00:90", ParseClockError::Shape),
(":00:00", ParseClockError::Hours),
("a:00:00", ParseClockError::Hours),
("0:1:00", ParseClockError::Minutes),
("0:001:00", ParseClockError::Minutes),
("0:60:00", ParseClockError::Minutes),
("0:00:1", ParseClockError::Seconds),
("0:00:60", ParseClockError::Seconds),
("0:00:00.", ParseClockError::Fraction),
("0:00:00.1234567890", ParseClockError::Fraction),
("0:00:00.abc", ParseClockError::Fraction),
("2562048:00:00", ParseClockError::Overflow),
("-2562048:00:00", ParseClockError::Overflow),
] {
assert_eq!(nanos(spelling), Err(expected), "{spelling:?}");
}
}
#[test]
fn only_ascii_digits_are_digits() {
assert_eq!(nanos("0:00:00"), Err(ParseClockError::Seconds));
assert_eq!(nanos("٠:00:00"), Err(ParseClockError::Hours));
}
#[test]
fn the_widest_positions_still_parse() {
assert_eq!(nanos("2562047:47:16.854775807"), Ok(i64::MAX));
assert_eq!(nanos("-2562047:47:16.854775808"), Ok(i64::MIN));
}
#[test]
fn a_rendered_clock_reads_back_as_the_position_it_came_from() {
for position in [
0,
1,
-1,
137_000_000,
90_500_000_000,
-1_500_000_000,
i64::MAX,
i64::MIN,
] {
let rendered = render(position);
assert_eq!(nanos(rendered.as_str()), Ok(position), "{rendered}");
}
}
#[test]
fn the_rendering_pads_the_way_the_grammar_reads() {
assert_eq!(render(0).as_str(), "0:00:00.000000000");
assert_eq!(render(90_500_000_000).as_str(), "0:01:30.500000000");
assert_eq!(render(-1_500_000_000).as_str(), "-0:00:01.500000000");
assert_eq!(render(i64::MIN).as_str(), "-2562047:47:16.854775808");
}
#[test]
fn a_rendered_clock_stays_inside_the_inline_representation() {
for position in [0, 90_500_000_000, -1_500_000_000, i64::MAX, i64::MIN] {
let rendered = render(position);
assert!(
rendered.is_inline(),
"`{rendered}` ({} bytes) spilled to the heap",
rendered.len()
);
}
}