reifydb_value/value/

duration.rs

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 ReifyDB

#![allow(clippy::disallowed_types)]

use std::{
	cmp,
	fmt::{self, Display, Formatter, Write},
	hash::{Hash, Hasher},
	ops,
	str::FromStr,
	time::Duration as StdDuration,
};

use serde::{Deserialize, Serialize};

use crate::{
	error::{Error, TemporalKind, TypeError},
	fragment::Fragment,
	reifydb_assertions,
	value::temporal::parse::duration::parse_duration,
};

#[repr(C)]
#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
pub struct Duration {
	months: i32,
	days: i32,
	nanos: i64,
}

const NANOS_PER_DAY: i64 = 86_400_000_000_000;
const SECONDS_PER_DAY: i64 = 86_400;
const DAYS_PER_MONTH: i64 = 30;
const SECONDS_PER_YEAR: i64 = 31_557_600;

impl Default for Duration {
	fn default() -> Self {
		Self::zero()
	}
}

impl Duration {
	fn overflow_err(message: impl Into<String>) -> TypeError {
		TypeError::Temporal {
			kind: TemporalKind::DurationOverflow {
				message: message.into(),
			},
			message: "duration overflow".to_string(),
			fragment: Fragment::None,
		}
	}

	fn mixed_sign_err(days: i32, nanos: i64) -> TypeError {
		TypeError::Temporal {
			kind: TemporalKind::DurationMixedSign {
				days,
				nanos,
			},
			message: format!(
				"duration days and nanos must share the same sign, got days={days}, nanos={nanos}"
			),
			fragment: Fragment::None,
		}
	}

	fn normalized(months: i32, days: i32, nanos: i64) -> Result<Self, Box<TypeError>> {
		let extra_days = i32::try_from(nanos / NANOS_PER_DAY)
			.map_err(|_| Box::new(Self::overflow_err("the days component overflows Duration range")))?;
		let nanos = nanos % NANOS_PER_DAY;
		let days = days
			.checked_add(extra_days)
			.ok_or_else(|| Box::new(Self::overflow_err("the days component overflows Duration range")))?;

		if (days > 0 && nanos < 0) || (days < 0 && nanos > 0) {
			return Err(Box::new(Self::mixed_sign_err(days, nanos)));
		}

		Ok(Self {
			months,
			days,
			nanos,
		})
	}

	pub fn new(months: i32, days: i32, nanos: i64) -> Result<Self, Box<TypeError>> {
		Self::normalized(months, days, nanos)
	}

	pub fn from_seconds(seconds: i64) -> Result<Self, Box<TypeError>> {
		Self::normalized(0, 0, seconds * 1_000_000_000)
	}

	pub fn from_milliseconds(milliseconds: i64) -> Result<Self, Box<TypeError>> {
		Self::normalized(0, 0, milliseconds * 1_000_000)
	}

	pub fn from_microseconds(microseconds: i64) -> Result<Self, Box<TypeError>> {
		Self::normalized(0, 0, microseconds * 1_000)
	}

	pub fn from_micros_infallible(microseconds: u64) -> Self {
		const US_PER_DAY: u64 = 86_400_000_000;
		let whole_days = microseconds / US_PER_DAY;
		let remainder_us = microseconds % US_PER_DAY;
		let days = if whole_days > i32::MAX as u64 {
			i32::MAX
		} else {
			whole_days as i32
		};
		Self {
			months: 0,
			days,
			nanos: (remainder_us * 1_000) as i64,
		}
	}

	pub fn from_nanos_infallible(nanoseconds: u64) -> Self {
		const NS_PER_DAY: u64 = 86_400_000_000_000;
		let whole_days = nanoseconds / NS_PER_DAY;
		let remainder_ns = nanoseconds % NS_PER_DAY;
		let days = if whole_days > i32::MAX as u64 {
			i32::MAX
		} else {
			whole_days as i32
		};
		Self {
			months: 0,
			days,
			nanos: remainder_ns as i64,
		}
	}

	pub const fn from_nanoseconds_const(nanoseconds: i64) -> Self {
		reifydb_assertions! {
			let day_count = nanoseconds / NANOS_PER_DAY;
			assert!(
				day_count >= i32::MIN as i64 && day_count <= i32::MAX as i64,
				"nanoseconds overflows Duration range"
			);
		}
		Self {
			months: 0,
			days: (nanoseconds / NANOS_PER_DAY) as i32,
			nanos: nanoseconds % NANOS_PER_DAY,
		}
	}

	pub const fn from_microseconds_const(microseconds: i64) -> Self {
		reifydb_assertions! {
			assert!(
				microseconds.checked_mul(1_000).is_some(),
				"microseconds overflows Duration range"
			);
		}
		Self::from_nanoseconds_const(microseconds * 1_000)
	}

	pub const fn from_milliseconds_const(milliseconds: i64) -> Self {
		reifydb_assertions! {
			assert!(
				milliseconds.checked_mul(1_000_000).is_some(),
				"milliseconds overflows Duration range"
			);
		}
		Self::from_nanoseconds_const(milliseconds * 1_000_000)
	}

	pub const fn from_seconds_const(seconds: i64) -> Self {
		reifydb_assertions! {
			assert!(
				seconds.checked_mul(1_000_000_000).is_some(),
				"seconds overflows Duration range"
			);
		}
		Self::from_nanoseconds_const(seconds * 1_000_000_000)
	}

	pub const fn from_minutes_const(minutes: i64) -> Self {
		reifydb_assertions! {
			assert!(
				minutes.checked_mul(60_000_000_000).is_some(),
				"minutes overflows Duration range"
			);
		}
		Self::from_nanoseconds_const(minutes * 60_000_000_000)
	}

	pub const fn from_hours_const(hours: i64) -> Self {
		reifydb_assertions! {
			assert!(
				hours.checked_mul(3_600_000_000_000).is_some(),
				"hours overflows Duration range"
			);
		}
		Self::from_nanoseconds_const(hours * 3_600_000_000_000)
	}

	pub fn from_nanoseconds(nanoseconds: i64) -> Result<Self, Box<TypeError>> {
		Self::normalized(0, 0, nanoseconds)
	}

	pub fn from_minutes(minutes: i64) -> Result<Self, Box<TypeError>> {
		Self::normalized(0, 0, minutes * 60 * 1_000_000_000)
	}

	pub fn from_hours(hours: i64) -> Result<Self, Box<TypeError>> {
		Self::normalized(0, 0, hours * 60 * 60 * 1_000_000_000)
	}

	pub fn from_days(days: i64) -> Result<Self, Box<TypeError>> {
		let days = i32::try_from(days)
			.map_err(|_| Box::new(Self::overflow_err(format!("{} days overflows Duration range", days))))?;
		Self::normalized(0, days, 0)
	}

	pub fn from_weeks(weeks: i64) -> Result<Self, Box<TypeError>> {
		let days = weeks.checked_mul(7).ok_or_else(|| {
			Box::new(Self::overflow_err(format!("{} weeks overflows Duration range", weeks)))
		})?;
		let days = i32::try_from(days).map_err(|_| {
			Box::new(Self::overflow_err(format!("{} weeks overflows Duration range", weeks)))
		})?;
		Self::normalized(0, days, 0)
	}

	pub fn from_months(months: i64) -> Result<Self, Box<TypeError>> {
		let months = i32::try_from(months).map_err(|_| {
			Box::new(Self::overflow_err(format!("{} months overflows Duration range", months)))
		})?;
		Self::normalized(months, 0, 0)
	}

	pub fn from_years(years: i64) -> Result<Self, Box<TypeError>> {
		let months = years.checked_mul(12).ok_or_else(|| {
			Box::new(Self::overflow_err(format!("{} years overflows Duration range", years)))
		})?;
		let months = i32::try_from(months).map_err(|_| {
			Box::new(Self::overflow_err(format!("{} years overflows Duration range", years)))
		})?;
		Self::normalized(months, 0, 0)
	}

	pub fn zero() -> Self {
		Self {
			months: 0,
			days: 0,
			nanos: 0,
		}
	}

	pub const MAX: Self = Self {
		months: i32::MAX,
		days: i32::MAX,
		nanos: NANOS_PER_DAY - 1,
	};

	fn checked_total(
		&self,
		per_year: i64,
		per_month: i64,
		per_day: i64,
		sub_day: i64,
		unit: &str,
	) -> Result<i64, Box<TypeError>> {
		let years = (self.months / 12) as i64;
		let rem_months = (self.months % 12) as i64;
		years.checked_mul(per_year)
			.and_then(|a| rem_months.checked_mul(per_month).and_then(|b| a.checked_add(b)))
			.and_then(|a| (self.days as i64).checked_mul(per_day).and_then(|b| a.checked_add(b)))
			.and_then(|a| a.checked_add(sub_day))
			.ok_or_else(|| Box::new(Self::overflow_err(format!("Duration overflows {} range", unit))))
	}

	pub fn seconds(&self) -> Result<i64, Box<TypeError>> {
		self.checked_total(
			SECONDS_PER_YEAR,
			DAYS_PER_MONTH * SECONDS_PER_DAY,
			SECONDS_PER_DAY,
			self.nanos / 1_000_000_000,
			"seconds",
		)
	}

	pub fn milliseconds(&self) -> Result<i64, Box<TypeError>> {
		self.checked_total(
			SECONDS_PER_YEAR * 1_000,
			DAYS_PER_MONTH * SECONDS_PER_DAY * 1_000,
			SECONDS_PER_DAY * 1_000,
			self.nanos / 1_000_000,
			"milliseconds",
		)
	}

	pub fn microseconds(&self) -> Result<i64, Box<TypeError>> {
		self.checked_total(
			SECONDS_PER_YEAR * 1_000_000,
			DAYS_PER_MONTH * SECONDS_PER_DAY * 1_000_000,
			SECONDS_PER_DAY * 1_000_000,
			self.nanos / 1_000,
			"microseconds",
		)
	}

	pub fn nanoseconds(&self) -> Result<i64, Box<TypeError>> {
		self.checked_total(
			SECONDS_PER_YEAR * 1_000_000_000,
			NANOS_PER_DAY * DAYS_PER_MONTH,
			NANOS_PER_DAY,
			self.nanos,
			"nanoseconds",
		)
	}

	pub fn get_months(&self) -> i32 {
		self.months
	}

	pub fn get_days(&self) -> i32 {
		self.days
	}

	pub fn get_nanos(&self) -> i64 {
		self.nanos
	}

	pub fn as_nanos(&self) -> Result<i64, Box<TypeError>> {
		self.nanoseconds()
	}

	pub fn is_positive(&self) -> bool {
		self.months >= 0
			&& self.days >= 0 && self.nanos >= 0
			&& (self.months > 0 || self.days > 0 || self.nanos > 0)
	}

	pub fn is_negative(&self) -> bool {
		self.months <= 0
			&& self.days <= 0 && self.nanos <= 0
			&& (self.months < 0 || self.days < 0 || self.nanos < 0)
	}

	pub fn abs(&self) -> Self {
		Self {
			months: self.months.abs(),
			days: self.days.abs(),
			nanos: self.nanos.abs(),
		}
	}

	pub fn negate(&self) -> Self {
		Self {
			months: -self.months,
			days: -self.days,
			nanos: -self.nanos,
		}
	}

	pub fn to_iso_string(&self) -> String {
		if self.months == 0 && self.days == 0 && self.nanos == 0 {
			return "PT0S".to_string();
		}

		let mut result = String::from("P");

		let years = self.months / 12;
		let months = self.months % 12;

		if years != 0 {
			write!(result, "{}Y", years).unwrap();
		}
		if months != 0 {
			write!(result, "{}M", months).unwrap();
		}

		let total_seconds = self.nanos / 1_000_000_000;
		let remaining_nanos = self.nanos % 1_000_000_000;

		let extra_days = total_seconds / 86400;
		let remaining_seconds = total_seconds % 86400;

		let display_days = self.days + extra_days as i32;
		let hours = remaining_seconds / 3600;
		let minutes = (remaining_seconds % 3600) / 60;
		let seconds = remaining_seconds % 60;

		if display_days != 0 {
			write!(result, "{}D", display_days).unwrap();
		}

		if hours != 0 || minutes != 0 || seconds != 0 || remaining_nanos != 0 {
			result.push('T');

			if hours != 0 {
				write!(result, "{}H", hours).unwrap();
			}
			if minutes != 0 {
				write!(result, "{}M", minutes).unwrap();
			}
			if seconds != 0 || remaining_nanos != 0 {
				if remaining_nanos != 0 {
					let fractional = remaining_nanos as f64 / 1_000_000_000.0;
					let total_seconds_f = seconds as f64 + fractional;
					let formatted_str = format!("{:.9}", total_seconds_f);
					let formatted = formatted_str.trim_end_matches('0').trim_end_matches('.');
					write!(result, "{}S", formatted).unwrap();
				} else {
					write!(result, "{}S", seconds).unwrap();
				}
			}
		}

		result
	}
}

impl Duration {
	fn total_nanos(&self) -> i128 {
		self.months as i128 * DAYS_PER_MONTH as i128 * NANOS_PER_DAY as i128
			+ self.days as i128 * NANOS_PER_DAY as i128
			+ self.nanos as i128
	}
}

impl PartialEq for Duration {
	fn eq(&self, other: &Self) -> bool {
		self.total_nanos() == other.total_nanos()
	}
}

impl Eq for Duration {}

impl Hash for Duration {
	fn hash<H: Hasher>(&self, state: &mut H) {
		self.total_nanos().hash(state);
	}
}

impl PartialOrd for Duration {
	fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
		Some(self.cmp(other))
	}
}

impl Ord for Duration {
	fn cmp(&self, other: &Self) -> cmp::Ordering {
		self.total_nanos().cmp(&other.total_nanos())
	}
}

impl Duration {
	pub fn try_add(self, rhs: Self) -> Result<Self, Box<TypeError>> {
		let months = self
			.months
			.checked_add(rhs.months)
			.ok_or_else(|| Box::new(Self::overflow_err("the months component overflows Duration range")))?;
		let days = self
			.days
			.checked_add(rhs.days)
			.ok_or_else(|| Box::new(Self::overflow_err("the days component overflows Duration range")))?;
		let nanos = self.nanos.checked_add(rhs.nanos).ok_or_else(|| {
			Box::new(Self::overflow_err("the nanoseconds component overflows Duration range"))
		})?;
		Self::normalized(months, days, nanos)
	}

	pub fn try_sub(self, rhs: Self) -> Result<Self, Box<TypeError>> {
		let months = self
			.months
			.checked_sub(rhs.months)
			.ok_or_else(|| Box::new(Self::overflow_err("the months component overflows Duration range")))?;
		let days = self
			.days
			.checked_sub(rhs.days)
			.ok_or_else(|| Box::new(Self::overflow_err("the days component overflows Duration range")))?;
		let nanos = self.nanos.checked_sub(rhs.nanos).ok_or_else(|| {
			Box::new(Self::overflow_err("the nanoseconds component overflows Duration range"))
		})?;
		Self::normalized(months, days, nanos)
	}

	pub fn try_mul(self, rhs: i64) -> Result<Self, Box<TypeError>> {
		let rhs_i32 = i32::try_from(rhs).map_err(|_| {
			Box::new(Self::overflow_err(format!("multiplier {} overflows Duration range", rhs)))
		})?;
		let months = self
			.months
			.checked_mul(rhs_i32)
			.ok_or_else(|| Box::new(Self::overflow_err("the months component overflows Duration range")))?;
		let days = self
			.days
			.checked_mul(rhs_i32)
			.ok_or_else(|| Box::new(Self::overflow_err("the days component overflows Duration range")))?;
		let nanos = self.nanos.checked_mul(rhs).ok_or_else(|| {
			Box::new(Self::overflow_err("the nanoseconds component overflows Duration range"))
		})?;
		Self::normalized(months, days, nanos)
	}

	pub fn div_duration(self, rhs: Self) -> Result<i64, Box<TypeError>> {
		let divisor = rhs.as_nanos()?;
		if divisor == 0 {
			return Err(Box::new(Self::overflow_err("cannot divide a duration by a zero duration")));
		}
		Ok(self.as_nanos()? / divisor)
	}

	fn saturating_normalized(months: i32, days: i32, nanos: i64) -> Self {
		let total = days as i128 * NANOS_PER_DAY as i128 + nanos as i128;
		let new_days = (total / NANOS_PER_DAY as i128).clamp(i32::MIN as i128, i32::MAX as i128) as i32;
		let new_nanos = (total % NANOS_PER_DAY as i128) as i64;
		Self {
			months,
			days: new_days,
			nanos: new_nanos,
		}
	}

	pub fn saturating_add(self, rhs: Self) -> Self {
		Self::saturating_normalized(
			self.months.saturating_add(rhs.months),
			self.days.saturating_add(rhs.days),
			self.nanos.saturating_add(rhs.nanos),
		)
	}

	pub fn saturating_sub(self, rhs: Self) -> Self {
		Self::saturating_normalized(
			self.months.saturating_sub(rhs.months),
			self.days.saturating_sub(rhs.days),
			self.nanos.saturating_sub(rhs.nanos),
		)
	}

	pub fn saturating_mul(self, rhs: i64) -> Self {
		let months = (self.months as i128 * rhs as i128).clamp(i32::MIN as i128, i32::MAX as i128) as i32;
		let days = (self.days as i128 * rhs as i128).clamp(i32::MIN as i128, i32::MAX as i128) as i32;
		Self::saturating_normalized(months, days, self.nanos.saturating_mul(rhs))
	}
}

impl ops::Add for Duration {
	type Output = Self;
	fn add(self, rhs: Self) -> Self {
		self.try_add(rhs).expect("duration add overflow")
	}
}

impl ops::Sub for Duration {
	type Output = Self;
	fn sub(self, rhs: Self) -> Self {
		self.try_sub(rhs).expect("duration sub overflow")
	}
}

impl ops::Mul<i64> for Duration {
	type Output = Self;
	fn mul(self, rhs: i64) -> Self {
		self.try_mul(rhs).expect("duration mul overflow")
	}
}

impl Display for Duration {
	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
		if self.months == 0 && self.days == 0 && self.nanos == 0 {
			return write!(f, "0s");
		}

		let years = self.months / 12;
		let months = self.months % 12;

		let total_seconds = self.nanos / 1_000_000_000;
		let remaining_nanos = self.nanos % 1_000_000_000;

		let extra_days = total_seconds / 86400;
		let remaining_seconds = total_seconds % 86400;

		let display_days = self.days + extra_days as i32;
		let hours = remaining_seconds / 3600;
		let minutes = (remaining_seconds % 3600) / 60;
		let seconds = remaining_seconds % 60;

		let abs_remaining = remaining_nanos.abs();
		let ms = abs_remaining / 1_000_000;
		let us = (abs_remaining % 1_000_000) / 1_000;
		let ns = abs_remaining % 1_000;

		if years != 0 {
			write!(f, "{}y", years)?;
		}
		if months != 0 {
			write!(f, "{}mo", months)?;
		}
		if display_days != 0 {
			write!(f, "{}d", display_days)?;
		}
		if hours != 0 {
			write!(f, "{}h", hours)?;
		}
		if minutes != 0 {
			write!(f, "{}m", minutes)?;
		}
		if seconds != 0 {
			write!(f, "{}s", seconds)?;
		}

		if ms != 0 || us != 0 || ns != 0 {
			if remaining_nanos < 0
				&& seconds == 0 && hours == 0
				&& minutes == 0 && display_days == 0
				&& years == 0 && months == 0
			{
				write!(f, "-")?;
			}
			if ms != 0 {
				write!(f, "{}ms", ms)?;
			}
			if us != 0 {
				write!(f, "{}us", us)?;
			}
			if ns != 0 {
				write!(f, "{}ns", ns)?;
			}
		}

		Ok(())
	}
}

impl Duration {
	pub fn is_zero(&self) -> bool {
		self.months == 0 && self.days == 0 && self.nanos == 0
	}

	pub fn to_std(&self) -> StdDuration {
		let nanos = self.nanoseconds().map(|n| n.max(0)).unwrap_or(0);
		StdDuration::from_nanos(nanos as u64)
	}

	pub fn from_std(duration: StdDuration) -> Self {
		let nanos = i64::try_from(duration.as_nanos()).expect("std Duration exceeds i64 nanoseconds");
		Self::from_nanoseconds(nanos).expect("std Duration nanoseconds within range")
	}
}

impl From<Duration> for StdDuration {
	fn from(duration: Duration) -> Self {
		duration.to_std()
	}
}

impl From<StdDuration> for Duration {
	fn from(duration: StdDuration) -> Self {
		Self::from_std(duration)
	}
}

impl FromStr for Duration {
	type Err = Error;

	fn from_str(s: &str) -> Result<Self, Self::Err> {
		parse_duration(Fragment::internal(s.trim()))
	}
}

#[cfg(test)]
pub mod tests {
	use super::*;
	use crate::error::TemporalKind;

	mod max {
		use super::*;

		#[test]
		fn adding_max_to_a_duration_saturates_instead_of_panicking() {
			// MAX backs the `forever` literal, added to an instant on every enqueue of a
			// never-expiring record; panicking here would take down the insert path.
			let saturated = Duration::from_hours_const(1).saturating_add(Duration::MAX);
			assert_eq!(saturated.months, i32::MAX);
			assert_eq!(saturated.days, i32::MAX);
		}

		#[test]
		fn max_outranks_every_ordinary_window() {
			// `forever` must outrank every window a user can spell, or an expiry check reads
			// it as already elapsed.
			assert_eq!(Duration::MAX, Duration::MAX);
			for window in [
				Duration::from_seconds_const(1),
				Duration::from_hours_const(24),
				Duration::from_seconds_const(365 * 86_400),
			] {
				assert!(window < Duration::MAX, "{window:?} must be shorter than forever");
			}
		}

		#[test]
		fn max_is_normalised() {
			// A denormalised constant would compare wrongly against durations built through
			// the constructors, which all keep nanos inside a single day.
			assert!(Duration::MAX.nanos < NANOS_PER_DAY);
			assert!(Duration::MAX.nanos >= 0);
		}
	}

	mod ordering {
		use std::{
			cmp::Ordering,
			collections::hash_map::DefaultHasher,
			hash::{Hash, Hasher},
		};

		use super::*;

		fn hash_of(duration: Duration) -> u64 {
			let mut hasher = DefaultHasher::new();
			duration.hash(&mut hasher);
			hasher.finish()
		}

		#[test]
		fn a_month_sorts_below_a_longer_span_expressed_in_days() {
			// A month is thirty days everywhere else in this type, so ordering must convert
			// rather than compare field by field.
			let month = Duration::from_months(1).unwrap();
			let thirty_one_days = Duration::from_days(31).unwrap();

			assert_eq!(
				month.cmp(&thirty_one_days),
				Ordering::Less,
				"one month is thirty days and must sort below thirty-one days"
			);
			assert!(month < thirty_one_days, "the comparison operators must agree with cmp");
		}

		#[test]
		fn days_shorter_than_a_month_sort_below_it() {
			// The inverse direction: a zero months field must not push a shorter span above a
			// month.
			let month = Duration::from_months(1).unwrap();
			let twenty_nine_days = Duration::from_days(29).unwrap();

			assert_eq!(
				twenty_nine_days.cmp(&month),
				Ordering::Less,
				"twenty-nine days is shorter than a thirty day month and must sort below it"
			);
		}

		#[test]
		fn equal_spans_in_different_units_are_equal_and_hash_alike() {
			// If cmp and == disagree, a BTreeMap keyed on Duration treats these as one key
			// while a HashMap treats them as two.
			let month = Duration::from_months(1).unwrap();
			let thirty_days = Duration::from_days(30).unwrap();

			assert_eq!(
				month.cmp(&thirty_days),
				Ordering::Equal,
				"the same elapsed span must compare equal"
			);
			assert_eq!(month, thirty_days, "equality must agree with cmp or Ord's contract is broken");
			assert_eq!(
				hash_of(month),
				hash_of(thirty_days),
				"values that compare equal must hash alike or hash containers lose entries"
			);
		}

		#[test]
		fn sorting_orders_mixed_units_by_elapsed_time() {
			// Field-wise comparison would sort the single month last because its months field
			// dominates.
			let mut durations = vec![
				Duration::from_months(1).unwrap(),
				Duration::from_hours(1).unwrap(),
				Duration::from_days(45).unwrap(),
				Duration::from_seconds(30).unwrap(),
			];
			durations.sort();

			let ordered: Vec<i64> = durations.iter().map(|d| d.as_nanos().unwrap()).collect();
			let mut expected = ordered.clone();
			expected.sort();

			assert_eq!(ordered, expected, "sorting must place durations in elapsed-time order");
		}

		#[test]
		fn a_bound_expressed_in_seconds_rejects_shorter_spans_in_any_unit() {
			// TTL validation compares against a nanos-only bound with a plain `<`, so the
			// bound only holds if ordering measures elapsed time across units.
			let one_second = Duration::from_seconds(1).unwrap();

			assert!(
				Duration::from_milliseconds(500).unwrap() < one_second,
				"500ms is below a one second bound"
			);
			assert!(Duration::from_days(1).unwrap() > one_second, "a day is above a one second bound");
			assert!(Duration::from_months(1).unwrap() > one_second, "a month is above a one second bound");
		}
	}

	fn assert_overflow(result: Result<Duration, Box<TypeError>>) {
		let err = result.expect_err("expected DurationOverflow error");
		match *err {
			TypeError::Temporal {
				kind: TemporalKind::DurationOverflow {
					..
				},
				..
			} => {}
			other => panic!("expected DurationOverflow, got: {:?}", other),
		}
	}

	fn assert_mixed_sign(result: Result<Duration, Box<TypeError>>, expected_days: i32, expected_nanos: i64) {
		let err = result.expect_err("expected DurationMixedSign error");
		match *err {
			TypeError::Temporal {
				kind: TemporalKind::DurationMixedSign {
					days,
					nanos,
				},
				..
			} => {
				assert_eq!(days, expected_days, "days mismatch");
				assert_eq!(nanos, expected_nanos, "nanos mismatch");
			}
			other => panic!("expected DurationMixedSign, got: {:?}", other),
		}
	}

	#[test]
	fn test_duration_iso_string_zero() {
		assert_eq!(Duration::zero().to_iso_string(), "PT0S");
		assert_eq!(Duration::from_seconds(0).unwrap().to_iso_string(), "PT0S");
		assert_eq!(Duration::from_nanoseconds(0).unwrap().to_iso_string(), "PT0S");
		assert_eq!(Duration::default().to_iso_string(), "PT0S");
	}

	#[test]
	fn test_duration_iso_string_seconds() {
		assert_eq!(Duration::from_seconds(1).unwrap().to_iso_string(), "PT1S");
		assert_eq!(Duration::from_seconds(30).unwrap().to_iso_string(), "PT30S");
		assert_eq!(Duration::from_seconds(59).unwrap().to_iso_string(), "PT59S");
	}

	#[test]
	fn test_duration_iso_string_minutes() {
		assert_eq!(Duration::from_minutes(1).unwrap().to_iso_string(), "PT1M");
		assert_eq!(Duration::from_minutes(30).unwrap().to_iso_string(), "PT30M");
		assert_eq!(Duration::from_minutes(59).unwrap().to_iso_string(), "PT59M");
	}

	#[test]
	fn test_duration_iso_string_hours() {
		assert_eq!(Duration::from_hours(1).unwrap().to_iso_string(), "PT1H");
		assert_eq!(Duration::from_hours(12).unwrap().to_iso_string(), "PT12H");
		assert_eq!(Duration::from_hours(23).unwrap().to_iso_string(), "PT23H");
	}

	#[test]
	fn test_duration_iso_string_days() {
		assert_eq!(Duration::from_days(1).unwrap().to_iso_string(), "P1D");
		assert_eq!(Duration::from_days(7).unwrap().to_iso_string(), "P7D");
		assert_eq!(Duration::from_days(365).unwrap().to_iso_string(), "P365D");
	}

	#[test]
	fn test_duration_iso_string_weeks() {
		assert_eq!(Duration::from_weeks(1).unwrap().to_iso_string(), "P7D");
		assert_eq!(Duration::from_weeks(2).unwrap().to_iso_string(), "P14D");
		assert_eq!(Duration::from_weeks(52).unwrap().to_iso_string(), "P364D");
	}

	#[test]
	fn test_duration_iso_string_combined_time() {
		let d = Duration::new(0, 0, (1 * 60 * 60 + 30 * 60) * 1_000_000_000).unwrap();
		assert_eq!(d.to_iso_string(), "PT1H30M");

		let d = Duration::new(0, 0, (5 * 60 + 45) * 1_000_000_000).unwrap();
		assert_eq!(d.to_iso_string(), "PT5M45S");

		let d = Duration::new(0, 0, (2 * 60 * 60 + 30 * 60 + 45) * 1_000_000_000).unwrap();
		assert_eq!(d.to_iso_string(), "PT2H30M45S");
	}

	#[test]
	fn test_duration_iso_string_combined_date_time() {
		assert_eq!(Duration::new(0, 1, 2 * 60 * 60 * 1_000_000_000).unwrap().to_iso_string(), "P1DT2H");
		assert_eq!(Duration::new(0, 1, 30 * 60 * 1_000_000_000).unwrap().to_iso_string(), "P1DT30M");
		assert_eq!(
			Duration::new(0, 1, (2 * 60 * 60 + 30 * 60) * 1_000_000_000).unwrap().to_iso_string(),
			"P1DT2H30M"
		);
		assert_eq!(
			Duration::new(0, 1, (2 * 60 * 60 + 30 * 60 + 45) * 1_000_000_000).unwrap().to_iso_string(),
			"P1DT2H30M45S"
		);
	}

	#[test]
	fn test_duration_iso_string_milliseconds() {
		assert_eq!(Duration::from_milliseconds(123).unwrap().to_iso_string(), "PT0.123S");
		assert_eq!(Duration::from_milliseconds(1).unwrap().to_iso_string(), "PT0.001S");
		assert_eq!(Duration::from_milliseconds(999).unwrap().to_iso_string(), "PT0.999S");
		assert_eq!(Duration::from_milliseconds(1500).unwrap().to_iso_string(), "PT1.5S");
	}

	#[test]
	fn test_duration_iso_string_microseconds() {
		assert_eq!(Duration::from_microseconds(123456).unwrap().to_iso_string(), "PT0.123456S");
		assert_eq!(Duration::from_microseconds(1).unwrap().to_iso_string(), "PT0.000001S");
		assert_eq!(Duration::from_microseconds(999999).unwrap().to_iso_string(), "PT0.999999S");
		assert_eq!(Duration::from_microseconds(1500000).unwrap().to_iso_string(), "PT1.5S");
	}

	#[test]
	fn test_duration_iso_string_nanoseconds() {
		assert_eq!(Duration::from_nanoseconds(123456789).unwrap().to_iso_string(), "PT0.123456789S");
		assert_eq!(Duration::from_nanoseconds(1).unwrap().to_iso_string(), "PT0.000000001S");
		assert_eq!(Duration::from_nanoseconds(999999999).unwrap().to_iso_string(), "PT0.999999999S");
		assert_eq!(Duration::from_nanoseconds(1500000000).unwrap().to_iso_string(), "PT1.5S");
	}

	#[test]
	fn test_duration_iso_string_fractional_seconds() {
		let d = Duration::new(0, 0, 1 * 1_000_000_000 + 500 * 1_000_000).unwrap();
		assert_eq!(d.to_iso_string(), "PT1.5S");

		let d = Duration::new(0, 0, 2 * 1_000_000_000 + 123456 * 1_000).unwrap();
		assert_eq!(d.to_iso_string(), "PT2.123456S");

		let d = Duration::new(0, 0, 3 * 1_000_000_000 + 123456789).unwrap();
		assert_eq!(d.to_iso_string(), "PT3.123456789S");
	}

	#[test]
	fn test_duration_iso_string_complex() {
		let d = Duration::new(0, 1, (2 * 60 * 60 + 30 * 60 + 45) * 1_000_000_000 + 123 * 1_000_000).unwrap();
		assert_eq!(d.to_iso_string(), "P1DT2H30M45.123S");

		let d = Duration::new(0, 7, (12 * 60 * 60 + 45 * 60 + 30) * 1_000_000_000 + 456789 * 1_000).unwrap();
		assert_eq!(d.to_iso_string(), "P7DT12H45M30.456789S");
	}

	#[test]
	fn test_duration_iso_string_trailing_zeros() {
		assert_eq!(Duration::from_nanoseconds(100000000).unwrap().to_iso_string(), "PT0.1S");
		assert_eq!(Duration::from_nanoseconds(120000000).unwrap().to_iso_string(), "PT0.12S");
		assert_eq!(Duration::from_nanoseconds(123000000).unwrap().to_iso_string(), "PT0.123S");
		assert_eq!(Duration::from_nanoseconds(123400000).unwrap().to_iso_string(), "PT0.1234S");
		assert_eq!(Duration::from_nanoseconds(123450000).unwrap().to_iso_string(), "PT0.12345S");
		assert_eq!(Duration::from_nanoseconds(123456000).unwrap().to_iso_string(), "PT0.123456S");
		assert_eq!(Duration::from_nanoseconds(123456700).unwrap().to_iso_string(), "PT0.1234567S");
		assert_eq!(Duration::from_nanoseconds(123456780).unwrap().to_iso_string(), "PT0.12345678S");
		assert_eq!(Duration::from_nanoseconds(123456789).unwrap().to_iso_string(), "PT0.123456789S");
	}

	#[test]
	fn test_duration_iso_string_negative() {
		assert_eq!(Duration::from_seconds(-30).unwrap().to_iso_string(), "PT-30S");
		assert_eq!(Duration::from_minutes(-5).unwrap().to_iso_string(), "PT-5M");
		assert_eq!(Duration::from_hours(-2).unwrap().to_iso_string(), "PT-2H");
		assert_eq!(Duration::from_days(-1).unwrap().to_iso_string(), "P-1D");
	}

	#[test]
	fn test_duration_iso_string_large() {
		assert_eq!(Duration::from_days(1000).unwrap().to_iso_string(), "P1000D");
		assert_eq!(Duration::from_hours(25).unwrap().to_iso_string(), "P1DT1H");
		assert_eq!(Duration::from_minutes(1500).unwrap().to_iso_string(), "P1DT1H");
		assert_eq!(Duration::from_seconds(90000).unwrap().to_iso_string(), "P1DT1H");
	}

	#[test]
	fn test_duration_iso_string_edge_cases() {
		assert_eq!(Duration::from_nanoseconds(1).unwrap().to_iso_string(), "PT0.000000001S");
		assert_eq!(Duration::from_nanoseconds(999999999).unwrap().to_iso_string(), "PT0.999999999S");
		assert_eq!(Duration::from_nanoseconds(1000000000).unwrap().to_iso_string(), "PT1S");
		assert_eq!(Duration::from_nanoseconds(60 * 1000000000).unwrap().to_iso_string(), "PT1M");
		assert_eq!(Duration::from_nanoseconds(3600 * 1000000000).unwrap().to_iso_string(), "PT1H");
		assert_eq!(Duration::from_nanoseconds(86400 * 1000000000).unwrap().to_iso_string(), "P1D");
	}

	#[test]
	fn test_duration_iso_string_precision() {
		assert_eq!(Duration::from_nanoseconds(100).unwrap().to_iso_string(), "PT0.0000001S");
		assert_eq!(Duration::from_nanoseconds(10).unwrap().to_iso_string(), "PT0.00000001S");
		assert_eq!(Duration::from_nanoseconds(1).unwrap().to_iso_string(), "PT0.000000001S");
	}

	#[test]
	fn test_duration_display_zero() {
		assert_eq!(format!("{}", Duration::zero()), "0s");
		assert_eq!(format!("{}", Duration::from_seconds(0).unwrap()), "0s");
		assert_eq!(format!("{}", Duration::from_nanoseconds(0).unwrap()), "0s");
		assert_eq!(format!("{}", Duration::default()), "0s");
	}

	#[test]
	fn test_duration_display_seconds_only() {
		assert_eq!(format!("{}", Duration::from_seconds(1).unwrap()), "1s");
		assert_eq!(format!("{}", Duration::from_seconds(30).unwrap()), "30s");
		assert_eq!(format!("{}", Duration::from_seconds(59).unwrap()), "59s");
	}

	#[test]
	fn test_duration_display_minutes_only() {
		assert_eq!(format!("{}", Duration::from_minutes(1).unwrap()), "1m");
		assert_eq!(format!("{}", Duration::from_minutes(30).unwrap()), "30m");
		assert_eq!(format!("{}", Duration::from_minutes(59).unwrap()), "59m");
	}

	#[test]
	fn test_duration_display_hours_only() {
		assert_eq!(format!("{}", Duration::from_hours(1).unwrap()), "1h");
		assert_eq!(format!("{}", Duration::from_hours(12).unwrap()), "12h");
		assert_eq!(format!("{}", Duration::from_hours(23).unwrap()), "23h");
	}

	#[test]
	fn test_duration_display_days_only() {
		assert_eq!(format!("{}", Duration::from_days(1).unwrap()), "1d");
		assert_eq!(format!("{}", Duration::from_days(7).unwrap()), "7d");
		assert_eq!(format!("{}", Duration::from_days(365).unwrap()), "365d");
	}

	#[test]
	fn test_duration_display_weeks_only() {
		assert_eq!(format!("{}", Duration::from_weeks(1).unwrap()), "7d");
		assert_eq!(format!("{}", Duration::from_weeks(2).unwrap()), "14d");
		assert_eq!(format!("{}", Duration::from_weeks(52).unwrap()), "364d");
	}

	#[test]
	fn test_duration_display_months_only() {
		assert_eq!(format!("{}", Duration::from_months(1).unwrap()), "1mo");
		assert_eq!(format!("{}", Duration::from_months(6).unwrap()), "6mo");
		assert_eq!(format!("{}", Duration::from_months(11).unwrap()), "11mo");
	}

	#[test]
	fn test_duration_display_years_only() {
		assert_eq!(format!("{}", Duration::from_years(1).unwrap()), "1y");
		assert_eq!(format!("{}", Duration::from_years(10).unwrap()), "10y");
		assert_eq!(format!("{}", Duration::from_years(100).unwrap()), "100y");
	}

	#[test]
	fn test_duration_display_combined_time() {
		let d = Duration::new(0, 0, (1 * 60 * 60 + 30 * 60) * 1_000_000_000).unwrap();
		assert_eq!(format!("{}", d), "1h30m");

		let d = Duration::new(0, 0, (5 * 60 + 45) * 1_000_000_000).unwrap();
		assert_eq!(format!("{}", d), "5m45s");

		let d = Duration::new(0, 0, (2 * 60 * 60 + 30 * 60 + 45) * 1_000_000_000).unwrap();
		assert_eq!(format!("{}", d), "2h30m45s");
	}

	#[test]
	fn test_duration_display_combined_date_time() {
		assert_eq!(format!("{}", Duration::new(0, 1, 2 * 60 * 60 * 1_000_000_000).unwrap()), "1d2h");
		assert_eq!(format!("{}", Duration::new(0, 1, 30 * 60 * 1_000_000_000).unwrap()), "1d30m");
		assert_eq!(
			format!("{}", Duration::new(0, 1, (2 * 60 * 60 + 30 * 60) * 1_000_000_000).unwrap()),
			"1d2h30m"
		);
		assert_eq!(
			format!("{}", Duration::new(0, 1, (2 * 60 * 60 + 30 * 60 + 45) * 1_000_000_000).unwrap()),
			"1d2h30m45s"
		);
	}

	#[test]
	fn test_duration_display_years_months() {
		assert_eq!(format!("{}", Duration::new(13, 0, 0).unwrap()), "1y1mo");
		assert_eq!(format!("{}", Duration::new(27, 0, 0).unwrap()), "2y3mo");
	}

	#[test]
	fn test_duration_display_full_components() {
		let nanos = (4 * 60 * 60 + 5 * 60 + 6) * 1_000_000_000i64;
		assert_eq!(format!("{}", Duration::new(14, 3, nanos).unwrap()), "1y2mo3d4h5m6s");
	}

	#[test]
	fn test_duration_display_milliseconds() {
		assert_eq!(format!("{}", Duration::from_milliseconds(123).unwrap()), "123ms");
		assert_eq!(format!("{}", Duration::from_milliseconds(1).unwrap()), "1ms");
		assert_eq!(format!("{}", Duration::from_milliseconds(999).unwrap()), "999ms");
		assert_eq!(format!("{}", Duration::from_milliseconds(1500).unwrap()), "1s500ms");
	}

	#[test]
	fn test_duration_display_microseconds() {
		assert_eq!(format!("{}", Duration::from_microseconds(123456).unwrap()), "123ms456us");
		assert_eq!(format!("{}", Duration::from_microseconds(1).unwrap()), "1us");
		assert_eq!(format!("{}", Duration::from_microseconds(999999).unwrap()), "999ms999us");
		assert_eq!(format!("{}", Duration::from_microseconds(1500000).unwrap()), "1s500ms");
	}

	#[test]
	fn test_duration_display_nanoseconds() {
		assert_eq!(format!("{}", Duration::from_nanoseconds(123456789).unwrap()), "123ms456us789ns");
		assert_eq!(format!("{}", Duration::from_nanoseconds(1).unwrap()), "1ns");
		assert_eq!(format!("{}", Duration::from_nanoseconds(999999999).unwrap()), "999ms999us999ns");
		assert_eq!(format!("{}", Duration::from_nanoseconds(1500000000).unwrap()), "1s500ms");
	}

	#[test]
	fn test_duration_display_sub_second_decomposition() {
		let d = Duration::new(0, 0, 1 * 1_000_000_000 + 500 * 1_000_000).unwrap();
		assert_eq!(format!("{}", d), "1s500ms");

		let d = Duration::new(0, 0, 2 * 1_000_000_000 + 123456 * 1_000).unwrap();
		assert_eq!(format!("{}", d), "2s123ms456us");

		let d = Duration::new(0, 0, 3 * 1_000_000_000 + 123456789).unwrap();
		assert_eq!(format!("{}", d), "3s123ms456us789ns");
	}

	#[test]
	fn test_duration_display_complex() {
		let d = Duration::new(0, 1, (2 * 60 * 60 + 30 * 60 + 45) * 1_000_000_000 + 123 * 1_000_000).unwrap();
		assert_eq!(format!("{}", d), "1d2h30m45s123ms");

		let d = Duration::new(0, 7, (12 * 60 * 60 + 45 * 60 + 30) * 1_000_000_000 + 456789 * 1_000).unwrap();
		assert_eq!(format!("{}", d), "7d12h45m30s456ms789us");
	}

	#[test]
	fn test_duration_display_sub_second_only() {
		assert_eq!(format!("{}", Duration::from_nanoseconds(100000000).unwrap()), "100ms");
		assert_eq!(format!("{}", Duration::from_nanoseconds(120000000).unwrap()), "120ms");
		assert_eq!(format!("{}", Duration::from_nanoseconds(123000000).unwrap()), "123ms");
		assert_eq!(format!("{}", Duration::from_nanoseconds(100).unwrap()), "100ns");
		assert_eq!(format!("{}", Duration::from_nanoseconds(10).unwrap()), "10ns");
		assert_eq!(format!("{}", Duration::from_nanoseconds(1000).unwrap()), "1us");
	}

	#[test]
	fn test_duration_display_negative() {
		assert_eq!(format!("{}", Duration::from_seconds(-30).unwrap()), "-30s");
		assert_eq!(format!("{}", Duration::from_minutes(-5).unwrap()), "-5m");
		assert_eq!(format!("{}", Duration::from_hours(-2).unwrap()), "-2h");
		assert_eq!(format!("{}", Duration::from_days(-1).unwrap()), "-1d");
	}

	#[test]
	fn test_duration_display_negative_sub_second() {
		assert_eq!(format!("{}", Duration::from_milliseconds(-500).unwrap()), "-500ms");
		assert_eq!(format!("{}", Duration::from_microseconds(-100).unwrap()), "-100us");
		assert_eq!(format!("{}", Duration::from_nanoseconds(-50).unwrap()), "-50ns");
	}

	#[test]
	fn test_duration_display_large() {
		assert_eq!(format!("{}", Duration::from_days(1000).unwrap()), "1000d");
		assert_eq!(format!("{}", Duration::from_hours(25).unwrap()), "1d1h");
		assert_eq!(format!("{}", Duration::from_minutes(1500).unwrap()), "1d1h");
		assert_eq!(format!("{}", Duration::from_seconds(90000).unwrap()), "1d1h");
	}

	#[test]
	fn test_duration_display_edge_cases() {
		assert_eq!(format!("{}", Duration::from_nanoseconds(1).unwrap()), "1ns");
		assert_eq!(format!("{}", Duration::from_nanoseconds(999999999).unwrap()), "999ms999us999ns");
		assert_eq!(format!("{}", Duration::from_nanoseconds(1000000000).unwrap()), "1s");
		assert_eq!(format!("{}", Duration::from_nanoseconds(60 * 1000000000).unwrap()), "1m");
		assert_eq!(format!("{}", Duration::from_nanoseconds(3600 * 1000000000).unwrap()), "1h");
		assert_eq!(format!("{}", Duration::from_nanoseconds(86400 * 1000000000).unwrap()), "1d");
	}

	#[test]
	fn test_duration_display_abs_and_negate() {
		let d = Duration::from_seconds(-30).unwrap();
		assert_eq!(format!("{}", d.abs()), "30s");

		let d = Duration::from_seconds(30).unwrap();
		assert_eq!(format!("{}", d.negate()), "-30s");
	}

	#[test]
	fn test_nanos_normalize_to_days() {
		let d = Duration::new(0, 0, 86_400_000_000_000).unwrap();
		assert_eq!(d.get_days(), 1);
		assert_eq!(d.get_nanos(), 0);
	}

	#[test]
	fn test_nanos_normalize_to_days_with_remainder() {
		let d = Duration::new(0, 0, 86_400_000_000_000 + 1_000_000_000).unwrap();
		assert_eq!(d.get_days(), 1);
		assert_eq!(d.get_nanos(), 1_000_000_000);
	}

	#[test]
	fn test_nanos_normalize_negative() {
		let d = Duration::new(0, 0, -86_400_000_000_000).unwrap();
		assert_eq!(d.get_days(), -1);
		assert_eq!(d.get_nanos(), 0);
	}

	#[test]
	fn test_normalized_equality() {
		let d1 = Duration::new(0, 0, 86_400_000_000_000).unwrap();
		let d2 = Duration::new(0, 1, 0).unwrap();
		assert_eq!(d1, d2);
	}

	#[test]
	fn test_normalized_ordering() {
		let d1 = Duration::new(0, 0, 86_400_000_000_000 + 1).unwrap();
		let d2 = Duration::new(0, 1, 0).unwrap();
		assert!(d1 > d2);
	}

	#[test]
	fn test_mixed_sign_months_days_allowed() {
		// Months are variable-length so they may disagree in sign with days and nanos, which
		// are commensurable with each other and may not.
		let d = Duration::new(1, -15, 0).unwrap();
		assert_eq!(d.get_months(), 1);
		assert_eq!(d.get_days(), -15);
	}

	#[test]
	fn test_mixed_sign_months_nanos_allowed() {
		let d = Duration::new(-1, 0, 1_000_000_000).unwrap();
		assert_eq!(d.get_months(), -1);
		assert_eq!(d.get_nanos(), 1_000_000_000);
	}

	#[test]
	fn test_mixed_sign_days_positive_nanos_negative() {
		assert_mixed_sign(Duration::new(0, 1, -1), 1, -1);
	}

	#[test]
	fn test_mixed_sign_days_negative_nanos_positive() {
		assert_mixed_sign(Duration::new(0, -1, 1), -1, 1);
	}

	#[test]
	fn test_is_positive_negative_mutually_exclusive() {
		let durations = [
			Duration::new(1, 0, 0).unwrap(),
			Duration::new(0, 1, 0).unwrap(),
			Duration::new(0, 0, 1).unwrap(),
			Duration::new(-1, 0, 0).unwrap(),
			Duration::new(0, -1, 0).unwrap(),
			Duration::new(0, 0, -1).unwrap(),
			Duration::new(1, 1, 1).unwrap(),
			Duration::new(-1, -1, -1).unwrap(),
			Duration::new(1, -15, 0).unwrap(), // mixed months/days
			Duration::new(-1, 15, 0).unwrap(), // mixed months/days
			Duration::zero(),
		];
		for d in durations {
			assert!(
				!(d.is_positive() && d.is_negative()),
				"Duration {:?} is both positive and negative",
				d
			);
		}
	}

	#[test]
	fn test_mixed_months_days_is_neither_positive_nor_negative() {
		let d = Duration::new(1, -15, 0).unwrap();
		assert!(!d.is_positive());
		assert!(!d.is_negative());
	}

	#[test]
	fn test_from_days_overflow() {
		assert_overflow(Duration::from_days(i32::MAX as i64 + 1));
	}

	#[test]
	fn test_months_positive_days_negative_ok() {
		let d = Duration::new(1, -15, 0).unwrap();
		assert_eq!(d.get_months(), 1);
		assert_eq!(d.get_days(), -15);
		assert_eq!(d.get_nanos(), 0);
	}

	#[test]
	fn test_months_negative_days_positive_ok() {
		let d = Duration::new(-1, 15, 0).unwrap();
		assert_eq!(d.get_months(), -1);
		assert_eq!(d.get_days(), 15);
	}

	#[test]
	fn test_months_positive_nanos_negative_ok() {
		let d = Duration::new(1, 0, -1_000_000_000).unwrap();
		assert_eq!(d.get_months(), 1);
		assert_eq!(d.get_nanos(), -1_000_000_000);
	}

	#[test]
	fn test_months_negative_nanos_positive_ok() {
		let d = Duration::new(-1, 0, 1_000_000_000).unwrap();
		assert_eq!(d.get_months(), -1);
		assert_eq!(d.get_nanos(), 1_000_000_000);
	}

	#[test]
	fn test_months_positive_days_negative_nanos_negative_ok() {
		let d = Duration::new(2, -3, -1_000_000_000).unwrap();
		assert_eq!(d.get_months(), 2);
		assert_eq!(d.get_days(), -3);
		assert_eq!(d.get_nanos(), -1_000_000_000);
	}

	#[test]
	fn test_months_negative_days_positive_nanos_positive_ok() {
		let d = Duration::new(-2, 3, 1_000_000_000).unwrap();
		assert_eq!(d.get_months(), -2);
		assert_eq!(d.get_days(), 3);
		assert_eq!(d.get_nanos(), 1_000_000_000);
	}

	#[test]
	fn test_days_positive_nanos_negative_with_months_err() {
		assert_mixed_sign(Duration::new(5, 1, -1), 1, -1);
	}

	#[test]
	fn test_days_negative_nanos_positive_with_months_err() {
		assert_mixed_sign(Duration::new(-5, -1, 1), -1, 1);
	}

	#[test]
	fn test_nanos_normalization_causes_days_nanos_mixed_sign_err() {
		// Normalization itself can produce the mixed sign, not just the raw input.
		assert_mixed_sign(Duration::new(0, -3, 2 * 86_400_000_000_000 + 1), -1, 1);
	}

	#[test]
	fn test_positive_months_negative_days_is_neither() {
		let d = Duration::new(1, -15, 0).unwrap();
		assert!(!d.is_positive());
		assert!(!d.is_negative());
	}

	#[test]
	fn test_negative_months_positive_days_is_neither() {
		let d = Duration::new(-1, 15, 0).unwrap();
		assert!(!d.is_positive());
		assert!(!d.is_negative());
	}

	#[test]
	fn test_positive_months_negative_days_negative_nanos_is_neither() {
		let d = Duration::new(2, -3, -1_000_000_000).unwrap();
		assert!(!d.is_positive());
		assert!(!d.is_negative());
	}

	#[test]
	fn test_all_positive_is_positive() {
		let d = Duration::new(1, 2, 3).unwrap();
		assert!(d.is_positive());
		assert!(!d.is_negative());
	}

	#[test]
	fn test_all_negative_is_negative() {
		let d = Duration::new(-1, -2, -3).unwrap();
		assert!(!d.is_positive());
		assert!(d.is_negative());
	}

	#[test]
	fn test_zero_is_neither_positive_nor_negative() {
		assert!(!Duration::zero().is_positive());
		assert!(!Duration::zero().is_negative());
	}

	#[test]
	fn test_only_months_positive() {
		let d = Duration::new(1, 0, 0).unwrap();
		assert!(d.is_positive());
	}

	#[test]
	fn test_only_days_negative() {
		let d = Duration::new(0, -1, 0).unwrap();
		assert!(d.is_negative());
	}

	#[test]
	fn test_normalization_nanos_into_negative_days() {
		let d = Duration::new(-5, 0, -2 * 86_400_000_000_000).unwrap();
		assert_eq!(d.get_months(), -5);
		assert_eq!(d.get_days(), -2);
		assert_eq!(d.get_nanos(), 0);
	}

	#[test]
	fn test_normalization_nanos_into_days_with_mixed_months() {
		let d = Duration::new(3, 1, 86_400_000_000_000 + 500_000_000).unwrap();
		assert_eq!(d.get_months(), 3);
		assert_eq!(d.get_days(), 2);
		assert_eq!(d.get_nanos(), 500_000_000);
	}

	#[test]
	fn test_try_sub_month_minus_days() {
		let a = Duration::new(1, 0, 0).unwrap();
		let b = Duration::new(0, 15, 0).unwrap();
		let result = a.try_sub(b).unwrap();
		assert_eq!(result.get_months(), 1);
		assert_eq!(result.get_days(), -15);
	}

	#[test]
	fn test_try_sub_day_minus_month() {
		let a = Duration::new(0, 1, 0).unwrap();
		let b = Duration::new(1, 0, 0).unwrap();
		let result = a.try_sub(b).unwrap();
		assert_eq!(result.get_months(), -1);
		assert_eq!(result.get_days(), 1);
	}

	#[test]
	fn test_try_add_mixed_months_days() {
		let a = Duration::new(2, -10, 0).unwrap();
		let b = Duration::new(-1, -5, 0).unwrap();
		let result = a.try_add(b).unwrap();
		assert_eq!(result.get_months(), 1);
		assert_eq!(result.get_days(), -15);
	}

	#[test]
	fn test_try_sub_days_nanos_mixed_sign_err() {
		// Subtraction can borrow across the day boundary into a days/nanos sign mismatch.
		let a = Duration::new(0, 1, 0).unwrap();
		let b = Duration::new(0, 0, 1).unwrap();
		assert_mixed_sign(a.try_sub(b), 1, -1);
	}

	#[test]
	fn test_try_mul_preserves_mixed_months() {
		let d = Duration::new(1, -3, 0).unwrap();
		let result = d.try_mul(2).unwrap();
		assert_eq!(result.get_months(), 2);
		assert_eq!(result.get_days(), -6);
	}

	#[test]
	fn test_from_days_underflow() {
		assert_overflow(Duration::from_days(i32::MIN as i64 - 1));
	}

	#[test]
	fn test_from_months_overflow() {
		assert_overflow(Duration::from_months(i32::MAX as i64 + 1));
	}

	#[test]
	fn test_from_years_overflow() {
		assert_overflow(Duration::from_years(i32::MAX as i64 / 12 + 1));
	}

	#[test]
	fn test_from_weeks_overflow() {
		assert_overflow(Duration::from_weeks(i32::MAX as i64 / 7 + 1));
	}

	#[test]
	fn test_mul_months_truncation() {
		let d = Duration::from_months(1).unwrap();
		assert_overflow(d.try_mul(i32::MAX as i64 + 1));
	}

	#[test]
	fn test_mul_days_truncation() {
		let d = Duration::from_days(1).unwrap();
		assert_overflow(d.try_mul(i32::MAX as i64 + 1));
	}

	fn assert_total_overflow(result: Result<i64, Box<TypeError>>) {
		let err = result.expect_err("expected DurationOverflow error");
		match *err {
			TypeError::Temporal {
				kind: TemporalKind::DurationOverflow {
					..
				},
				..
			} => {}
			other => panic!("expected DurationOverflow, got: {:?}", other),
		}
	}

	#[test]
	fn test_total_seconds_roundtrips_across_day_boundary() {
		// Construction normalizes whole days out of the nanos field, so a unit total that
		// ignores the days field reports only the sub-day remainder.
		let d = Duration::from_seconds(90_000).unwrap();
		assert_eq!(d.get_days(), 1);
		assert_eq!(d.seconds().unwrap(), 90_000);
	}

	#[test]
	fn test_total_milliseconds_roundtrips_across_day_boundary() {
		let d = Duration::from_milliseconds(90_000_000).unwrap();
		assert_eq!(d.get_days(), 1);
		assert_eq!(d.milliseconds().unwrap(), 90_000_000);
	}

	#[test]
	fn test_total_microseconds_roundtrips_across_day_boundary() {
		let d = Duration::from_microseconds(90_000_000_000).unwrap();
		assert_eq!(d.get_days(), 1);
		assert_eq!(d.microseconds().unwrap(), 90_000_000_000);
	}

	#[test]
	fn test_total_nanoseconds_roundtrips_across_day_boundary() {
		let d = Duration::from_nanoseconds(90_000_000_000_000).unwrap();
		assert_eq!(d.get_days(), 1);
		assert_eq!(d.nanoseconds().unwrap(), 90_000_000_000_000);
		assert_eq!(d.as_nanos().unwrap(), 90_000_000_000_000);
	}

	#[test]
	fn test_total_from_minutes_crossing_day() {
		let d = Duration::from_minutes(1_500).unwrap();
		assert_eq!(d.get_days(), 1);
		assert_eq!(d.seconds().unwrap(), 90_000);
	}

	#[test]
	fn test_total_from_hours_crossing_day() {
		let d = Duration::from_hours(25).unwrap();
		assert_eq!(d.get_days(), 1);
		assert_eq!(d.seconds().unwrap(), 90_000);
	}

	#[test]
	fn test_total_from_days_counts_days() {
		let d = Duration::from_days(3).unwrap();
		assert_eq!(d.seconds().unwrap(), 3 * 86_400);
		assert_eq!(d.nanoseconds().unwrap(), 3 * NANOS_PER_DAY);
	}

	#[test]
	fn test_total_from_weeks_counts_days() {
		let d = Duration::from_weeks(2).unwrap();
		assert_eq!(d.get_days(), 14);
		assert_eq!(d.seconds().unwrap(), 14 * 86_400);
	}

	#[test]
	fn test_total_from_months_uses_thirty_days() {
		// Residual months (< 12) count as 30 days each.
		let d = Duration::from_months(5).unwrap();
		assert_eq!(d.get_months(), 5);
		assert_eq!(d.seconds().unwrap(), 5 * 30 * 86_400);
	}

	#[test]
	fn test_total_from_years_uses_three_six_five_quarter_days() {
		// Whole years count as 365.25 days each (the Postgres EXTRACT(EPOCH) convention), so
		// one year is deliberately not equal to 365 days.
		let one_year = Duration::from_years(1).unwrap();
		assert_eq!(one_year.get_months(), 12);
		assert_eq!(one_year.seconds().unwrap(), 31_557_600);

		let three_sixty_five_days = Duration::from_days(365).unwrap();
		assert_eq!(three_sixty_five_days.seconds().unwrap(), 31_536_000);
		assert_ne!(one_year.seconds().unwrap(), three_sixty_five_days.seconds().unwrap());

		assert_eq!(Duration::from_years(2).unwrap().seconds().unwrap(), 2 * 31_557_600);
	}

	#[test]
	fn test_total_months_split_into_years_and_residual() {
		// Whole years convert at 365.25 days, residual months at 30.
		let d = Duration::from_months(13).unwrap();
		assert_eq!(d.seconds().unwrap(), 31_557_600 + 30 * 86_400);
	}

	#[test]
	fn test_total_new_combined_mixed_sign() {
		// Months and days may carry opposite signs, so the total must accumulate them signed
		// rather than take a magnitude.
		let d = Duration::new(1, -5, 0).unwrap();
		assert_eq!(d.seconds().unwrap(), 30 * 86_400 - 5 * 86_400);
	}

	#[test]
	fn test_total_from_micros_infallible_roundtrips() {
		let micros: u64 = 90_000_000_000;
		let d = Duration::from_micros_infallible(micros);
		assert_eq!(d.get_days(), 1);
		assert_eq!(d.microseconds().unwrap(), micros as i64);
	}

	#[test]
	fn test_total_from_nanos_infallible_roundtrips() {
		// Spans arrive from monotonic counters on paths that must not panic, so the infallible
		// constructor has to round-trip rather than reject.
		let nanos: u64 = 7 * 86_400_000_000_000 + 1_500_000_000;
		let d = Duration::from_nanos_infallible(nanos);
		assert_eq!(d.get_days(), 7);
		assert_eq!(d.nanoseconds().unwrap(), nanos as i64);
	}

	#[test]
	fn test_from_nanos_infallible_clamps_instead_of_wrapping() {
		// Wrapping would produce a negative span, which reads as a duration in the past.
		let d = Duration::from_nanos_infallible(u64::MAX);
		assert!(d.get_days() > 0, "an unrepresentable span must clamp to a positive duration");
	}

	#[test]
	fn test_total_zero_is_zero_in_every_unit() {
		let d = Duration::zero();
		assert_eq!(d.seconds().unwrap(), 0);
		assert_eq!(d.milliseconds().unwrap(), 0);
		assert_eq!(d.microseconds().unwrap(), 0);
		assert_eq!(d.nanoseconds().unwrap(), 0);
		assert_eq!(d.as_nanos().unwrap(), 0);
	}

	#[test]
	fn test_total_overflow_fails_loud_per_unit() {
		// A day count that overflows i64 nanoseconds still fits i64 seconds, so each unit is
		// checked independently and overflow surfaces as an error rather than wrapping.
		let d = Duration::new(0, i32::MAX, 0).unwrap();
		assert_eq!(d.seconds().unwrap(), i32::MAX as i64 * 86_400);
		assert_total_overflow(d.nanoseconds());
		assert_total_overflow(d.as_nanos());
	}

	#[test]
	fn saturating_add_matches_try_add_in_range() {
		// Saturation must only engage at the i32/i64 boundaries, never in range.
		let a = Duration::new(1, 2, 3_000_000_000).unwrap();
		let b = Duration::new(0, 1, 1_000_000_000).unwrap();
		assert_eq!(a.saturating_add(b), a.try_add(b).unwrap());
		assert_eq!(a.saturating_sub(b), a.try_sub(b).unwrap());
	}

	#[test]
	fn saturating_add_clamps_months_overflow() {
		let d = Duration::new(i32::MAX, 0, 0).unwrap().saturating_add(Duration::new(1000, 0, 0).unwrap());
		assert_eq!(d.get_months(), i32::MAX);
	}

	#[test]
	fn saturating_add_clamps_days_overflow() {
		let d = Duration::new(0, i32::MAX, 0).unwrap().saturating_add(Duration::new(0, 1000, 0).unwrap());
		assert_eq!(d.get_days(), i32::MAX);
	}

	#[test]
	fn saturating_sub_carries_mixed_sign() {
		// try_sub rejects this borrow as a mixed days/nanos sign; the saturating form must
		// instead carry it into one same-sign value.
		let d = Duration::new(0, 1, 0).unwrap().saturating_sub(Duration::new(0, 0, 1).unwrap());
		assert_eq!(d.get_days(), 0);
		assert_eq!(d.get_nanos(), 86_399_999_999_999);
	}

	#[test]
	fn saturating_mul_scales_and_clamps() {
		assert_eq!(Duration::from_seconds(1).unwrap().saturating_mul(60), Duration::from_seconds(60).unwrap());
		assert_eq!(Duration::new(0, i32::MAX, 0).unwrap().saturating_mul(2).get_days(), i32::MAX);
	}
}

#[cfg(test)]
mod conversion_tests {
	use std::str::FromStr;

	use super::{Duration, StdDuration};

	#[test]
	fn from_str_parses_human_units() {
		// Config values carry their unit in the literal, so the unit can never be misread.
		assert_eq!(Duration::from_str("10ms").unwrap().to_std(), StdDuration::from_millis(10));
		assert_eq!("5s".parse::<Duration>().unwrap().to_std(), StdDuration::from_secs(5));
		assert_eq!("2m".parse::<Duration>().unwrap().to_std(), StdDuration::from_secs(120));
	}

	#[test]
	fn from_str_trims_whitespace() {
		assert_eq!("  400ms  ".parse::<Duration>().unwrap().to_std(), StdDuration::from_millis(400));
	}

	#[test]
	fn from_str_rejects_bare_integer() {
		// A bare "5000" must fail loudly rather than be silently read as ms or s.
		assert!("5000".parse::<Duration>().is_err());
	}

	#[test]
	fn from_str_rejects_garbage() {
		assert!("soon".parse::<Duration>().is_err());
		assert!("".parse::<Duration>().is_err());
	}

	#[test]
	fn to_std_and_from_std_round_trip() {
		let std = StdDuration::from_millis(1234);
		assert_eq!(Duration::from_std(std).to_std(), std);
	}

	#[test]
	fn to_std_saturates_negative_to_zero() {
		// Config durations are never negative; a negative one degrades to zero, not a panic.
		let negative = Duration::from_seconds(-5).unwrap();
		assert_eq!(negative.to_std(), StdDuration::ZERO);
	}

	#[test]
	fn dividing_a_span_counts_whole_steps_and_drops_the_remainder() {
		// A partial slide must not count: rounding up files the row under a window start in its future.
		let second = Duration::from_seconds(1).unwrap();

		assert_eq!(second.div_duration(Duration::from_milliseconds(250).unwrap()).unwrap(), 4);
		assert_eq!(second.div_duration(Duration::from_milliseconds(300).unwrap()).unwrap(), 3);
		assert_eq!(second.div_duration(Duration::from_seconds(2).unwrap()).unwrap(), 0);
	}

	#[test]
	fn dividing_by_a_zero_span_is_refused_rather_than_panicking() {
		// RQL does not close every route to a zero slide, and dividing would panic the flow.
		let err = Duration::from_seconds(1).unwrap().div_duration(Duration::zero());

		assert!(err.is_err(), "a zero divisor must be an error, not a division by zero");
	}

	#[test]
	fn division_reads_the_whole_duration_not_just_its_nanosecond_field() {
		// Days and nanos are separate fields; reading nanos alone answers zero for a days dividend.
		let day = Duration::from_days(1).unwrap();
		let hour = Duration::from_hours(1).unwrap();

		assert_eq!(day.div_duration(hour).unwrap(), 24);
		assert_eq!(day.get_nanos(), 0, "precondition: the dividend carries no nanoseconds of its own");
	}
}